mirror of
https://github.com/protocolbuffers/protobuf-go.git
synced 2025-03-13 07:14:50 +00:00
9d637ca923
This change performs two optimizations: * It uses a pre-constructed rangeInfos slice to iterate over all the fields. This is more performant since iterating over a slice is faster than iterating over a map. Furthermore, this slice does not contain fields that are part of a oneof. If a oneof has N fields, the time to check presence on the oneof is now O(1) instead of O(N). * It uses a dense field info slice that is optmized for the common case where the field number is relatively low and close in value to the index itself. We also fix a minor bug in the construction of oneofInfo where it wasn't treating a typed nil pointer to a wrapper struct as if it were unset. This ensures WhichOneof and Has always agree. name old time/op new time/op delta Reflect/Has-4 7.81µs ± 3% 6.74µs ± 3% -13.61% (p=0.000 n=9+9) Reflect/Get-4 12.7µs ± 1% 11.3µs ± 4% -10.85% (p=0.000 n=8+10) Reflect/Set-4 19.5µs ± 5% 17.8µs ± 2% -8.99% (p=0.000 n=10+10) Reflect/Clear-4 12.0µs ± 4% 10.2µs ± 3% -14.86% (p=0.000 n=9+10) Reflect/Range-4 6.58µs ± 1% 4.17µs ± 2% -36.65% (p=0.000 n=8+9) Change-Id: I2c48b4d3fb6103ab238924950529ded0d37f8c8a Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/196358 Reviewed-by: Damien Neil <dneil@google.com>
446 lines
11 KiB
Go
446 lines
11 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"
|
|
"math"
|
|
"reflect"
|
|
"sync"
|
|
|
|
"google.golang.org/protobuf/internal/flags"
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
preg "google.golang.org/protobuf/reflect/protoregistry"
|
|
piface "google.golang.org/protobuf/runtime/protoiface"
|
|
)
|
|
|
|
type fieldInfo struct {
|
|
fieldDesc pref.FieldDescriptor
|
|
|
|
// These fields are used for protobuf reflection support.
|
|
has func(pointer) bool
|
|
clear func(pointer)
|
|
get func(pointer) pref.Value
|
|
set func(pointer, pref.Value)
|
|
mutable func(pointer) pref.Value
|
|
newMessage func() pref.Message
|
|
newField func() pref.Value
|
|
}
|
|
|
|
func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
|
|
ft := fs.Type
|
|
if ft.Kind() != reflect.Interface {
|
|
panic(fmt.Sprintf("invalid type: got %v, want interface kind", ft))
|
|
}
|
|
if ot.Kind() != reflect.Struct {
|
|
panic(fmt.Sprintf("invalid type: got %v, want struct kind", ot))
|
|
}
|
|
if !reflect.PtrTo(ot).Implements(ft) {
|
|
panic(fmt.Sprintf("invalid type: %v does not implement %v", ot, ft))
|
|
}
|
|
conv := NewConverter(ot.Field(0).Type, fd)
|
|
isMessage := fd.Message() != nil
|
|
|
|
// TODO: Implement unsafe fast path?
|
|
fieldOffset := offsetOf(fs, x)
|
|
return fieldInfo{
|
|
// NOTE: The logic below intentionally assumes that oneof fields are
|
|
// well-formatted. That is, the oneof interface never contains a
|
|
// typed nil pointer to one of the wrapper structs.
|
|
|
|
fieldDesc: fd,
|
|
has: func(p pointer) bool {
|
|
if p.IsNil() {
|
|
return false
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
|
|
return false
|
|
}
|
|
return true
|
|
},
|
|
clear: func(p pointer) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if rv.IsNil() || rv.Elem().Type().Elem() != ot {
|
|
// NOTE: We intentionally don't check for rv.Elem().IsNil()
|
|
// so that (*OneofWrapperType)(nil) gets cleared to nil.
|
|
return
|
|
}
|
|
rv.Set(reflect.Zero(rv.Type()))
|
|
},
|
|
get: func(p pointer) pref.Value {
|
|
if p.IsNil() {
|
|
return conv.Zero()
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
|
|
return conv.Zero()
|
|
}
|
|
rv = rv.Elem().Elem().Field(0)
|
|
return conv.PBValueOf(rv)
|
|
},
|
|
set: func(p pointer, v pref.Value) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
|
|
rv.Set(reflect.New(ot))
|
|
}
|
|
rv = rv.Elem().Elem().Field(0)
|
|
rv.Set(conv.GoValueOf(v))
|
|
},
|
|
mutable: func(p pointer) pref.Value {
|
|
if !isMessage {
|
|
panic("invalid Mutable on field with non-composite type")
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
|
|
rv.Set(reflect.New(ot))
|
|
}
|
|
rv = rv.Elem().Elem().Field(0)
|
|
if rv.IsNil() {
|
|
rv.Set(conv.GoValueOf(pref.ValueOfMessage(conv.New().Message())))
|
|
}
|
|
return conv.PBValueOf(rv)
|
|
},
|
|
newMessage: func() pref.Message {
|
|
return conv.New().Message()
|
|
},
|
|
newField: func() pref.Value {
|
|
return conv.New()
|
|
},
|
|
}
|
|
}
|
|
|
|
func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
|
|
ft := fs.Type
|
|
if ft.Kind() != reflect.Map {
|
|
panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
|
|
}
|
|
conv := NewConverter(ft, fd)
|
|
|
|
// TODO: Implement unsafe fast path?
|
|
fieldOffset := offsetOf(fs, x)
|
|
return fieldInfo{
|
|
fieldDesc: fd,
|
|
has: func(p pointer) bool {
|
|
if p.IsNil() {
|
|
return false
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
return rv.Len() > 0
|
|
},
|
|
clear: func(p pointer) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
rv.Set(reflect.Zero(rv.Type()))
|
|
},
|
|
get: func(p pointer) pref.Value {
|
|
if p.IsNil() {
|
|
return conv.Zero()
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
return conv.PBValueOf(rv)
|
|
},
|
|
set: func(p pointer, v pref.Value) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
rv.Set(conv.GoValueOf(v))
|
|
},
|
|
mutable: func(p pointer) pref.Value {
|
|
v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if v.IsNil() {
|
|
v.Set(reflect.MakeMap(fs.Type))
|
|
}
|
|
return conv.PBValueOf(v)
|
|
},
|
|
newField: func() pref.Value {
|
|
return conv.New()
|
|
},
|
|
}
|
|
}
|
|
|
|
func fieldInfoForList(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
|
|
ft := fs.Type
|
|
if ft.Kind() != reflect.Slice {
|
|
panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
|
|
}
|
|
conv := NewConverter(reflect.PtrTo(ft), fd)
|
|
|
|
// TODO: Implement unsafe fast path?
|
|
fieldOffset := offsetOf(fs, x)
|
|
return fieldInfo{
|
|
fieldDesc: fd,
|
|
has: func(p pointer) bool {
|
|
if p.IsNil() {
|
|
return false
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
return rv.Len() > 0
|
|
},
|
|
clear: func(p pointer) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
rv.Set(reflect.Zero(rv.Type()))
|
|
},
|
|
get: func(p pointer) pref.Value {
|
|
if p.IsNil() {
|
|
return conv.Zero()
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
|
|
return conv.PBValueOf(rv)
|
|
},
|
|
set: func(p pointer, v pref.Value) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
rv.Set(reflect.ValueOf(v.List().(unwrapper).protoUnwrap()).Elem())
|
|
},
|
|
mutable: func(p pointer) pref.Value {
|
|
v := p.Apply(fieldOffset).AsValueOf(fs.Type)
|
|
return conv.PBValueOf(v)
|
|
},
|
|
newField: func() pref.Value {
|
|
return conv.New()
|
|
},
|
|
}
|
|
}
|
|
|
|
var (
|
|
nilBytes = reflect.ValueOf([]byte(nil))
|
|
emptyBytes = reflect.ValueOf([]byte{})
|
|
)
|
|
|
|
func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
|
|
ft := fs.Type
|
|
nullable := fd.Syntax() == pref.Proto2
|
|
isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8
|
|
if nullable {
|
|
if ft.Kind() != reflect.Ptr && ft.Kind() != reflect.Slice {
|
|
panic(fmt.Sprintf("invalid type: got %v, want pointer", ft))
|
|
}
|
|
if ft.Kind() == reflect.Ptr {
|
|
ft = ft.Elem()
|
|
}
|
|
}
|
|
conv := NewConverter(ft, fd)
|
|
|
|
// TODO: Implement unsafe fast path?
|
|
fieldOffset := offsetOf(fs, x)
|
|
return fieldInfo{
|
|
fieldDesc: fd,
|
|
has: func(p pointer) bool {
|
|
if p.IsNil() {
|
|
return false
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if nullable {
|
|
return !rv.IsNil()
|
|
}
|
|
switch rv.Kind() {
|
|
case reflect.Bool:
|
|
return rv.Bool()
|
|
case reflect.Int32, reflect.Int64:
|
|
return rv.Int() != 0
|
|
case reflect.Uint32, reflect.Uint64:
|
|
return rv.Uint() != 0
|
|
case reflect.Float32, reflect.Float64:
|
|
return rv.Float() != 0 || math.Signbit(rv.Float())
|
|
case reflect.String, reflect.Slice:
|
|
return rv.Len() > 0
|
|
default:
|
|
panic(fmt.Sprintf("invalid type: %v", rv.Type())) // should never happen
|
|
}
|
|
},
|
|
clear: func(p pointer) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
rv.Set(reflect.Zero(rv.Type()))
|
|
},
|
|
get: func(p pointer) pref.Value {
|
|
if p.IsNil() {
|
|
return conv.Zero()
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if nullable {
|
|
if rv.IsNil() {
|
|
return conv.Zero()
|
|
}
|
|
if rv.Kind() == reflect.Ptr {
|
|
rv = rv.Elem()
|
|
}
|
|
}
|
|
return conv.PBValueOf(rv)
|
|
},
|
|
set: func(p pointer, v pref.Value) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if nullable && rv.Kind() == reflect.Ptr {
|
|
if rv.IsNil() {
|
|
rv.Set(reflect.New(ft))
|
|
}
|
|
rv = rv.Elem()
|
|
}
|
|
rv.Set(conv.GoValueOf(v))
|
|
if isBytes && rv.Len() == 0 {
|
|
if nullable {
|
|
rv.Set(emptyBytes) // preserve presence in proto2
|
|
} else {
|
|
rv.Set(nilBytes) // do not preserve presence in proto3
|
|
}
|
|
}
|
|
},
|
|
newField: func() pref.Value {
|
|
return conv.New()
|
|
},
|
|
}
|
|
}
|
|
|
|
func fieldInfoForWeakMessage(fd pref.FieldDescriptor, weakOffset offset) fieldInfo {
|
|
if !flags.ProtoLegacy {
|
|
panic("no support for proto1 weak fields")
|
|
}
|
|
|
|
var once sync.Once
|
|
var messageType pref.MessageType
|
|
lazyInit := func() {
|
|
once.Do(func() {
|
|
messageName := fd.Message().FullName()
|
|
messageType, _ = preg.GlobalTypes.FindMessageByName(messageName)
|
|
if messageType == nil {
|
|
panic(fmt.Sprintf("weak message %v is not linked in", messageName))
|
|
}
|
|
})
|
|
}
|
|
|
|
num := int32(fd.Number())
|
|
return fieldInfo{
|
|
fieldDesc: fd,
|
|
has: func(p pointer) bool {
|
|
if p.IsNil() {
|
|
return false
|
|
}
|
|
fs := p.Apply(weakOffset).WeakFields()
|
|
_, ok := (*fs)[num]
|
|
return ok
|
|
},
|
|
clear: func(p pointer) {
|
|
fs := p.Apply(weakOffset).WeakFields()
|
|
delete(*fs, num)
|
|
},
|
|
get: func(p pointer) pref.Value {
|
|
lazyInit()
|
|
if p.IsNil() {
|
|
return pref.ValueOfMessage(messageType.Zero())
|
|
}
|
|
fs := p.Apply(weakOffset).WeakFields()
|
|
m, ok := (*fs)[num]
|
|
if !ok {
|
|
return pref.ValueOfMessage(messageType.Zero())
|
|
}
|
|
return pref.ValueOfMessage(m.(pref.ProtoMessage).ProtoReflect())
|
|
},
|
|
set: func(p pointer, v pref.Value) {
|
|
lazyInit()
|
|
m := v.Message()
|
|
if m.Descriptor() != messageType.Descriptor() {
|
|
panic("mismatching message descriptor")
|
|
}
|
|
fs := p.Apply(weakOffset).WeakFields()
|
|
if *fs == nil {
|
|
*fs = make(WeakFields)
|
|
}
|
|
(*fs)[num] = m.Interface().(piface.MessageV1)
|
|
},
|
|
mutable: func(p pointer) pref.Value {
|
|
lazyInit()
|
|
fs := p.Apply(weakOffset).WeakFields()
|
|
if *fs == nil {
|
|
*fs = make(WeakFields)
|
|
}
|
|
m, ok := (*fs)[num]
|
|
if !ok {
|
|
m = messageType.New().Interface().(piface.MessageV1)
|
|
(*fs)[num] = m
|
|
}
|
|
return pref.ValueOfMessage(m.(pref.ProtoMessage).ProtoReflect())
|
|
},
|
|
newMessage: func() pref.Message {
|
|
lazyInit()
|
|
return messageType.New()
|
|
},
|
|
newField: func() pref.Value {
|
|
lazyInit()
|
|
return pref.ValueOfMessage(messageType.New())
|
|
},
|
|
}
|
|
}
|
|
|
|
func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField, x exporter) fieldInfo {
|
|
ft := fs.Type
|
|
conv := NewConverter(ft, fd)
|
|
|
|
// TODO: Implement unsafe fast path?
|
|
fieldOffset := offsetOf(fs, x)
|
|
return fieldInfo{
|
|
fieldDesc: fd,
|
|
has: func(p pointer) bool {
|
|
if p.IsNil() {
|
|
return false
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
return !rv.IsNil()
|
|
},
|
|
clear: func(p pointer) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
rv.Set(reflect.Zero(rv.Type()))
|
|
},
|
|
get: func(p pointer) pref.Value {
|
|
if p.IsNil() {
|
|
return conv.Zero()
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
return conv.PBValueOf(rv)
|
|
},
|
|
set: func(p pointer, v pref.Value) {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
rv.Set(conv.GoValueOf(v))
|
|
if rv.IsNil() {
|
|
panic("invalid nil pointer")
|
|
}
|
|
},
|
|
mutable: func(p pointer) pref.Value {
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if rv.IsNil() {
|
|
rv.Set(conv.GoValueOf(conv.New()))
|
|
}
|
|
return conv.PBValueOf(rv)
|
|
},
|
|
newMessage: func() pref.Message {
|
|
return conv.New().Message()
|
|
},
|
|
newField: func() pref.Value {
|
|
return conv.New()
|
|
},
|
|
}
|
|
}
|
|
|
|
type oneofInfo struct {
|
|
oneofDesc pref.OneofDescriptor
|
|
which func(pointer) pref.FieldNumber
|
|
}
|
|
|
|
func makeOneofInfo(od pref.OneofDescriptor, fs reflect.StructField, x exporter, wrappersByType map[reflect.Type]pref.FieldNumber) *oneofInfo {
|
|
fieldOffset := offsetOf(fs, x)
|
|
return &oneofInfo{
|
|
oneofDesc: od,
|
|
which: func(p pointer) pref.FieldNumber {
|
|
if p.IsNil() {
|
|
return 0
|
|
}
|
|
rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
|
|
if rv.IsNil() {
|
|
return 0
|
|
}
|
|
rv = rv.Elem()
|
|
if rv.IsNil() {
|
|
return 0
|
|
}
|
|
return wrappersByType[rv.Type().Elem()]
|
|
},
|
|
}
|
|
}
|