Reduce struct field lookup hashing

Author: oschwald

CHANGELOG.md

@@ -6,6 +6,8 @@
   records.
 - Reduced allocations when recurring decoded strings share a primary cache
   slot.
+- Reduced struct decoding time by using compact field-name fingerprints before
+  falling back to full string hashing.
 - Rejected impossible or malformed large container sizes before allocating
   destination maps and slices, while reducing preflight overhead for common
   strings and booleans and avoiding preflight when caller-provided slice

internal/decoder/reflection.go

@@ -1085,7 +1085,11 @@ func (d *ReflectionDecoder) decodeStructWithFields(
 		}
 		// The string() does not create a copy due to this compiler
 		// optimization: https://github.com/golang/go/issues/3512
-		fieldInfo, ok := fields.namedFields[string(key)]
+		fingerprint := fieldKeyFingerprint(key)
+		fieldInfo, ok := fields.fieldForFingerprint(fingerprint)
+		if ok && (fieldInfo == nil || fieldInfo.name != string(key)) {
+			fieldInfo, ok = fields.namedFields[string(key)]
+		}
 		if !ok {
 			offset, err = d.nextValueOffset(offset, 1)
 			if err != nil {
@@ -1373,8 +1377,69 @@ type fieldInfo struct {
 }
 
 type fieldsType struct {
-	namedFields   map[string]*fieldInfo // Map from field name to field info
-	validationErr error
+	validationErr     error
+	namedFields       map[string]*fieldInfo // Map from field name to field info
+	fingerprintFields []fingerprintField
+}
+
+type fingerprintField struct {
+	field       *fieldInfo
+	fingerprint uint64
+}
+
+func (fs *fieldsType) fieldForFingerprint(fingerprint uint64) (*fieldInfo, bool) {
+	mask := uint64(len(fs.fingerprintFields) - 1)
+	index := (fingerprint ^ (fingerprint >> 16) ^ (fingerprint >> 32)) & mask
+	for {
+		entry := fs.fingerprintFields[index]
+		if entry.fingerprint == 0 {
+			return nil, false
+		}
+		if entry.fingerprint == fingerprint {
+			return entry.field, true
+		}
+		index = (index + 1) & mask
+	}
+}
+
+func fieldKeyFingerprint(key []byte) uint64 {
+	// Length plus the first and last two bytes distinguish ordinary MMDB
+	// field names cheaply. Collisions fall back to the full string map.
+	n := len(key)
+	fingerprint := uint64(n) << 32
+	if n > 0 {
+		fingerprint |= uint64(key[0]) << 24
+		fingerprint |= uint64(key[n-1]) << 16
+	}
+	if n > 1 {
+		fingerprint |= uint64(key[1]) << 8
+		fingerprint |= uint64(key[n-2])
+	}
+	return fingerprint
+}
+
+func makeFingerprintFields(namedFields map[string]*fieldInfo) []fingerprintField {
+	tableSize := 1
+	for tableSize < len(namedFields)*2 {
+		tableSize *= 2
+	}
+	fingerprintFields := make([]fingerprintField, tableSize)
+	mask := uint64(tableSize - 1)
+	for _, field := range namedFields {
+		fingerprint := fieldKeyFingerprint([]byte(field.name))
+		index := (fingerprint ^ (fingerprint >> 16) ^ (fingerprint >> 32)) & mask
+		for fingerprintFields[index].fingerprint != 0 &&
+			fingerprintFields[index].fingerprint != fingerprint {
+			index = (index + 1) & mask
+		}
+		entry := &fingerprintFields[index]
+		if entry.fingerprint != 0 {
+			entry.field = nil
+			continue
+		}
+		*entry = fingerprintField{fingerprint: fingerprint, field: field}
+	}
+	return fingerprintFields
 }
 
 type queueEntry struct {
@@ -1648,8 +1713,9 @@ func makeStructFieldsWithStack(
 	}
 
 	fields := &fieldsType{
-		namedFields:   namedFields,
-		validationErr: validationErr,
+		namedFields:       namedFields,
+		fingerprintFields: makeFingerprintFields(namedFields),
+		validationErr:     validationErr,
 	}
 
 	// Reindex all fields for optimized access

internal/decoder/reflection_test.go

@@ -299,6 +299,38 @@ func TestMap(t *testing.T) {
 	validateDecoding(t, maps)
 }
 
+func TestDecodeStructFieldFingerprintCollisions(t *testing.T) {
+	type resultType struct {
+		First  string `maxminddb:"abXXyz"`
+		Second string `maxminddb:"abYYyz"`
+	}
+
+	firstKey := []byte("abXXyz")
+	secondKey := []byte("abYYyz")
+	unknownKey := []byte("abZZyz")
+	require.Equal(t, fieldKeyFingerprint(firstKey), fieldKeyFingerprint(secondKey))
+	require.Equal(t, fieldKeyFingerprint(firstKey), fieldKeyFingerprint(unknownKey))
+
+	capacity := 1 + 6 + len(firstKey) + len(secondKey) + len(unknownKey) +
+		len("one") + len("two") + len("ignored")
+	data := make([]byte, 1, capacity)
+	data[0] = 0xe3 // map with three entries
+	data = append(data, 0x46)
+	data = append(data, firstKey...)
+	data = append(data, 0x43, 'o', 'n', 'e')
+	data = append(data, 0x46)
+	data = append(data, secondKey...)
+	data = append(data, 0x43, 't', 'w', 'o')
+	data = append(data, 0x46)
+	data = append(data, unknownKey...)
+	data = append(data, 0x47, 'i', 'g', 'n', 'o', 'r', 'e', 'd')
+
+	var result resultType
+	d := NewWithoutStringCache(data)
+	require.NoError(t, d.Decode(0, &result))
+	require.Equal(t, resultType{First: "one", Second: "two"}, result)
+}
+
 func TestSlice(t *testing.T) {
 	slice := map[string]any{
 		"0004":                 []any{},