139 lines
3.3 KiB
Text
139 lines
3.3 KiB
Text
// Implementation: Demetri Spanos (github.com/demetri/scribbles)
|
|
// Jai Port: Jesse Coyle (github.com/Zilarrezko)
|
|
|
|
MurmurSeed : u32 : 0xa3c91521;
|
|
|
|
Murmur32 :: inline (s: string, seed: u32 = MurmurSeed) -> u32 {
|
|
return Murmur32(s.data, s.count, seed);
|
|
}
|
|
|
|
Murmur32 :: inline (x: $T, seed: u32 = MurmurSeed) -> u32 {
|
|
return Murmur32(*x, size_of(T), seed);
|
|
}
|
|
|
|
Murmur32 :: (key: *void, len: int, seed: u32 = MurmurSeed) -> u32 {
|
|
scrambler :: (k: u32) -> u32 #expand {
|
|
c1: u32 : 0xcc9e2d51;
|
|
c2: u32 : 0x1b873593;
|
|
r1: int : 15;
|
|
k = k*c1;
|
|
k = k <<< r1;
|
|
k = k*c2;
|
|
return k;
|
|
}
|
|
|
|
h: u32 = seed;
|
|
tail: *u8 = cast(*u8)key + (len/4)*4;
|
|
p: *u32 = cast(*u32)key;
|
|
|
|
while cast(*u8)p < tail {
|
|
k: u32 = <<p;
|
|
k = scrambler(k);
|
|
h = h^k;
|
|
h = h <<< 13;
|
|
h = h*5 + 0xe6546b64;
|
|
p += 1;
|
|
}
|
|
|
|
t: u32;
|
|
if len & 3 == {
|
|
case 3;
|
|
t ^= cast(u32)(tail[2]) << 16;
|
|
#through;
|
|
case 2;
|
|
t ^= cast(u32)(tail[1]) << 8;
|
|
#through;
|
|
case 1;
|
|
t ^= cast(u32)(tail[0]);
|
|
t = scrambler(t);
|
|
h = h^t;
|
|
}
|
|
h ^= cast,trunc(u32)len;
|
|
h ^= h >> 16; h *= 0x85ebca6b;
|
|
h ^= h >> 13; h *= 0xc2b2ae35;
|
|
h ^= h >> 16;
|
|
return h;
|
|
}
|
|
|
|
// Implementation: Demetri Spanos (github.com/demetri/scribbles)
|
|
// Jai Port: Jesse Coyle (github.com/Zilarrezko)
|
|
|
|
XXHashSeed :: 0;
|
|
|
|
XXHash64 :: inline (s: string, seed: u32 = XXHashSeed) -> u64 {
|
|
return XXHash64(s.data, s.count, seed);
|
|
}
|
|
|
|
XXHash64 :: inline (x: $T, seed: u32 = XXHashSeed) -> u64 {
|
|
return XXHash64(cast(*u8)*x, size_of(T), seed);
|
|
}
|
|
|
|
XXHash64 :: (key: *void, len: int, seed: u64 = XXHashSeed) -> u64 {
|
|
p1: u64 : 0x9e3779b185ebca87;
|
|
p2: u64 : 0xc2b2ae3d27d4eb4f;
|
|
p3: u64 : 0x165667b19e3779f9;
|
|
p4: u64 : 0x85ebca77c2b2ae63;
|
|
p5: u64 : 0x27d4eb2f165667c5;
|
|
|
|
h: u64 = seed;
|
|
|
|
s: [4]u64 = ---;
|
|
s[0] = h + p1 + p2;
|
|
s[1] = h + p2;
|
|
s[2] = h;
|
|
s[3] = h - p1;
|
|
|
|
// Bulk work
|
|
k32: *u64 = cast(*u64)key;
|
|
i: int;
|
|
while i < len/32 {
|
|
b: [4]u64 = ---;
|
|
b[0] = k32[4*i+0];
|
|
b[1] = k32[4*i+1];
|
|
b[2] = k32[4*i+2];
|
|
b[3] = k32[4*i+3];
|
|
for j : 0..3
|
|
b[j] = b[j]*p2 + s[j];
|
|
for j : 0..3
|
|
s[j] = (b[j] <<< 31)*p1;
|
|
i += 1;
|
|
}
|
|
|
|
// Mix 32 byte state down to 8 byte state
|
|
x: u64 = s[2] + p5;
|
|
if len > 32 {
|
|
x = (s[0] <<< 1) + (s[1] >>> 7) + (s[2] <<< 12) + (s[3] <<< 18);
|
|
for i : 0..3 {
|
|
ps: u64 = ((s[i]*p2) <<< 31)*p1;
|
|
x = (x ^ ps)*p1 + p4;
|
|
}
|
|
}
|
|
x += cast(u64)len;
|
|
|
|
// 31 max bytes remain...
|
|
tail: *u8 = cast(*u8)key + (len/32)*32;
|
|
for i : 0 .. (len & 31)/8 - 1 { // No idea why there's a mask then a divide that can be a smaller mask there
|
|
b: u64 = (<<cast(*u64)tail)*p2;
|
|
b = ((b <<< 31)*p1) ^ x;
|
|
x = (b <<< 27)*p1 + p4;
|
|
tail += 8;
|
|
}
|
|
|
|
// 7 max bytes remain...
|
|
for i : 0 .. (len & 7)/4 - 1 {
|
|
b: u64 = x ^ ((<<cast(*u32)tail)*p1);
|
|
x = (b <<< 23)*p2 + p3;
|
|
tail += 4;
|
|
}
|
|
|
|
// 3 max bytes remain
|
|
for i : 0 .. (len & 3) {
|
|
b: u64 = x ^ (<<tail)*p5;
|
|
x = (b <<< 11)*p1;
|
|
}
|
|
|
|
x = (x ^ (x >> 33))*p2;
|
|
x = (x ^ (x >> 29))*p3;
|
|
x = (x ^ (x >> 32));
|
|
return x;
|
|
}
|