cmd/compile: reuse sort helpers

sort.Sort's argument always escapes.
cse generates many calls to sort.Sort.
Set up a single escaping variable
and re-use it across loops.

name       old alloc/op     new alloc/op     delta
Template       40.7MB ± 0%      40.2MB ± 0%  -1.24%        (p=0.000 n=15+15)
Unicode        33.4MB ± 0%      33.3MB ± 0%  -0.09%        (p=0.000 n=15+15)
GoTypes         121MB ± 0%       119MB ± 0%  -1.48%        (p=0.000 n=14+15)
Compiler        474MB ± 0%       465MB ± 0%  -1.94%        (p=0.000 n=14+15)

name       old allocs/op    new allocs/op    delta
Template         405k ± 0%        394k ± 0%  -2.64%        (p=0.000 n=15+15)
Unicode          350k ± 0%        350k ± 0%  -0.14%        (p=0.000 n=14+15)
GoTypes         1.21M ± 0%       1.18M ± 0%  -3.07%        (p=0.000 n=15+14)
Compiler        4.37M ± 0%       4.18M ± 0%  -4.39%        (p=0.000 n=15+15)

Change-Id: I68cf56dafa0f3ea778826eea19908bd761556154
Reviewed-on: https://go-review.googlesource.com/32220
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/src/cmd/compile/internal/ssa/cse.go b/src/cmd/compile/internal/ssa/cse.go
index 24f071bcfd0ff3822672af05d7b729bb2944a8b8..94104333259ec04c25d3e262a506c740beadaf87 100644 (file)
--- a/src/cmd/compile/internal/ssa/cse.go
+++ b/src/cmd/compile/internal/ssa/cse.go
@@ -83,6 +83,7 @@ func cse(f *Func) {
        // non-equivalent arguments.  Repeat until we can't find any
        // more splits.
        var splitPoints []int
+       byArgClass := new(partitionByArgClass) // reuseable partitionByArgClass to reduce allocations
        for {
                changed := false
 
@@ -92,7 +93,9 @@ func cse(f *Func) {
                        e := partition[i]
 
                        // Sort by eq class of arguments.
-                       sort.Sort(partitionByArgClass{e, valueEqClass})
+                       byArgClass.a = e
+                       byArgClass.eqClass = valueEqClass
+                       sort.Sort(byArgClass)
 
                        // Find split points.
                        splitPoints = append(splitPoints[:0], 0)
@@ -147,8 +150,11 @@ func cse(f *Func) {
        // Compute substitutions we would like to do. We substitute v for w
        // if v and w are in the same equivalence class and v dominates w.
        rewrite := make([]*Value, f.NumValues())
+       byDom := new(partitionByDom) // reusable partitionByDom to reduce allocs
        for _, e := range partition {
-               sort.Sort(partitionByDom{e, sdom})
+               byDom.a = e
+               byDom.sdom = sdom
+               sort.Sort(byDom)
                for i := 0; i < len(e)-1; i++ {
                        // e is sorted by domorder, so a maximal dominant element is first in the slice
                        v := e[i]