package core:hash/xxhash
Source

⌘K
Ctrl+K
or
/

    Overview

    An implementation of Yann Collet's xxhash Fast Hash Algorithm.

    An implementation of Yann Collet's [xxhash Fast Hash Algorithm](https://cyan4973.github.io/xxHash/).
Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.

Made available under Odin's BSD-3 license, based on the original C code.

List of contributors:
	Jeroen van Rijn: Initial implementation.

An implementation of Yann Collet's [xxhash Fast Hash Algorithm](https://cyan4973.github.io/xxHash/).
Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.

Made available under Odin's BSD-3 license, based on the original C code.

List of contributors:
	Jeroen van Rijn: Initial implementation.

An implementation of Yann Collet's [xxhash Fast Hash Algorithm](https://cyan4973.github.io/xxHash/).
Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.

Made available under Odin's BSD-3 license, based on the original C code.

List of contributors:
	Jeroen van Rijn: Initial implementation.

An implementation of Yann Collet's [xxhash Fast Hash Algorithm](https://cyan4973.github.io/xxHash/).
Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.

Made available under Odin's BSD-3 license, based on the original C code.

List of contributors:
	Jeroen van Rijn: Initial implementation.

    Index

    Procedures (99)
    Procedure Groups (2)

    Types

    Alignment ¶
    Source

    Alignment :: enum int {
	Aligned, 
	Unaligned, 
}
    Related Procedures With Parameters

    Error ¶
    Source

    Error :: enum int {
	None  = 0, 
	Error, 
}
    Related Procedures With Returns

    XXH128_canonical ¶
    Source

    XXH128_canonical :: struct {
	digest: [16]u8,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    XXH128_hash_t ¶
    Source

    XXH128_hash_t :: struct #raw_union {
	using raw: struct {
		low:  u64,
		// !< `value & 0xFFFFFFFFFFFFFFFF` 
		high: u64,
	},
	h:   u128,
}
    Related Procedures With Parameters

    XXH32_canonical ¶
    Source

    XXH32_canonical :: struct {
	digest: [4]u8,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    XXH32_hash ¶
    Source

    XXH32_hash :: u32
     

    32-bit hash functions

    XXH32_state ¶
    Source

    XXH32_state :: struct {
	total_len_32: u32,
	// !< Total length hashed, modulo 2^32 
	large_len:    u32,
	// !< Whether the hash is >= 16 (handles @ref total_len_32 overflow) 
	v1:           u32,
	// !< First accumulator lane 
	v2:           u32,
	// !< Second accumulator lane 
	v3:           u32,
	// !< Third accumulator lane 
	v4:           u32,
	// !< Fourth accumulator lane 
	mem32:        [4]u32,
	// !< Internal buffer for partial reads. Treated as unsigned char[16]. 
	memsize:      u32,
	// !< Amount of data in @ref mem32 
	reserved:     u32,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    XXH3_128_hash ¶
    Source

    XXH3_128_hash :: u128

    XXH3_accumulate_512_f ¶
    Source

    XXH3_accumulate_512_f :: proc(acc: []u64, input: []u8, secret: []u8)
    Related Procedures With Parameters

    XXH3_hashLong128_f ¶
    Source

    XXH3_hashLong128_f :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128)
    Related Procedures With Parameters

    XXH3_hashLong64_f ¶
    Source

    XXH3_hashLong64_f :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u64)
    Related Procedures With Parameters

    XXH3_init_custom_secret_f ¶
    Source

    XXH3_init_custom_secret_f :: proc(custom_secret: []u8, seed64: u64)
    Related Procedures With Parameters

    XXH3_scramble_accumulator_f ¶
    Source

    XXH3_scramble_accumulator_f :: proc(acc: []u64, secret: []u8)
    Related Procedures With Parameters

    XXH3_state ¶
    Source

    XXH3_state :: struct {
	acc:               [8]u64,
	custom_secret:     [192]u8,
	buffer:            [256]u8,
	buffered_size:     u32,
	reserved32:        u32,
	stripes_so_far:    uint,
	total_length:      u64,
	stripes_per_block: uint,
	secret_limit:      uint,
	seed:              u64,
	reserved64:        u64,
	external_secret:   []u8,
}
     

    Streaming state.

    IMPORTANT: This structure has a strict alignment requirement of 64 bytes!! ** Do not allocate this with make() or new, it will not be sufficiently aligned. UseXXH3_create_state and `XXH3_destroy_state, or stack allocation.

    Related Procedures With Parameters
    Related Procedures With Returns

    XXH64_canonical ¶
    Source

    XXH64_canonical :: struct {
	digest: [8]u8,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    XXH64_hash ¶
    Source

    XXH64_hash :: u64
     

    64-bit hash functions

    XXH64_state ¶
    Source

    XXH64_state :: struct {
	total_len:  u64,
	// !< Total length hashed. This is always 64-bit. 
	v1:         u64,
	// !< First accumulator lane 
	v2:         u64,
	// !< Second accumulator lane 
	v3:         u64,
	// !< Third accumulator lane 
	v4:         u64,
	// !< Fourth accumulator lane 
	mem64:      [4]u64,
	// !< Internal buffer for partial reads. Treated as unsigned char[32]. 
	memsize:    u32,
	// !< Amount of data in @ref mem64 
	reserved32: u32,
	// !< Reserved field, needed for padding anyways
	reserved64: u64,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    xxh_u128 ¶
    Source

    xxh_u128 :: u128
     

    Stored in little endian order, although the fields themselves are in native endianness.

    xxh_u32 ¶
    Source

    xxh_u32 :: u32

    xxh_u64 ¶
    Source

    xxh_u64 :: u64

    Constants

    XXH32_DEFAULT_SEED ¶
    Source

    XXH32_DEFAULT_SEED: u32 : XXH32_hash(0)

    XXH3_INIT_ACC ¶
    Source

    XXH3_INIT_ACC: [8]u64 : [XXH_ACC_NB]xxh_u64{XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1}

    XXH3_INTERNAL_BUFFER_SIZE ¶
    Source

    XXH3_INTERNAL_BUFFER_SIZE :: 256
     

    This is the optimal update size for incremental hashing.

    XXH3_MIDSIZE_LASTOFFSET ¶
    Source

    XXH3_MIDSIZE_LASTOFFSET :: 17

    XXH3_MIDSIZE_MAX ¶
    Source

    XXH3_MIDSIZE_MAX :: 240

    XXH3_MIDSIZE_STARTOFFSET ¶
    Source

    XXH3_MIDSIZE_STARTOFFSET :: 3

    XXH3_SECRET_SIZE_MIN ¶
    Source

    XXH3_SECRET_SIZE_MIN :: 136
     

    Do not change this constant.

    XXH64_DEFAULT_SEED ¶
    Source

    XXH64_DEFAULT_SEED: u64 : XXH64_hash(0)

    XXH_ACC_ALIGN ¶
    Source

    XXH_ACC_ALIGN :: 8
     

    scalar

    XXH_ACC_NB ¶
    Source

    XXH_ACC_NB :: XXH_STRIPE_LEN / size_of(xxh_u64)

    XXH_DISABLE_PREFETCH ¶
    Source

    XXH_DISABLE_PREFETCH :: #config(XXH_DISABLE_PREFETCH, true)

    XXH_FORCE_ALIGN_CHECK ¶
    Source

    XXH_FORCE_ALIGN_CHECK :: #config(XXH_FORCE_ALIGN_CHECK, false)
     

    false - Use this on platforms where unaligned reads are fast true - Use this on platforms where unaligned reads are slow

    XXH_FORCE_MEMORY_ACCESS ¶
    Source

    XXH_FORCE_MEMORY_ACCESS :: #config(XXH_FORCE_MEMORY_ACCESS, 2)
     

    0 - Use memcopy, for platforms where unaligned reads are a problem 2 - Direct cast, for platforms where unaligned are allowed (default)

    XXH_PREFETCH_DIST ¶
    Source

    XXH_PREFETCH_DIST :: 320

    XXH_PRIME32_1 ¶
    Source

    XXH_PRIME32_1 :: 0x9E3779B1
     

    !< 0b10011110001101110111100110110001

    XXH_PRIME32_2 ¶
    Source

    XXH_PRIME32_2 :: 0x85EBCA77
     

    !< 0b10000101111010111100101001110111

    XXH_PRIME32_3 ¶
    Source

    XXH_PRIME32_3 :: 0xC2B2AE3D
     

    !< 0b11000010101100101010111000111101

    XXH_PRIME32_4 ¶
    Source

    XXH_PRIME32_4 :: 0x27D4EB2F
     

    !< 0b00100111110101001110101100101111

    XXH_PRIME32_5 ¶
    Source

    XXH_PRIME32_5 :: 0x165667B1
     

    !< 0b00010110010101100110011110110001

    XXH_PRIME64_1 ¶
    Source

    XXH_PRIME64_1 :: 0x9E3779B185EBCA87
     

    !< 0b1001111000110111011110011011000110000101111010111100101010000111

    XXH_PRIME64_2 ¶
    Source

    XXH_PRIME64_2 :: 0xC2B2AE3D27D4EB4F
     

    !< 0b1100001010110010101011100011110100100111110101001110101101001111

    XXH_PRIME64_3 ¶
    Source

    XXH_PRIME64_3 :: 0x165667B19E3779F9
     

    !< 0b0001011001010110011001111011000110011110001101110111100111111001

    XXH_PRIME64_4 ¶
    Source

    XXH_PRIME64_4 :: 0x85EBCA77C2B2AE63
     

    !< 0b1000010111101011110010100111011111000010101100101010111001100011

    XXH_PRIME64_5 ¶
    Source

    XXH_PRIME64_5 :: 0x27D4EB2F165667C5
     

    !< 0b0010011111010100111010110010111100010110010101100110011111000101

    XXH_SECRET_CONSUME_RATE ¶
    Source

    XXH_SECRET_CONSUME_RATE :: 8
     

    nb of secret bytes consumed at each accumulation

    XXH_SECRET_DEFAULT_SIZE ¶
    Source

    XXH_SECRET_DEFAULT_SIZE :: max(XXH3_SECRET_SIZE_MIN, #config(XXH_SECRET_DEFAULT_SIZE, 192))
     

    Custom secrets have a default length of 192, but can be set to a different size. The minimum secret size is 136 bytes. It must also be a multiple of 64.

    XXH_SECRET_LASTACC_START ¶
    Source

    XXH_SECRET_LASTACC_START :: 7
     

    not aligned on 8, last secret is different from acc & scrambler

    XXH_SECRET_MERGEACCS_START ¶
    Source

    XXH_SECRET_MERGEACCS_START :: 11

    XXH_STRIPE_LEN ¶
    Source

    XXH_STRIPE_LEN :: 64

    XXH_VERSION_MAJOR ¶
    Source

    XXH_VERSION_MAJOR :: 0
     

    Version definition

    XXH_VERSION_MINOR ¶
    Source

    XXH_VERSION_MINOR :: 8

    XXH_VERSION_NUMBER ¶
    Source

    XXH_VERSION_NUMBER :: XXH_VERSION_MAJOR * 100 * 100 + XXH_VERSION_MINOR * 100 + XXH_VERSION_RELEASE

    XXH_VERSION_RELEASE ¶
    Source

    XXH_VERSION_RELEASE :: 1

    Variables

    XXH3_accumulate_512 ¶
    Source

    XXH3_accumulate_512: XXH3_accumulate_512_f = …

    XXH3_init_custom_secret ¶
    Source

    XXH3_init_custom_secret: XXH3_init_custom_secret_f = …

    XXH3_kSecret ¶
    Source

    XXH3_kSecret: [192]u8 = …

    XXH3_scramble_accumulator ¶
    Source

    XXH3_scramble_accumulator: XXH3_scramble_accumulator_f = …

    Procedures

    XXH128_mix32B ¶
    Source

    XXH128_mix32B :: proc(acc: u128, input_1: []u8, input_2: []u8, secret: []u8, seed: u64) -> (res: u128) {…}
     

    A bit slower than XXH3_mix16B, but handles multiply by zero better.

    XXH32 ¶
    Source

    XXH32 :: proc(input: []u8, seed: u32 = XXH32_DEFAULT_SEED) -> (digest: u32) {…}

    XXH32_avalanche ¶
    Source

    XXH32_avalanche :: proc(h32: u32) -> (res: u32) {…}
     

    Mix all bits

    XXH32_canonical_from_hash ¶
    Source

    XXH32_canonical_from_hash :: proc(hash: u32) -> (canonical: XXH32_canonical) {…}
     

    * Canonical representation *

    The default return values from XXH functions are unsigned 32 and 64 bit integers.

    The canonical representation uses big endian convention, the same convention as human-readable numbers (large digits first).

    This way, hash values can be written into a file or buffer, remaining comparable across different systems.

    The following functions allow transformation of hash values to and from their canonical format.

    XXH32_copy_state ¶
    Source

    XXH32_copy_state :: proc(dest, src: ^XXH32_state) {…}

    XXH32_create_state ¶
    Source

    XXH32_create_state :: proc(allocator := context.allocator) -> (res: ^XXH32_state, err: Error) {…}
     

    * Hash streaming *

    XXH32_destroy_state ¶
    Source

    XXH32_destroy_state :: proc(state: ^XXH32_state, allocator := context.allocator) -> (err: Error) {…}

    XXH32_digest ¶
    Source

    XXH32_digest :: proc(state: ^XXH32_state) -> (res: u32) {…}

    XXH32_endian_align ¶
    Source

    XXH32_endian_align :: proc(input: []u8, seed: u32 = XXH32_DEFAULT_SEED, alignment: Alignment) -> (res: u32) {…}

    XXH32_finalize ¶
    Source

    XXH32_finalize :: proc(h32: u32, buf: []u8, alignment: Alignment) -> (res: u32) {…}

    XXH32_hash_from_canonical ¶
    Source

    XXH32_hash_from_canonical :: proc(canonical: ^XXH32_canonical) -> (hash: u32) {…}

    XXH32_read32 ¶
    Source

    XXH32_read32 :: proc(buf: []u8, alignment: Alignment = Alignment.Unaligned) -> (res: u32) {…}

    XXH32_reset_state ¶
    Source

    XXH32_reset_state :: proc(state_ptr: ^XXH32_state, seed: u32 = XXH32_DEFAULT_SEED) -> (err: Error) {…}

    XXH32_round ¶
    Source

    XXH32_round :: proc(seed, input: u32) -> (res: u32) {…}

    XXH32_update ¶
    Source

    XXH32_update :: proc(state: ^XXH32_state, input: []u8) -> (err: Error) {…}

    XXH3_128_canonical_from_hash ¶
    Source

    XXH3_128_canonical_from_hash :: proc(hash: XXH128_hash_t) -> (canonical: XXH128_canonical) {…}

    XXH3_128_default ¶
    Source

    XXH3_128_default :: proc(input: []u8) -> (hash: u128) {…}
     

    === Public XXH128 API ===

    XXH3_128_digest ¶
    Source

    XXH3_128_digest :: proc(state: ^XXH3_state) -> (hash: u128) {…}

    XXH3_128_hash_from_canonical ¶
    Source

    XXH3_128_hash_from_canonical :: proc(src: ^XXH128_canonical) -> (hash: u128) {…}

    XXH3_128_reset ¶
    Source

    XXH3_128_reset :: proc(state: ^XXH3_state) -> (err: Error) {…}
     

    === XXH3 128-bit streaming ===

    All the functions are actually the same as for 64-bit streaming variant. The only difference is the finalization routine.

    XXH3_128_reset_with_secret ¶
    Source

    XXH3_128_reset_with_secret :: proc(state: ^XXH3_state, secret: []u8) -> (err: Error) {…}

    XXH3_128_reset_with_seed ¶
    Source

    XXH3_128_reset_with_seed :: proc(state: ^XXH3_state, seed: u64) -> (err: Error) {…}

    XXH3_128_update ¶
    Source

    XXH3_128_update :: proc(state: ^XXH3_state, input: []u8) -> (err: Error) {…}

    XXH3_128_with_secret ¶
    Source

    XXH3_128_with_secret :: proc(input: []u8, secret: []u8) -> (hash: u128) {…}

    XXH3_128_with_seed ¶
    Source

    XXH3_128_with_seed :: proc(input: []u8, seed: u64 = XXH64_DEFAULT_SEED) -> (hash: u128) {…}

    XXH3_128bits_internal ¶
    Source

    XXH3_128bits_internal :: proc(input: []u8, seed: u64, secret: []u8, f_hl128: XXH3_hashLong128_f) -> (res: u128) {…}

    XXH3_64_default ¶
    Source

    XXH3_64_default :: proc(input: []u8) -> (hash: u64) {…}
     

    === Public entry point ===

    XXH3_64_digest ¶
    Source

    XXH3_64_digest :: proc(state: ^XXH3_state) -> (hash: u64) {…}

    XXH3_64_reset ¶
    Source

    XXH3_64_reset :: XXH3_128_reset
     

    === XXH3 128-bit streaming ===

    All the functions are actually the same as for 64-bit streaming variant. The only difference is the finalization routine.

    XXH3_64_reset_with_secret ¶
    Source

    XXH3_64_reset_with_secret :: XXH3_128_reset_with_secret

    XXH3_64_reset_with_seed ¶
    Source

    XXH3_64_reset_with_seed :: XXH3_128_reset_with_seed

    XXH3_64_update ¶
    Source

    XXH3_64_update :: XXH3_128_update

    XXH3_64_with_secret ¶
    Source

    XXH3_64_with_secret :: proc(input: []u8, secret: []u8) -> (hash: u64) {…}

    XXH3_64_with_seed ¶
    Source

    XXH3_64_with_seed :: proc(input: []u8, seed: u64 = XXH64_DEFAULT_SEED) -> (hash: u64) {…}

    XXH3_64bits_internal ¶
    Source

    XXH3_64bits_internal :: proc(input: []u8, seed: u64, secret: []u8, f_hashLong: XXH3_hashLong64_f) -> (hash: u64) {…}

    XXH3_accumulate ¶
    Source

    XXH3_accumulate :: proc(acc: []u64, input: []u8, secret: []u8, nbStripes: uint, f_acc512: XXH3_accumulate_512_f) {…}
     

    * XXH3_accumulate() * Loops over XXH3_accumulate_512(). * Assumption: nbStripes will not overflow the secret size

    XXH3_accumulate_512_scalar ¶
    Source

    XXH3_accumulate_512_scalar :: proc(acc: []u64, input: []u8, secret: []u8) {…}
     

    scalar variants - universal

    XXH3_avalanche ¶
    Source

    XXH3_avalanche :: proc(h64: u64) -> (res: u64) {…}
     

    This is a fast avalanche stage, suitable when input bits are already partially mixed

    XXH3_consume_stripes ¶
    Source

    XXH3_consume_stripes :: proc(
	acc:               []u64, 
	stripes_so_far:    ^uint, 
	stripes_per_block: uint, 
	input:             []u8, 
	number_of_stripes: uint, 
	secret:            []u8, 
	secret_limit:      uint, 
	f_acc512:          XXH3_accumulate_512_f, 
	f_scramble:        XXH3_scramble_accumulator_f, 
) {…}

    XXH3_copy_state ¶
    Source

    XXH3_copy_state :: proc(dest, src: ^XXH3_state) {…}

    XXH3_create_state ¶
    Source

    XXH3_create_state :: proc(allocator := context.allocator) -> (res: ^XXH3_state, err: Error) {…}

    XXH3_destroy_state ¶
    Source

    XXH3_destroy_state :: proc(state: ^XXH3_state, allocator := context.allocator) -> (err: Error) {…}

    XXH3_digest_long ¶
    Source

    XXH3_digest_long :: proc(acc: []u64, state: ^XXH3_state, secret: []u8) {…}

    XXH3_generate_secret ¶
    Source

    XXH3_generate_secret :: proc(secret_buffer: []u8, custom_seed: []u8) {…}

    XXH3_hashLong_128b_default ¶
    Source

    XXH3_hashLong_128b_default :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128) {…}
     

    * It's important for performance that XXH3_hashLong is not inlined.

    XXH3_hashLong_128b_internal ¶
    Source

    XXH3_hashLong_128b_internal :: proc(input: []u8, secret: []u8, f_acc512: XXH3_accumulate_512_f, f_scramble: XXH3_scramble_accumulator_f) -> (res: u128) {…}

    XXH3_hashLong_128b_withSecret ¶
    Source

    XXH3_hashLong_128b_withSecret :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128) {…}
     

    * It's important for performance that XXH3_hashLong is not inlined.

    XXH3_hashLong_128b_withSeed ¶
    Source

    XXH3_hashLong_128b_withSeed :: proc(input: []u8, seed: u64, secret: []u8) -> (res: u128) {…}
     

    * It's important for performance that XXH3_hashLong is not inlined.

    XXH3_hashLong_128b_withSeed_internal ¶
    Source

    XXH3_hashLong_128b_withSeed_internal :: proc(
	input:      []u8, 
	seed:       u64, 
	secret:     []u8, 
	f_acc512:   XXH3_accumulate_512_f, 
	f_scramble: XXH3_scramble_accumulator_f, 
	f_initSec:  XXH3_init_custom_secret_f, 
) -> (res: u128) {…}

    XXH3_hashLong_64b_default ¶
    Source

    XXH3_hashLong_64b_default :: proc(input: []u8, seed64: u64, secret: []u8) -> (hash: u64) {…}
     

    It's important for performance that XXH3_hashLong is not inlined. Since the function is not inlined, the compiler may not be able to understand that, in some scenarios, its secret argument is actually a compile time constant. This variant enforces that the compiler can detect that, and uses this opportunity to streamline the generated code for better performance.

    XXH3_hashLong_64b_internal ¶
    Source

    XXH3_hashLong_64b_internal :: proc(input: []u8, secret: []u8, f_acc512: XXH3_accumulate_512_f, f_scramble: XXH3_scramble_accumulator_f) -> (hash: u64) {…}

    XXH3_hashLong_64b_withSecret ¶
    Source

    XXH3_hashLong_64b_withSecret :: proc(input: []u8, seed64: u64, secret: []u8) -> (hash: u64) {…}
     

    It's important for performance that XXH3_hashLong is not inlined.

    XXH3_hashLong_64b_withSeed ¶
    Source

    XXH3_hashLong_64b_withSeed :: proc(input: []u8, seed: u64, secret: []u8) -> (hash: u64) {…}
     

    It's important for performance that XXH3_hashLong is not inlined.

    XXH3_hashLong_64b_withSeed_internal ¶
    Source

    XXH3_hashLong_64b_withSeed_internal :: proc(input: []u8, seed: u64, f_acc512: XXH3_accumulate_512_f, f_scramble: XXH3_scramble_accumulator_f, f_init_sec: XXH3_init_custom_secret_f) -> (hash: u64) {…}
     

    XXH3_hashLong_64b_withSeed(): Generate a custom key based on alteration of default XXH3_kSecret with the seed, and then use this key for long mode hashing.

    This operation is decently fast but nonetheless costs a little bit of time. Try to avoid it whenever possible (typically when seed==0).

    It's important for performance that XXH3_hashLong is not inlined. Not sure why (uop cache maybe?), but the difference is large and easily measurable.

    XXH3_hashLong_internal_loop ¶
    Source

    XXH3_hashLong_internal_loop :: proc(acc: []u64, input: []u8, secret: []u8, f_acc512: XXH3_accumulate_512_f, f_scramble: XXH3_scramble_accumulator_f) {…}

    XXH3_init_custom_secret_scalar ¶
    Source

    XXH3_init_custom_secret_scalar :: proc(custom_secret: []u8, seed64: u64) {…}

    XXH3_init_state ¶
    Source

    XXH3_init_state :: proc(state: ^XXH3_state) {…}

    XXH3_len_0to16_128b ¶
    Source

    XXH3_len_0to16_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}
     

    Assumption: secret size is >= XXH3_SECRET_SIZE_MIN

    XXH3_len_0to16_64b ¶
    Source

    XXH3_len_0to16_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

    XXH3_len_129to240_128b ¶
    Source

    XXH3_len_129to240_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

    XXH3_len_129to240_64b ¶
    Source

    XXH3_len_129to240_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

    XXH3_len_17to128_128b ¶
    Source

    XXH3_len_17to128_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

    XXH3_len_17to128_64b ¶
    Source

    XXH3_len_17to128_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}
     

    For mid range keys, XXH3 uses a Mum-hash variant.

    XXH3_len_1to3_128b ¶
    Source

    XXH3_len_1to3_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

    XXH3_len_1to3_64b ¶
    Source

    XXH3_len_1to3_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}
     

    At very short lengths, there isn't enough input to fully hide secrets, or use the entire secret.

    There is also only a limited amount of mixing we can do before significantly impacting performance.

    Therefore, we use different sections of the secret and always mix two secret samples with an XOR. This should have no effect on performance on the seedless or withSeed variants because everything _should_ be constant folded by modern compilers.

    The XOR mixing hides individual parts of the secret and increases entropy. This adds an extra layer of strength for custom secrets.

    XXH3_len_4to8_128b ¶
    Source

    XXH3_len_4to8_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

    XXH3_len_4to8_64b ¶
    Source

    XXH3_len_4to8_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

    XXH3_len_9to16_128b ¶
    Source

    XXH3_len_9to16_128b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u128) {…}

    XXH3_len_9to16_64b ¶
    Source

    XXH3_len_9to16_64b :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}

    XXH3_mergeAccs ¶
    Source

    XXH3_mergeAccs :: proc(acc: []u64, secret: []u8, start: u64) -> (res: u64) {…}

    XXH3_mix16B ¶
    Source

    XXH3_mix16B :: proc(input: []u8, secret: []u8, seed: u64) -> (res: u64) {…}
     

    DISCLAIMER: There are known seed-dependent multicollisions here due to multiplication by zero, affecting hashes of lengths 17 to 240.

    However, they are very unlikely.

    Keep this in mind when using the unseeded XXH3_64bits() variant: As with all unseeded non-cryptographic hashes, it does not attempt to defend itself against specially crafted inputs, only random inputs.

    Compared to classic UMAC where a 1 in 2^31 chance of 4 consecutive bytes cancelling out the secret is taken an arbitrary number of times (addressed in XXH3_accumulate_512), this collision is very unlikely with random inputs and/or proper seeding:

    This only has a 1 in 2^63 chance of 8 consecutive bytes cancelling out, in a function that is only called up to 16 times per hash with up to 240 bytes of input.

    This is not too bad for a non-cryptographic hash function, especially with only 64 bit outputs.

    The 128-bit variant (which trades some speed for strength) is NOT affected by this, although it is always a good idea to use a proper seed if you care about strength.

    XXH3_mix2Accs ¶
    Source

    XXH3_mix2Accs :: proc(acc: []u64, secret: []u8) -> (res: u64) {…}

    XXH3_reset_internal ¶
    Source

    XXH3_reset_internal :: proc(state: ^XXH3_state, seed: u64, secret: []u8, secret_size: uint) {…}

    XXH3_rrmxmx ¶
    Source

    XXH3_rrmxmx :: proc(h64, length: u64) -> (res: u64) {…}
     

    This is a stronger avalanche, inspired by Pelle Evensen's rrmxmx preferable when input has not been previously mixed

    XXH3_scramble_accumulator_scalar ¶
    Source

    XXH3_scramble_accumulator_scalar :: proc(acc: []u64, secret: []u8) {…}

    XXH3_update ¶
    Source

    XXH3_update :: proc(state: ^XXH3_state, input: []u8, f_acc512: XXH3_accumulate_512_f, f_scramble: XXH3_scramble_accumulator_f) -> (err: Error) {…}
     

    Both XXH3_64bits_update and XXH3_128bits_update use this routine.

    XXH64 ¶
    Source

    XXH64 :: proc(input: []u8, seed: u64 = XXH64_DEFAULT_SEED) -> (digest: u64) {…}

    XXH64_avalanche ¶
    Source

    XXH64_avalanche :: proc(h64: u64) -> (res: u64) {…}

    XXH64_canonical_from_hash ¶
    Source

    XXH64_canonical_from_hash :: proc(hash: u64) -> (canonical: XXH64_canonical) {…}
     

    * Canonical representation *

    The default return values from XXH functions are unsigned 32 and 64 bit integers.

    The canonical representation uses big endian convention, the same convention as human-readable numbers (large digits first).

    This way, hash values can be written into a file or buffer, remaining comparable across different systems.

    The following functions allow transformation of hash values to and from their canonical format.

    XXH64_copy_state ¶
    Source

    XXH64_copy_state :: proc(dest, src: ^XXH64_state) {…}

    XXH64_create_state ¶
    Source

    XXH64_create_state :: proc(allocator := context.allocator) -> (res: ^XXH64_state, err: Error) {…}
     

    * Hash Streaming *

    XXH64_destroy_state ¶
    Source

    XXH64_destroy_state :: proc(state: ^XXH64_state, allocator := context.allocator) -> (err: Error) {…}

    XXH64_digest ¶
    Source

    XXH64_digest :: proc(state: ^XXH64_state) -> (res: u64) {…}

    XXH64_endian_align ¶
    Source

    XXH64_endian_align :: proc(input: []u8, seed: u64 = XXH64_DEFAULT_SEED, alignment: Alignment = Alignment.Unaligned) -> (res: u64) {…}

    XXH64_finalize ¶
    Source

    XXH64_finalize :: proc(h64: u64, buf: []u8, alignment: Alignment) -> (res: u64) {…}

    XXH64_hash_from_canonical ¶
    Source

    XXH64_hash_from_canonical :: proc(canonical: ^XXH64_canonical) -> (hash: u64) {…}

    XXH64_mergeRound ¶
    Source

    XXH64_mergeRound :: proc(acc, val: u64) -> (res: u64) {…}

    XXH64_read64 ¶
    Source

    XXH64_read64 :: proc(buf: []u8, alignment: Alignment = Alignment.Unaligned) -> (res: u64) {…}

    XXH64_reset_state ¶
    Source

    XXH64_reset_state :: proc(state_ptr: ^XXH64_state, seed: u64 = XXH64_DEFAULT_SEED) -> (err: Error) {…}

    XXH64_round ¶
    Source

    XXH64_round :: proc(acc, input: u64) -> (res: u64) {…}

    XXH64_update ¶
    Source

    XXH64_update :: proc(state: ^XXH64_state, input: []u8) -> (err: Error) {…}

    XXH_mul_64_to_128_fold_64 ¶
    Source

    XXH_mul_64_to_128_fold_64 :: proc(lhs, rhs: u64) -> (res: u64) {…}
     

    The reason for the separate function is to prevent passing too many structs around by value. This will hopefully inline the multiply, but we don't force it.

    @param lhs, rhs The 64-bit integers to multiply @return The low 64 bits of the product XOR'd by the high 64 bits.

    XXH_rotl32 ¶
    Source

    XXH_rotl32 :: proc(x, r: u32) -> (res: u32) {…}

    XXH_rotl64 ¶
    Source

    XXH_rotl64 :: proc(x, r: u64) -> (res: u64) {…}

    XXH_writeLE64 ¶
    Source

    XXH_writeLE64 :: proc(dst: []u8, v64: u64le) {…}

    XXH_xorshift_64 ¶
    Source

    XXH_xorshift_64 :: proc(v: u64, #any_int shift: uint) -> (res: u64) {…}

    byte_swap ¶

    byte_swap :: intrinsics.byte_swap

    prefetch_address ¶
    Source

    prefetch_address :: proc(address: rawptr) {…}

    prefetch_offset ¶
    Source

    prefetch_offset :: proc(address: rawptr, #any_int offset: uintptr) {…}

    Procedure Groups

    XXH3_128 ¶
    Source

    XXH3_64 ¶
    Source

    Source Files

    Generation Information

    Generated with odin version dev-2024-11 (vendor "odin") Windows_amd64 @ 2024-11-16 21:10:09.859154600 +0000 UTC