From 40b83d67fc7570f164347daff25e6b179b8a0bc6 Mon Sep 17 00:00:00 2001 From: Joe Tsai Date: Thu, 16 May 2019 11:45:52 -0700 Subject: [PATCH] internal/impl: add scaffolding for lazy extension support Once the ExtensionFieldV1.Value field is unexported, it forces all read operations to go through GetValue, which can perform some form of lazy retrieval. The SetEagerValue method is equivalent to setting the Value directly. The SetLazyValue method permits setting a lazy equivalent of the Value by simply storing a function closure returning the value. Change-Id: I410f74924f0957f5eadc82eea3669ca335a02701 Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/177619 Reviewed-by: Damien Neil --- internal/impl/legacy_extension.go | 104 +++++++++++++++++++++++------- 1 file changed, 79 insertions(+), 25 deletions(-) diff --git a/internal/impl/legacy_extension.go b/internal/impl/legacy_extension.go index eac04b99..f011192e 100644 --- a/internal/impl/legacy_extension.go +++ b/internal/impl/legacy_extension.go @@ -6,6 +6,8 @@ package impl import ( "reflect" + "sync" + "sync/atomic" pref "google.golang.org/protobuf/reflect/protoreflect" piface "google.golang.org/protobuf/runtime/protoiface" @@ -59,13 +61,13 @@ func (p legacyExtensionFields) Len() (n int) { func (p legacyExtensionFields) Has(n pref.FieldNumber) bool { x := p.x.Get(n) - if x.Value == nil { + if !x.HasValue() { return false } t := extensionTypeFromDesc(x.Desc) d := t.Descriptor() if d.IsList() { - return t.ValueOf(x.Value).List().Len() > 0 + return t.ValueOf(x.GetValue()).List().Len() > 0 } return true } @@ -77,7 +79,7 @@ func (p legacyExtensionFields) Get(n pref.FieldNumber) pref.Value { } t := extensionTypeFromDesc(x.Desc) d := t.Descriptor() - if x.Value == nil { + if !x.HasValue() { // NOTE: x.Value is never nil for Lists since they are always populated // during ExtensionFieldTypes.Register. if d.Kind() == pref.MessageKind || d.Kind() == pref.GroupKind { @@ -85,7 +87,7 @@ func (p legacyExtensionFields) Get(n pref.FieldNumber) pref.Value { } return d.Default() } - return t.ValueOf(x.Value) + return t.ValueOf(x.GetValue()) } func (p legacyExtensionFields) Set(n pref.FieldNumber, v pref.Value) { @@ -94,7 +96,7 @@ func (p legacyExtensionFields) Set(n pref.FieldNumber, v pref.Value) { panic("no extension descriptor registered") } t := extensionTypeFromDesc(x.Desc) - x.Value = t.InterfaceOf(v) + x.SetEagerValue(t.InterfaceOf(v)) p.x.Set(n, x) } @@ -106,10 +108,10 @@ func (p legacyExtensionFields) Clear(n pref.FieldNumber) { t := extensionTypeFromDesc(x.Desc) d := t.Descriptor() if d.IsList() { - t.ValueOf(x.Value).List().Truncate(0) + t.ValueOf(x.GetValue()).List().Truncate(0) return } - x.Value = nil + x.SetEagerValue(nil) p.x.Set(n, x) } @@ -167,7 +169,7 @@ func (p legacyExtensionTypes) Register(t pref.ExtensionType) { if d.IsList() { // If the field is repeated, initialize the entry with an empty list // so that future Get operations can return a mutable and concrete list. - x.Value = t.InterfaceOf(t.New()) + x.SetEagerValue(t.InterfaceOf(t.New())) } p.x.Set(d.Number(), x) } @@ -180,12 +182,12 @@ func (p legacyExtensionTypes) Remove(t pref.ExtensionType) { x := p.x.Get(d.Number()) if d.IsList() { // Treat an empty repeated field as unpopulated. - v := reflect.ValueOf(x.Value) - if x.Value == nil || v.IsNil() || v.Elem().Len() == 0 { - x.Value = nil + v := reflect.ValueOf(x.GetValue()) + if !x.HasValue() || v.IsNil() || v.Elem().Len() == 0 { + x.SetEagerValue(nil) } } - if x.Value != nil { + if x.GetValue() != nil { panic("value for extension descriptor still populated") } p.x.Clear(d.Number()) @@ -254,20 +256,72 @@ type ExtensionFieldV1 struct { // will be set. Desc *piface.ExtensionDescV1 // TODO: switch to protoreflect.ExtensionType - // Value is a concrete value for the extension field. Let the type of - // Desc.ExtensionType be the "API type" and the type of Value be the - // "storage type". The API type and storage type are the same except: - // * for scalars (except []byte), where the API type uses *T, - // while the storage type uses T. - // * for repeated fields, where the API type uses []T, - // while the storage type uses *[]T. + // value is either the value of GetValue, + // or a *lazyExtensionValue that then returns the value of GetValue. // - // The reason for the divergence is so that the storage type more naturally - // matches what is expected of when retrieving the values through the - // protobuf reflection APIs. - // - // The Value may only be populated if Desc is also populated. - Value interface{} // TODO: switch to protoreflect.Value + // TODO: unexport this. + Value interface{} +} + +// HasValue reports whether a value is set for the extension field. +// This may be called concurrently. +func (f ExtensionFieldV1) HasValue() bool { + return f.Value != nil +} + +// GetValue returns the concrete value for the extension field. +// Let the type of Desc.ExtensionType be the "API type" and +// the type of GetValue be the "storage type". +// The API type and storage type are the same except: +// * for scalars (except []byte), where the API type uses *T, +// while the storage type uses T. +// * for repeated fields, where the API type uses []T, +// while the storage type uses *[]T. +// +// The reason for the divergence is so that the storage type more naturally +// matches what is expected of when retrieving the values through the +// protobuf reflection APIs. +// +// GetValue is only populated if Desc is also populated. +// This may be called concurrently. +// +// TODO: switch interface{} to protoreflect.Value +func (f ExtensionFieldV1) GetValue() interface{} { + if f, ok := f.Value.(*lazyExtensionValue); ok { + return f.GetValue() + } + return f.Value +} + +// SetEagerValue sets the current value of the extension. +// This must not be called concurrently. +func (f *ExtensionFieldV1) SetEagerValue(v interface{}) { + f.Value = v +} + +// SetLazyValue sets a value that is to be lazily evaluated upon first use. +// The returned value must not be nil. +// This must not be called concurrently. +func (f *ExtensionFieldV1) SetLazyValue(v func() interface{}) { + f.Value = &lazyExtensionValue{value: v} +} + +type lazyExtensionValue struct { + once uint32 // atomically set if value is valid + mu sync.Mutex // protects value + value interface{} // either the value itself or a func() interface{} +} + +func (v *lazyExtensionValue) GetValue() interface{} { + if atomic.LoadUint32(&v.once) == 0 { + v.mu.Lock() + if f, ok := v.value.(func() interface{}); ok { + v.value = f() + } + atomic.StoreUint32(&v.once, 1) + v.mu.Unlock() + } + return v.value } type legacyExtensionMap map[int32]ExtensionFieldV1