Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity
go/src/cmd/compile/internal/gc/pgen_test.go

208 lines
4.8 KiB
Go
Raw Normal View History

cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
// Copyright 2015 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 gc
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
import (
cmd/compile: factor out Pkg, Sym, and Type into package types - created new package cmd/compile/internal/types - moved Pkg, Sym, Type to new package - to break cycles, for now we need the (ugly) types/utils.go file which contains a handful of functions that must be installed early by the gc frontend - to break cycles, for now we need two functions to convert between *gc.Node and *types.Node (the latter is a dummy type) - adjusted the gc's code to use the new package and the conversion functions as needed - made several Pkg, Sym, and Type methods functions as needed - renamed constructors typ, typPtr, typArray, etc. to types.New, types.NewPtr, types.NewArray, etc. Passes toolstash-check -all. Change-Id: I8adfa5e85c731645d0a7fd2030375ed6ebf54b72 Reviewed-on: https://go-review.googlesource.com/39855 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-04 17:54:02 -07:00
"cmd/compile/internal/types"
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
"reflect"
cmd/compile: remove listsort The listsort function is no longer used, except in a test. Change the test to use sort.Sort instead. Change-Id: Ib634705cc1bc3b1d8fc3795bd4ed2894e6abc284 Reviewed-on: https://go-review.googlesource.com/19964 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-02-26 13:03:11 -08:00
"sort"
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
"testing"
)
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
cmd/compile: factor out Pkg, Sym, and Type into package types - created new package cmd/compile/internal/types - moved Pkg, Sym, Type to new package - to break cycles, for now we need the (ugly) types/utils.go file which contains a handful of functions that must be installed early by the gc frontend - to break cycles, for now we need two functions to convert between *gc.Node and *types.Node (the latter is a dummy type) - adjusted the gc's code to use the new package and the conversion functions as needed - made several Pkg, Sym, and Type methods functions as needed - renamed constructors typ, typPtr, typArray, etc. to types.New, types.NewPtr, types.NewArray, etc. Passes toolstash-check -all. Change-Id: I8adfa5e85c731645d0a7fd2030375ed6ebf54b72 Reviewed-on: https://go-review.googlesource.com/39855 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-04 17:54:02 -07:00
func typeWithoutPointers() *types.Type {
t := types.New(TSTRUCT)
f := &types.Field{Type: types.New(TINT)}
t.SetFields([]*types.Field{f})
cmd/compile: remove Type haspointers caches Even very large Types are not very big. The haspointer cache looks like premature optimization. Removing them has no detectable compiler performance impact, and it removes mutable shared state used by the backend. Updates #15756 Change-Id: I2d2cf03f470f5eef5bcd50ff693ef6a01d481700 Reviewed-on: https://go-review.googlesource.com/38912 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-03-29 21:04:00 -07:00
return t
cmd/compile: shrink gc.Type in half Many of Type's fields are etype-specific. This CL organizes them into their own auxiliary types, duplicating a few fields as necessary, and adds an Extra field to hold them. It also sorts the remaining fields for better struct packing. It also improves documentation for most fields. This reduces the size of Type at the cost of some extra allocations. There's no CPU impact; memory impact below. It also makes the natural structure of Type clearer. Passes toolstash -cmp on all architectures. Ideas for future work in this vein: (1) Width and Align probably only need to be stored for Struct and Array types. The refactoring to accomplish this would hopefully also eliminate TFUNCARGS and TCHANARGS entirely. (2) Maplineno is sparsely used and could probably better be stored in a separate map[*Type]int32, with mapqueue updated to store both a Node and a line number. (3) The Printed field may be removable once the old (non-binary) importer/exported has been removed. (4) StructType's fields field could be changed from *[]*Field to []*Field, which would remove a common allocation. (5) I believe that Type.Nod can be moved to ForwardType. Separate CL. name old alloc/op new alloc/op delta Template 57.9MB ± 0% 55.9MB ± 0% -3.43% (p=0.000 n=50+50) Unicode 38.3MB ± 0% 37.8MB ± 0% -1.39% (p=0.000 n=50+50) GoTypes 185MB ± 0% 180MB ± 0% -2.56% (p=0.000 n=50+50) Compiler 824MB ± 0% 806MB ± 0% -2.19% (p=0.000 n=50+50) name old allocs/op new allocs/op delta Template 486k ± 0% 497k ± 0% +2.25% (p=0.000 n=50+50) Unicode 377k ± 0% 379k ± 0% +0.55% (p=0.000 n=50+50) GoTypes 1.39M ± 0% 1.42M ± 0% +1.63% (p=0.000 n=50+50) Compiler 5.52M ± 0% 5.57M ± 0% +0.84% (p=0.000 n=47+50) Change-Id: I828488eeb74902b013d5ae4cf844de0b6c0dfc87 Reviewed-on: https://go-review.googlesource.com/21611 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-04-01 20:11:30 -07:00
}
cmd/compile: factor out Pkg, Sym, and Type into package types - created new package cmd/compile/internal/types - moved Pkg, Sym, Type to new package - to break cycles, for now we need the (ugly) types/utils.go file which contains a handful of functions that must be installed early by the gc frontend - to break cycles, for now we need two functions to convert between *gc.Node and *types.Node (the latter is a dummy type) - adjusted the gc's code to use the new package and the conversion functions as needed - made several Pkg, Sym, and Type methods functions as needed - renamed constructors typ, typPtr, typArray, etc. to types.New, types.NewPtr, types.NewArray, etc. Passes toolstash-check -all. Change-Id: I8adfa5e85c731645d0a7fd2030375ed6ebf54b72 Reviewed-on: https://go-review.googlesource.com/39855 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-04 17:54:02 -07:00
func typeWithPointers() *types.Type {
t := types.New(TSTRUCT)
cmd/compile: don't allow go:notinheap on the heap or stack Right now we just prevent such types from being on the heap. This CL makes it so they cannot appear on the stack either. The distinction between heap and stack is pretty vague at the language level (e.g. it is affected by -N), and we don't need the flexibility anyway. Once go:notinheap types cannot be in either place, we don't need to consider pointers to such types to be pointers, at least according to the garbage collector and stack copying. (This is the big win of this CL, in my opinion.) The distinction between HasPointers and HasHeapPointer no longer exists. There is only HasPointers. This CL is cleanup before possible use of go:notinheap to fix #40954. Update #13386 Change-Id: Ibd895aadf001c0385078a6d4809c3f374991231a Reviewed-on: https://go-review.googlesource.com/c/go/+/249917 Run-TryBot: Keith Randall <khr@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
2020-08-21 20:20:12 -07:00
f := &types.Field{Type: types.NewPtr(types.New(TINT))}
cmd/compile: factor out Pkg, Sym, and Type into package types - created new package cmd/compile/internal/types - moved Pkg, Sym, Type to new package - to break cycles, for now we need the (ugly) types/utils.go file which contains a handful of functions that must be installed early by the gc frontend - to break cycles, for now we need two functions to convert between *gc.Node and *types.Node (the latter is a dummy type) - adjusted the gc's code to use the new package and the conversion functions as needed - made several Pkg, Sym, and Type methods functions as needed - renamed constructors typ, typPtr, typArray, etc. to types.New, types.NewPtr, types.NewArray, etc. Passes toolstash-check -all. Change-Id: I8adfa5e85c731645d0a7fd2030375ed6ebf54b72 Reviewed-on: https://go-review.googlesource.com/39855 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-04 17:54:02 -07:00
t.SetFields([]*types.Field{f})
cmd/compile: remove Type haspointers caches Even very large Types are not very big. The haspointer cache looks like premature optimization. Removing them has no detectable compiler performance impact, and it removes mutable shared state used by the backend. Updates #15756 Change-Id: I2d2cf03f470f5eef5bcd50ff693ef6a01d481700 Reviewed-on: https://go-review.googlesource.com/38912 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-03-29 21:04:00 -07:00
return t
cmd/compile: shrink gc.Type in half Many of Type's fields are etype-specific. This CL organizes them into their own auxiliary types, duplicating a few fields as necessary, and adds an Extra field to hold them. It also sorts the remaining fields for better struct packing. It also improves documentation for most fields. This reduces the size of Type at the cost of some extra allocations. There's no CPU impact; memory impact below. It also makes the natural structure of Type clearer. Passes toolstash -cmp on all architectures. Ideas for future work in this vein: (1) Width and Align probably only need to be stored for Struct and Array types. The refactoring to accomplish this would hopefully also eliminate TFUNCARGS and TCHANARGS entirely. (2) Maplineno is sparsely used and could probably better be stored in a separate map[*Type]int32, with mapqueue updated to store both a Node and a line number. (3) The Printed field may be removable once the old (non-binary) importer/exported has been removed. (4) StructType's fields field could be changed from *[]*Field to []*Field, which would remove a common allocation. (5) I believe that Type.Nod can be moved to ForwardType. Separate CL. name old alloc/op new alloc/op delta Template 57.9MB ± 0% 55.9MB ± 0% -3.43% (p=0.000 n=50+50) Unicode 38.3MB ± 0% 37.8MB ± 0% -1.39% (p=0.000 n=50+50) GoTypes 185MB ± 0% 180MB ± 0% -2.56% (p=0.000 n=50+50) Compiler 824MB ± 0% 806MB ± 0% -2.19% (p=0.000 n=50+50) name old allocs/op new allocs/op delta Template 486k ± 0% 497k ± 0% +2.25% (p=0.000 n=50+50) Unicode 377k ± 0% 379k ± 0% +0.55% (p=0.000 n=50+50) GoTypes 1.39M ± 0% 1.42M ± 0% +1.63% (p=0.000 n=50+50) Compiler 5.52M ± 0% 5.57M ± 0% +0.84% (p=0.000 n=47+50) Change-Id: I828488eeb74902b013d5ae4cf844de0b6c0dfc87 Reviewed-on: https://go-review.googlesource.com/21611 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-04-01 20:11:30 -07:00
}
cmd/compile: move Used from gc.Node to gc.Name Node.Used was written to from the backend concurrently with reads of Node.Class for the same ONAME Nodes. I do not know why it was not failing consistently under the race detector, but it is a race. This is likely also a problem with Node.HasVal and Node.HasOpt. They will be handled in a separate CL. Fix Used by moving it to gc.Name and making it a separate bool. There was one non-Name use of Used, marking OLABELs as used. That is no longer needed, now that goto and label checking happens early in the front end. Leave the getters and setters in place, to ease changing the representation in the future (or changing to an interface!). Updates #20144 Change-Id: I9bec7c6d33dcb129a4cfa9d338462ea33087f9f7 Reviewed-on: https://go-review.googlesource.com/42015 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2017-04-27 15:17:57 -07:00
func markUsed(n *Node) *Node {
n.Name.SetUsed(true)
return n
}
func markNeedZero(n *Node) *Node {
n.Name.SetNeedzero(true)
return n
}
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
// Test all code paths for cmpstackvarlt.
func TestCmpstackvar(t *testing.T) {
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod := func(xoffset int64, t *types.Type, s *types.Sym, cl Class) *Node {
if s == nil {
s = &types.Sym{Name: "."}
}
n := newname(s)
n.Type = t
n.Xoffset = xoffset
n.SetClass(cl)
return n
}
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
testdata := []struct {
cmd/compile: move Node.Class to flags Put it at position zero, since it is fairly hot. This shrinks gc.Node into a smaller size class on 64 bit systems. name old time/op new time/op delta Template 193ms ± 5% 192ms ± 3% ~ (p=0.353 n=94+93) Unicode 86.1ms ± 5% 85.0ms ± 4% -1.23% (p=0.000 n=95+98) GoTypes 546ms ± 3% 544ms ± 4% -0.40% (p=0.007 n=94+97) Compiler 2.56s ± 3% 2.54s ± 3% -0.67% (p=0.000 n=99+97) SSA 5.13s ± 2% 5.10s ± 3% -0.55% (p=0.000 n=94+98) Flate 122ms ± 6% 121ms ± 4% -0.75% (p=0.002 n=97+95) GoParser 144ms ± 5% 144ms ± 4% ~ (p=0.298 n=98+97) Reflect 348ms ± 4% 349ms ± 4% ~ (p=0.350 n=98+97) Tar 105ms ± 5% 104ms ± 5% ~ (p=0.154 n=96+98) XML 200ms ± 5% 198ms ± 4% -0.71% (p=0.015 n=97+98) [Geo mean] 330ms 328ms -0.52% name old user-time/op new user-time/op delta Template 229ms ±11% 224ms ± 7% -2.16% (p=0.001 n=100+87) Unicode 109ms ± 5% 109ms ± 6% ~ (p=0.897 n=96+91) GoTypes 712ms ± 4% 709ms ± 4% ~ (p=0.085 n=96+98) Compiler 3.41s ± 3% 3.36s ± 3% -1.43% (p=0.000 n=98+98) SSA 7.46s ± 3% 7.31s ± 3% -2.02% (p=0.000 n=100+99) Flate 145ms ± 6% 143ms ± 6% -1.11% (p=0.001 n=99+97) GoParser 177ms ± 5% 176ms ± 5% -0.78% (p=0.018 n=95+95) Reflect 432ms ± 7% 435ms ± 9% ~ (p=0.296 n=100+100) Tar 121ms ± 7% 121ms ± 5% ~ (p=0.072 n=100+95) XML 241ms ± 4% 239ms ± 5% ~ (p=0.085 n=97+99) [Geo mean] 413ms 410ms -0.73% name old alloc/op new alloc/op delta Template 38.4MB ± 0% 37.7MB ± 0% -1.85% (p=0.008 n=5+5) Unicode 30.1MB ± 0% 28.8MB ± 0% -4.09% (p=0.008 n=5+5) GoTypes 112MB ± 0% 110MB ± 0% -1.69% (p=0.008 n=5+5) Compiler 470MB ± 0% 461MB ± 0% -1.91% (p=0.008 n=5+5) SSA 1.13GB ± 0% 1.11GB ± 0% -1.70% (p=0.008 n=5+5) Flate 25.0MB ± 0% 24.6MB ± 0% -1.67% (p=0.008 n=5+5) GoParser 31.6MB ± 0% 31.1MB ± 0% -1.66% (p=0.008 n=5+5) Reflect 77.1MB ± 0% 75.8MB ± 0% -1.69% (p=0.008 n=5+5) Tar 26.3MB ± 0% 25.7MB ± 0% -2.06% (p=0.008 n=5+5) XML 41.9MB ± 0% 41.1MB ± 0% -1.93% (p=0.008 n=5+5) [Geo mean] 73.5MB 72.0MB -2.03% name old allocs/op new allocs/op delta Template 383k ± 0% 383k ± 0% ~ (p=0.690 n=5+5) Unicode 343k ± 0% 343k ± 0% ~ (p=0.841 n=5+5) GoTypes 1.16M ± 0% 1.16M ± 0% ~ (p=0.310 n=5+5) Compiler 4.43M ± 0% 4.42M ± 0% -0.17% (p=0.008 n=5+5) SSA 9.85M ± 0% 9.85M ± 0% ~ (p=0.310 n=5+5) Flate 236k ± 0% 236k ± 1% ~ (p=0.841 n=5+5) GoParser 320k ± 0% 320k ± 0% ~ (p=0.421 n=5+5) Reflect 988k ± 0% 987k ± 0% ~ (p=0.690 n=5+5) Tar 252k ± 0% 251k ± 0% ~ (p=0.095 n=5+5) XML 399k ± 0% 399k ± 0% ~ (p=1.000 n=5+5) [Geo mean] 741k 740k -0.07% Change-Id: I9e952b58a98e30a12494304db9ce50d0a85e459c Reviewed-on: https://go-review.googlesource.com/41797 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Marvin Stenger <marvin.stenger94@gmail.com>
2017-04-25 18:14:12 -07:00
a, b *Node
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
lt bool
}{
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, nil, nil, PAUTO),
nod(0, nil, nil, PFUNC),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, nil, nil, PFUNC),
nod(0, nil, nil, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, nil, nil, PFUNC),
nod(10, nil, nil, PFUNC),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(20, nil, nil, PFUNC),
nod(10, nil, nil, PFUNC),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(10, nil, nil, PFUNC),
nod(10, nil, nil, PFUNC),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
cmd/compile: make cmpstackvarlt properly asymmetric Previously, given two Nodes n1 and n2 of different non-PAUTO classes (e.g., PPARAM and PPARAMOUT), cmpstackvarlt(n1, n2) and cmpstackvarlt(n2, n1) both returned true, which is nonsense. This doesn't seem to cause any visible miscompilation problems, but notably fixing it does cause toolstash/buildall to fail. Change-Id: I33b2c66e902c5eced875d8fbf18b7cfdc81e8aed Reviewed-on: https://go-review.googlesource.com/19778 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-20 21:36:12 -08:00
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(10, nil, nil, PPARAM),
nod(20, nil, nil, PPARAMOUT),
cmd/compile: make cmpstackvarlt properly asymmetric Previously, given two Nodes n1 and n2 of different non-PAUTO classes (e.g., PPARAM and PPARAMOUT), cmpstackvarlt(n1, n2) and cmpstackvarlt(n2, n1) both returned true, which is nonsense. This doesn't seem to cause any visible miscompilation problems, but notably fixing it does cause toolstash/buildall to fail. Change-Id: I33b2c66e902c5eced875d8fbf18b7cfdc81e8aed Reviewed-on: https://go-review.googlesource.com/19778 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-20 21:36:12 -08:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(10, nil, nil, PPARAMOUT),
nod(20, nil, nil, PPARAM),
cmd/compile: make cmpstackvarlt properly asymmetric Previously, given two Nodes n1 and n2 of different non-PAUTO classes (e.g., PPARAM and PPARAMOUT), cmpstackvarlt(n1, n2) and cmpstackvarlt(n2, n1) both returned true, which is nonsense. This doesn't seem to cause any visible miscompilation problems, but notably fixing it does cause toolstash/buildall to fail. Change-Id: I33b2c66e902c5eced875d8fbf18b7cfdc81e8aed Reviewed-on: https://go-review.googlesource.com/19778 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-20 21:36:12 -08:00
true,
},
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
markUsed(nod(0, nil, nil, PAUTO)),
nod(0, nil, nil, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, nil, nil, PAUTO),
markUsed(nod(0, nil, nil, PAUTO)),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, typeWithoutPointers(), nil, PAUTO),
nod(0, typeWithPointers(), nil, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, typeWithPointers(), nil, PAUTO),
nod(0, typeWithoutPointers(), nil, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
markNeedZero(nod(0, &types.Type{}, nil, PAUTO)),
nod(0, &types.Type{}, nil, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{}, nil, PAUTO),
markNeedZero(nod(0, &types.Type{}, nil, PAUTO)),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{Width: 1}, nil, PAUTO),
nod(0, &types.Type{Width: 2}, nil, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{Width: 2}, nil, PAUTO),
nod(0, &types.Type{Width: 1}, nil, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
true,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
false,
},
}
for _, d := range testdata {
cmd/compile: move Node.Class to flags Put it at position zero, since it is fairly hot. This shrinks gc.Node into a smaller size class on 64 bit systems. name old time/op new time/op delta Template 193ms ± 5% 192ms ± 3% ~ (p=0.353 n=94+93) Unicode 86.1ms ± 5% 85.0ms ± 4% -1.23% (p=0.000 n=95+98) GoTypes 546ms ± 3% 544ms ± 4% -0.40% (p=0.007 n=94+97) Compiler 2.56s ± 3% 2.54s ± 3% -0.67% (p=0.000 n=99+97) SSA 5.13s ± 2% 5.10s ± 3% -0.55% (p=0.000 n=94+98) Flate 122ms ± 6% 121ms ± 4% -0.75% (p=0.002 n=97+95) GoParser 144ms ± 5% 144ms ± 4% ~ (p=0.298 n=98+97) Reflect 348ms ± 4% 349ms ± 4% ~ (p=0.350 n=98+97) Tar 105ms ± 5% 104ms ± 5% ~ (p=0.154 n=96+98) XML 200ms ± 5% 198ms ± 4% -0.71% (p=0.015 n=97+98) [Geo mean] 330ms 328ms -0.52% name old user-time/op new user-time/op delta Template 229ms ±11% 224ms ± 7% -2.16% (p=0.001 n=100+87) Unicode 109ms ± 5% 109ms ± 6% ~ (p=0.897 n=96+91) GoTypes 712ms ± 4% 709ms ± 4% ~ (p=0.085 n=96+98) Compiler 3.41s ± 3% 3.36s ± 3% -1.43% (p=0.000 n=98+98) SSA 7.46s ± 3% 7.31s ± 3% -2.02% (p=0.000 n=100+99) Flate 145ms ± 6% 143ms ± 6% -1.11% (p=0.001 n=99+97) GoParser 177ms ± 5% 176ms ± 5% -0.78% (p=0.018 n=95+95) Reflect 432ms ± 7% 435ms ± 9% ~ (p=0.296 n=100+100) Tar 121ms ± 7% 121ms ± 5% ~ (p=0.072 n=100+95) XML 241ms ± 4% 239ms ± 5% ~ (p=0.085 n=97+99) [Geo mean] 413ms 410ms -0.73% name old alloc/op new alloc/op delta Template 38.4MB ± 0% 37.7MB ± 0% -1.85% (p=0.008 n=5+5) Unicode 30.1MB ± 0% 28.8MB ± 0% -4.09% (p=0.008 n=5+5) GoTypes 112MB ± 0% 110MB ± 0% -1.69% (p=0.008 n=5+5) Compiler 470MB ± 0% 461MB ± 0% -1.91% (p=0.008 n=5+5) SSA 1.13GB ± 0% 1.11GB ± 0% -1.70% (p=0.008 n=5+5) Flate 25.0MB ± 0% 24.6MB ± 0% -1.67% (p=0.008 n=5+5) GoParser 31.6MB ± 0% 31.1MB ± 0% -1.66% (p=0.008 n=5+5) Reflect 77.1MB ± 0% 75.8MB ± 0% -1.69% (p=0.008 n=5+5) Tar 26.3MB ± 0% 25.7MB ± 0% -2.06% (p=0.008 n=5+5) XML 41.9MB ± 0% 41.1MB ± 0% -1.93% (p=0.008 n=5+5) [Geo mean] 73.5MB 72.0MB -2.03% name old allocs/op new allocs/op delta Template 383k ± 0% 383k ± 0% ~ (p=0.690 n=5+5) Unicode 343k ± 0% 343k ± 0% ~ (p=0.841 n=5+5) GoTypes 1.16M ± 0% 1.16M ± 0% ~ (p=0.310 n=5+5) Compiler 4.43M ± 0% 4.42M ± 0% -0.17% (p=0.008 n=5+5) SSA 9.85M ± 0% 9.85M ± 0% ~ (p=0.310 n=5+5) Flate 236k ± 0% 236k ± 1% ~ (p=0.841 n=5+5) GoParser 320k ± 0% 320k ± 0% ~ (p=0.421 n=5+5) Reflect 988k ± 0% 987k ± 0% ~ (p=0.690 n=5+5) Tar 252k ± 0% 251k ± 0% ~ (p=0.095 n=5+5) XML 399k ± 0% 399k ± 0% ~ (p=1.000 n=5+5) [Geo mean] 741k 740k -0.07% Change-Id: I9e952b58a98e30a12494304db9ce50d0a85e459c Reviewed-on: https://go-review.googlesource.com/41797 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Marvin Stenger <marvin.stenger94@gmail.com>
2017-04-25 18:14:12 -07:00
got := cmpstackvarlt(d.a, d.b)
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
if got != d.lt {
t.Errorf("want %#v < %#v", d.a, d.b)
}
cmd/compile: make cmpstackvarlt properly asymmetric Previously, given two Nodes n1 and n2 of different non-PAUTO classes (e.g., PPARAM and PPARAMOUT), cmpstackvarlt(n1, n2) and cmpstackvarlt(n2, n1) both returned true, which is nonsense. This doesn't seem to cause any visible miscompilation problems, but notably fixing it does cause toolstash/buildall to fail. Change-Id: I33b2c66e902c5eced875d8fbf18b7cfdc81e8aed Reviewed-on: https://go-review.googlesource.com/19778 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-20 21:36:12 -08:00
// If we expect a < b to be true, check that b < a is false.
cmd/compile: move Node.Class to flags Put it at position zero, since it is fairly hot. This shrinks gc.Node into a smaller size class on 64 bit systems. name old time/op new time/op delta Template 193ms ± 5% 192ms ± 3% ~ (p=0.353 n=94+93) Unicode 86.1ms ± 5% 85.0ms ± 4% -1.23% (p=0.000 n=95+98) GoTypes 546ms ± 3% 544ms ± 4% -0.40% (p=0.007 n=94+97) Compiler 2.56s ± 3% 2.54s ± 3% -0.67% (p=0.000 n=99+97) SSA 5.13s ± 2% 5.10s ± 3% -0.55% (p=0.000 n=94+98) Flate 122ms ± 6% 121ms ± 4% -0.75% (p=0.002 n=97+95) GoParser 144ms ± 5% 144ms ± 4% ~ (p=0.298 n=98+97) Reflect 348ms ± 4% 349ms ± 4% ~ (p=0.350 n=98+97) Tar 105ms ± 5% 104ms ± 5% ~ (p=0.154 n=96+98) XML 200ms ± 5% 198ms ± 4% -0.71% (p=0.015 n=97+98) [Geo mean] 330ms 328ms -0.52% name old user-time/op new user-time/op delta Template 229ms ±11% 224ms ± 7% -2.16% (p=0.001 n=100+87) Unicode 109ms ± 5% 109ms ± 6% ~ (p=0.897 n=96+91) GoTypes 712ms ± 4% 709ms ± 4% ~ (p=0.085 n=96+98) Compiler 3.41s ± 3% 3.36s ± 3% -1.43% (p=0.000 n=98+98) SSA 7.46s ± 3% 7.31s ± 3% -2.02% (p=0.000 n=100+99) Flate 145ms ± 6% 143ms ± 6% -1.11% (p=0.001 n=99+97) GoParser 177ms ± 5% 176ms ± 5% -0.78% (p=0.018 n=95+95) Reflect 432ms ± 7% 435ms ± 9% ~ (p=0.296 n=100+100) Tar 121ms ± 7% 121ms ± 5% ~ (p=0.072 n=100+95) XML 241ms ± 4% 239ms ± 5% ~ (p=0.085 n=97+99) [Geo mean] 413ms 410ms -0.73% name old alloc/op new alloc/op delta Template 38.4MB ± 0% 37.7MB ± 0% -1.85% (p=0.008 n=5+5) Unicode 30.1MB ± 0% 28.8MB ± 0% -4.09% (p=0.008 n=5+5) GoTypes 112MB ± 0% 110MB ± 0% -1.69% (p=0.008 n=5+5) Compiler 470MB ± 0% 461MB ± 0% -1.91% (p=0.008 n=5+5) SSA 1.13GB ± 0% 1.11GB ± 0% -1.70% (p=0.008 n=5+5) Flate 25.0MB ± 0% 24.6MB ± 0% -1.67% (p=0.008 n=5+5) GoParser 31.6MB ± 0% 31.1MB ± 0% -1.66% (p=0.008 n=5+5) Reflect 77.1MB ± 0% 75.8MB ± 0% -1.69% (p=0.008 n=5+5) Tar 26.3MB ± 0% 25.7MB ± 0% -2.06% (p=0.008 n=5+5) XML 41.9MB ± 0% 41.1MB ± 0% -1.93% (p=0.008 n=5+5) [Geo mean] 73.5MB 72.0MB -2.03% name old allocs/op new allocs/op delta Template 383k ± 0% 383k ± 0% ~ (p=0.690 n=5+5) Unicode 343k ± 0% 343k ± 0% ~ (p=0.841 n=5+5) GoTypes 1.16M ± 0% 1.16M ± 0% ~ (p=0.310 n=5+5) Compiler 4.43M ± 0% 4.42M ± 0% -0.17% (p=0.008 n=5+5) SSA 9.85M ± 0% 9.85M ± 0% ~ (p=0.310 n=5+5) Flate 236k ± 0% 236k ± 1% ~ (p=0.841 n=5+5) GoParser 320k ± 0% 320k ± 0% ~ (p=0.421 n=5+5) Reflect 988k ± 0% 987k ± 0% ~ (p=0.690 n=5+5) Tar 252k ± 0% 251k ± 0% ~ (p=0.095 n=5+5) XML 399k ± 0% 399k ± 0% ~ (p=1.000 n=5+5) [Geo mean] 741k 740k -0.07% Change-Id: I9e952b58a98e30a12494304db9ce50d0a85e459c Reviewed-on: https://go-review.googlesource.com/41797 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Marvin Stenger <marvin.stenger94@gmail.com>
2017-04-25 18:14:12 -07:00
if d.lt && cmpstackvarlt(d.b, d.a) {
cmd/compile: make cmpstackvarlt properly asymmetric Previously, given two Nodes n1 and n2 of different non-PAUTO classes (e.g., PPARAM and PPARAMOUT), cmpstackvarlt(n1, n2) and cmpstackvarlt(n2, n1) both returned true, which is nonsense. This doesn't seem to cause any visible miscompilation problems, but notably fixing it does cause toolstash/buildall to fail. Change-Id: I33b2c66e902c5eced875d8fbf18b7cfdc81e8aed Reviewed-on: https://go-review.googlesource.com/19778 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-20 21:36:12 -08:00
t.Errorf("unexpected %#v < %#v", d.b, d.a)
}
cmd/compile/internal/gc: add unit test for cmpstackvar A followup CL will rewrite listsort to use the new cmpstackvarlt and change cmpstackvar to avoid stringsCompare. Change-Id: Idf0857a3bd67f9e2243ba82aa0bff510612927c3 Reviewed-on: https://go-review.googlesource.com/14611 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-15 21:43:53 +02:00
}
}
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
cmd/compile: remove listsort The listsort function is no longer used, except in a test. Change the test to use sort.Sort instead. Change-Id: Ib634705cc1bc3b1d8fc3795bd4ed2894e6abc284 Reviewed-on: https://go-review.googlesource.com/19964 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-02-26 13:03:11 -08:00
func TestStackvarSort(t *testing.T) {
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod := func(xoffset int64, t *types.Type, s *types.Sym, cl Class) *Node {
n := newname(s)
n.Type = t
n.Xoffset = xoffset
n.SetClass(cl)
return n
}
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
inp := []*Node{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{}, &types.Sym{}, PFUNC),
nod(0, &types.Type{}, &types.Sym{}, PAUTO),
nod(0, &types.Type{}, &types.Sym{}, PFUNC),
nod(10, &types.Type{}, &types.Sym{}, PFUNC),
nod(20, &types.Type{}, &types.Sym{}, PFUNC),
markUsed(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
nod(0, typeWithoutPointers(), &types.Sym{}, PAUTO),
nod(0, &types.Type{}, &types.Sym{}, PAUTO),
markNeedZero(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
nod(0, &types.Type{Width: 1}, &types.Sym{}, PAUTO),
nod(0, &types.Type{Width: 2}, &types.Sym{}, PAUTO),
nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
}
want := []*Node{
[dev.regabi] cmd/compile: clean up tests to know less about Node We want to refactor a bit, and these tests know too much about the layout of Nodes. Use standard constructors instead. Change-Id: I91f0325c89ea60086655414468c53419ebeacea4 Reviewed-on: https://go-review.googlesource.com/c/go/+/272626 Trust: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org>
2020-11-18 15:14:24 -05:00
nod(0, &types.Type{}, &types.Sym{}, PFUNC),
nod(0, &types.Type{}, &types.Sym{}, PFUNC),
nod(10, &types.Type{}, &types.Sym{}, PFUNC),
nod(20, &types.Type{}, &types.Sym{}, PFUNC),
markUsed(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
markNeedZero(nod(0, &types.Type{}, &types.Sym{}, PAUTO)),
nod(0, &types.Type{Width: 2}, &types.Sym{}, PAUTO),
nod(0, &types.Type{Width: 1}, &types.Sym{}, PAUTO),
nod(0, &types.Type{}, &types.Sym{}, PAUTO),
nod(0, &types.Type{}, &types.Sym{}, PAUTO),
nod(0, &types.Type{}, &types.Sym{Name: "abc"}, PAUTO),
nod(0, &types.Type{}, &types.Sym{Name: "xyz"}, PAUTO),
nod(0, typeWithoutPointers(), &types.Sym{}, PAUTO),
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
}
cmd/compile: remove listsort The listsort function is no longer used, except in a test. Change the test to use sort.Sort instead. Change-Id: Ib634705cc1bc3b1d8fc3795bd4ed2894e6abc284 Reviewed-on: https://go-review.googlesource.com/19964 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-02-26 13:03:11 -08:00
sort.Sort(byStackVar(inp))
if !reflect.DeepEqual(want, inp) {
t.Error("sort failed")
for i := range inp {
g := inp[i]
cmd/compile/internal/gc: eliminate stringsCompare for stackvar sorting Passes go build -a -toolexec 'toolstash -cmp' std cmd. Change-Id: I2a87d31da74affdf3d0f358d0efdb3f1c646d917 Reviewed-on: https://go-review.googlesource.com/14759 Reviewed-by: Dave Cheney <dave@cheney.net>
2015-09-19 23:55:27 +02:00
w := want[i]
eq := reflect.DeepEqual(w, g)
if !eq {
t.Log(i, w, g)
}
}
}
}
Reference in a new issue Copy permalink