Improve allocation performance

* improve reflect and option allocations
* optimize binary writes for numbers
* optimize string writes(#3)
* optimize object wrapping
* update go.mod to 1.20 to support unsafe string conversion

Author: johannes94

go.mod

@@ -1,5 +1,5 @@
 module github.com/gohugoio/hashstructure
 
-go 1.18
+go 1.20
 
 require github.com/cespare/xxhash/v2 v2.3.0

hashstructure.go

@@ -5,9 +5,10 @@ import (
 	"fmt"
 	"hash"
 	"hash/fnv"
-	"io"
+	"math"
 	"reflect"
 	"time"
+	"unsafe"
 )
 
 // HashOptions are options that are available for hashing.
@@ -115,6 +116,7 @@ type walker struct {
 	ignorezerovalue bool
 	sets            bool
 	stringer        bool
+	buf             [16]byte // Reusable buffer for binary encoding
 }
 
 type visitOpts struct {
@@ -131,8 +133,54 @@ var timeType = reflect.TypeOf(time.Time{})
 // A direct hash calculation used for numeric and bool values.
 func (w *walker) hashDirect(v any) (uint64, error) {
 	w.h.Reset()
-	err := binary.Write(w.h, binary.LittleEndian, v)
-	return w.h.Sum64(), err
+
+	// Use direct byte manipulation for numbers instead of binary.Write to avoid allocations
+	switch val := v.(type) {
+	case int64:
+		binary.LittleEndian.PutUint64(w.buf[:8], uint64(val))
+		w.h.Write(w.buf[:8])
+	case uint64:
+		binary.LittleEndian.PutUint64(w.buf[:8], val)
+		w.h.Write(w.buf[:8])
+	case int8:
+		w.buf[0] = byte(val)
+		w.h.Write(w.buf[:1])
+	case uint8:
+		w.buf[0] = val
+		w.h.Write(w.buf[:1])
+	case int16:
+		binary.LittleEndian.PutUint16(w.buf[:2], uint16(val))
+		w.h.Write(w.buf[:2])
+	case uint16:
+		binary.LittleEndian.PutUint16(w.buf[:2], val)
+		w.h.Write(w.buf[:2])
+	case int32:
+		binary.LittleEndian.PutUint32(w.buf[:4], uint32(val))
+		w.h.Write(w.buf[:4])
+	case uint32:
+		binary.LittleEndian.PutUint32(w.buf[:4], val)
+		w.h.Write(w.buf[:4])
+	case float32:
+		binary.LittleEndian.PutUint32(w.buf[:4], math.Float32bits(val))
+		w.h.Write(w.buf[:4])
+	case float64:
+		binary.LittleEndian.PutUint64(w.buf[:8], math.Float64bits(val))
+		w.h.Write(w.buf[:8])
+	case complex64:
+		binary.LittleEndian.PutUint32(w.buf[:4], math.Float32bits(real(val)))
+		binary.LittleEndian.PutUint32(w.buf[4:8], math.Float32bits(imag(val)))
+		w.h.Write(w.buf[:8])
+	case complex128:
+		binary.LittleEndian.PutUint64(w.buf[:8], math.Float64bits(real(val)))
+		binary.LittleEndian.PutUint64(w.buf[8:16], math.Float64bits(imag(val)))
+		w.h.Write(w.buf[:16])
+	default:
+		// Fallback to binary.Write for unsupported types, for instance enums
+		err := binary.Write(w.h, binary.LittleEndian, v)
+		return w.h.Sum64(), err
+	}
+
+	return w.h.Sum64(), nil
 }
 
 // A direct hash calculation used for strings.
@@ -144,10 +192,12 @@ func (w *walker) hashString(s string) (uint64, error) {
 func hashString(h hash.Hash64, s string) (uint64, error) {
 	h.Reset()
 
-	// io.WriteString uses io.StringWriter if it exists, which is
-	// implemented by e.g. github.com/cespare/xxhash.
-	_, err := io.WriteString(h, s)
-	return h.Sum64(), err
+	// Use zero-copy conversion from string to []byte using unsafe
+	if len(s) > 0 {
+		b := unsafe.Slice(unsafe.StringData(s), len(s))
+		h.Write(b)
+	}
+	return h.Sum64(), nil
 }
 
 func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
@@ -181,23 +231,55 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 	}
 
 	if v.CanInt() {
-		if v.Kind() == reflect.Int {
-			// binary.Write requires a fixed-size value.
-			return w.hashDirect(v.Int())
+		i := v.Int()
+		switch v.Kind() {
+		case reflect.Int:
+			return w.hashDirect(i)
+		case reflect.Int8:
+			return w.hashDirect(int8(i))
+		case reflect.Int16:
+			return w.hashDirect(int16(i))
+		case reflect.Int32:
+			return w.hashDirect(int32(i))
+		case reflect.Int64:
+			return w.hashDirect(i)
 		}
-		return w.hashDirect(v.Interface())
 	}
 
 	if v.CanUint() {
-		if v.Kind() == reflect.Uint {
-			// binary.Write requires a fixed-size value.
-			return w.hashDirect(v.Uint())
+		u := v.Uint()
+		switch v.Kind() {
+		case reflect.Uint:
+			return w.hashDirect(u)
+		case reflect.Uint8:
+			return w.hashDirect(uint8(u))
+		case reflect.Uint16:
+			return w.hashDirect(uint16(u))
+		case reflect.Uint32:
+			return w.hashDirect(uint32(u))
+		case reflect.Uint64:
+			return w.hashDirect(u)
 		}
-		return w.hashDirect(v.Interface())
 	}
 
-	if v.CanFloat() || v.CanComplex() {
-		return w.hashDirect(v.Interface())
+	if v.CanFloat() {
+		f := v.Float()
+		switch v.Kind() {
+		case reflect.Float32:
+			return w.hashDirect(float32(f))
+		case reflect.Float64:
+			return w.hashDirect(f)
+		}
+	}
+
+	if v.CanComplex() {
+		c := v.Complex()
+		switch v.Kind() {
+		case reflect.Complex64:
+			return w.hashDirect(complex64(c))
+		case reflect.Complex128:
+			return w.hashDirect(c)
+		}
 	}
 
 	k := v.Kind()
@@ -218,8 +300,8 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 			return 0, err
 		}
 
-		err = binary.Write(w.h, binary.LittleEndian, b)
-		return w.h.Sum64(), err
+		w.h.Write(b)
+		return w.h.Sum64(), nil
 	}
 
 	switch k {
@@ -290,18 +372,10 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 		return h, nil
 
 	case reflect.Struct:
-		parent := v.Interface()
 		var include Includable
-		if impl, ok := parent.(Includable); ok {
-			include = impl
-		}
-
-		if impl, ok := parent.(Hashable); ok {
-			return impl.Hash()
-		}
+		var parent interface{}
 
-		// If we can address this value, check if the pointer value
-		// implements our interfaces and use that if so.
+		// Check if we can address this value first (more common case for pointer receivers)
 		if v.CanAddr() {
 			vptr := v.Addr()
 			parentptr := vptr.Interface()
@@ -312,18 +386,38 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 			if impl, ok := parentptr.(Hashable); ok {
 				return impl.Hash()
 			}
+			// Only set parent if we'll need it for IncludableMap
+			parent = parentptr
+		}
+
+		// Only box the value if we haven't already found an implementation via pointer
+		if include == nil && parent == nil {
+			parent = v.Interface()
+			if impl, ok := parent.(Includable); ok {
+				include = impl
+			}
+
+			if impl, ok := parent.(Hashable); ok {
+				return impl.Hash()
+			}
 		}
 
 		t := v.Type()
-		h, err := w.visit(reflect.ValueOf(t.Name()), nil)
+		h, err := w.hashString(t.Name())
 		if err != nil {
 			return 0, err
 		}
 
 		l := v.NumField()
+		var fieldOpts visitOpts
+		// Defer boxing parent until we know we need it
+		if parent == nil {
+			parent = v.Interface()
+		}
+		fieldOpts.Struct = parent
+
 		for i := 0; i < l; i++ {
 			if innerV := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
-				var f visitFlag
 				fieldType := t.Field(i)
 				if fieldType.PkgPath != "" {
 					// Unexported
@@ -366,21 +460,18 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 					}
 				}
 
-				switch tag {
-				case "set":
-					f |= visitFlagSet
+				fieldOpts.Flags = 0
+				if tag == "set" {
+					fieldOpts.Flags |= visitFlagSet
 				}
 
-				kh, err := w.visit(reflect.ValueOf(fieldType.Name), nil)
+				kh, err := w.hashString(fieldType.Name)
 				if err != nil {
 					return 0, err
 				}
 
-				vh, err := w.visit(innerV, &visitOpts{
-					Flags:       f,
-					Struct:      parent,
-					StructField: fieldType.Name,
-				})
+				fieldOpts.StructField = fieldType.Name
+				vh, err := w.visit(innerV, &fieldOpts)
 				if err != nil {
 					return 0, err
 				}
@@ -435,16 +526,10 @@ func hashUpdateOrdered(h hash.Hash64, a, b uint64) uint64 {
 	// For ordered updates, use a real hash function
 	h.Reset()
 
-	// We just panic if the binary writes fail because we are writing
-	// an int64 which should never be fail-able.
-	e1 := binary.Write(h, binary.LittleEndian, a)
-	e2 := binary.Write(h, binary.LittleEndian, b)
-	if e1 != nil {
-		panic(e1)
-	}
-	if e2 != nil {
-		panic(e2)
-	}
+	var buf [16]byte
+	binary.LittleEndian.PutUint64(buf[0:8], a)
+	binary.LittleEndian.PutUint64(buf[8:16], b)
+	h.Write(buf[:])
 
 	return h.Sum64()
 }
@@ -470,11 +555,9 @@ func hashUpdateUnordered(a, b uint64) uint64 {
 func hashFinishUnordered(h hash.Hash64, a uint64) uint64 {
 	h.Reset()
 
-	// We just panic if the writes fail
-	e1 := binary.Write(h, binary.LittleEndian, a)
-	if e1 != nil {
-		panic(e1)
-	}
+	var buf [8]byte
+	binary.LittleEndian.PutUint64(buf[:], a)
+	h.Write(buf[:])
 
 	return h.Sum64()
 }