code review 5071044: testing: Add support for running tests in parallel (t.P...

src/pkg/testing/testing.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package testing provides support for automated testing of Go packages.
 // It is intended to be used in concert with the ``gotest'' utility, which automates
 // execution of any function of the form
 //     func TestXxx(*testing.T)
 // where Xxx can be any alphanumeric string (but the first letter must not be in
 // [a-z]) and serves to identify the test routine.
@@ skipping 47 matching lines @@
         short = flag.Bool("test.short", false, "run smaller test suite to save time")
 
         // Report as tests are run; default is silent for success.
         chatty         = flag.Bool("test.v", false, "verbose: print additional output")
         match          = flag.String("test.run", "", "regular expression to select tests to run")
         memProfile     = flag.String("test.memprofile", "", "write a memory profile to the named file after execution")
         memProfileRate = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate")
         cpuProfile     = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution")
         timeout        = flag.Int64("test.timeout", 0, "if > 0, sets time limit for tests in seconds")
         cpuListStr     = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
+        parallel       = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
 
         cpuList []int
 )
 
 // Short reports whether the -test.short flag is set.
 func Short() bool {
         return *short
 }
 
 // Insert final newline if needed and tabs after internal newlines.
 func tabify(s string) string {
         n := len(s)
         if n > 0 && s[n-1] != '\n' {
                 s += "\n"
                 n++
         }
         for i := 0; i < n-1; i++ { // -1 to avoid final newline
                 if s[i] == '\n' {
                         return s[0:i+1] + "\t" + tabify(s[i+1:n])
                 }
         }
         return s
 }
 
 // T is a type passed to Test functions to manage test state and support formatted test logs.
 // Logs are accumulated during execution and dumped to standard error when done.
 type T struct {
-        errors   string
-        failed   bool
-        ch       chan *T   // Output for serial tests
-        pch      chan *T   // Output for parallel tests

[rog, 2011/09/21 20:22:53]

d

-        wch      chan bool // Sync channel for parallel tests
-        parallel bool
-        name     string
+        name          string    // Name of test.
+        errors        string    // Error string from test.
+        failed        bool      // Test has failed.
+        ch            chan *T   // Output for serial tests.
+        startParallel chan bool // Parallel tests will wait on this.
+        ns            int64     // Duration of test in nanoseconds.
 }
 
 // Fail marks the Test function as having failed but continues execution.
 func (t *T) Fail() { t.failed = true }
 
 // Failed returns whether the Test function has failed.
 func (t *T) Failed() bool { return t.failed }
 
 // FailNow marks the Test function as having failed and stops its execution.
 // Execution will continue at the next Test.
@@ skipping 30 matching lines @@
         t.Log(args...)
         t.FailNow()
 }
 
 // Fatalf is equivalent to Logf() followed by FailNow().
 func (t *T) Fatalf(format string, args ...interface{}) {
         t.Logf(format, args...)
         t.FailNow()
 }
 
-// Parallel signal that this test can be run in parallel to other parallel tests.
-// This will block until all serial tests in this cpu group are done.
+// Parallel signals that this test is to be run in parallel with (and only with)·
+// other parallel tests in this CPU group.
 func (t *T) Parallel() {
-        t.parallel = true

[rog, 2011/09/21 20:22:53]

this doesn't appear to be used. perhaps it should be, to make t.Parallel
idempotent. as it is it'll deadlock if called twice.

-        t.ch <- nil // Release main testing loop
-        t.ch = t.pch

[rog, 2011/09/21 20:22:53]

d

-
-        // Wait for serial tests to finish
-        <-t.wch
+        t.ch <- nil       // Release main testing loop
+        <-t.startParallel // Wait for serial tests to finish
 }
 
 // An internal type but exported because it is cross-package; part of the implementation
 // of gotest.
 type InternalTest struct {
         Name string
         F    func(*T)
 }
 
