cmd/compile: parallelize another big chunk of rulegen

rulegen has a sanity check that ensures all the arch-specific opcodes
are handled by each of the gen files.

This is an expensive chunk of work, particularly since there are a lot
of opcodes in total, and each one of them compiles and runs a regular
expression.

Parallelize that for each architecture, which greatly speeds up 'go run
*.go' on my laptop with four real CPU cores.

	name     old time/op         new time/op         delta
	Rulegen          3.39s ± 1%          2.53s ± 2%  -25.34%  (p=0.008 n=5+5)

	name     old user-time/op    new user-time/op    delta
	Rulegen          10.6s ± 1%          11.2s ± 1%   +6.09%  (p=0.008 n=5+5)

	name     old sys-time/op     new sys-time/op     delta
	Rulegen          201ms ± 7%          218ms ±17%     ~     (p=0.548 n=5+5)

	name     old peak-RSS-bytes  new peak-RSS-bytes  delta
	Rulegen          182MB ± 3%          184MB ± 3%     ~     (p=0.690 n=5+5)

Change-Id: Iec538ed0fa7eb867eeeeaab3da1e2615ce32cbb9
Reviewed-on: https://go-review.googlesource.com/c/go/+/195218
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go
index ba17148fc9defccb373fd294ee1a1313d85f8e05..783ac1bd30523f9d4000775ad09aaf623d21cd69 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/main.go
+++ b/src/cmd/compile/internal/ssa/gen/main.go
@@ -392,27 +392,34 @@ func genOp() {
 
        // Check that the arch genfile handles all the arch-specific opcodes.
        // This is very much a hack, but it is better than nothing.
+       var wg sync.WaitGroup
        for _, a := range archs {
                if a.genfile == "" {
                        continue
                }
 
-               src, err := ioutil.ReadFile(a.genfile)
-               if err != nil {
-                       log.Fatalf("can't read %s: %v", a.genfile, err)
-               }
-
-               for _, v := range a.ops {
-                       pattern := fmt.Sprintf("\\Wssa[.]Op%s%s\\W", a.name, v.name)
-                       match, err := regexp.Match(pattern, src)
+               a := a
+               wg.Add(1)
+               go func() {
+                       src, err := ioutil.ReadFile(a.genfile)
                        if err != nil {
-                               log.Fatalf("bad opcode regexp %s: %v", pattern, err)
+                               log.Fatalf("can't read %s: %v", a.genfile, err)
                        }
-                       if !match {
-                               log.Fatalf("Op%s%s has no code generation in %s", a.name, v.name, a.genfile)
+
+                       for _, v := range a.ops {
+                               pattern := fmt.Sprintf(`\Wssa\.Op%s%s\W`, a.name, v.name)
+                               match, err := regexp.Match(pattern, src)
+                               if err != nil {
+                                       log.Fatalf("bad opcode regexp %s: %v", pattern, err)
+                               }
+                               if !match {
+                                       log.Fatalf("Op%s%s has no code generation in %s", a.name, v.name, a.genfile)
+                               }
                        }
-               }
+                       wg.Done()
+               }()
        }
+       wg.Wait()
 }
 
 // Name returns the name of the architecture for use in Op* and Block* enumerations.