WIP: unstage me

Author: charlievieth

bson/bsoncodec/codec_cache.go

@@ -102,8 +102,10 @@ func (c *kindEncoderCache) Store(rt reflect.Kind, enc ValueEncoder) {
 
 func (c *kindEncoderCache) Load(rt reflect.Kind) (ValueEncoder, bool) {
 	if rt < reflect.Kind(len(c.entries)) {
-		if ent, ok := c.entries[rt].Load().(*kindEncoderCacheEntry); ok {
-			return ent.enc, ent.enc != nil
+		// if ent, ok := c.entries[rt].Load().(*kindEncoderCacheEntry); ok {
+		if v := c.entries[rt].Load(); v != nil {
+			return v.(*kindEncoderCacheEntry).enc, true
+			// return ent.enc, ent.enc != nil
 		}
 	}
 	return nil, false

bson/bsoncodec/codec_cache_test.go

@@ -10,6 +10,7 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+	"sync"
 	"testing"
 )
 
@@ -90,6 +91,21 @@ func TestKindCacheArray(t *testing.T) {
 	if v, ok := c.Load(reflect.UnsafePointer + 1); ok || v != nil {
 		t.Errorf("Load(reflect.UnsafePointer + 1) = %v, %t; want: %v, %t", v, ok, nil, false)
 	}
+	encoders := new([reflect.UnsafePointer + 1]ValueEncoder)
+	for i := range encoders {
+		encoders[i] = new(fakeCodec)
+		c.Store(reflect.Kind(i), encoders[i])
+	}
+	for i := range encoders {
+		rt := reflect.Kind(i)
+		got, ok := c.Load(rt)
+		if !ok {
+			t.Error("missing encoder for:", rt)
+		}
+		if !reflect.DeepEqual(got, encoders[rt]) {
+			t.Errorf("Load(%q) = %#v; want: %#v", rt, got, encoders[rt])
+		}
+	}
 
 	// Make sure that reflect.UnsafePointer is the last/largest reflect.Type.
 	//
@@ -172,3 +188,41 @@ func BenchmarkEncoderCacheStore(b *testing.B) {
 		}
 	})
 }
+
+func BenchmarkKindEncoderCacheLoad(b *testing.B) {
+	m := new(sync.Map)
+	x := make(map[reflect.Kind]ValueEncoder)
+	c := new(kindEncoderCache)
+	for k := reflect.Kind(0); k <= reflect.UnsafePointer; k++ {
+		c.Store(k, fakeCodec{})
+		m.Store(k, fakeCodec{})
+		x[k] = fakeCodec{}
+	}
+	b.Run("Array", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			kind := reflect.Kind(i) % (reflect.UnsafePointer + 1)
+			_, ok := c.Load(kind)
+			if !ok {
+				b.Fatal("missing:", kind)
+			}
+		}
+	})
+	b.Run("SyncMap", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			kind := reflect.Kind(i) % (reflect.UnsafePointer + 1)
+			_, ok := m.Load(kind)
+			if !ok {
+				b.Fatal("missing:", kind)
+			}
+		}
+	})
+	b.Run("Map", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			kind := reflect.Kind(i) % (reflect.UnsafePointer + 1)
+			_, ok := x[kind]
+			if !ok {
+				b.Fatal("wat")
+			}
+		}
+	})
+}

bson/bsoncodec/registry.go

@@ -388,6 +388,10 @@ func (r *Registry) RegisterTypeMapEntry(bt bsontype.Type, rt reflect.Type) {
 // If no encoder is found, an error of type ErrNoEncoder is returned. LookupEncoder is safe for
 // concurrent use by multiple goroutines after all codecs and encoders are registered.
 func (r *Registry) LookupEncoder(valueType reflect.Type) (ValueEncoder, error) {
+	if valueType == nil {
+		return nil, ErrNoEncoder{Type: valueType}
+	}
+
 	enc, found := r.lookupTypeEncoder(valueType)
 	if found {
 		if enc == nil {
@@ -396,14 +400,9 @@ func (r *Registry) LookupEncoder(valueType reflect.Type) (ValueEncoder, error) {
 		return enc, nil
 	}
 
-	enc, found = r.lookupInterfaceEncoder(valueType, true)
-	if found {
+	if enc, found := r.lookupInterfaceEncoder(valueType, true); found {
 		return r.typeEncoders.LoadOrStore(valueType, enc), nil
 	}
-	if valueType == nil {
-		r.storeTypeEncoder(valueType, nil)
-		return nil, ErrNoEncoder{Type: valueType}
-	}
 
 	if v, ok := r.kindEncoders.Load(valueType.Kind()); ok {
 		return r.storeTypeEncoder(valueType, v), nil

bson/bsoncodec/registry_test.go

@@ -922,10 +922,10 @@ type fakeCodec struct {
 	num int
 }
 
-func (*fakeCodec) EncodeValue(EncodeContext, bsonrw.ValueWriter, reflect.Value) error {
+func (fakeCodec) EncodeValue(EncodeContext, bsonrw.ValueWriter, reflect.Value) error {
 	return nil
 }
-func (*fakeCodec) DecodeValue(DecodeContext, bsonrw.ValueReader, reflect.Value) error {
+func (fakeCodec) DecodeValue(DecodeContext, bsonrw.ValueReader, reflect.Value) error {
 	return nil
 }