-func tRunner(t *T, test *InternalTest, report chan string) {
-        if *chatty {
-                report <- fmt.Sprintf("=== RUN %s\n", t.name)
-        }
-        ns := time.Nanoseconds()
+func tRunner(t *T, test *InternalTest) {
+        t.ns = time.Nanoseconds()
         test.F(t)
-        ns = time.Nanoseconds() - ns
-
-        tstr := fmt.Sprintf("(%.2f seconds)", float64(ns)/1e9)
-        format := "--- %s: %s %s\n%s"
-        if t.failed {
-                report <- fmt.Sprintf(format, "FAIL", t.name, tstr, t.errors)
-        } else if *chatty {
-                report <- fmt.Sprintf(format, "PASS", t.name, tstr, t.errors)
-        }
+        t.ns = time.Nanoseconds() - t.ns
         t.ch <- t
 }
 
 // An internal function but exported because it is cross-package; part of the implementation
 // of gotest.
 func Main(matchString func(pat, str string) (bool, os.Error), tests []InternalTest, benchmarks []InternalBenchmark) {
         flag.Parse()
         parseCpuList()
 
         before()
         startAlarm()
         RunTests(matchString, tests)
         stopAlarm()
         RunBenchmarks(matchString, benchmarks)
         after()
 }
 
+func report(t *T) {
+        tstr := fmt.Sprintf("(%.2f seconds)", float64(t.ns)/1e9)
+        format := "--- %s: %s %s\n%s"
+        if t.failed {
+                fmt.Fprintf(os.Stderr, format, "FAIL", t.name, tstr, t.errors)
+        } else if *chatty {
+                fmt.Fprintf(os.Stderr, format, "PASS", t.name, tstr, t.errors)
+        }
+}
+
 func RunTests(matchString func(pat, str string) (bool, os.Error), tests []InternalTest) {
         if len(tests) == 0 {
-                println("testing: warning: no tests to run")
+                fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
                 return
         }
 
         ok := true
-        pch := make(chan *T)

[rog, 2011/09/21 20:22:53]

s/pch/ch/

-
-        // One reporter, to avoid print collision
-        report := make(chan string)
-        go func() {
-                for msg := range report {
-                        print(msg)
-                }
-        }()
-
-PROCS:
+        ch := make(chan *T)
+
         for _, procs := range cpuList {
                 runtime.GOMAXPROCS(procs)
-                if p := runtime.GOMAXPROCS(-1); p != procs {
-                        fmt.Printf("error: can't restore GOMAXPROCS to %d (currently %d)\n", procs, p)
-                        ok = false
-                        break PROCS
-                }
 
                 numParallel := 0
-                wch := make(chan bool)

[rog, 2011/09/21 20:22:53]

i'm not sure wch is a good name here. startParallel? (same in T)

+                startParallel := make(chan bool)
+
                 for i := 0; i < len(tests); i++ {
                         matched, err := matchString(*match, tests[i].Name)
                         if err != nil {
                                 println("invalid regexp for -test.run:", err.String())
                                 os.Exit(1)
                         }
                         if !matched {
                                 continue
                         }
                         testName := tests[i].Name
                         if procs != 1 {
                                 testName = fmt.Sprintf("%s-%d", tests[i].Name, procs)
                         }
-                        t := &T{ch: make(chan *T), pch: pch, name: testName, wch: wch}

[rog, 2011/09/21 20:22:53]

t := &T{ch: ch, name: testName, wch: wch}

-                        go tRunner(t, &tests[i], report)
+                        t := &T{ch: ch, name: testName, startParallel: startParallel}
+                        if *chatty {
+                                println("=== RUN", t.name)
+                        }
+                        go tRunner(t, &tests[i])
                         out := <-t.ch
                         if out == nil { // Parallel run.
                                 numParallel++
                                 continue
                         }
+                        report(t)
                         ok = ok && !out.failed
                 }
 
-                close(wch) // Release parallel tests
-                for i := 0; i < numParallel; i++ {
-                        out := <-pch

[rog, 2011/09/21 20:22:53]

s/pch/ch/

-                        ok = ok && !out.failed
+                running := 0
+                for numParallel+running > 0 {
+                        if running < *parallel && numParallel > 0 {
+                                startParallel <- true
+                                running++
+                                numParallel--
+                                continue
+                        }
+                        t := <-ch
+                        report(t)
+                        ok = ok && !t.failed
+                        running--
                 }
         }
 
         if !ok {
                 println("FAIL")
                 os.Exit(1)
         }
         println("PASS")
 }
 
@@ skipping 64 matching lines @@
                 for _, val := range strings.Split(*cpuListStr, ",") {
                         cpu, err := strconv.Atoi(val)
                         if err != nil || cpu <= 0 {
                                 println("invalid value for -test.cpu")
                                 os.Exit(1)
                         }
                         cpuList = append(cpuList, cpu)
                 }
         }
 }