[pkg/pdatautil] Optimize the hashing function for pcommon.Map (open…

…-telemetry#27840)

**Description:**

Improve the performance of the `MapHash` function, mostly by using the
xxhash architecture optimized version.

`hash.Sum` is a 'Go-code' only implementation
`xxhash.Sum64` has optimized versions for different architectures
Both result in the exact same hash though.


For the given benchmarks, the gain is > 10%

From `main`:
```
goos: linux
goarch: amd64
pkg: github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatautil
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkMapHashFourItems-16                  	47676003	       236.0 ns/op	      24 B/op	       1 allocs/op
BenchmarkMapHashEightItems-16                 	22551222	       532.3 ns/op	      32 B/op	       2 allocs/op
BenchmarkMapHashWithEmbeddedSliceAndMap-16    	14098969	       893.1 ns/op	      56 B/op	       3 allocs/op
```

The PR:
```
goos: linux
goarch: amd64
pkg: github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatautil
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkMapHashFourItems-16                  	59854737	       203.4 ns/op	      24 B/op	       1 allocs/op
BenchmarkMapHashEightItems-16                 	25609375	       475.0 ns/op	      32 B/op	       2 allocs/op
BenchmarkMapHashWithEmbeddedSliceAndMap-16    	15950144	       753.8 ns/op	      56 B/op	       3 allocs/op
```

**Testing:**
(Re-)using the same tests and benchmarks to prove semantics didn't
change.

pkg/pdatautil/hash.go

@@ -5,7 +5,6 @@ package pdatautil // import "github.com/open-telemetry/opentelemetry-collector-c
 
 import (
 	"encoding/binary"
-	"hash"
 	"math"
 	"sort"
 	"sync"
@@ -28,23 +27,19 @@ var (
 	valMapSuffix    = []byte{'\xfd'}
 	valSlicePrefix  = []byte{'\xfe'}
 	valSliceSuffix  = []byte{'\xff'}
+
+	emptyHash = [16]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
 )
 
 type hashWriter struct {
-	h       hash.Hash
-	strBuf  []byte
+	byteBuf []byte
 	keysBuf []string
-	sumHash []byte
-	numBuf  []byte
 }
 
 func newHashWriter() *hashWriter {
 	return &hashWriter{
-		h:       xxhash.New(),
-		strBuf:  make([]byte, 0, 128),
+		byteBuf: make([]byte, 0, 512),
 		keysBuf: make([]string, 0, 16),
-		sumHash: make([]byte, 0, 16),
-		numBuf:  make([]byte, 8),
 	}
 }
 
@@ -55,19 +50,27 @@ var hashWriterPool = &sync.Pool{
 // MapHash return a hash for the provided map.
 // Maps with the same underlying key/value pairs in different order produce the same deterministic hash value.
 func MapHash(m pcommon.Map) [16]byte {
+	if m.Len() == 0 {
+		return emptyHash
+	}
+
 	hw := hashWriterPool.Get().(*hashWriter)
 	defer hashWriterPool.Put(hw)
-	hw.h.Reset()
+	hw.byteBuf = hw.byteBuf[:0]
+
 	hw.writeMapHash(m)
+
 	return hw.hashSum128()
 }
 
 // ValueHash return a hash for the provided pcommon.Value.
 func ValueHash(v pcommon.Value) [16]byte {
 	hw := hashWriterPool.Get().(*hashWriter)
 	defer hashWriterPool.Put(hw)
-	hw.h.Reset()
+	hw.byteBuf = hw.byteBuf[:0]
+
 	hw.writeValueHash(v)
+
 	return hw.hashSum128()
 }
 
@@ -90,70 +93,63 @@ func (hw *hashWriter) writeMapHash(m pcommon.Map) {
 	sort.Strings(workingKeySet)
 	for _, k := range workingKeySet {
 		v, _ := m.Get(k)
-		hw.strBuf = hw.strBuf[:0]
-		hw.strBuf = append(hw.strBuf, keyPrefix...)
-		hw.strBuf = append(hw.strBuf, k...)
-		hw.h.Write(hw.strBuf)
+		hw.byteBuf = append(hw.byteBuf, keyPrefix...)
+		hw.byteBuf = append(hw.byteBuf, k...)
 		hw.writeValueHash(v)
 	}
 
 	// Remove all keys that were added to the buffer during this call of the function
 	hw.keysBuf = hw.keysBuf[:nextIndex]
 }
 
-func (hw *hashWriter) writeSliceHash(sl pcommon.Slice) {
-	for i := 0; i < sl.Len(); i++ {
-		hw.writeValueHash(sl.At(i))
-	}
-}
-
 func (hw *hashWriter) writeValueHash(v pcommon.Value) {
 	switch v.Type() {
 	case pcommon.ValueTypeStr:
-		hw.strBuf = hw.strBuf[:0]
-		hw.strBuf = append(hw.strBuf, valStrPrefix...)
-		hw.strBuf = append(hw.strBuf, v.Str()...)
-		hw.h.Write(hw.strBuf)
+		hw.byteBuf = append(hw.byteBuf, valStrPrefix...)
+		hw.byteBuf = append(hw.byteBuf, v.Str()...)
 	case pcommon.ValueTypeBool:
 		if v.Bool() {
-			hw.h.Write(valBoolTrue)
+			hw.byteBuf = append(hw.byteBuf, valBoolTrue...)
 		} else {
-			hw.h.Write(valBoolFalse)
+			hw.byteBuf = append(hw.byteBuf, valBoolFalse...)
 		}
 	case pcommon.ValueTypeInt:
-		hw.h.Write(valIntPrefix)
-		binary.LittleEndian.PutUint64(hw.numBuf, uint64(v.Int()))
-		hw.h.Write(hw.numBuf)
+		hw.byteBuf = append(hw.byteBuf, valIntPrefix...)
+		hw.byteBuf = binary.LittleEndian.AppendUint64(hw.byteBuf, uint64(v.Int()))
 	case pcommon.ValueTypeDouble:
-		hw.h.Write(valDoublePrefix)
-		binary.LittleEndian.PutUint64(hw.numBuf, math.Float64bits(v.Double()))
-		hw.h.Write(hw.numBuf)
+		hw.byteBuf = append(hw.byteBuf, valDoublePrefix...)
+		hw.byteBuf = binary.LittleEndian.AppendUint64(hw.byteBuf, math.Float64bits(v.Double()))
 	case pcommon.ValueTypeMap:
-		hw.h.Write(valMapPrefix)
+		hw.byteBuf = append(hw.byteBuf, valMapPrefix...)
 		hw.writeMapHash(v.Map())
-		hw.h.Write(valMapSuffix)
+		hw.byteBuf = append(hw.byteBuf, valMapSuffix...)
 	case pcommon.ValueTypeSlice:
-		hw.h.Write(valSlicePrefix)
-		hw.writeSliceHash(v.Slice())
-		hw.h.Write(valSliceSuffix)
+		sl := v.Slice()
+		hw.byteBuf = append(hw.byteBuf, valSlicePrefix...)
+		for i := 0; i < sl.Len(); i++ {
+			hw.writeValueHash(sl.At(i))
+		}
+		hw.byteBuf = append(hw.byteBuf, valSliceSuffix...)
 	case pcommon.ValueTypeBytes:
-		hw.h.Write(valBytesPrefix)
-		hw.h.Write(v.Bytes().AsRaw())
+		hw.byteBuf = append(hw.byteBuf, valBytesPrefix...)
+		hw.byteBuf = append(hw.byteBuf, v.Bytes().AsRaw()...)
 	case pcommon.ValueTypeEmpty:
-		hw.h.Write(valEmpty)
+		hw.byteBuf = append(hw.byteBuf, valEmpty...)
 	}
 }
 
 // hashSum128 returns a [16]byte hash sum.
 func (hw *hashWriter) hashSum128() [16]byte {
-	b := hw.sumHash[:0]
-	b = hw.h.Sum(b)
+	r := [16]byte{}
+	res := r[:]
+
+	h := xxhash.Sum64(hw.byteBuf)
+	res = binary.LittleEndian.AppendUint64(res[:0], h)
 
 	// Append an extra byte to generate another part of the hash sum
-	_, _ = hw.h.Write(extraByte)
-	b = hw.h.Sum(b)
+	hw.byteBuf = append(hw.byteBuf, extraByte...)
+	h = xxhash.Sum64(hw.byteBuf)
+	_ = binary.LittleEndian.AppendUint64(res[8:], h)
 
-	res := [16]byte{}
-	copy(res[:], b)
-	return res
+	return r
 }