qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-18 08:14:41 -07:00
Code Releases Activity

cmd/compile: slightly regularize interface method types

Browse Source 
Use a single *struct{} type instance rather than reconstructing one
for every declared/imported interface method. Minor allocations win:

name       old alloc/op    new alloc/op    delta
Template      41.8MB ± 0%     41.7MB ± 0%  -0.10%         (p=0.000 n=9+10)
Unicode       34.2MB ± 0%     34.2MB ± 0%    ~           (p=0.971 n=10+10)
GoTypes        123MB ± 0%      122MB ± 0%  -0.03%         (p=0.000 n=9+10)
Compiler       495MB ± 0%      495MB ± 0%  -0.01%        (p=0.000 n=10+10)

name       old allocs/op   new allocs/op   delta
Template        409k ± 0%       408k ± 0%  -0.13%        (p=0.000 n=10+10)
Unicode         354k ± 0%       354k ± 0%    ~           (p=0.516 n=10+10)
GoTypes        1.22M ± 0%      1.22M ± 0%  -0.03%        (p=0.009 n=10+10)
Compiler       4.43M ± 0%      4.43M ± 0%  -0.02%        (p=0.000 n=10+10)

Change-Id: Id3a4ca3dd09112bb96ccc982b06c9e79f661d31f
Reviewed-on: https://go-review.googlesource.com/32051
Reviewed-by: Robert Griesemer <gri@golang.org>
This commit is contained in:
Matthew Dempsky 2016-10-25 16:25:57 -07:00
parent c78d072c8e
commit d89b70d433
2 changed files with 16 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/cmd/compile/internal/gc/dcl.go
View File

@ -988,34 +988,30 @@ func embedded(s *Sym, pkg *Pkg) *Node {
return n
}
// thisT is the singleton type used for interface method receivers.
var thisT *Type
func fakethis() *Node {
n := nod(ODCLFIELD, nil, typenod(ptrto(typ(TSTRUCT))))
return n
if thisT == nil {
thisT = ptrto(typ(TSTRUCT))
}
return nod(ODCLFIELD, nil, typenod(thisT))
}
func fakethisfield() *Field {
if thisT == nil {
thisT = ptrto(typ(TSTRUCT))
}
f := newField()
f.Type = ptrto(typ(TSTRUCT))
f.Type = thisT
return f
}
// Is this field a method on an interface?
// Those methods have an anonymous *struct{} as the receiver.
// Those methods have thisT as the receiver.
// (See fakethis above.)
func isifacemethod(f *Type) bool {
rcvr := f.Recv()
if rcvr.Sym != nil {
return false
}
t := rcvr.Type
if !t.IsPtr() {
return false
}
t = t.Elem()
if t.Sym != nil || !t.IsStruct() || t.NumFields() != 0 {
return false
}
return true
return f.Recv().Type == thisT
}
// turn a parsed function declaration into a type

22
src/cmd/compile/internal/gc/universe.go
View File

@ -374,32 +374,16 @@ func typeinit() {
}
func makeErrorInterface() *Type {
rcvr := typ(TSTRUCT)
rcvr.StructType().Funarg = FunargRcvr
field := newField()
field.Type = ptrto(typ(TSTRUCT))
rcvr.SetFields([]*Field{field})
in := typ(TSTRUCT)
in.StructType().Funarg = FunargParams
out := typ(TSTRUCT)
out.StructType().Funarg = FunargResults
field = newField()
field.Type = Types[TSTRING]
out.SetFields([]*Field{field})
f := functypefield(fakethisfield(), nil, []*Field{field})
f := typ(TFUNC)
f.FuncType().Receiver = rcvr
f.FuncType().Results = out
f.FuncType().Params = in
t := typ(TINTER)
field = newField()
field.Sym = lookup("Error")
field.Type = f
t.SetFields([]*Field{field})
t := typ(TINTER)
t.SetFields([]*Field{field})
return t
}