86 строки
1,9 КиБ
Go
86 строки
1,9 КиБ
Go
//go:build runtime_memhash_leveldb
|
|
// +build runtime_memhash_leveldb
|
|
|
|
// This is the hash function from Google's leveldb key-value storage system. It
|
|
// processes 4 bytes at a time making it faster than the FNV hash for buffer
|
|
// lengths > 16 bytes.
|
|
|
|
// https://github.com/google/leveldb
|
|
// https://en.wikipedia.org/wiki/LevelDB
|
|
|
|
package runtime
|
|
|
|
import (
|
|
"unsafe"
|
|
)
|
|
|
|
func ptrToSlice(ptr unsafe.Pointer, n uintptr) []byte {
|
|
var p []byte
|
|
|
|
type _bslice struct {
|
|
ptr *byte
|
|
len uintptr
|
|
cap uintptr
|
|
}
|
|
|
|
pslice := (*_bslice)(unsafe.Pointer(&p))
|
|
pslice.ptr = (*byte)(ptr)
|
|
pslice.cap = n
|
|
pslice.len = n
|
|
|
|
return p
|
|
}
|
|
|
|
// leveldb hash
|
|
func hash32(ptr unsafe.Pointer, n, seed uintptr) uint32 {
|
|
|
|
const (
|
|
lseed = 0xbc9f1d34
|
|
m = 0xc6a4a793
|
|
)
|
|
|
|
b := ptrToSlice(ptr, n)
|
|
|
|
h := uint32(lseed^seed) ^ uint32(uint(len(b))*uint(m))
|
|
|
|
for ; len(b) >= 4; b = b[4:] {
|
|
h += uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
|
|
h *= m
|
|
h ^= h >> 16
|
|
}
|
|
switch len(b) {
|
|
case 3:
|
|
h += uint32(b[2]) << 16
|
|
fallthrough
|
|
case 2:
|
|
h += uint32(b[1]) << 8
|
|
fallthrough
|
|
case 1:
|
|
h += uint32(b[0])
|
|
h *= m
|
|
h ^= h >> 24
|
|
}
|
|
|
|
return h
|
|
}
|
|
|
|
// hash64finalizer is a 64-bit integer mixing function from
|
|
// https://web.archive.org/web/20120720045250/http://www.cris.com/~Ttwang/tech/inthash.htm
|
|
func hash64finalizer(key uint64) uint64 {
|
|
key = ^key + (key << 21) // key = (key << 21) - key - 1;
|
|
key = key ^ (key >> 24)
|
|
key = (key + (key << 3)) + (key << 8) // key * 265
|
|
key = key ^ (key >> 14)
|
|
key = (key + (key << 2)) + (key << 4) // key * 21
|
|
key = key ^ (key >> 28)
|
|
key = key + (key << 31)
|
|
return key
|
|
}
|
|
|
|
// hash64 turns hash32 into a 64-bit hash, by use hash64finalizer to
|
|
// mix the result of hash32 function combined with an xorshifted version of
|
|
// the seed.
|
|
func hash64(ptr unsafe.Pointer, n, seed uintptr) uint64 {
|
|
h32 := hash32(ptr, n, seed)
|
|
return hash64finalizer((uint64(h32^xorshift32(uint32(seed))) << 32) | uint64(h32))
|
|
}
|