qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-05 11:56:12 -07:00
Code Releases Activity

cmd/compile: parallelize another big chunk of rulegen

Browse Source 
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>
This commit is contained in:
Daniel Martí 2019-09-13 14:42:05 +01:00
parent 4d18a7ceb2
commit 357e8f83f8
1 changed files with 19 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/cmd/compile/internal/ssa/gen/main.go
View File

@ -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.