mirror
/
go
mirror of https://github.com/golang/go.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

reflect: avoid calling common if type is known to be *rtype 

If the type of Type is known to be *rtype than the common
function is a no-op and does not need to be called.

name  old time/op  new time/op  delta
New   31.0ns ± 5%  30.2ns ± 4%  -2.74%  (p=0.008 n=20+20)

Change-Id: I5d00346dbc782e34c530166d1ee0499b24068b51
Reviewed-on: https://go-review.googlesource.com/96115
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
This commit is contained in:
Martin Möhrmann 2018-02-21 22:27:12 +01:00
parent f4c3072cf5
commit 1dbe4c50f2
1 changed files with 14 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/reflect/value.go
View File

@ -2102,7 +2102,7 @@ func MakeSlice(typ Type, len, cap int) Value {
}
s := sliceHeader{unsafe_NewArray(typ.Elem().(*rtype), cap), len, cap}
return Value{typ.common(), unsafe.Pointer(&s), flagIndir | flag(Slice)}
return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
}
// MakeChan creates a new channel with the specified type and buffer size.
@ -2116,8 +2116,9 @@ func MakeChan(typ Type, buffer int) Value {
if typ.ChanDir() != BothDir {
panic("reflect.MakeChan: unidirectional channel type")
}
ch := makechan(typ.(*rtype), buffer)
return Value{typ.common(), ch, flag(Chan)}
t := typ.(*rtype)
ch := makechan(t, buffer)
return Value{t, ch, flag(Chan)}
}
// MakeMap creates a new map with the specified type.
@ -2131,8 +2132,9 @@ func MakeMapWithSize(typ Type, n int) Value {
if typ.Kind() != Map {
panic("reflect.MakeMapWithSize of non-map type")
}
m := makemap(typ.(*rtype), n)
return Value{typ.common(), m, flag(Map)}
t := typ.(*rtype)
m := makemap(t, n)
return Value{t, m, flag(Map)}
}
// Indirect returns the value that v points to.
@ -2170,10 +2172,10 @@ func Zero(typ Type) Value {
if typ == nil {
panic("reflect: Zero(nil)")
}
t := typ.common()
t := typ.(*rtype)
fl := flag(t.Kind())
if ifaceIndir(t) {
return Value{t, unsafe_New(typ.(*rtype)), fl | flagIndir}
return Value{t, unsafe_New(t), fl | flagIndir}
}
return Value{t, nil, fl}
}
@ -2184,16 +2186,18 @@ func New(typ Type) Value {
if typ == nil {
panic("reflect: New(nil)")
}
ptr := unsafe_New(typ.(*rtype))
t := typ.(*rtype)
ptr := unsafe_New(t)
fl := flag(Ptr)
return Value{typ.common().ptrTo(), ptr, fl}
return Value{t.ptrTo(), ptr, fl}
}
// NewAt returns a Value representing a pointer to a value of the
// specified type, using p as that pointer.
func NewAt(typ Type, p unsafe.Pointer) Value {
fl := flag(Ptr)
return Value{typ.common().ptrTo(), p, fl}
t := typ.(*rtype)
return Value{t.ptrTo(), p, fl}
}
// assignTo returns a value v that can be assigned directly to typ.