mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-01-08 09:38:16 +00:00
3e42b667d2
Avoid using protobuf reflection on map values in the fast path. Range
operations in particular are expensive in protoreflect, because the
closure passed to Map.Range escapes.
Iterate maps using a reflect.MapIter when available.
When operating on maps of messages where we have a *MessageInfo for the
message type, directly jump to the fast-path *MessageInfo methods rather
than passing through the proto package.
Benchmarks deltas for a google.protobuf.Struct with JSON represention:
{"parameters":{"a":{"b":{"c":{"d":{"e":{"f":{"g":{}}}}}}}}}
Compared to previous revision:
name old time/op new time/op delta
NestedStruct/Size 7.22µs ± 2% 4.84µs ± 2% -32.96% (p=0.000 n=8+8)
NestedStruct/Size-8 9.30µs ± 2% 5.89µs ± 2% -36.60% (p=0.000 n=8+8)
NestedStruct/Marshal 77.6µs ±12% 9.8µs ± 4% -87.33% (p=0.000 n=8+8)
NestedStruct/Marshal-8 91.6µs ± 2% 11.9µs ± 2% -86.99% (p=0.000 n=8+8)
NestedStruct/Unmarshal 11.5µs ± 4% 8.7µs ± 2% -24.76% (p=0.000 n=8+8)
NestedStruct/Unmarshal-8 15.4µs ± 4% 11.9µs ± 2% -22.41% (p=0.000 n=8+8)
Compared to github.com/golang/protobuf:
name old time/op new time/op delta
NestedStruct/Size 5.42µs ± 1% 4.84µs ± 2% -10.61% (p=0.000 n=8+8)
NestedStruct/Size-8 6.34µs ± 2% 5.89µs ± 2% -7.10% (p=0.000 n=8+8)
NestedStruct/Marshal 12.5µs ± 2% 9.8µs ± 4% -21.41% (p=0.000 n=7+8)
NestedStruct/Marshal-8 14.1µs ± 3% 11.9µs ± 2% -15.52% (p=0.000 n=8+8)
NestedStruct/Unmarshal 9.66µs ± 1% 8.65µs ± 2% -10.40% (p=0.000 n=7+8)
NestedStruct/Unmarshal-8 11.7µs ± 3% 11.9µs ± 2% +1.95% (p=0.038 n=8+8)
Change-Id: I0effe6491f30d41f31904777f74eca3ac3694db3
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/211737
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
111 lines
2.6 KiB
Go
111 lines
2.6 KiB
Go
// Copyright 2018 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 impl
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
)
|
|
|
|
type mapConverter struct {
|
|
goType reflect.Type
|
|
keyConv, valConv Converter
|
|
}
|
|
|
|
func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
|
|
if t.Kind() != reflect.Map {
|
|
panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
|
|
}
|
|
return &mapConverter{
|
|
goType: t,
|
|
keyConv: newSingularConverter(t.Key(), fd.MapKey()),
|
|
valConv: newSingularConverter(t.Elem(), fd.MapValue()),
|
|
}
|
|
}
|
|
|
|
func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value {
|
|
if v.Type() != c.goType {
|
|
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
|
|
}
|
|
return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
|
|
}
|
|
|
|
func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
|
|
return v.Map().(*mapReflect).v
|
|
}
|
|
|
|
func (c *mapConverter) IsValidPB(v pref.Value) bool {
|
|
mapv, ok := v.Interface().(*mapReflect)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return mapv.v.Type() == c.goType && mapv.IsValid()
|
|
}
|
|
|
|
func (c *mapConverter) IsValidGo(v reflect.Value) bool {
|
|
return v.Type() == c.goType
|
|
}
|
|
|
|
func (c *mapConverter) New() pref.Value {
|
|
return c.PBValueOf(reflect.MakeMap(c.goType))
|
|
}
|
|
|
|
func (c *mapConverter) Zero() pref.Value {
|
|
return c.PBValueOf(reflect.Zero(c.goType))
|
|
}
|
|
|
|
type mapReflect struct {
|
|
v reflect.Value // map[K]V
|
|
keyConv Converter
|
|
valConv Converter
|
|
}
|
|
|
|
func (ms *mapReflect) Len() int {
|
|
return ms.v.Len()
|
|
}
|
|
func (ms *mapReflect) Has(k pref.MapKey) bool {
|
|
rk := ms.keyConv.GoValueOf(k.Value())
|
|
rv := ms.v.MapIndex(rk)
|
|
return rv.IsValid()
|
|
}
|
|
func (ms *mapReflect) Get(k pref.MapKey) pref.Value {
|
|
rk := ms.keyConv.GoValueOf(k.Value())
|
|
rv := ms.v.MapIndex(rk)
|
|
if !rv.IsValid() {
|
|
return pref.Value{}
|
|
}
|
|
return ms.valConv.PBValueOf(rv)
|
|
}
|
|
func (ms *mapReflect) Set(k pref.MapKey, v pref.Value) {
|
|
rk := ms.keyConv.GoValueOf(k.Value())
|
|
rv := ms.valConv.GoValueOf(v)
|
|
ms.v.SetMapIndex(rk, rv)
|
|
}
|
|
func (ms *mapReflect) Clear(k pref.MapKey) {
|
|
rk := ms.keyConv.GoValueOf(k.Value())
|
|
ms.v.SetMapIndex(rk, reflect.Value{})
|
|
}
|
|
func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
|
|
iter := mapRange(ms.v)
|
|
for iter.Next() {
|
|
k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
|
|
v := ms.valConv.PBValueOf(iter.Value())
|
|
if !f(k, v) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
func (ms *mapReflect) NewValue() pref.Value {
|
|
return ms.valConv.New()
|
|
}
|
|
func (ms *mapReflect) IsValid() bool {
|
|
return !ms.v.IsNil()
|
|
}
|
|
func (ms *mapReflect) protoUnwrap() interface{} {
|
|
return ms.v.Interface()
|
|
}
|