std.hash.xxhash.do
函数
fn do() !void
std.hash.xxhash.do
函数
fn do() !void
std.hash.xxhash.do
函数
fn do() !void
std.hash.xxhash.do
函数
fn do() !void
std.hash.xxhash.do
函数
fn do() !void
std.hash.xxhash.do
函数
fn do() !void
std.hash.xxhash.expectEqual
别名
std.hash.xxhash.mem
别名
别名目标 std.mem
std.hash.xxhash.rotl
别名
别名目标 std.math.rotl
std.hash.xxhash.std
别名
别名目标 std
std.hash.xxhash.testExpect
函数
fn testExpect(comptime H: type, seed: anytype, input: []const u8, expected: u64) !void
参数
H: type
input: []const u8
expected: u64
std.hash.xxhash.verify
别名
别名目标 std.hash.verify
std.hash.xxhash.XxHash3
容器
字段
std.hash.xxhash.XxHash3.Accumulator
容器
字段
std.hash.xxhash.XxHash3.Accumulator.accumulate
函数
fn accumulate(noalias self: *Accumulator, blocks: []const InputBlock) void
参数
self: *Accumulator
blocks: []const InputBlock
std.hash.xxhash.XxHash3.Accumulator.consume
函数
fn consume(noalias self: *Accumulator, input_blocks: []const InputBlock) void
参数
self: *Accumulator
input_blocks: []const InputBlock
std.hash.xxhash.XxHash3.Accumulator.digest
函数
fn digest(noalias self: *Accumulator, total_len: u64, noalias last_block: *const InputBlock) u64
参数
std.hash.xxhash.XxHash3.Accumulator.init
函数
inline fn init(seed: u64) Accumulator
参数
seed: u64
std.hash.xxhash.XxHash3.Accumulator.round
函数
inline fn round( noalias state: *Block, noalias input_block: *const InputBlock, noalias secret_block: *const InputBlock, ) void
参数
std.hash.xxhash.XxHash3.Accumulator.scramble
函数
fn scramble(self: *Accumulator) void
参数
self: *Accumulator
std.hash.xxhash.XxHash3.avalanche
函数
inline fn avalanche(mode: union(enum) { h3, h64, rrmxmx: u64 }, x0: u64) u64
参数
mode: union(enum) { h3, h64, rrmxmx: u64 }
x0: u64
std.hash.xxhash.XxHash3.Block
常量
std.hash.xxhash.XxHash3.block_bytes
常量
std.hash.xxhash.XxHash3.default_secret
常量
[192]u8
std.hash.xxhash.XxHash3.disableAutoVectorization
函数
inline fn disableAutoVectorization(x: anytype) void
std.hash.xxhash.XxHash3.final
函数
pub fn final(self: *XxHash3) u64
参数
self: *XxHash3
std.hash.xxhash.XxHash3.fold
函数
inline fn fold(a: u64, b: u64) u64
参数
a: u64
b: u64
std.hash.xxhash.XxHash3.hash
函数
pub fn hash(seed: u64, input: anytype) u64
参数
seed: u64
std.hash.xxhash.XxHash3.hash128
函数
fn hash128(seed: u64, input: anytype, noalias secret: *const [192]u8) u64
参数
seed: u64
secret: *const [192]u8
std.hash.xxhash.XxHash3.hash16
函数
fn hash16(seed: u64, input: anytype, noalias secret: *const [192]u8) u64
参数
seed: u64
secret: *const [192]u8
std.hash.xxhash.XxHash3.hash240
函数
fn hash240(seed: u64, input: anytype, noalias secret: *const [192]u8) u64
参数
seed: u64
secret: *const [192]u8
std.hash.xxhash.XxHash3.hash3
函数
fn hash3(seed: u64, input: anytype, noalias secret: *const [192]u8) u64
参数
seed: u64
secret: *const [192]u8
std.hash.xxhash.XxHash3.hash8
函数
fn hash8(seed: u64, input: anytype, noalias secret: *const [192]u8) u64
参数
seed: u64
secret: *const [192]u8
std.hash.xxhash.XxHash3.hashLong
函数
noinline fn hashLong(seed: u64, input: []const u8) u64
参数
seed: u64
input: []const u8
std.hash.xxhash.XxHash3.init
函数
pub fn init(seed: u64) XxHash3
参数
seed: u64
std.hash.xxhash.XxHash3.InputBlock
容器
字段
raw: [block_bytes]u8
std.hash.xxhash.XxHash3.InputBlock.load
函数
inline fn load(ptr: *const InputBlock) Block
参数
ptr: *const InputBlock
std.hash.xxhash.XxHash3.InputBlock.store
函数
inline fn store(ptr: *InputBlock, val: Block) void
参数
ptr: *InputBlock
val: Block
std.hash.xxhash.XxHash3.mix16
函数
inline fn mix16(seed: u64, input: []const u8, secret: []const u8) u64
参数
seed: u64
input: []const u8
secret: []const u8
std.hash.xxhash.XxHash3.prime_mx1
常量
std.hash.xxhash.XxHash3.prime_mx2
常量
std.hash.xxhash.XxHash3.update
函数
pub fn update(self: *XxHash3, input: anytype) void
参数
self: *XxHash3
std.hash.xxhash.XxHash32
容器
字段
std.hash.xxhash.XxHash32.Accumulator
容器
字段
acc1: u32
acc2: u32
acc3: u32
acc4: u32
std.hash.xxhash.XxHash32.Accumulator.init
函数
fn init(seed: u32) Accumulator
参数
seed: u32
std.hash.xxhash.XxHash32.Accumulator.merge
函数
fn merge(self: Accumulator) u32
参数
self: Accumulator
std.hash.xxhash.XxHash32.Accumulator.processStripe
函数
fn processStripe(self: *Accumulator, buf: *const [16]u8) void
参数
self: *Accumulator
buf: *const [16]u8
std.hash.xxhash.XxHash32.Accumulator.updateEmpty
函数
fn updateEmpty(self: *Accumulator, input: anytype, comptime unroll_count: usize) usize
参数
self: *Accumulator
unroll_count: usize
std.hash.xxhash.XxHash32.avalanche
函数
fn avalanche(value: u32) u32
参数
value: u32
std.hash.xxhash.XxHash32.final
函数
pub fn final(self: *XxHash32) u32
参数
self: *XxHash32
std.hash.xxhash.XxHash32.finalize
函数
fn finalize(unfinished: u32, byte_count: usize, partial: anytype) u32
参数
unfinished: u32
byte_count: usize
std.hash.xxhash.XxHash32.finalize1
函数
fn finalize1(v: u32, byte: u8) u32
参数
v: u32
byte: u8
std.hash.xxhash.XxHash32.finalize4
函数
fn finalize4(v: u32, bytes: *const [4]u8) u32
参数
v: u32
bytes: *const [4]u8
std.hash.xxhash.XxHash32.hash
函数
pub fn hash(seed: u32, input: anytype) u32
参数
seed: u32
std.hash.xxhash.XxHash32.init
函数
pub fn init(seed: u32) XxHash32
参数
seed: u32
std.hash.xxhash.XxHash32.prime_1
常量
std.hash.xxhash.XxHash32.prime_2
常量
std.hash.xxhash.XxHash32.prime_3
常量
std.hash.xxhash.XxHash32.prime_4
常量
std.hash.xxhash.XxHash32.prime_5
常量
std.hash.xxhash.XxHash32.round
函数
fn round(acc: u32, lane: u32) u32
参数
acc: u32
lane: u32
std.hash.xxhash.XxHash32.update
函数
pub fn update(self: *XxHash32, input: []const u8) void
参数
self: *XxHash32
input: []const u8
std.hash.xxhash.XxHash64
容器
字段
std.hash.xxhash.XxHash64.Accumulator
容器
字段
acc1: u64
acc2: u64
acc3: u64
acc4: u64
std.hash.xxhash.XxHash64.Accumulator.init
函数
fn init(seed: u64) Accumulator
参数
seed: u64
std.hash.xxhash.XxHash64.Accumulator.merge
函数
fn merge(self: Accumulator) u64
参数
self: Accumulator
std.hash.xxhash.XxHash64.Accumulator.mergeAccumulator
函数
fn mergeAccumulator(acc: u64, other: u64) u64
参数
acc: u64
other: u64
std.hash.xxhash.XxHash64.Accumulator.processStripe
函数
fn processStripe(self: *Accumulator, buf: *const [32]u8) void
参数
self: *Accumulator
buf: *const [32]u8
std.hash.xxhash.XxHash64.Accumulator.updateEmpty
函数
fn updateEmpty(self: *Accumulator, input: anytype, comptime unroll_count: usize) usize
参数
self: *Accumulator
unroll_count: usize
std.hash.xxhash.XxHash64.avalanche
函数
fn avalanche(value: u64) u64
参数
value: u64
std.hash.xxhash.XxHash64.final
函数
pub fn final(self: *XxHash64) u64
参数
self: *XxHash64
std.hash.xxhash.XxHash64.finalize
函数
fn finalize( unfinished: u64, byte_count: usize, partial: anytype, ) u64
参数
unfinished: u64
byte_count: usize
std.hash.xxhash.XxHash64.finalize1
函数
fn finalize1(v: u64, byte: u8) u64
参数
v: u64
byte: u8
std.hash.xxhash.XxHash64.finalize4
函数
fn finalize4(v: u64, bytes: *const [4]u8) u64
参数
v: u64
bytes: *const [4]u8
std.hash.xxhash.XxHash64.finalize8
函数
fn finalize8(v: u64, bytes: *const [8]u8) u64
参数
v: u64
bytes: *const [8]u8
std.hash.xxhash.XxHash64.hash
函数
pub fn hash(seed: u64, input: anytype) u64
参数
seed: u64
std.hash.xxhash.XxHash64.init
函数
pub fn init(seed: u64) XxHash64
参数
seed: u64
std.hash.xxhash.XxHash64.prime_1
常量
std.hash.xxhash.XxHash64.prime_2
常量
std.hash.xxhash.XxHash64.prime_3
常量
std.hash.xxhash.XxHash64.prime_4
常量
std.hash.xxhash.XxHash64.prime_5
常量
std.hash.xxhash.XxHash64.round
函数
fn round(acc: u64, lane: u64) u64
参数
acc: u64
lane: u64
std.hash.xxhash.XxHash64.Size
容器
字段
small
large
unknown
std.hash.xxhash.XxHash64.update
函数
pub fn update(self: *XxHash64, input: anytype) void
参数
self: *XxHash64
源码
std/hash/xxhash.zig
const std = @import("std");
const mem = std.mem;
const expectEqual = std.testing.expectEqual;
const rotl = std.math.rotl;
pub const XxHash64 = struct {
accumulator: Accumulator,
seed: u64,
buf: [32]u8,
buf_len: usize,
byte_count: usize,
const prime_1 = 0x9E3779B185EBCA87; // 0b1001111000110111011110011011000110000101111010111100101010000111
const prime_2 = 0xC2B2AE3D27D4EB4F; // 0b1100001010110010101011100011110100100111110101001110101101001111
const prime_3 = 0x165667B19E3779F9; // 0b0001011001010110011001111011000110011110001101110111100111111001
const prime_4 = 0x85EBCA77C2B2AE63; // 0b1000010111101011110010100111011111000010101100101010111001100011
const prime_5 = 0x27D4EB2F165667C5; // 0b0010011111010100111010110010111100010110010101100110011111000101
const Accumulator = struct {
acc1: u64,
acc2: u64,
acc3: u64,
acc4: u64,
fn init(seed: u64) Accumulator {
return .{
.acc1 = seed +% prime_1 +% prime_2,
.acc2 = seed +% prime_2,
.acc3 = seed,
.acc4 = seed -% prime_1,
};
}
fn updateEmpty(self: *Accumulator, input: anytype, comptime unroll_count: usize) usize {
var i: usize = 0;
if (unroll_count > 0) {
const unrolled_bytes = unroll_count * 32;
while (i + unrolled_bytes <= input.len) : (i += unrolled_bytes) {
inline for (0..unroll_count) |j| {
self.processStripe(input[i + j * 32 ..][0..32]);
}
}
}
while (i + 32 <= input.len) : (i += 32) {
self.processStripe(input[i..][0..32]);
}
return i;
}
fn processStripe(self: *Accumulator, buf: *const [32]u8) void {
self.acc1 = round(self.acc1, mem.readInt(u64, buf[0..8], .little));
self.acc2 = round(self.acc2, mem.readInt(u64, buf[8..16], .little));
self.acc3 = round(self.acc3, mem.readInt(u64, buf[16..24], .little));
self.acc4 = round(self.acc4, mem.readInt(u64, buf[24..32], .little));
}
fn merge(self: Accumulator) u64 {
var acc = rotl(u64, self.acc1, 1) +% rotl(u64, self.acc2, 7) +%
rotl(u64, self.acc3, 12) +% rotl(u64, self.acc4, 18);
acc = mergeAccumulator(acc, self.acc1);
acc = mergeAccumulator(acc, self.acc2);
acc = mergeAccumulator(acc, self.acc3);
acc = mergeAccumulator(acc, self.acc4);
return acc;
}
fn mergeAccumulator(acc: u64, other: u64) u64 {
const a = acc ^ round(0, other);
const b = a *% prime_1;
return b +% prime_4;
}
};
fn finalize(
unfinished: u64,
byte_count: usize,
partial: anytype,
) u64 {
std.debug.assert(partial.len < 32);
var acc = unfinished +% @as(u64, byte_count) +% @as(u64, partial.len);
switch (partial.len) {
inline 0, 1, 2, 3 => |count| {
inline for (0..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 4, 5, 6, 7 => |count| {
acc = finalize4(acc, partial[0..4]);
inline for (4..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 8, 9, 10, 11 => |count| {
acc = finalize8(acc, partial[0..8]);
inline for (8..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 12, 13, 14, 15 => |count| {
acc = finalize8(acc, partial[0..8]);
acc = finalize4(acc, partial[8..12]);
inline for (12..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 16, 17, 18, 19 => |count| {
acc = finalize8(acc, partial[0..8]);
acc = finalize8(acc, partial[8..16]);
inline for (16..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 20, 21, 22, 23 => |count| {
acc = finalize8(acc, partial[0..8]);
acc = finalize8(acc, partial[8..16]);
acc = finalize4(acc, partial[16..20]);
inline for (20..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 24, 25, 26, 27 => |count| {
acc = finalize8(acc, partial[0..8]);
acc = finalize8(acc, partial[8..16]);
acc = finalize8(acc, partial[16..24]);
inline for (24..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 28, 29, 30, 31 => |count| {
acc = finalize8(acc, partial[0..8]);
acc = finalize8(acc, partial[8..16]);
acc = finalize8(acc, partial[16..24]);
acc = finalize4(acc, partial[24..28]);
inline for (28..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
else => unreachable,
}
}
fn finalize8(v: u64, bytes: *const [8]u8) u64 {
var acc = v;
const lane = mem.readInt(u64, bytes, .little);
acc ^= round(0, lane);
acc = rotl(u64, acc, 27) *% prime_1;
acc +%= prime_4;
return acc;
}
fn finalize4(v: u64, bytes: *const [4]u8) u64 {
var acc = v;
const lane = @as(u64, mem.readInt(u32, bytes, .little));
acc ^= lane *% prime_1;
acc = rotl(u64, acc, 23) *% prime_2;
acc +%= prime_3;
return acc;
}
fn finalize1(v: u64, byte: u8) u64 {
var acc = v;
const lane = @as(u64, byte);
acc ^= lane *% prime_5;
acc = rotl(u64, acc, 11) *% prime_1;
return acc;
}
fn avalanche(value: u64) u64 {
var result = value ^ (value >> 33);
result *%= prime_2;
result ^= result >> 29;
result *%= prime_3;
result ^= result >> 32;
return result;
}
pub fn init(seed: u64) XxHash64 {
return XxHash64{
.accumulator = Accumulator.init(seed),
.seed = seed,
.buf = undefined,
.buf_len = 0,
.byte_count = 0,
};
}
pub fn update(self: *XxHash64, input: anytype) void {
if (input.len < 32 - self.buf_len) {
@memcpy(self.buf[self.buf_len..][0..input.len], input);
self.buf_len += input.len;
return;
}
var i: usize = 0;
if (self.buf_len > 0) {
i = 32 - self.buf_len;
@memcpy(self.buf[self.buf_len..][0..i], input[0..i]);
self.accumulator.processStripe(&self.buf);
self.byte_count += self.buf_len;
}
i += self.accumulator.updateEmpty(input[i..], 32);
self.byte_count += i;
const remaining_bytes = input[i..];
@memcpy(self.buf[0..remaining_bytes.len], remaining_bytes);
self.buf_len = remaining_bytes.len;
}
fn round(acc: u64, lane: u64) u64 {
const a = acc +% (lane *% prime_2);
const b = rotl(u64, a, 31);
return b *% prime_1;
}
pub fn final(self: *XxHash64) u64 {
const unfinished = if (self.byte_count < 32)
self.seed +% prime_5
else
self.accumulator.merge();
return finalize(unfinished, self.byte_count, self.buf[0..self.buf_len]);
}
const Size = enum {
small,
large,
unknown,
};
pub fn hash(seed: u64, input: anytype) u64 {
if (input.len < 32) {
return finalize(seed +% prime_5, 0, input);
} else {
var hasher = Accumulator.init(seed);
const i = hasher.updateEmpty(input, 0);
return finalize(hasher.merge(), i, input[i..]);
}
}
};
pub const XxHash32 = struct {
accumulator: Accumulator,
seed: u32,
buf: [16]u8,
buf_len: usize,
byte_count: usize,
const prime_1 = 0x9E3779B1; // 0b10011110001101110111100110110001
const prime_2 = 0x85EBCA77; // 0b10000101111010111100101001110111
const prime_3 = 0xC2B2AE3D; // 0b11000010101100101010111000111101
const prime_4 = 0x27D4EB2F; // 0b00100111110101001110101100101111
const prime_5 = 0x165667B1; // 0b00010110010101100110011110110001
const Accumulator = struct {
acc1: u32,
acc2: u32,
acc3: u32,
acc4: u32,
fn init(seed: u32) Accumulator {
return .{
.acc1 = seed +% prime_1 +% prime_2,
.acc2 = seed +% prime_2,
.acc3 = seed,
.acc4 = seed -% prime_1,
};
}
fn updateEmpty(self: *Accumulator, input: anytype, comptime unroll_count: usize) usize {
var i: usize = 0;
if (unroll_count > 0) {
const unrolled_bytes = unroll_count * 16;
while (i + unrolled_bytes <= input.len) : (i += unrolled_bytes) {
inline for (0..unroll_count) |j| {
self.processStripe(input[i + j * 16 ..][0..16]);
}
}
}
while (i + 16 <= input.len) : (i += 16) {
self.processStripe(input[i..][0..16]);
}
return i;
}
fn processStripe(self: *Accumulator, buf: *const [16]u8) void {
self.acc1 = round(self.acc1, mem.readInt(u32, buf[0..4], .little));
self.acc2 = round(self.acc2, mem.readInt(u32, buf[4..8], .little));
self.acc3 = round(self.acc3, mem.readInt(u32, buf[8..12], .little));
self.acc4 = round(self.acc4, mem.readInt(u32, buf[12..16], .little));
}
fn merge(self: Accumulator) u32 {
return rotl(u32, self.acc1, 1) +% rotl(u32, self.acc2, 7) +%
rotl(u32, self.acc3, 12) +% rotl(u32, self.acc4, 18);
}
};
pub fn init(seed: u32) XxHash32 {
return XxHash32{
.accumulator = Accumulator.init(seed),
.seed = seed,
.buf = undefined,
.buf_len = 0,
.byte_count = 0,
};
}
pub fn update(self: *XxHash32, input: []const u8) void {
if (input.len < 16 - self.buf_len) {
@memcpy(self.buf[self.buf_len..][0..input.len], input);
self.buf_len += input.len;
return;
}
var i: usize = 0;
if (self.buf_len > 0) {
i = 16 - self.buf_len;
@memcpy(self.buf[self.buf_len..][0..i], input[0..i]);
self.accumulator.processStripe(&self.buf);
self.byte_count += self.buf_len;
self.buf_len = 0;
}
i += self.accumulator.updateEmpty(input[i..], 16);
self.byte_count += i;
const remaining_bytes = input[i..];
@memcpy(self.buf[0..remaining_bytes.len], remaining_bytes);
self.buf_len = remaining_bytes.len;
}
fn round(acc: u32, lane: u32) u32 {
const a = acc +% (lane *% prime_2);
const b = rotl(u32, a, 13);
return b *% prime_1;
}
pub fn final(self: *XxHash32) u32 {
const unfinished = if (self.byte_count < 16)
self.seed +% prime_5
else
self.accumulator.merge();
return finalize(unfinished, self.byte_count, self.buf[0..self.buf_len]);
}
fn finalize(unfinished: u32, byte_count: usize, partial: anytype) u32 {
std.debug.assert(partial.len < 16);
var acc = unfinished +% @as(u32, @intCast(byte_count)) +% @as(u32, @intCast(partial.len));
switch (partial.len) {
inline 0, 1, 2, 3 => |count| {
inline for (0..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 4, 5, 6, 7 => |count| {
acc = finalize4(acc, partial[0..4]);
inline for (4..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 8, 9, 10, 11 => |count| {
acc = finalize4(acc, partial[0..4]);
acc = finalize4(acc, partial[4..8]);
inline for (8..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
inline 12, 13, 14, 15 => |count| {
acc = finalize4(acc, partial[0..4]);
acc = finalize4(acc, partial[4..8]);
acc = finalize4(acc, partial[8..12]);
inline for (12..count) |i| acc = finalize1(acc, partial[i]);
return avalanche(acc);
},
else => unreachable,
}
return avalanche(acc);
}
fn finalize4(v: u32, bytes: *const [4]u8) u32 {
var acc = v;
const lane = mem.readInt(u32, bytes, .little);
acc +%= lane *% prime_3;
acc = rotl(u32, acc, 17) *% prime_4;
return acc;
}
fn finalize1(v: u32, byte: u8) u32 {
var acc = v;
const lane = @as(u32, byte);
acc +%= lane *% prime_5;
acc = rotl(u32, acc, 11) *% prime_1;
return acc;
}
fn avalanche(value: u32) u32 {
var acc = value ^ value >> 15;
acc *%= prime_2;
acc ^= acc >> 13;
acc *%= prime_3;
acc ^= acc >> 16;
return acc;
}
pub fn hash(seed: u32, input: anytype) u32 {
if (input.len < 16) {
return finalize(seed +% prime_5, 0, input);
} else {
var hasher = Accumulator.init(seed);
const i = hasher.updateEmpty(input, 0);
return finalize(hasher.merge(), i, input[i..]);
}
}
};
pub const XxHash3 = struct {
const block_bytes = 64;
const Block = @Vector(8, u64);
const InputBlock = extern struct {
raw: [block_bytes]u8,
inline fn load(ptr: *const InputBlock) Block {
return @bitCast(ptr.raw);
}
inline fn store(ptr: *InputBlock, val: Block) void {
ptr.raw = @bitCast(val);
}
};
const default_secret: [192]u8 = .{
0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,
0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,
0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,
0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,
0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,
0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,
0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,
0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,
0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,
0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,
0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,
0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
};
const prime_mx1 = 0x165667919E3779F9;
const prime_mx2 = 0x9FB21C651E98DF25;
inline fn avalanche(mode: union(enum) { h3, h64, rrmxmx: u64 }, x0: u64) u64 {
switch (mode) {
.h3 => {
const x1 = (x0 ^ (x0 >> 37)) *% prime_mx1;
return x1 ^ (x1 >> 32);
},
.h64 => {
const x1 = (x0 ^ (x0 >> 33)) *% XxHash64.prime_2;
const x2 = (x1 ^ (x1 >> 29)) *% XxHash64.prime_3;
return x2 ^ (x2 >> 32);
},
.rrmxmx => |len| {
const x1 = (x0 ^ rotl(u64, x0, 49) ^ rotl(u64, x0, 24)) *% prime_mx2;
const x2 = (x1 ^ ((x1 >> 35) +% len)) *% prime_mx2;
return x2 ^ (x2 >> 28);
},
}
}
inline fn fold(a: u64, b: u64) u64 {
const wide: [2]u64 = @bitCast(@as(u128, a) *% b);
return wide[0] ^ wide[1];
}
inline fn disableAutoVectorization(x: anytype) void {
if (!@inComptime()) asm volatile (""
:
: [x] "r" (x),
);
}
inline fn mix16(seed: u64, input: []const u8, secret: []const u8) u64 {
const blk: [4]u64 = @bitCast([2][16]u8{ input[0..16].*, secret[0..16].* });
disableAutoVectorization(seed);
return fold(
blk[0] ^ (blk[2] +% seed),
blk[1] ^ (blk[3] -% seed),
);
}
const Accumulator = struct {
consumed: usize = 0,
seed: u64,
secret: [192]u8,
state: Block = .{
XxHash32.prime_3,
XxHash64.prime_1,
XxHash64.prime_2,
XxHash64.prime_3,
XxHash64.prime_4,
XxHash32.prime_2,
XxHash64.prime_5,
XxHash32.prime_1,
},
inline fn init(seed: u64) Accumulator {
const seed_block: Block = .{
seed, @as(u64, 0) -% seed,
seed, @as(u64, 0) -% seed,
seed, @as(u64, 0) -% seed,
seed, @as(u64, 0) -% seed,
};
var secret: [192]u8 = undefined;
const secret_blocks: []InputBlock = @ptrCast(&secret);
const default_secret_blocks: []const InputBlock = @ptrCast(&default_secret);
for (secret_blocks, default_secret_blocks) |*dst, *src| {
dst.store(src.load() +% seed_block);
}
return .{ .seed = seed, .secret = secret };
}
inline fn round(
noalias state: *Block,
noalias input_block: *const InputBlock,
noalias secret_block: *const InputBlock,
) void {
const data = input_block.load();
const mixed = data ^ secret_block.load();
state.* +%= (mixed & @as(Block, @splat(0xffffffff))) *% (mixed >> @splat(32));
state.* +%= @shuffle(u64, data, undefined, [_]i32{ 1, 0, 3, 2, 5, 4, 7, 6 });
}
fn accumulate(noalias self: *Accumulator, blocks: []const InputBlock) void {
const secret = std.mem.bytesAsSlice(u64, self.secret[self.consumed * 8 ..]);
for (blocks, secret[0..blocks.len]) |*input_block, *secret_block| {
@prefetch(@as([*]const u8, @ptrCast(input_block)) + 320, .{});
round(&self.state, input_block, @ptrCast(secret_block));
}
}
fn scramble(self: *Accumulator) void {
const secret_block: Block = @bitCast(self.secret[192 - block_bytes .. 192].*);
self.state ^= self.state >> @splat(47);
self.state ^= secret_block;
self.state *%= @as(Block, @splat(XxHash32.prime_1));
}
fn consume(noalias self: *Accumulator, input_blocks: []const InputBlock) void {
const blocks_per_scramble = 1024 / block_bytes;
std.debug.assert(self.consumed <= blocks_per_scramble);
var blocks = input_blocks;
var blocks_until_scramble = blocks_per_scramble - self.consumed;
while (blocks.len >= blocks_until_scramble) {
self.accumulate(blocks[0..blocks_until_scramble]);
self.scramble();
self.consumed = 0;
blocks = blocks[blocks_until_scramble..];
blocks_until_scramble = blocks_per_scramble;
}
self.accumulate(blocks);
self.consumed += blocks.len;
}
fn digest(noalias self: *Accumulator, total_len: u64, noalias last_block: *const InputBlock) u64 {
const secret_block = self.secret[192 - block_bytes - 7 ..][0..block_bytes];
round(&self.state, last_block, @ptrCast(secret_block));
const merge_block: Block = @bitCast(self.secret[11 .. 11 + block_bytes].*);
self.state ^= merge_block;
var result = XxHash64.prime_1 *% total_len;
inline for (0..4) |i| {
result +%= fold(self.state[i * 2], self.state[i * 2 + 1]);
}
return avalanche(.h3, result);
}
};
// 公共 API——一次性操作
pub fn hash(seed: u64, input: anytype) u64 {
const secret = &default_secret;
if (input.len > 240) return hashLong(seed, input);
if (input.len > 128) return hash240(seed, input, secret);
if (input.len > 16) return hash128(seed, input, secret);
if (input.len > 8) return hash16(seed, input, secret);
if (input.len > 3) return hash8(seed, input, secret);
if (input.len > 0) return hash3(seed, input, secret);
const flip: [2]u64 = @bitCast(secret[56..72].*);
const key = flip[0] ^ flip[1];
return avalanche(.h64, seed ^ key);
}
fn hash3(seed: u64, input: anytype, noalias secret: *const [192]u8) u64 {
@branchHint(.unlikely);
std.debug.assert(input.len > 0 and input.len < 4);
const flip: [2]u32 = @bitCast(secret[0..8].*);
const blk: u32 = @bitCast([_]u8{
input[input.len - 1],
@truncate(input.len),
input[0],
input[input.len / 2],
});
const key = @as(u64, flip[0] ^ flip[1]) +% seed;
return avalanche(.h64, key ^ blk);
}
fn hash8(seed: u64, input: anytype, noalias secret: *const [192]u8) u64 {
@branchHint(.cold);
std.debug.assert(input.len >= 4 and input.len <= 8);
const flip: [2]u64 = @bitCast(secret[8..24].*);
const blk: [2]u32 = @bitCast([_][4]u8{
input[0..4].*,
input[input.len - 4 ..][0..4].*,
});
const mixed = seed ^ (@as(u64, @byteSwap(@as(u32, @truncate(seed)))) << 32);
const key = (flip[0] ^ flip[1]) -% mixed;
const combined = (@as(u64, blk[0]) << 32) +% blk[1];
return avalanche(.{ .rrmxmx = input.len }, key ^ combined);
}
fn hash16(seed: u64, input: anytype, noalias secret: *const [192]u8) u64 {
@branchHint(.unlikely);
std.debug.assert(input.len > 8 and input.len <= 16);
const flip: [4]u64 = @bitCast(secret[24..56].*);
const blk: [2]u64 = @bitCast([_][8]u8{
input[0..8].*,
input[input.len - 8 ..][0..8].*,
});
const lo = blk[0] ^ ((flip[0] ^ flip[1]) +% seed);
const hi = blk[1] ^ ((flip[2] ^ flip[3]) -% seed);
const combined = @as(u64, input.len) +% @byteSwap(lo) +% hi +% fold(lo, hi);
return avalanche(.h3, combined);
}
fn hash128(seed: u64, input: anytype, noalias secret: *const [192]u8) u64 {
@branchHint(.unlikely);
std.debug.assert(input.len > 16 and input.len <= 128);
var acc = XxHash64.prime_1 *% @as(u64, input.len);
inline for (0..4) |i| {
const in_offset = 48 - (i * 16);
const scrt_offset = 96 - (i * 32);
if (input.len > scrt_offset) {
acc +%= mix16(seed, input[in_offset..], secret[scrt_offset..]);
acc +%= mix16(seed, input[input.len - (in_offset + 16) ..], secret[scrt_offset + 16 ..]);
}
}
return avalanche(.h3, acc);
}
fn hash240(seed: u64, input: anytype, noalias secret: *const [192]u8) u64 {
@branchHint(.unlikely);
std.debug.assert(input.len > 128 and input.len <= 240);
var acc = XxHash64.prime_1 *% @as(u64, input.len);
inline for (0..8) |i| {
acc +%= mix16(seed, input[i * 16 ..], secret[i * 16 ..]);
}
var acc_end = mix16(seed, input[input.len - 16 ..], secret[136 - 17 ..]);
for (8..(input.len / 16)) |i| {
acc_end +%= mix16(seed, input[i * 16 ..], secret[((i - 8) * 16) + 3 ..]);
disableAutoVectorization(i);
}
acc = avalanche(.h3, acc) +% acc_end;
return avalanche(.h3, acc);
}
noinline fn hashLong(seed: u64, input: []const u8) u64 {
@branchHint(.unlikely);
std.debug.assert(input.len >= 240);
const block_count = ((input.len - 1) / block_bytes) * block_bytes;
const last_block = input[input.len - block_bytes ..][0..block_bytes];
var acc = Accumulator.init(seed);
acc.consume(std.mem.bytesAsSlice(InputBlock, input[0..block_count]));
return acc.digest(input.len, @ptrCast(last_block));
}
// 公共 API - 流式
buffered: usize = 0,
buffer: [256]u8 = undefined,
total_len: usize = 0,
accumulator: Accumulator,
pub fn init(seed: u64) XxHash3 {
return .{ .accumulator = Accumulator.init(seed) };
}
pub fn update(self: *XxHash3, input: anytype) void {
self.total_len += input.len;
std.debug.assert(self.buffered <= self.buffer.len);
// 若缓冲区尚未填满,则将输入复制进去。
const remaining = self.buffer.len - self.buffered;
if (input.len <= remaining) {
@memcpy(self.buffer[self.buffered..][0..input.len], input);
self.buffered += input.len;
return;
}
// 输入会使缓冲区溢出。用部分输入填满缓冲区,再消费它。
var consumable: []const u8 = input;
if (self.buffered > 0) {
@memcpy(self.buffer[self.buffered..], consumable[0..remaining]);
consumable = consumable[remaining..];
self.accumulator.consume(std.mem.bytesAsSlice(InputBlock, &self.buffer));
self.buffered = 0;
}
// 输入无法完整装入缓冲区。直接消费它。
if (consumable.len > self.buffer.len) {
const block_count = ((consumable.len - 1) / block_bytes) * block_bytes;
self.accumulator.consume(std.mem.bytesAsSlice(InputBlock, consumable[0..block_count]));
consumable = consumable[block_count..];
// 若消费了全部剩余输入,则将最后一个块写到缓冲区末尾,
// 以填充 final() 中的 last_block_copy,类似于 hashLong() 的 last_block。
@memcpy(
self.buffer[self.buffer.len - block_bytes .. self.buffer.len],
(consumable.ptr - block_bytes)[0..block_bytes],
);
}
// 将所有剩余输入复制进缓冲区。
std.debug.assert(consumable.len <= self.buffer.len);
@memcpy(self.buffer[0..consumable.len], consumable);
self.buffered = consumable.len;
}
pub fn final(self: *XxHash3) u64 {
std.debug.assert(self.buffered <= self.total_len);
std.debug.assert(self.buffered <= self.buffer.len);
// 对于较小输入使用 Oneshot 哈希,因为它不像 hashLong 那样使用 Accumulator。
if (self.total_len <= 240) {
return hash(self.accumulator.seed, self.buffer[0..self.total_len]);
}
// 复制 Accumulator 状态,以备 `self` 之后需要 update() 或再次使用。
var accumulator_copy = self.accumulator;
var last_block_copy: [block_bytes]u8 = undefined;
// 在 Accumulator 副本上处理最后一个块的摘要。
return accumulator_copy.digest(self.total_len, last_block: {
if (self.buffered >= block_bytes) {
const block_count = ((self.buffered - 1) / block_bytes) * block_bytes;
accumulator_copy.consume(std.mem.bytesAsSlice(InputBlock, self.buffer[0..block_count]));
break :last_block @ptrCast(self.buffer[self.buffered - block_bytes ..][0..block_bytes]);
} else {
const remaining = block_bytes - self.buffered;
@memcpy(last_block_copy[0..remaining], self.buffer[self.buffer.len - remaining ..][0..remaining]);
@memcpy(last_block_copy[remaining..][0..self.buffered], self.buffer[0..self.buffered]);
break :last_block @ptrCast(&last_block_copy);
}
});
}
};
const verify = @import("verify.zig");
fn testExpect(comptime H: type, seed: anytype, input: []const u8, expected: u64) !void {
try expectEqual(expected, H.hash(seed, input));
var hasher = H.init(seed);
hasher.update(input);
try expectEqual(expected, hasher.final());
}
test "xxhash3" {
const H = XxHash3;
// 不设种子的测试
try testExpect(H, 0, "", 0x2d06800538d394c2);
try testExpect(H, 0, "a", 0xe6c632b61e964e1f);
try testExpect(H, 0, "abc", 0x78af5f94892f3950);
try testExpect(H, 0, "message", 0x0b1ca9b8977554fa);
try testExpect(H, 0, "message digest", 0x160d8e9329be94f9);
try testExpect(H, 0, "abcdefghijklmnopqrstuvwxyz", 0x810f9ca067fbb90c);
try testExpect(H, 0, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 0x643542bb51639cb2);
try testExpect(H, 0, "12345678901234567890123456789012345678901234567890123456789012345678901234567890", 0x7f58aa2520c681f9);
try testExpect(H, 0, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678", 0xb66ea795b5edc38c);
try testExpect(H, 0, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 0x8845e0b1b57330de);
try testExpect(H, 0, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123123", 0xf031f373d63c5653);
try testExpect(H, 0, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 0xf1bf601f9d868dce);
// 设定种子的测试
try testExpect(H, 1, "", 0x4dc5b0cc826f6703);
try testExpect(H, 1, "a", 0xd2f6d0996f37a720);
try testExpect(H, 1, "abc", 0x6b4467b443c76228);
try testExpect(H, 1, "message", 0x73fb1cf20d561766);
try testExpect(H, 1, "message digest", 0xfe71a82a70381174);
try testExpect(H, 1, "abcdefghijklmnopqrstuvwxyz", 0x902a2c2d016a37ba);
try testExpect(H, 1, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 0xbf552e540c5c6882);
try testExpect(H, 1, "12345678901234567890123456789012345678901234567890123456789012345678901234567890", 0xf2ca33235a6b865b);
try testExpect(H, 1, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678", 0x6ef5cf958ba52c4);
try testExpect(H, 1, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 0xfbc5f9c53d21cb2f);
try testExpect(H, 1, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123123", 0x48682aca3b1c5c18);
try testExpect(H, 1, "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 0x3903c5437fc4e726);
}
test "xxhash3 smhasher" {
const Test = struct {
fn do() !void {
try expectEqual(verify.smhasher(XxHash3.hash), 0x9a636405);
}
};
try Test.do();
@setEvalBranchQuota(75000);
comptime try Test.do();
}
test "xxhash3 iterative api" {
const Test = struct {
fn do() !void {
try verify.iterativeApi(XxHash3);
}
};
try Test.do();
@setEvalBranchQuota(30000);
comptime try Test.do();
}
test "xxhash64" {
const H = XxHash64;
try testExpect(H, 0, "", 0xef46db3751d8e999);
try testExpect(H, 0, "a", 0xd24ec4f1a98c6e5b);
try testExpect(H, 0, "abc", 0x44bc2cf5ad770999);
try testExpect(H, 0, "message digest", 0x066ed728fceeb3be);
try testExpect(H, 0, "abcdefghijklmnopqrstuvwxyz", 0xcfe1f278fa89835c);
try testExpect(H, 0, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 0xaaa46907d3047814);
try testExpect(H, 0, "12345678901234567890123456789012345678901234567890123456789012345678901234567890", 0xe04a477f19ee145d);
}
test "xxhash64 smhasher" {
const Test = struct {
fn do() !void {
try expectEqual(verify.smhasher(XxHash64.hash), 0x024B7CF4);
}
};
try Test.do();
@setEvalBranchQuota(75000);
comptime try Test.do();
}
test "xxhash64 iterative api" {
const Test = struct {
fn do() !void {
try verify.iterativeApi(XxHash64);
}
};
try Test.do();
@setEvalBranchQuota(30000);
comptime try Test.do();
}
test "xxhash32" {
const H = XxHash32;
try testExpect(H, 0, "", 0x02cc5d05);
try testExpect(H, 0, "a", 0x550d7456);
try testExpect(H, 0, "abc", 0x32d153ff);
try testExpect(H, 0, "message digest", 0x7c948494);
try testExpect(H, 0, "abcdefghijklmnopqrstuvwxyz", 0x63a14d5f);
try testExpect(H, 0, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 0x9c285e64);
try testExpect(H, 0, "12345678901234567890123456789012345678901234567890123456789012345678901234567890", 0x9c05f475);
}
test "xxhash32 smhasher" {
const Test = struct {
fn do() !void {
try expectEqual(verify.smhasher(XxHash32.hash), 0xBA88B743);
}
};
try Test.do();
@setEvalBranchQuota(85000);
comptime try Test.do();
}
test "xxhash32 iterative api" {
const Test = struct {
fn do() !void {
try verify.iterativeApi(XxHash32);
}
};
try Test.do();
@setEvalBranchQuota(30000);
comptime try Test.do();
}