Обновлены завендоренные зависимости

vendor/github.com/cespare/xxhash/v2/xxhash.go

@@ -16,16 +16,21 @@ const (
 	prime5 uint64 = 2870177450012600261
 )
 
-// Store the primes in an array as well.
-//
-// The consts are used when possible in Go code to avoid MOVs but we need a
-// contiguous array for the assembly code.
-var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5}
+// NOTE(caleb): I'm using both consts and vars of the primes. Using consts where
+// possible in the Go code is worth a small (but measurable) performance boost
+// by avoiding some MOVQs. Vars are needed for the asm and also are useful for
+// convenience in the Go code in a few places where we need to intentionally
+// avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the
+// result overflows a uint64).
+var (
+	prime1v = prime1
+	prime2v = prime2
+	prime3v = prime3
+	prime4v = prime4
+	prime5v = prime5
+)
 
 // Digest implements hash.Hash64.
-//
-// Note that a zero-valued Digest is not ready to receive writes.
-// Call Reset or create a Digest using New before calling other methods.
 type Digest struct {
 	v1    uint64
 	v2    uint64
@@ -36,31 +41,19 @@ type Digest struct {
 	n     int // how much of mem is used
 }
 
-// New creates a new Digest with a zero seed.
+// New creates a new Digest that computes the 64-bit xxHash algorithm.
 func New() *Digest {
-	return NewWithSeed(0)
-}
-
-// NewWithSeed creates a new Digest with the given seed.
-func NewWithSeed(seed uint64) *Digest {
 	var d Digest
-	d.ResetWithSeed(seed)
+	d.Reset()
 	return &d
 }
 
 // Reset clears the Digest's state so that it can be reused.
-// It uses a seed value of zero.
 func (d *Digest) Reset() {
-	d.ResetWithSeed(0)
-}
-
-// ResetWithSeed clears the Digest's state so that it can be reused.
-// It uses the given seed to initialize the state.
-func (d *Digest) ResetWithSeed(seed uint64) {
-	d.v1 = seed + prime1 + prime2
-	d.v2 = seed + prime2
-	d.v3 = seed
-	d.v4 = seed - prime1
+	d.v1 = prime1v + prime2
+	d.v2 = prime2
+	d.v3 = 0
+	d.v4 = -prime1v
 	d.total = 0
 	d.n = 0
 }
@@ -76,23 +69,21 @@ func (d *Digest) Write(b []byte) (n int, err error) {
 	n = len(b)
 	d.total += uint64(n)
 
-	memleft := d.mem[d.n&(len(d.mem)-1):]
-
 	if d.n+n < 32 {
 		// This new data doesn't even fill the current block.
-		copy(memleft, b)
+		copy(d.mem[d.n:], b)
 		d.n += n
 		return
 	}
 
 	if d.n > 0 {
 		// Finish off the partial block.
-		c := copy(memleft, b)
+		copy(d.mem[d.n:], b)
 		d.v1 = round(d.v1, u64(d.mem[0:8]))
 		d.v2 = round(d.v2, u64(d.mem[8:16]))
 		d.v3 = round(d.v3, u64(d.mem[16:24]))
 		d.v4 = round(d.v4, u64(d.mem[24:32]))
-		b = b[c:]
+		b = b[32-d.n:]
 		d.n = 0
 	}
 
@@ -142,20 +133,21 @@ func (d *Digest) Sum64() uint64 {
 
 	h += d.total
 
-	b := d.mem[:d.n&(len(d.mem)-1)]
-	for ; len(b) >= 8; b = b[8:] {
-		k1 := round(0, u64(b[:8]))
+	i, end := 0, d.n
+	for ; i+8 <= end; i += 8 {
+		k1 := round(0, u64(d.mem[i:i+8]))
 		h ^= k1
 		h = rol27(h)*prime1 + prime4
 	}
-	if len(b) >= 4 {
-		h ^= uint64(u32(b[:4])) * prime1
+	if i+4 <= end {
+		h ^= uint64(u32(d.mem[i:i+4])) * prime1
 		h = rol23(h)*prime2 + prime3
-		b = b[4:]
+		i += 4
 	}
-	for ; len(b) > 0; b = b[1:] {
-		h ^= uint64(b[0]) * prime5
+	for i < end {
+		h ^= uint64(d.mem[i]) * prime5
 		h = rol11(h) * prime1
+		i++
 	}
 
 	h ^= h >> 33