mirror of
https://github.com/golang/go
synced 2024-11-19 13:04:45 -07:00
2a56b023af
AMD64 with AES support disabled: name old time/op new time/op delta MapPopulate/1 78.0ns ± 1% 75.5ns ± 1% -3.17% (p=0.000 n=10+9) MapPopulate/10 764ns ± 2% 673ns ± 2% -11.91% (p=0.000 n=10+10) MapPopulate/100 9.52µs ± 1% 8.54µs ± 1% -10.37% (p=0.000 n=8+10) MapPopulate/1000 116µs ± 2% 103µs ± 1% -10.40% (p=0.000 n=10+8) MapPopulate/10000 1.01ms ± 1% 0.90ms ± 1% -10.70% (p=0.000 n=10+10) MapPopulate/100000 9.81ms ± 1% 8.67ms ± 2% -11.54% (p=0.000 n=10+10) 386 with AES support disabled: name old time/op new time/op delta MapPopulate/1 95.3ns ± 1% 90.6ns ± 1% -4.95% (p=0.000 n=10+9) MapPopulate/10 983ns ± 2% 912ns ± 1% -7.18% (p=0.000 n=10+10) MapPopulate/100 11.9µs ± 2% 11.2µs ± 1% -6.01% (p=0.000 n=10+10) MapPopulate/1000 140µs ± 1% 131µs ± 1% -6.19% (p=0.000 n=10+10) MapPopulate/10000 1.26ms ± 2% 1.18ms ± 1% -5.93% (p=0.000 n=9+10) MapPopulate/100000 12.1ms ± 2% 11.4ms ± 1% -5.48% (p=0.000 n=10+10) Fixes #21539 Change-Id: Ice128c947c9a6a294800d6a5250d82045eb70b55 Reviewed-on: https://go-review.googlesource.com/59352 Run-TryBot: Martin Möhrmann <moehrmann@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
116 lines
2.6 KiB
Go
116 lines
2.6 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 386 arm mips mipsle
|
|
|
|
package runtime
|
|
|
|
import "unsafe"
|
|
|
|
const (
|
|
// Constants for multiplication: four random odd 32-bit numbers.
|
|
m1 = 3168982561
|
|
m2 = 3339683297
|
|
m3 = 832293441
|
|
m4 = 2336365089
|
|
)
|
|
|
|
func memhash(p unsafe.Pointer, seed, s uintptr) uintptr {
|
|
if GOARCH == "386" && GOOS != "nacl" && useAeshash {
|
|
return aeshash(p, seed, s)
|
|
}
|
|
h := uint32(seed + s*hashkey[0])
|
|
tail:
|
|
switch {
|
|
case s == 0:
|
|
case s < 4:
|
|
h ^= uint32(*(*byte)(p))
|
|
h ^= uint32(*(*byte)(add(p, s>>1))) << 8
|
|
h ^= uint32(*(*byte)(add(p, s-1))) << 16
|
|
h = rotl_15(h*m1) * m2
|
|
case s == 4:
|
|
h ^= readUnaligned32(p)
|
|
h = rotl_15(h*m1) * m2
|
|
case s <= 8:
|
|
h ^= readUnaligned32(p)
|
|
h = rotl_15(h*m1) * m2
|
|
h ^= readUnaligned32(add(p, s-4))
|
|
h = rotl_15(h*m1) * m2
|
|
case s <= 16:
|
|
h ^= readUnaligned32(p)
|
|
h = rotl_15(h*m1) * m2
|
|
h ^= readUnaligned32(add(p, 4))
|
|
h = rotl_15(h*m1) * m2
|
|
h ^= readUnaligned32(add(p, s-8))
|
|
h = rotl_15(h*m1) * m2
|
|
h ^= readUnaligned32(add(p, s-4))
|
|
h = rotl_15(h*m1) * m2
|
|
default:
|
|
v1 := h
|
|
v2 := uint32(seed * hashkey[1])
|
|
v3 := uint32(seed * hashkey[2])
|
|
v4 := uint32(seed * hashkey[3])
|
|
for s >= 16 {
|
|
v1 ^= readUnaligned32(p)
|
|
v1 = rotl_15(v1*m1) * m2
|
|
p = add(p, 4)
|
|
v2 ^= readUnaligned32(p)
|
|
v2 = rotl_15(v2*m2) * m3
|
|
p = add(p, 4)
|
|
v3 ^= readUnaligned32(p)
|
|
v3 = rotl_15(v3*m3) * m4
|
|
p = add(p, 4)
|
|
v4 ^= readUnaligned32(p)
|
|
v4 = rotl_15(v4*m4) * m1
|
|
p = add(p, 4)
|
|
s -= 16
|
|
}
|
|
h = v1 ^ v2 ^ v3 ^ v4
|
|
goto tail
|
|
}
|
|
h ^= h >> 17
|
|
h *= m3
|
|
h ^= h >> 13
|
|
h *= m4
|
|
h ^= h >> 16
|
|
return uintptr(h)
|
|
}
|
|
|
|
func memhash32(p unsafe.Pointer, seed uintptr) uintptr {
|
|
h := uint32(seed + 4*hashkey[0])
|
|
h ^= readUnaligned32(p)
|
|
h = rotl_15(h*m1) * m2
|
|
h ^= h >> 17
|
|
h *= m3
|
|
h ^= h >> 13
|
|
h *= m4
|
|
h ^= h >> 16
|
|
return uintptr(h)
|
|
}
|
|
|
|
func memhash64(p unsafe.Pointer, seed uintptr) uintptr {
|
|
h := uint32(seed + 8*hashkey[0])
|
|
h ^= readUnaligned32(p)
|
|
h = rotl_15(h*m1) * m2
|
|
h ^= readUnaligned32(add(p, 4))
|
|
h = rotl_15(h*m1) * m2
|
|
h ^= h >> 17
|
|
h *= m3
|
|
h ^= h >> 13
|
|
h *= m4
|
|
h ^= h >> 16
|
|
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_15(x uint32) uint32 {
|
|
return (x << 15) | (x >> (32 - 15))
|
|
}
|