mirror of
https://github.com/golang/go
synced 2024-11-08 10:36:10 -07:00
73e0c302b2
Fix #10109 name old time/op new time/op delta Hash5 72.3ns ± 0% 51.5ns ± 0% -28.71% (p=0.000 n=4+5) Hash16 78.8ns ± 0% 48.7ns ± 0% ~ (p=0.079 n=4+5) Hash64 196ns ±25% 73ns ±16% -62.68% (p=0.008 n=5+5) Hash1024 1.57µs ± 0% 0.27µs ± 1% -82.90% (p=0.000 n=5+4) Hash65536 96.5µs ± 0% 14.3µs ± 0% -85.14% (p=0.016 n=5+4) HashStringSpeed 156ns ± 6% 129ns ± 3% -17.56% (p=0.008 n=5+5) HashBytesSpeed 227ns ± 1% 200ns ± 1% -11.98% (p=0.008 n=5+5) HashInt32Speed 116ns ± 2% 102ns ± 0% -11.92% (p=0.016 n=5+4) HashInt64Speed 120ns ± 3% 101ns ± 2% -15.55% (p=0.008 n=5+5) HashStringArraySpeed 342ns ± 0% 306ns ± 2% -10.58% (p=0.008 n=5+5) FastrandHashiter 217ns ± 1% 217ns ± 1% ~ (p=1.000 n=5+5) name old speed new speed delta Hash5 69.1MB/s ± 0% 97.0MB/s ± 0% +40.32% (p=0.008 n=5+5) Hash16 203MB/s ± 0% 329MB/s ± 0% +61.76% (p=0.016 n=4+5) Hash64 332MB/s ±21% 881MB/s ±14% +165.66% (p=0.008 n=5+5) Hash1024 651MB/s ± 0% 3652MB/s ±17% +460.73% (p=0.008 n=5+5) Hash65536 679MB/s ± 0% 4570MB/s ± 0% +572.85% (p=0.016 n=5+4) Change-Id: I573028979f84cf2e0e087951271d5de8865dbf04 Reviewed-on: https://go-review.googlesource.com/89755 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
113 lines
2.7 KiB
Go
113 lines
2.7 KiB
Go
// Copyright 2014 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Hashing algorithm inspired by
|
|
// xxhash: https://code.google.com/p/xxhash/
|
|
// cityhash: https://code.google.com/p/cityhash/
|
|
|
|
// +build amd64 amd64p32 arm64 mips64 mips64le ppc64 ppc64le s390x
|
|
|
|
package runtime
|
|
|
|
import "unsafe"
|
|
|
|
const (
|
|
// Constants for multiplication: four random odd 64-bit numbers.
|
|
m1 = 16877499708836156737
|
|
m2 = 2820277070424839065
|
|
m3 = 9497967016996688599
|
|
m4 = 15839092249703872147
|
|
)
|
|
|
|
func memhash(p unsafe.Pointer, seed, s uintptr) uintptr {
|
|
if (GOARCH == "amd64" || GOARCH == "arm64") &&
|
|
GOOS != "nacl" && useAeshash {
|
|
return aeshash(p, seed, s)
|
|
}
|
|
h := uint64(seed + s*hashkey[0])
|
|
tail:
|
|
switch {
|
|
case s == 0:
|
|
case s < 4:
|
|
h ^= uint64(*(*byte)(p))
|
|
h ^= uint64(*(*byte)(add(p, s>>1))) << 8
|
|
h ^= uint64(*(*byte)(add(p, s-1))) << 16
|
|
h = rotl_31(h*m1) * m2
|
|
case s <= 8:
|
|
h ^= uint64(readUnaligned32(p))
|
|
h ^= uint64(readUnaligned32(add(p, s-4))) << 32
|
|
h = rotl_31(h*m1) * m2
|
|
case s <= 16:
|
|
h ^= readUnaligned64(p)
|
|
h = rotl_31(h*m1) * m2
|
|
h ^= readUnaligned64(add(p, s-8))
|
|
h = rotl_31(h*m1) * m2
|
|
case s <= 32:
|
|
h ^= readUnaligned64(p)
|
|
h = rotl_31(h*m1) * m2
|
|
h ^= readUnaligned64(add(p, 8))
|
|
h = rotl_31(h*m1) * m2
|
|
h ^= readUnaligned64(add(p, s-16))
|
|
h = rotl_31(h*m1) * m2
|
|
h ^= readUnaligned64(add(p, s-8))
|
|
h = rotl_31(h*m1) * m2
|
|
default:
|
|
v1 := h
|
|
v2 := uint64(seed * hashkey[1])
|
|
v3 := uint64(seed * hashkey[2])
|
|
v4 := uint64(seed * hashkey[3])
|
|
for s >= 32 {
|
|
v1 ^= readUnaligned64(p)
|
|
v1 = rotl_31(v1*m1) * m2
|
|
p = add(p, 8)
|
|
v2 ^= readUnaligned64(p)
|
|
v2 = rotl_31(v2*m2) * m3
|
|
p = add(p, 8)
|
|
v3 ^= readUnaligned64(p)
|
|
v3 = rotl_31(v3*m3) * m4
|
|
p = add(p, 8)
|
|
v4 ^= readUnaligned64(p)
|
|
v4 = rotl_31(v4*m4) * m1
|
|
p = add(p, 8)
|
|
s -= 32
|
|
}
|
|
h = v1 ^ v2 ^ v3 ^ v4
|
|
goto tail
|
|
}
|
|
|
|
h ^= h >> 29
|
|
h *= m3
|
|
h ^= h >> 32
|
|
return uintptr(h)
|
|
}
|
|
|
|
func memhash32(p unsafe.Pointer, seed uintptr) uintptr {
|
|
h := uint64(seed + 4*hashkey[0])
|
|
v := uint64(readUnaligned32(p))
|
|
h ^= v
|
|
h ^= v << 32
|
|
h = rotl_31(h*m1) * m2
|
|
h ^= h >> 29
|
|
h *= m3
|
|
h ^= h >> 32
|
|
return uintptr(h)
|
|
}
|
|
|
|
func memhash64(p unsafe.Pointer, seed uintptr) uintptr {
|
|
h := uint64(seed + 8*hashkey[0])
|
|
h ^= uint64(readUnaligned32(p)) | uint64(readUnaligned32(add(p, 4)))<<32
|
|
h = rotl_31(h*m1) * m2
|
|
h ^= h >> 29
|
|
h *= m3
|
|
h ^= h >> 32
|
|
return uintptr(h)
|
|
}
|
|
|
|
// Note: in order to get the compiler to issue rotl instructions, we
|
|
// need to constant fold the shift amount by hand.
|
|
// TODO: convince the compiler to issue rotl instructions after inlining.
|
|
func rotl_31(x uint64) uint64 {
|
|
return (x << 31) | (x >> (64 - 31))
|
|
}
|