xxh3.h File Reference

#include "xxhash.h"
#include <string.h>

Go to the source code of this file.

Macros
#define	XXH_INLINE_ALL
#define	XXH_RESTRICT   /* disable */
#define	XXH_likely(x)   (x)
#define	XXH_unlikely(x)   (x)
#define	XXH_SCALAR   0 /* Portable scalar version */
#define	XXH_SSE2   1 /* SSE2 for Pentium 4 and all x86_64 */
#define	XXH_AVX2   2 /* AVX2 for Haswell and Bulldozer */
#define	XXH_NEON   3 /* NEON for most ARMv7-A and all AArch64 */
#define	XXH_VSX   4 /* VSX and ZVector for POWER8/z13 */
#define	XXH_PREFETCH(ptr)   (void)(ptr) /* disabled */
#define	XXH_SECRET_DEFAULT_SIZE   192 /* minimum XXH3_SECRET_SIZE_MIN */
#define	XXH_mult32to64(x, y)   ((xxh_u64)(xxh_u32)(x) * (xxh_u64)(xxh_u32)(y))
#define	XXH3_MIDSIZE_MAX   240
#define	XXH3_MIDSIZE_STARTOFFSET   3
#define	XXH3_MIDSIZE_LASTOFFSET   17
#define	STRIPE_LEN   64
#define	XXH_SECRET_CONSUME_RATE   8 /* nb of secret bytes consumed at each accumulation */
#define	ACC_NB   (STRIPE_LEN / sizeof(xxh_u64))
#define	XXH_PREFETCH_DIST   384
#define	XXH_SECRET_LASTACC_START   7
#define	XXH3_INIT_ACC
#define	XXH_SECRET_MERGEACCS_START   11
#define	XXH3_INTERNALBUFFER_STRIPES   (XXH3_INTERNALBUFFER_SIZE / STRIPE_LEN)

Enumerations
enum	XXH3_accWidth_e { XXH3_acc_64bits, XXH3_acc_128bits }

Functions
	XXH_ALIGN (64) static const xxh_u8 kSecret[XXH_SECRET_DEFAULT_SIZE]
static XXH128_hash_t	XXH_mult64to128 (xxh_u64 lhs, xxh_u64 rhs)
static xxh_u64	XXH3_mul128_fold64 (xxh_u64 lhs, xxh_u64 rhs)
XXH_FORCE_INLINE xxh_u64	XXH_xorshift64 (xxh_u64 v64, int shift)
static XXH64_hash_t	XXH3_avalanche (xxh_u64 h64)
XXH_FORCE_INLINE XXH64_hash_t	XXH3_len_1to3_64b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH64_hash_t	XXH3_len_4to8_64b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH64_hash_t	XXH3_len_9to16_64b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH64_hash_t	XXH3_len_0to16_64b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE xxh_u64	XXH3_mix16B (const xxh_u8 *XXH_RESTRICT input, const xxh_u8 *XXH_RESTRICT secret, xxh_u64 seed64)
XXH_FORCE_INLINE XXH64_hash_t	XXH3_len_17to128_64b (const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed)
XXH_NO_INLINE XXH64_hash_t	XXH3_len_129to240_64b (const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed)
XXH_FORCE_INLINE void	XXH3_accumulate_512 (void *XXH_RESTRICT acc, const void *XXH_RESTRICT input, const void *XXH_RESTRICT secret, XXH3_accWidth_e accWidth)
XXH_FORCE_INLINE void	XXH3_scrambleAcc (void *XXH_RESTRICT acc, const void *XXH_RESTRICT secret)
XXH_FORCE_INLINE void	XXH3_accumulate (xxh_u64 *XXH_RESTRICT acc, const xxh_u8 *XXH_RESTRICT input, const xxh_u8 *XXH_RESTRICT secret, size_t nbStripes, XXH3_accWidth_e accWidth)
XXH_FORCE_INLINE void	XXH3_hashLong_internal_loop (xxh_u64 *XXH_RESTRICT acc, const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize, XXH3_accWidth_e accWidth)
XXH_FORCE_INLINE xxh_u64	XXH3_mix2Accs (const xxh_u64 *XXH_RESTRICT acc, const xxh_u8 *XXH_RESTRICT secret)
static XXH64_hash_t	XXH3_mergeAccs (const xxh_u64 *XXH_RESTRICT acc, const xxh_u8 *XXH_RESTRICT secret, xxh_u64 start)
XXH_FORCE_INLINE XXH64_hash_t	XXH3_hashLong_internal (const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize)
XXH_NO_INLINE XXH64_hash_t	XXH3_hashLong_64b_defaultSecret (const xxh_u8 *XXH_RESTRICT input, size_t len)
XXH_NO_INLINE XXH64_hash_t	XXH3_hashLong_64b_withSecret (const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize)
XXH_FORCE_INLINE void	XXH_writeLE64 (void *dst, xxh_u64 v64)
XXH_FORCE_INLINE void	XXH3_initCustomSecret (xxh_u8 *customSecret, xxh_u64 seed64)
XXH_NO_INLINE XXH64_hash_t	XXH3_hashLong_64b_withSeed (const xxh_u8 *input, size_t len, XXH64_hash_t seed)
XXH_PUBLIC_API XXH64_hash_t	XXH3_64bits (const void *input, size_t len)
XXH_PUBLIC_API XXH64_hash_t	XXH3_64bits_withSecret (const void *input, size_t len, const void *secret, size_t secretSize)
XXH_PUBLIC_API XXH64_hash_t	XXH3_64bits_withSeed (const void *input, size_t len, XXH64_hash_t seed)
XXH_PUBLIC_API XXH3_state_t *	XXH3_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH3_freeState (XXH3_state_t *statePtr)
XXH_PUBLIC_API void	XXH3_copyState (XXH3_state_t *dst_state, const XXH3_state_t *src_state)
static void	XXH3_64bits_reset_internal (XXH3_state_t *statePtr, XXH64_hash_t seed, const xxh_u8 *secret, size_t secretSize)
XXH_PUBLIC_API XXH_errorcode	XXH3_64bits_reset (XXH3_state_t *statePtr)
XXH_PUBLIC_API XXH_errorcode	XXH3_64bits_reset_withSecret (XXH3_state_t *statePtr, const void *secret, size_t secretSize)
XXH_PUBLIC_API XXH_errorcode	XXH3_64bits_reset_withSeed (XXH3_state_t *statePtr, XXH64_hash_t seed)
XXH_FORCE_INLINE void	XXH3_consumeStripes (xxh_u64 *acc, XXH32_hash_t *nbStripesSoFarPtr, XXH32_hash_t nbStripesPerBlock, const xxh_u8 *input, size_t totalStripes, const xxh_u8 *secret, size_t secretLimit, XXH3_accWidth_e accWidth)
XXH_FORCE_INLINE XXH_errorcode	XXH3_update (XXH3_state_t *state, const xxh_u8 *input, size_t len, XXH3_accWidth_e accWidth)
XXH_PUBLIC_API XXH_errorcode	XXH3_64bits_update (XXH3_state_t *state, const void *input, size_t len)
XXH_FORCE_INLINE void	XXH3_digest_long (XXH64_hash_t *acc, const XXH3_state_t *state, XXH3_accWidth_e accWidth)
XXH_PUBLIC_API XXH64_hash_t	XXH3_64bits_digest (const XXH3_state_t *state)
XXH_FORCE_INLINE XXH128_hash_t	XXH3_len_1to3_128b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH128_hash_t	XXH3_len_4to8_128b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH128_hash_t	XXH3_len_9to16_128b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH128_hash_t	XXH3_len_0to16_128b (const xxh_u8 *input, size_t len, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH128_hash_t	XXH128_mix32B (XXH128_hash_t acc, const xxh_u8 *input_1, const xxh_u8 *input_2, const xxh_u8 *secret, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH128_hash_t	XXH3_len_17to128_128b (const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed)
XXH_NO_INLINE XXH128_hash_t	XXH3_len_129to240_128b (const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize, XXH64_hash_t seed)
XXH_FORCE_INLINE XXH128_hash_t	XXH3_hashLong_128b_internal (const xxh_u8 *XXH_RESTRICT input, size_t len, const xxh_u8 *XXH_RESTRICT secret, size_t secretSize)
XXH_NO_INLINE XXH128_hash_t	XXH3_hashLong_128b_defaultSecret (const xxh_u8 *input, size_t len)
XXH_NO_INLINE XXH128_hash_t	XXH3_hashLong_128b_withSecret (const xxh_u8 *input, size_t len, const xxh_u8 *secret, size_t secretSize)
XXH_NO_INLINE XXH128_hash_t	XXH3_hashLong_128b_withSeed (const xxh_u8 *input, size_t len, XXH64_hash_t seed)
XXH_PUBLIC_API XXH128_hash_t	XXH3_128bits (const void *input, size_t len)
XXH_PUBLIC_API XXH128_hash_t	XXH3_128bits_withSecret (const void *input, size_t len, const void *secret, size_t secretSize)
XXH_PUBLIC_API XXH128_hash_t	XXH3_128bits_withSeed (const void *input, size_t len, XXH64_hash_t seed)
XXH_PUBLIC_API XXH128_hash_t	XXH128 (const void *input, size_t len, XXH64_hash_t seed)
static void	XXH3_128bits_reset_internal (XXH3_state_t *statePtr, XXH64_hash_t seed, const xxh_u8 *secret, size_t secretSize)
XXH_PUBLIC_API XXH_errorcode	XXH3_128bits_reset (XXH3_state_t *statePtr)
XXH_PUBLIC_API XXH_errorcode	XXH3_128bits_reset_withSecret (XXH3_state_t *statePtr, const void *secret, size_t secretSize)
XXH_PUBLIC_API XXH_errorcode	XXH3_128bits_reset_withSeed (XXH3_state_t *statePtr, XXH64_hash_t seed)
XXH_PUBLIC_API XXH_errorcode	XXH3_128bits_update (XXH3_state_t *state, const void *input, size_t len)
XXH_PUBLIC_API XXH128_hash_t	XXH3_128bits_digest (const XXH3_state_t *state)
XXH_PUBLIC_API int	XXH128_isEqual (XXH128_hash_t h1, XXH128_hash_t h2)
XXH_PUBLIC_API int	XXH128_cmp (const void *h128_1, const void *h128_2)
XXH_PUBLIC_API void	XXH128_canonicalFromHash (XXH128_canonical_t *dst, XXH128_hash_t hash)
XXH_PUBLIC_API XXH128_hash_t	XXH128_hashFromCanonical (const XXH128_canonical_t *src)

Macro Definition Documentation

ACC_NB

#define ACC_NB   (STRIPE_LEN / sizeof(xxh_u64))

Definition at line 894 of file xxh3.h.

Referenced by XXH3_128bits_digest(), XXH3_64bits_digest(), XXH3_accumulate_512(), XXH3_hashLong_128b_internal(), XXH3_hashLong_internal(), and XXH3_scrambleAcc().

STRIPE_LEN

#define STRIPE_LEN   64

Definition at line 892 of file xxh3.h.

Referenced by XXH3_128bits_digest(), XXH3_64bits_digest(), XXH3_64bits_reset_internal(), XXH3_accumulate(), XXH3_accumulate_512(), XXH3_consumeStripes(), XXH3_digest_long(), XXH3_hashLong_internal_loop(), XXH3_scrambleAcc(), and XXH3_update().

XXH3_INIT_ACC

#define XXH3_INIT_ACC

Value:

{ PRIME32_3, PRIME64_1, PRIME64_2, PRIME64_3, \
                        PRIME64_4, PRIME32_2, PRIME64_5, PRIME32_1 };

Definition at line 1344 of file xxh3.h.

Referenced by XXH3_hashLong_128b_internal(), and XXH3_hashLong_internal().

XXH3_INTERNALBUFFER_STRIPES

#define XXH3_INTERNALBUFFER_STRIPES   (XXH3_INTERNALBUFFER_SIZE / STRIPE_LEN)

Referenced by XXH3_update().

XXH3_MIDSIZE_LASTOFFSET

#define XXH3_MIDSIZE_LASTOFFSET   17

Referenced by XXH3_len_129to240_128b(), and XXH3_len_129to240_64b().

XXH3_MIDSIZE_MAX

#define XXH3_MIDSIZE_MAX   240

Definition at line 834 of file xxh3.h.

Referenced by XXH3_128bits(), XXH3_128bits_digest(), XXH3_128bits_withSecret(), XXH3_128bits_withSeed(), XXH3_64bits(), XXH3_64bits_digest(), XXH3_64bits_withSecret(), XXH3_64bits_withSeed(), XXH3_len_129to240_128b(), and XXH3_len_129to240_64b().

XXH3_MIDSIZE_STARTOFFSET

#define XXH3_MIDSIZE_STARTOFFSET   3

Referenced by XXH3_len_129to240_128b(), and XXH3_len_129to240_64b().

XXH_AVX2

#define XXH_AVX2   2 /* AVX2 for Haswell and Bulldozer */

Definition at line 163 of file xxh3.h.

XXH_INLINE_ALL

#define XXH_INLINE_ALL

Definition at line 50 of file xxh3.h.

XXH_likely

#define XXH_likely

(

x

)

(x)

Definition at line 70 of file xxh3.h.

Referenced by XXH3_len_0to16_64b().

XXH_mult32to64

#define XXH_mult32to64	(		x,
			y
	)		((xxh_u64)(xxh_u32)(x) * (xxh_u64)(xxh_u32)(y))

Definition at line 498 of file xxh3.h.

Referenced by XXH3_accumulate_512(), XXH3_len_9to16_128b(), and XXH_mult64to128().

XXH_NEON

#define XXH_NEON   3 /* NEON for most ARMv7-A and all AArch64 */

Definition at line 164 of file xxh3.h.

XXH_PREFETCH

#define XXH_PREFETCH

(

ptr

)

(void)(ptr) /* disabled */

Definition at line 439 of file xxh3.h.

Referenced by XXH3_accumulate().

XXH_PREFETCH_DIST

#define XXH_PREFETCH_DIST   384

Definition at line 1264 of file xxh3.h.

Referenced by XXH3_accumulate().

XXH_RESTRICT

#define XXH_RESTRICT   /* disable */

Definition at line 61 of file xxh3.h.

XXH_SCALAR

#define XXH_SCALAR   0 /* Portable scalar version */

Definition at line 161 of file xxh3.h.

XXH_SECRET_CONSUME_RATE

#define XXH_SECRET_CONSUME_RATE   8 /* nb of secret bytes consumed at each accumulation */

Definition at line 893 of file xxh3.h.

Referenced by XXH3_64bits_reset_internal(), XXH3_accumulate(), XXH3_consumeStripes(), and XXH3_hashLong_internal_loop().

XXH_SECRET_DEFAULT_SIZE

#define XXH_SECRET_DEFAULT_SIZE   192 /* minimum XXH3_SECRET_SIZE_MIN */

Definition at line 448 of file xxh3.h.

Referenced by XXH3_128bits_reset(), XXH3_128bits_reset_withSeed(), XXH3_64bits_reset(), XXH3_64bits_reset_withSeed(), XXH3_hashLong_128b_withSeed(), XXH3_hashLong_64b_withSeed(), and XXH3_initCustomSecret().

XXH_SECRET_LASTACC_START

#define XXH_SECRET_LASTACC_START   7

Referenced by XXH3_digest_long(), and XXH3_hashLong_internal_loop().

XXH_SECRET_MERGEACCS_START

#define XXH_SECRET_MERGEACCS_START   11

Referenced by XXH3_128bits_digest(), XXH3_64bits_digest(), XXH3_hashLong_128b_internal(), and XXH3_hashLong_internal().

XXH_SSE2

#define XXH_SSE2   1 /* SSE2 for Pentium 4 and all x86_64 */

Definition at line 162 of file xxh3.h.

XXH_unlikely

#define XXH_unlikely

(

x

)

(x)

Definition at line 71 of file xxh3.h.

XXH_VSX

#define XXH_VSX   4 /* VSX and ZVector for POWER8/z13 */

Definition at line 165 of file xxh3.h.

Enumeration Type Documentation

XXH3_accWidth_e

enum XXH3_accWidth_e

Enumerator
XXH3_acc_64bits
XXH3_acc_128bits

Definition at line 896 of file xxh3.h.

{ XXH3_acc_64bits, XXH3_acc_128bits } XXH3_accWidth_e;

Function Documentation

XXH128()

XXH_PUBLIC_API XXH128_hash_t XXH128	(	const void *	input,
		size_t	len,
		XXH64_hash_t	seed
	)

Definition at line 1985 of file xxh3.h.

References XXH3_128bits_withSeed().

{
    return XXH3_128bits_withSeed(input, len, seed);
}

XXH128_canonicalFromHash()

XXH_PUBLIC_API void XXH128_canonicalFromHash	(	XXH128_canonical_t *	dst,
		XXH128_hash_t	hash
	)

Definition at line 2085 of file xxh3.h.

{
    XXH_STATIC_ASSERT(sizeof(XXH128_canonical_t) == sizeof(XXH128_hash_t));
    if (XXH_CPU_LITTLE_ENDIAN) {
        hash.high64 = XXH_swap64(hash.high64);
        hash.low64  = XXH_swap64(hash.low64);
    }
    memcpy(dst, &hash.high64, sizeof(hash.high64));
    memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));
}

XXH128_cmp()

XXH_PUBLIC_API int XXH128_cmp	(	const void *	h128_1,
		const void *	h128_2
	)

Definition at line 2072 of file xxh3.h.

References h1(), and h2().

{
    XXH128_hash_t const h1 = *(const XXH128_hash_t*)h128_1;
    XXH128_hash_t const h2 = *(const XXH128_hash_t*)h128_2;
    int const hcmp = (h1.high64 > h2.high64) - (h2.high64 > h1.high64);
    /* note : bets that, in most cases, hash values are different */
    if (hcmp) return hcmp;
    return (h1.low64 > h2.low64) - (h2.low64 > h1.low64);
}

XXH128_hashFromCanonical()

XXH_PUBLIC_API XXH128_hash_t XXH128_hashFromCanonical

(

const XXH128_canonical_t *

src

)

Definition at line 2097 of file xxh3.h.

{
    XXH128_hash_t h;
    h.high64 = XXH_readBE64(src);
    h.low64  = XXH_readBE64(src->digest + 8);
    return h;
}

XXH128_isEqual()

XXH_PUBLIC_API int XXH128_isEqual	(	XXH128_hash_t	h1,
		XXH128_hash_t	h2
	)

Definition at line 2062 of file xxh3.h.

References h1(), and h2().

{
    /* note : XXH128_hash_t is compact, it has no padding byte */
    return !(memcmp(&h1, &h2, sizeof(h1)));
}

XXH128_mix32B()

XXH_FORCE_INLINE XXH128_hash_t XXH128_mix32B	(	XXH128_hash_t	acc,
		const xxh_u8 *	input_1,
		const xxh_u8 *	input_2,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 1826 of file xxh3.h.

References XXH3_mix16B().

Referenced by XXH3_len_129to240_128b(), and XXH3_len_17to128_128b().

{
    acc.low64  += XXH3_mix16B (input_1, secret+0, seed);
    acc.low64  ^= XXH_readLE64(input_2) + XXH_readLE64(input_2 + 8);
    acc.high64 += XXH3_mix16B (input_2, secret+16, seed);
    acc.high64 ^= XXH_readLE64(input_1) + XXH_readLE64(input_1 + 8);
    return acc;
}

XXH3_128bits()

XXH_PUBLIC_API XXH128_hash_t XXH3_128bits	(	const void *	input,
		size_t	len
	)

Definition at line 1951 of file xxh3.h.

References XXH3_hashLong_128b_defaultSecret(), XXH3_len_0to16_128b(), XXH3_len_129to240_128b(), XXH3_len_17to128_128b(), and XXH3_MIDSIZE_MAX.

{
    if (len <= 16) return XXH3_len_0to16_128b((const xxh_u8*)input, len, kSecret, 0);
    if (len <= 128) return XXH3_len_17to128_128b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), 0);
    if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_128b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), 0);
    return XXH3_hashLong_128b_defaultSecret((const xxh_u8*)input, len);
}

XXH3_128bits_digest()

XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest

(

const XXH3_state_t *

state

)

Definition at line 2039 of file xxh3.h.

References ACC_NB, STRIPE_LEN, XXH3_128bits_withSecret(), XXH3_128bits_withSeed(), XXH3_acc_128bits, XXH3_digest_long(), XXH3_mergeAccs(), XXH3_MIDSIZE_MAX, XXH_ALIGN(), and XXH_SECRET_MERGEACCS_START.

{
    if (state->totalLen > XXH3_MIDSIZE_MAX) {
        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[ACC_NB];
        XXH3_digest_long(acc, state, XXH3_acc_128bits);
        XXH_ASSERT(state->secretLimit + STRIPE_LEN >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
        {   xxh_u64 const low64 = XXH3_mergeAccs(acc, state->secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)state->totalLen * PRIME64_1);
            xxh_u64 const high64 = XXH3_mergeAccs(acc, state->secret + state->secretLimit + STRIPE_LEN - sizeof(acc) - XXH_SECRET_MERGEACCS_START, ~((xxh_u64)state->totalLen * PRIME64_2));
            XXH128_hash_t const h128 = { low64, high64 };
            return h128;
        }
    }
    /* len <= XXH3_MIDSIZE_MAX : short code */
    if (state->seed)
        return XXH3_128bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);
    return XXH3_128bits_withSecret(state->buffer, (size_t)(state->totalLen), state->secret, state->secretLimit + STRIPE_LEN);
}

XXH3_128bits_reset()

XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset

(

XXH3_state_t *

statePtr

)

Definition at line 2006 of file xxh3.h.

References XXH3_128bits_reset_internal(), XXH_ERROR, XXH_OK, and XXH_SECRET_DEFAULT_SIZE.

{
    if (statePtr == NULL) return XXH_ERROR;
    XXH3_128bits_reset_internal(statePtr, 0, kSecret, XXH_SECRET_DEFAULT_SIZE);
    return XXH_OK;
}

XXH3_128bits_reset_internal()

static void XXH3_128bits_reset_internal ( XXH3_state_t *  statePtr, XXH64_hash_t  seed, const xxh_u8 *  secret, size_t  secretSize  )

static

Definition at line 1998 of file xxh3.h.

References XXH3_64bits_reset_internal().

Referenced by XXH3_128bits_reset(), XXH3_128bits_reset_withSecret(), and XXH3_128bits_reset_withSeed().

{
    XXH3_64bits_reset_internal(statePtr, seed, secret, secretSize);
}

XXH3_128bits_reset_withSecret()

XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret	(	XXH3_state_t *	statePtr,
		const void *	secret,
		size_t	secretSize
	)

Definition at line 2014 of file xxh3.h.

References XXH3_128bits_reset_internal(), XXH_ERROR, and XXH_OK.

{
    if (statePtr == NULL) return XXH_ERROR;
    XXH3_128bits_reset_internal(statePtr, 0, (const xxh_u8*)secret, secretSize);
    if (secret == NULL) return XXH_ERROR;
    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
    return XXH_OK;
}

XXH3_128bits_reset_withSeed()

XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed	(	XXH3_state_t *	statePtr,
		XXH64_hash_t	seed
	)

Definition at line 2024 of file xxh3.h.

References XXH3_128bits_reset_internal(), XXH3_initCustomSecret(), XXH_ERROR, XXH_OK, and XXH_SECRET_DEFAULT_SIZE.

{
    if (statePtr == NULL) return XXH_ERROR;
    XXH3_128bits_reset_internal(statePtr, seed, kSecret, XXH_SECRET_DEFAULT_SIZE);
    XXH3_initCustomSecret(statePtr->customSecret, seed);
    statePtr->secret = statePtr->customSecret;
    return XXH_OK;
}

XXH3_128bits_update()

XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update	(	XXH3_state_t *	state,
		const void *	input,
		size_t	len
	)

Definition at line 2034 of file xxh3.h.

References XXH3_acc_128bits, and XXH3_update().

{
    return XXH3_update(state, (const xxh_u8*)input, len, XXH3_acc_128bits);
}

XXH3_128bits_withSecret()

XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSecret	(	const void *	input,
		size_t	len,
		const void *	secret,
		size_t	secretSize
	)

Definition at line 1960 of file xxh3.h.

References XXH3_hashLong_128b_withSecret(), XXH3_len_0to16_128b(), XXH3_len_129to240_128b(), XXH3_len_17to128_128b(), and XXH3_MIDSIZE_MAX.

Referenced by XXH3_128bits_digest().

{
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
    /*
     * If an action is to be taken if `secret` conditions are not respected,
     * it should be done here.
     * For now, it's a contract pre-condition.
     * Adding a check and a branch here would cost performance at every hash.
     */
     if (len <= 16) return XXH3_len_0to16_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, 0);
     if (len <= 128) return XXH3_len_17to128_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, 0);
     if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, 0);
     return XXH3_hashLong_128b_withSecret((const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize);
}

XXH3_128bits_withSeed()

XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSeed	(	const void *	input,
		size_t	len,
		XXH64_hash_t	seed
	)

Definition at line 1976 of file xxh3.h.

References XXH3_hashLong_128b_withSeed(), XXH3_len_0to16_128b(), XXH3_len_129to240_128b(), XXH3_len_17to128_128b(), and XXH3_MIDSIZE_MAX.

Referenced by XXH128(), and XXH3_128bits_digest().

{
    if (len <= 16) return XXH3_len_0to16_128b((const xxh_u8*)input, len, kSecret, seed);
    if (len <= 128) return XXH3_len_17to128_128b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), seed);
    if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_128b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), seed);
    return XXH3_hashLong_128b_withSeed((const xxh_u8*)input, len, seed);
}

XXH3_64bits()

XXH_PUBLIC_API XXH64_hash_t XXH3_64bits	(	const void *	input,
		size_t	len
	)

Definition at line 1430 of file xxh3.h.

References XXH3_hashLong_64b_defaultSecret(), XXH3_len_0to16_64b(), XXH3_len_129to240_64b(), XXH3_len_17to128_64b(), and XXH3_MIDSIZE_MAX.

Referenced by TupleString< 4 >::makeHash().

{
    if (len <= 16) return XXH3_len_0to16_64b((const xxh_u8*)input, len, kSecret, 0);
    if (len <= 128) return XXH3_len_17to128_64b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), 0);
    if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_64b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), 0);
    return XXH3_hashLong_64b_defaultSecret((const xxh_u8*)input, len);
}

XXH3_64bits_digest()

XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest

(

const XXH3_state_t *

state

)

Definition at line 1661 of file xxh3.h.

References ACC_NB, STRIPE_LEN, XXH3_64bits_withSecret(), XXH3_64bits_withSeed(), XXH3_acc_64bits, XXH3_digest_long(), XXH3_mergeAccs(), XXH3_MIDSIZE_MAX, XXH_ALIGN(), and XXH_SECRET_MERGEACCS_START.

{
    if (state->totalLen > XXH3_MIDSIZE_MAX) {
        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[ACC_NB];
        XXH3_digest_long(acc, state, XXH3_acc_64bits);
        return XXH3_mergeAccs(acc, state->secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)state->totalLen * PRIME64_1);
    }
    /* len <= XXH3_MIDSIZE_MAX : short code */
    if (state->seed)
        return XXH3_64bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);
    return XXH3_64bits_withSecret(state->buffer, (size_t)(state->totalLen), state->secret, state->secretLimit + STRIPE_LEN);
}

XXH3_64bits_reset()

XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset

(

XXH3_state_t *

statePtr

)

Definition at line 1506 of file xxh3.h.

References XXH3_64bits_reset_internal(), XXH_ERROR, XXH_OK, and XXH_SECRET_DEFAULT_SIZE.

{
    if (statePtr == NULL) return XXH_ERROR;
    XXH3_64bits_reset_internal(statePtr, 0, kSecret, XXH_SECRET_DEFAULT_SIZE);
    return XXH_OK;
}

XXH3_64bits_reset_internal()

static void XXH3_64bits_reset_internal ( XXH3_state_t *  statePtr, XXH64_hash_t  seed, const xxh_u8 *  secret, size_t  secretSize  )

static

Definition at line 1483 of file xxh3.h.

References STRIPE_LEN, and XXH_SECRET_CONSUME_RATE.

Referenced by XXH3_128bits_reset_internal(), XXH3_64bits_reset(), XXH3_64bits_reset_withSecret(), and XXH3_64bits_reset_withSeed().

{
    XXH_ASSERT(statePtr != NULL);
    memset(statePtr, 0, sizeof(*statePtr));
    statePtr->acc[0] = PRIME32_3;
    statePtr->acc[1] = PRIME64_1;
    statePtr->acc[2] = PRIME64_2;
    statePtr->acc[3] = PRIME64_3;
    statePtr->acc[4] = PRIME64_4;
    statePtr->acc[5] = PRIME32_2;
    statePtr->acc[6] = PRIME64_5;
    statePtr->acc[7] = PRIME32_1;
    statePtr->seed = seed;
    XXH_ASSERT(secret != NULL);
    statePtr->secret = secret;
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
    statePtr->secretLimit = (XXH32_hash_t)(secretSize - STRIPE_LEN);
    statePtr->nbStripesPerBlock = statePtr->secretLimit / XXH_SECRET_CONSUME_RATE;
}

XXH3_64bits_reset_withSecret()

XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret	(	XXH3_state_t *	statePtr,
		const void *	secret,
		size_t	secretSize
	)

Definition at line 1514 of file xxh3.h.

References XXH3_64bits_reset_internal(), XXH_ERROR, and XXH_OK.

{
    if (statePtr == NULL) return XXH_ERROR;
    XXH3_64bits_reset_internal(statePtr, 0, (const xxh_u8*)secret, secretSize);
    if (secret == NULL) return XXH_ERROR;
    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
    return XXH_OK;
}

XXH3_64bits_reset_withSeed()

XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed	(	XXH3_state_t *	statePtr,
		XXH64_hash_t	seed
	)

Definition at line 1524 of file xxh3.h.

References XXH3_64bits_reset_internal(), XXH3_initCustomSecret(), XXH_ERROR, XXH_OK, and XXH_SECRET_DEFAULT_SIZE.

{
    if (statePtr == NULL) return XXH_ERROR;
    XXH3_64bits_reset_internal(statePtr, seed, kSecret, XXH_SECRET_DEFAULT_SIZE);
    XXH3_initCustomSecret(statePtr->customSecret, seed);
    statePtr->secret = statePtr->customSecret;
    return XXH_OK;
}

XXH3_64bits_update()

XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update	(	XXH3_state_t *	state,
		const void *	input,
		size_t	len
	)

Definition at line 1620 of file xxh3.h.

References XXH3_acc_64bits, and XXH3_update().

{
    return XXH3_update(state, (const xxh_u8*)input, len, XXH3_acc_64bits);
}

XXH3_64bits_withSecret()

XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret	(	const void *	input,
		size_t	len,
		const void *	secret,
		size_t	secretSize
	)

Definition at line 1439 of file xxh3.h.

References XXH3_hashLong_64b_withSecret(), XXH3_len_0to16_64b(), XXH3_len_129to240_64b(), XXH3_len_17to128_64b(), and XXH3_MIDSIZE_MAX.

Referenced by XXH3_64bits_digest().

{
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
    /*
     * If an action is to be taken if `secret` conditions are not respected,
     * it should be done here.
     * For now, it's a contract pre-condition.
     * Adding a check and a branch here would cost performance at every hash.
     */
    if (len <= 16) return XXH3_len_0to16_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, 0);
    if (len <= 128) return XXH3_len_17to128_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, 0);
    if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, 0);
    return XXH3_hashLong_64b_withSecret((const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize);
}

XXH3_64bits_withSeed()

XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed	(	const void *	input,
		size_t	len,
		XXH64_hash_t	seed
	)

Definition at line 1455 of file xxh3.h.

References XXH3_hashLong_64b_withSeed(), XXH3_len_0to16_64b(), XXH3_len_129to240_64b(), XXH3_len_17to128_64b(), and XXH3_MIDSIZE_MAX.

Referenced by XXH3_64bits_digest().

{
    if (len <= 16) return XXH3_len_0to16_64b((const xxh_u8*)input, len, kSecret, seed);
    if (len <= 128) return XXH3_len_17to128_64b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), seed);
    if (len <= XXH3_MIDSIZE_MAX) return XXH3_len_129to240_64b((const xxh_u8*)input, len, kSecret, sizeof(kSecret), seed);
    return XXH3_hashLong_64b_withSeed((const xxh_u8*)input, len, seed);
}

XXH3_accumulate()

XXH_FORCE_INLINE void XXH3_accumulate	(	xxh_u64 *XXH_RESTRICT	acc,
		const xxh_u8 *XXH_RESTRICT	input,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	nbStripes,
		XXH3_accWidth_e	accWidth
	)

Definition at line 1272 of file xxh3.h.

References STRIPE_LEN, XXH3_accumulate_512(), XXH_PREFETCH, XXH_PREFETCH_DIST, and XXH_SECRET_CONSUME_RATE.

Referenced by XXH3_consumeStripes(), and XXH3_hashLong_internal_loop().

{
    size_t n;
    for (n = 0; n < nbStripes; n++ ) {
        const xxh_u8* const in = input + n*STRIPE_LEN;
        XXH_PREFETCH(in + XXH_PREFETCH_DIST);
        XXH3_accumulate_512(acc,
                            in,
                            secret + n*XXH_SECRET_CONSUME_RATE,
                            accWidth);
    }
}

XXH3_accumulate_512()

XXH_FORCE_INLINE void XXH3_accumulate_512	(	void *XXH_RESTRICT	acc,
		const void *XXH_RESTRICT	input,
		const void *XXH_RESTRICT	secret,
		XXH3_accWidth_e	accWidth
	)

Definition at line 921 of file xxh3.h.

References ACC_NB, STRIPE_LEN, XXH3_acc_128bits, XXH3_acc_64bits, XXH_ALIGN(), and XXH_mult32to64.

Referenced by XXH3_accumulate(), XXH3_digest_long(), and XXH3_hashLong_internal_loop().

{
#if (XXH_VECTOR == XXH_AVX2)

    XXH_ASSERT((((size_t)acc) & 31) == 0);
    {   XXH_ALIGN(32) __m256i* const xacc    =       (__m256i *) acc;
        /* Unaligned. This is mainly for pointer arithmetic, and because
         * _mm256_loadu_si256 requires  a const __m256i * pointer for some reason. */
        const         __m256i* const xinput  = (const __m256i *) input;
        /* Unaligned. This is mainly for pointer arithmetic, and because
         * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */
        const         __m256i* const xsecret = (const __m256i *) secret;

        size_t i;
        for (i=0; i < STRIPE_LEN/sizeof(__m256i); i++) {
            /* data_vec    = xinput[i]; */
            __m256i const data_vec    = _mm256_loadu_si256    (xinput+i);
            /* key_vec     = xsecret[i]; */
            __m256i const key_vec     = _mm256_loadu_si256   (xsecret+i);
            /* data_key    = data_vec ^ key_vec; */
            __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);
            /* data_key_lo = data_key >> 32; */
            __m256i const data_key_lo = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
            /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */
            __m256i const product     = _mm256_mul_epu32     (data_key, data_key_lo);
            if (accWidth == XXH3_acc_128bits) {
                /* xacc[i] += swap(data_vec); */
                __m256i const data_swap = _mm256_shuffle_epi32(data_vec, _MM_SHUFFLE(1, 0, 3, 2));
                __m256i const sum       = _mm256_add_epi64(xacc[i], data_swap);
                /* xacc[i] += product; */
                xacc[i] = _mm256_add_epi64(product, sum);
            } else {  /* XXH3_acc_64bits */
                /* xacc[i] += data_vec; */
                __m256i const sum = _mm256_add_epi64(xacc[i], data_vec);
                /* xacc[i] += product; */
                xacc[i] = _mm256_add_epi64(product, sum);
            }
    }   }

#elif (XXH_VECTOR == XXH_SSE2)

    /* SSE2 is just a half-scale version of the AVX2 version. */
    XXH_ASSERT((((size_t)acc) & 15) == 0);
    {   XXH_ALIGN(16) __m128i* const xacc    =       (__m128i *) acc;
        /* Unaligned. This is mainly for pointer arithmetic, and because
         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */
        const         __m128i* const xinput  = (const __m128i *) input;
        /* Unaligned. This is mainly for pointer arithmetic, and because
         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */
        const         __m128i* const xsecret = (const __m128i *) secret;

        size_t i;
        for (i=0; i < STRIPE_LEN/sizeof(__m128i); i++) {
            /* data_vec    = xinput[i]; */
            __m128i const data_vec    = _mm_loadu_si128   (xinput+i);
            /* key_vec     = xsecret[i]; */
            __m128i const key_vec     = _mm_loadu_si128   (xsecret+i);
            /* data_key    = data_vec ^ key_vec; */
            __m128i const data_key    = _mm_xor_si128     (data_vec, key_vec);
            /* data_key_lo = data_key >> 32; */
            __m128i const data_key_lo = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
            /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */
            __m128i const product     = _mm_mul_epu32     (data_key, data_key_lo);
            if (accWidth == XXH3_acc_128bits) {
                /* xacc[i] += swap(data_vec); */
                __m128i const data_swap = _mm_shuffle_epi32(data_vec, _MM_SHUFFLE(1,0,3,2));
                __m128i const sum       = _mm_add_epi64(xacc[i], data_swap);
                /* xacc[i] += product; */
                xacc[i] = _mm_add_epi64(product, sum);
            } else {  /* XXH3_acc_64bits */
                /* xacc[i] += data_vec; */
                __m128i const sum = _mm_add_epi64(xacc[i], data_vec);
                /* xacc[i] += product; */
                xacc[i] = _mm_add_epi64(product, sum);
            }
    }   }

#elif (XXH_VECTOR == XXH_NEON)

    XXH_ASSERT((((size_t)acc) & 15) == 0);
    {
        XXH_ALIGN(16) uint64x2_t* const xacc = (uint64x2_t *) acc;
        /* We don't use a uint32x4_t pointer because it causes bus errors on ARMv7. */
        uint8_t const* const xinput = (const uint8_t *) input;
        uint8_t const* const xsecret  = (const uint8_t *) secret;

        size_t i;
        for (i=0; i < STRIPE_LEN / sizeof(uint64x2_t); i++) {
            /* data_vec = xinput[i]; */
            uint8x16_t data_vec    = vld1q_u8(xinput  + (i * 16));
            /* key_vec  = xsecret[i];  */
            uint8x16_t key_vec     = vld1q_u8(xsecret + (i * 16));
            /* data_key = data_vec ^ key_vec; */
            uint64x2_t data_key    = vreinterpretq_u64_u8(veorq_u8(data_vec, key_vec));
            uint32x2_t data_key_lo, data_key_hi;
            if (accWidth == XXH3_acc_64bits) {
                /* xacc[i] += data_vec; */
                xacc[i] = vaddq_u64 (xacc[i], vreinterpretq_u64_u8(data_vec));
            } else {  /* XXH3_acc_128bits */
                /* xacc[i] += swap(data_vec); */
                uint64x2_t const data64  = vreinterpretq_u64_u8(data_vec);
                uint64x2_t const swapped = vextq_u64(data64, data64, 1);
                xacc[i] = vaddq_u64 (xacc[i], swapped);
            }
            /* data_key_lo = (uint32x2_t) (data_key & 0xFFFFFFFF);
             * data_key_hi = (uint32x2_t) (data_key >> 32);
             * data_key = UNDEFINED; */
            XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi);
            /* xacc[i] += (uint64x2_t) data_key_lo * (uint64x2_t) data_key_hi; */
            xacc[i] = vmlal_u32 (xacc[i], data_key_lo, data_key_hi);

        }
    }

#elif (XXH_VECTOR == XXH_VSX)
          xxh_u64x2* const xacc     =       (xxh_u64x2*) acc;    /* presumed aligned */
    xxh_u64x2 const* const xinput   = (xxh_u64x2 const*) input;   /* no alignment restriction */
    xxh_u64x2 const* const xsecret  = (xxh_u64x2 const*) secret;    /* no alignment restriction */
    xxh_u64x2 const v32 = { 32, 32 };
    size_t i;
    for (i = 0; i < STRIPE_LEN / sizeof(xxh_u64x2); i++) {
        /* data_vec = xinput[i]; */
        xxh_u64x2 const data_vec = XXH_vec_loadu(xinput + i);
        /* key_vec = xsecret[i]; */
        xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + i);
        xxh_u64x2 const data_key = data_vec ^ key_vec;
        /* shuffled = (data_key << 32) | (data_key >> 32); */
        xxh_u32x4 const shuffled = (xxh_u32x4)vec_rl(data_key, v32);
        /* product = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)shuffled & 0xFFFFFFFF); */
        xxh_u64x2 const product  = XXH_vec_mulo((xxh_u32x4)data_key, shuffled);
        xacc[i] += product;

        if (accWidth == XXH3_acc_64bits) {
            xacc[i] += data_vec;
        } else {  /* XXH3_acc_128bits */
            /* swap high and low halves */
#ifdef __s390x__
            xxh_u64x2 const data_swapped = vec_permi(data_vec, data_vec, 2);
#else
            xxh_u64x2 const data_swapped = vec_xxpermdi(data_vec, data_vec, 2);
#endif
            xacc[i] += data_swapped;
        }
    }

#else   /* scalar variant of Accumulator - universal */

    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64* const xacc = (xxh_u64*) acc; /* presumed aligned */
    const xxh_u8* const xinput = (const xxh_u8*) input;  /* no alignment restriction */
    const xxh_u8* const xsecret  = (const xxh_u8*) secret;   /* no alignment restriction */
    size_t i;
    XXH_ASSERT(((size_t)acc & (XXH_ACC_ALIGN-1)) == 0);
    for (i=0; i < ACC_NB; i++) {
        xxh_u64 const data_val = XXH_readLE64(xinput + 8*i);
        xxh_u64 const data_key = data_val ^ XXH_readLE64(xsecret + i*8);

        if (accWidth == XXH3_acc_64bits) {
            xacc[i] += data_val;
        } else {
            xacc[i ^ 1] += data_val; /* swap adjacent lanes */
        }
        xacc[i] += XXH_mult32to64(data_key & 0xFFFFFFFF, data_key >> 32);
    }
#endif
}

XXH3_avalanche()

static XXH64_hash_t XXH3_avalanche ( xxh_u64  h64 )

static

Definition at line 634 of file xxh3.h.

References XXH_xorshift64().

Referenced by XXH3_len_0to16_128b(), XXH3_len_0to16_64b(), XXH3_len_129to240_128b(), XXH3_len_129to240_64b(), XXH3_len_17to128_128b(), XXH3_len_17to128_64b(), XXH3_len_1to3_128b(), XXH3_len_1to3_64b(), XXH3_len_4to8_128b(), XXH3_len_9to16_128b(), XXH3_len_9to16_64b(), and XXH3_mergeAccs().

{
    h64 = XXH_xorshift64(h64, 37);
    h64 *= 0x165667919E3779F9ULL;
    h64 = XXH_xorshift64(h64, 32);
    return h64;
}

XXH3_consumeStripes()

XXH_FORCE_INLINE void XXH3_consumeStripes	(	xxh_u64 *	acc,
		XXH32_hash_t *	nbStripesSoFarPtr,
		XXH32_hash_t	nbStripesPerBlock,
		const xxh_u8 *	input,
		size_t	totalStripes,
		const xxh_u8 *	secret,
		size_t	secretLimit,
		XXH3_accWidth_e	accWidth
	)

Definition at line 1534 of file xxh3.h.

References STRIPE_LEN, XXH3_accumulate(), XXH3_scrambleAcc(), and XXH_SECRET_CONSUME_RATE.

Referenced by XXH3_digest_long(), and XXH3_update().

{
    XXH_ASSERT(*nbStripesSoFarPtr < nbStripesPerBlock);
    if (nbStripesPerBlock - *nbStripesSoFarPtr <= totalStripes) {
        /* need a scrambling operation */
        size_t const nbStripes = nbStripesPerBlock - *nbStripesSoFarPtr;
        XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, nbStripes, accWidth);
        XXH3_scrambleAcc(acc, secret + secretLimit);
        XXH3_accumulate(acc, input + nbStripes * STRIPE_LEN, secret, totalStripes - nbStripes, accWidth);
        *nbStripesSoFarPtr = (XXH32_hash_t)(totalStripes - nbStripes);
    } else {
        XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, totalStripes, accWidth);
        *nbStripesSoFarPtr += (XXH32_hash_t)totalStripes;
    }
}

XXH3_copyState()

XXH_PUBLIC_API void XXH3_copyState	(	XXH3_state_t *	dst_state,
		const XXH3_state_t *	src_state
	)

Definition at line 1477 of file xxh3.h.

{
    memcpy(dst_state, src_state, sizeof(*dst_state));
}

XXH3_createState()

XXH_PUBLIC_API XXH3_state_t* XXH3_createState

(

void

)

Definition at line 1465 of file xxh3.h.

{
    return (XXH3_state_t*)XXH_malloc(sizeof(XXH3_state_t));
}

XXH3_digest_long()

XXH_FORCE_INLINE void XXH3_digest_long	(	XXH64_hash_t *	acc,
		const XXH3_state_t *	state,
		XXH3_accWidth_e	accWidth
	)

Definition at line 1627 of file xxh3.h.

References STRIPE_LEN, XXH3_accumulate_512(), XXH3_consumeStripes(), and XXH_SECRET_LASTACC_START.

Referenced by XXH3_128bits_digest(), and XXH3_64bits_digest().

{
    /*
     * Digest on a local copy. This way, the state remains unaltered, and it can
     * continue ingesting more input afterwards.
     */
    memcpy(acc, state->acc, sizeof(state->acc));
    if (state->bufferedSize >= STRIPE_LEN) {
        size_t const totalNbStripes = state->bufferedSize / STRIPE_LEN;
        XXH32_hash_t nbStripesSoFar = state->nbStripesSoFar;
        XXH3_consumeStripes(acc,
                           &nbStripesSoFar, state->nbStripesPerBlock,
                            state->buffer, totalNbStripes,
                            state->secret, state->secretLimit,
                            accWidth);
        if (state->bufferedSize % STRIPE_LEN) {  /* one last partial stripe */
            XXH3_accumulate_512(acc,
                                state->buffer + state->bufferedSize - STRIPE_LEN,
                                state->secret + state->secretLimit - XXH_SECRET_LASTACC_START,
                                accWidth);
        }
    } else {  /* bufferedSize < STRIPE_LEN */
        if (state->bufferedSize) { /* one last stripe */
            xxh_u8 lastStripe[STRIPE_LEN];
            size_t const catchupSize = STRIPE_LEN - state->bufferedSize;
            memcpy(lastStripe, state->buffer + sizeof(state->buffer) - catchupSize, catchupSize);
            memcpy(lastStripe + catchupSize, state->buffer, state->bufferedSize);
            XXH3_accumulate_512(acc,
                                lastStripe,
                                state->secret + state->secretLimit - XXH_SECRET_LASTACC_START,
                                accWidth);
    }   }
}

XXH3_freeState()

XXH_PUBLIC_API XXH_errorcode XXH3_freeState

(

XXH3_state_t *

statePtr

)

Definition at line 1470 of file xxh3.h.

References XXH_OK.

{
    XXH_free(statePtr);
    return XXH_OK;
}

XXH3_hashLong_128b_defaultSecret()

XXH_NO_INLINE XXH128_hash_t XXH3_hashLong_128b_defaultSecret	(	const xxh_u8 *	input,
		size_t	len
	)

Definition at line 1921 of file xxh3.h.

References XXH3_hashLong_128b_internal().

Referenced by XXH3_128bits(), and XXH3_hashLong_128b_withSeed().

{
    return XXH3_hashLong_128b_internal(input, len, kSecret, sizeof(kSecret));
}

XXH3_hashLong_128b_internal()

XXH_FORCE_INLINE XXH128_hash_t XXH3_hashLong_128b_internal	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize
	)

Definition at line 1899 of file xxh3.h.

References ACC_NB, XXH3_acc_128bits, XXH3_hashLong_internal_loop(), XXH3_INIT_ACC, XXH3_mergeAccs(), XXH_ALIGN(), and XXH_SECRET_MERGEACCS_START.

Referenced by XXH3_hashLong_128b_defaultSecret(), XXH3_hashLong_128b_withSecret(), and XXH3_hashLong_128b_withSeed().

{
    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[ACC_NB] = XXH3_INIT_ACC;

    XXH3_hashLong_internal_loop(acc, input, len, secret, secretSize, XXH3_acc_128bits);

    /* converge into final hash */
    XXH_STATIC_ASSERT(sizeof(acc) == 64);
    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
    {   xxh_u64 const low64 = XXH3_mergeAccs(acc, secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * PRIME64_1);
        xxh_u64 const high64 = XXH3_mergeAccs(acc, secret + secretSize - sizeof(acc) - XXH_SECRET_MERGEACCS_START, ~((xxh_u64)len * PRIME64_2));
        XXH128_hash_t const h128 = { low64, high64 };
        return h128;
    }
}

XXH3_hashLong_128b_withSecret()

XXH_NO_INLINE XXH128_hash_t XXH3_hashLong_128b_withSecret	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		size_t	secretSize
	)

Definition at line 1931 of file xxh3.h.

References XXH3_hashLong_128b_internal().

Referenced by XXH3_128bits_withSecret().

{
    return XXH3_hashLong_128b_internal(input, len, secret, secretSize);
}

XXH3_hashLong_128b_withSeed()

XXH_NO_INLINE XXH128_hash_t XXH3_hashLong_128b_withSeed	(	const xxh_u8 *	input,
		size_t	len,
		XXH64_hash_t	seed
	)

Definition at line 1942 of file xxh3.h.

References XXH3_hashLong_128b_defaultSecret(), XXH3_hashLong_128b_internal(), XXH3_initCustomSecret(), XXH_ALIGN(), and XXH_SECRET_DEFAULT_SIZE.

Referenced by XXH3_128bits_withSeed().

{
    XXH_ALIGN(8) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
    if (seed == 0) return XXH3_hashLong_128b_defaultSecret(input, len);
    XXH3_initCustomSecret(secret, seed);
    return XXH3_hashLong_128b_internal(input, len, secret, sizeof(secret));
}

XXH3_hashLong_64b_defaultSecret()

XXH_NO_INLINE XXH64_hash_t XXH3_hashLong_64b_defaultSecret	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len
	)

Definition at line 1368 of file xxh3.h.

References XXH3_hashLong_internal().

Referenced by XXH3_64bits(), and XXH3_hashLong_64b_withSeed().

{
    return XXH3_hashLong_internal(input, len, kSecret, sizeof(kSecret));
}

XXH3_hashLong_64b_withSecret()

XXH_NO_INLINE XXH64_hash_t XXH3_hashLong_64b_withSecret	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize
	)

Definition at line 1378 of file xxh3.h.

References XXH3_hashLong_internal().

Referenced by XXH3_64bits_withSecret().

{
    return XXH3_hashLong_internal(input, len, secret, secretSize);
}

XXH3_hashLong_64b_withSeed()

XXH_NO_INLINE XXH64_hash_t XXH3_hashLong_64b_withSeed	(	const xxh_u8 *	input,
		size_t	len,
		XXH64_hash_t	seed
	)

Definition at line 1420 of file xxh3.h.

References XXH3_hashLong_64b_defaultSecret(), XXH3_hashLong_internal(), XXH3_initCustomSecret(), XXH_ALIGN(), and XXH_SECRET_DEFAULT_SIZE.

Referenced by XXH3_64bits_withSeed().

{
    XXH_ALIGN(8) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
    if (seed==0) return XXH3_hashLong_64b_defaultSecret(input, len);
    XXH3_initCustomSecret(secret, seed);
    return XXH3_hashLong_internal(input, len, secret, sizeof(secret));
}

XXH3_hashLong_internal()

XXH_FORCE_INLINE XXH64_hash_t XXH3_hashLong_internal	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize
	)

Definition at line 1348 of file xxh3.h.

References ACC_NB, XXH3_acc_64bits, XXH3_hashLong_internal_loop(), XXH3_INIT_ACC, XXH3_mergeAccs(), XXH_ALIGN(), and XXH_SECRET_MERGEACCS_START.

Referenced by XXH3_hashLong_64b_defaultSecret(), XXH3_hashLong_64b_withSecret(), and XXH3_hashLong_64b_withSeed().

{
    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[ACC_NB] = XXH3_INIT_ACC;

    XXH3_hashLong_internal_loop(acc, input, len, secret, secretSize, XXH3_acc_64bits);

    /* converge into final hash */
    XXH_STATIC_ASSERT(sizeof(acc) == 64);
    /* do not align on 8, so that the secret is different from the accumulator */
#define XXH_SECRET_MERGEACCS_START 11
    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
    return XXH3_mergeAccs(acc, secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * PRIME64_1);
}

XXH3_hashLong_internal_loop()

XXH_FORCE_INLINE void XXH3_hashLong_internal_loop	(	xxh_u64 *XXH_RESTRICT	acc,
		const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize,
		XXH3_accWidth_e	accWidth
	)

Definition at line 1290 of file xxh3.h.

References STRIPE_LEN, XXH3_accumulate(), XXH3_accumulate_512(), XXH3_scrambleAcc(), XXH_SECRET_CONSUME_RATE, and XXH_SECRET_LASTACC_START.

Referenced by XXH3_hashLong_128b_internal(), and XXH3_hashLong_internal().

{
    size_t const nb_rounds = (secretSize - STRIPE_LEN) / XXH_SECRET_CONSUME_RATE;
    size_t const block_len = STRIPE_LEN * nb_rounds;
    size_t const nb_blocks = len / block_len;

    size_t n;

    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);

    for (n = 0; n < nb_blocks; n++) {
        XXH3_accumulate(acc, input + n*block_len, secret, nb_rounds, accWidth);
        XXH3_scrambleAcc(acc, secret + secretSize - STRIPE_LEN);
    }

    /* last partial block */
    XXH_ASSERT(len > STRIPE_LEN);
    {   size_t const nbStripes = (len - (block_len * nb_blocks)) / STRIPE_LEN;
        XXH_ASSERT(nbStripes <= (secretSize / XXH_SECRET_CONSUME_RATE));
        XXH3_accumulate(acc, input + nb_blocks*block_len, secret, nbStripes, accWidth);

        /* last stripe */
        if (len & (STRIPE_LEN - 1)) {
            const xxh_u8* const p = input + len - STRIPE_LEN;
            /* Do not align on 8, so that the secret is different from the scrambler */
#define XXH_SECRET_LASTACC_START 7
            XXH3_accumulate_512(acc, p, secret + secretSize - STRIPE_LEN - XXH_SECRET_LASTACC_START, accWidth);
    }   }
}

XXH3_initCustomSecret()

XXH_FORCE_INLINE void XXH3_initCustomSecret	(	xxh_u8 *	customSecret,
		xxh_u64	seed64
	)

Definition at line 1394 of file xxh3.h.

References XXH_SECRET_DEFAULT_SIZE, and XXH_writeLE64().

Referenced by XXH3_128bits_reset_withSeed(), XXH3_64bits_reset_withSeed(), XXH3_hashLong_128b_withSeed(), and XXH3_hashLong_64b_withSeed().

{
    int const nbRounds = XXH_SECRET_DEFAULT_SIZE / 16;
    int i;

    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);

    for (i=0; i < nbRounds; i++) {
        XXH_writeLE64(customSecret + 16*i,     XXH_readLE64(kSecret + 16*i)     + seed64);
        XXH_writeLE64(customSecret + 16*i + 8, XXH_readLE64(kSecret + 16*i + 8) - seed64);
    }
}

XXH3_len_0to16_128b()

XXH_FORCE_INLINE XXH128_hash_t XXH3_len_0to16_128b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 1807 of file xxh3.h.

References XXH3_avalanche(), XXH3_len_1to3_128b(), XXH3_len_4to8_128b(), and XXH3_len_9to16_128b().

Referenced by XXH3_128bits(), XXH3_128bits_withSecret(), and XXH3_128bits_withSeed().

{
    XXH_ASSERT(len <= 16);
    {   if (len > 8) return XXH3_len_9to16_128b(input, len, secret, seed);
        if (len >= 4) return XXH3_len_4to8_128b(input, len, secret, seed);
        if (len) return XXH3_len_1to3_128b(input, len, secret, seed);
        {   XXH128_hash_t h128;
            xxh_u64 const bitflipl = XXH_readLE64(secret+64) ^ XXH_readLE64(secret+72);
            xxh_u64 const bitfliph = XXH_readLE64(secret+80) ^ XXH_readLE64(secret+88);
            h128.low64 = XXH3_avalanche((PRIME64_1 + seed) ^ bitflipl);
            h128.high64 = XXH3_avalanche((PRIME64_2 - seed) ^ bitfliph);
            return h128;
    }   }
}

XXH3_len_0to16_64b()

XXH_FORCE_INLINE XXH64_hash_t XXH3_len_0to16_64b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 737 of file xxh3.h.

References XXH3_avalanche(), XXH3_len_1to3_64b(), XXH3_len_4to8_64b(), XXH3_len_9to16_64b(), and XXH_likely.

Referenced by XXH3_64bits(), XXH3_64bits_withSecret(), and XXH3_64bits_withSeed().

{
    XXH_ASSERT(len <= 16);
    {   if (XXH_likely(len >  8)) return XXH3_len_9to16_64b(input, len, secret, seed);
        if (XXH_likely(len >= 4)) return XXH3_len_4to8_64b(input, len, secret, seed);
        if (len) return XXH3_len_1to3_64b(input, len, secret, seed);
        return XXH3_avalanche((PRIME64_1 + seed) ^ (XXH_readLE64(secret+56) ^ XXH_readLE64(secret+64)));
    }
}

XXH3_len_129to240_128b()

XXH_NO_INLINE XXH128_hash_t XXH3_len_129to240_128b	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize,
		XXH64_hash_t	seed
	)

Definition at line 1866 of file xxh3.h.

References XXH128_mix32B(), XXH3_avalanche(), XXH3_MIDSIZE_LASTOFFSET, XXH3_MIDSIZE_MAX, and XXH3_MIDSIZE_STARTOFFSET.

Referenced by XXH3_128bits(), XXH3_128bits_withSecret(), and XXH3_128bits_withSeed().

{
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
    XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);

    {   XXH128_hash_t acc;
        int const nbRounds = (int)len / 32;
        int i;
        acc.low64 = len * PRIME64_1;
        acc.high64 = 0;
        for (i=0; i<4; i++) {
            acc = XXH128_mix32B(acc, input+(32*i), input+(32*i)+16, secret+(32*i), seed);
        }
        acc.low64 = XXH3_avalanche(acc.low64);
        acc.high64 = XXH3_avalanche(acc.high64);
        XXH_ASSERT(nbRounds >= 4);
        for (i=4 ; i < nbRounds; i++) {
            acc = XXH128_mix32B(acc, input+(32*i), input+(32*i)+16, secret+XXH3_MIDSIZE_STARTOFFSET+(32*(i-4)), seed);
        }
        /* last bytes */
        acc = XXH128_mix32B(acc, input + len - 16, input + len - 32, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET - 16, 0ULL - seed);

        {   xxh_u64 const low64 = acc.low64 + acc.high64;
            xxh_u64 const high64 = (acc.low64 * PRIME64_1) + (acc.high64 * PRIME64_4) + ((len - seed) * PRIME64_2);
            XXH128_hash_t const h128 = { XXH3_avalanche(low64), (XXH64_hash_t)0 - XXH3_avalanche(high64) };
            return h128;
        }
    }
}

XXH3_len_129to240_64b()

XXH_NO_INLINE XXH64_hash_t XXH3_len_129to240_64b	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize,
		XXH64_hash_t	seed
	)

Definition at line 837 of file xxh3.h.

References XXH3_avalanche(), XXH3_MIDSIZE_LASTOFFSET, XXH3_MIDSIZE_MAX, XXH3_MIDSIZE_STARTOFFSET, and XXH3_mix16B().

Referenced by XXH3_64bits(), XXH3_64bits_withSecret(), and XXH3_64bits_withSeed().

{
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
    XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);

    #define XXH3_MIDSIZE_STARTOFFSET 3
    #define XXH3_MIDSIZE_LASTOFFSET  17

    {   xxh_u64 acc = len * PRIME64_1;
        int const nbRounds = (int)len / 16;
        int i;
        for (i=0; i<8; i++) {
            acc += XXH3_mix16B(input+(16*i), secret+(16*i), seed);
        }
        acc = XXH3_avalanche(acc);
        XXH_ASSERT(nbRounds >= 8);
#if defined(__clang__)                                /* Clang */ \
    && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \
    && !defined(XXH_ENABLE_AUTOVECTORIZE)             /* Define to disable */
        /*
         * UGLY HACK:
         * Clang for ARMv7-A tries to vectorize this loop, similar to GCC x86.
         * In everywhere else, it uses scalar code.
         *
         * For 64->128-bit multiplies, even if the NEON was 100% optimal, it
         * would still be slower than UMAAL (see XXH_mult64to128).
         *
         * Unfortunately, Clang doesn't handle the long multiplies properly and
         * converts them to the nonexistent "vmulq_u64" intrinsic, which is then
         * scalarized into an ugly mess of VMOV.32 instructions.
         *
         * This mess is difficult to avoid without turning autovectorization
         * off completely, but they are usually relatively minor and/or not
         * worth it to fix.
         *
         * This loop is the easiest to fix, as unlike XXH32, this pragma
         * _actually works_ because it is a loop vectorization instead of an
         * SLP vectorization.
         */
        #pragma clang loop vectorize(disable)
#endif
        for (i=8 ; i < nbRounds; i++) {
            acc += XXH3_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3_MIDSIZE_STARTOFFSET, seed);
        }
        /* last bytes */
        acc += XXH3_mix16B(input + len - 16, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed);
        return XXH3_avalanche(acc);
    }
}

XXH3_len_17to128_128b()

XXH_FORCE_INLINE XXH128_hash_t XXH3_len_17to128_128b	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize,
		XXH64_hash_t	seed
	)

Definition at line 1837 of file xxh3.h.

References XXH128_mix32B(), and XXH3_avalanche().

Referenced by XXH3_128bits(), XXH3_128bits_withSecret(), and XXH3_128bits_withSeed().

{
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
    XXH_ASSERT(16 < len && len <= 128);

    {   XXH128_hash_t acc;
        acc.low64 = len * PRIME64_1;
        acc.high64 = 0;
        if (len > 32) {
            if (len > 64) {
                if (len > 96) {
                    acc = XXH128_mix32B(acc, input+48, input+len-64, secret+96, seed);
                }
                acc = XXH128_mix32B(acc, input+32, input+len-48, secret+64, seed);
            }
            acc = XXH128_mix32B(acc, input+16, input+len-32, secret+32, seed);
        }
        acc = XXH128_mix32B(acc, input, input+len-16, secret, seed);
        {   xxh_u64 const low64 = acc.low64 + acc.high64;
            xxh_u64 const high64 = (acc.low64 * PRIME64_1) + (acc.high64 * PRIME64_4) + ((len - seed) * PRIME64_2);
            XXH128_hash_t const h128 = { XXH3_avalanche(low64), (XXH64_hash_t)0 - XXH3_avalanche(high64) };
            return h128;
        }
    }
}

XXH3_len_17to128_64b()

XXH_FORCE_INLINE XXH64_hash_t XXH3_len_17to128_64b	(	const xxh_u8 *XXH_RESTRICT	input,
		size_t	len,
		const xxh_u8 *XXH_RESTRICT	secret,
		size_t	secretSize,
		XXH64_hash_t	seed
	)

Definition at line 807 of file xxh3.h.

References XXH3_avalanche(), and XXH3_mix16B().

Referenced by XXH3_64bits(), XXH3_64bits_withSecret(), and XXH3_64bits_withSeed().

{
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;
    XXH_ASSERT(16 < len && len <= 128);

    {   xxh_u64 acc = len * PRIME64_1;
        if (len > 32) {
            if (len > 64) {
                if (len > 96) {
                    acc += XXH3_mix16B(input+48, secret+96, seed);
                    acc += XXH3_mix16B(input+len-64, secret+112, seed);
                }
                acc += XXH3_mix16B(input+32, secret+64, seed);
                acc += XXH3_mix16B(input+len-48, secret+80, seed);
            }
            acc += XXH3_mix16B(input+16, secret+32, seed);
            acc += XXH3_mix16B(input+len-32, secret+48, seed);
        }
        acc += XXH3_mix16B(input+0, secret+0, seed);
        acc += XXH3_mix16B(input+len-16, secret+16, seed);

        return XXH3_avalanche(acc);
    }
}

XXH3_len_1to3_128b()

XXH_FORCE_INLINE XXH128_hash_t XXH3_len_1to3_128b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 1679 of file xxh3.h.

References XXH3_avalanche().

Referenced by XXH3_len_0to16_128b().

{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(1 <= len && len <= 3);
    XXH_ASSERT(secret != NULL);
    /*
     * len = 1: combinedl = { input[0], 0x01, input[0], input[0] }
     * len = 2: combinedl = { input[1], 0x02, input[0], input[1] }
     * len = 3: combinedl = { input[2], 0x03, input[0], input[1] }
     */
    {   xxh_u8 const c1 = input[0];
        xxh_u8 const c2 = input[len >> 1];
        xxh_u8 const c3 = input[len - 1];
        xxh_u32 const combinedl = ((xxh_u32)c1<<16) | (((xxh_u32)c2) << 24) | (((xxh_u32)c3) << 0) | (((xxh_u32)len) << 8);
        xxh_u32 const combinedh = XXH_rotl32(XXH_swap32(combinedl), 13);
        xxh_u64 const bitflipl = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;
        xxh_u64 const bitfliph = (XXH_readLE32(secret+8) ^ XXH_readLE32(secret+12)) - seed;
        xxh_u64 const keyed_lo = (xxh_u64)combinedl ^ bitflipl;
        xxh_u64 const keyed_hi = (xxh_u64)combinedh ^ bitfliph;
        xxh_u64 const mixedl = keyed_lo * PRIME64_1;
        xxh_u64 const mixedh = keyed_hi * PRIME64_5;
        XXH128_hash_t const h128 = { XXH3_avalanche(mixedl) /*low64*/, XXH3_avalanche(mixedh) /*high64*/ };
        return h128;
    }
}

XXH3_len_1to3_64b()

XXH_FORCE_INLINE XXH64_hash_t XXH3_len_1to3_64b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 677 of file xxh3.h.

References XXH3_avalanche().

Referenced by XXH3_len_0to16_64b().

{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(1 <= len && len <= 3);
    XXH_ASSERT(secret != NULL);
    /*
     * len = 1: combined = { input[0], 0x01, input[0], input[0] }
     * len = 2: combined = { input[1], 0x02, input[0], input[1] }
     * len = 3: combined = { input[2], 0x03, input[0], input[1] }
     */
    {   xxh_u8 const c1 = input[0];
        xxh_u8 const c2 = input[len >> 1];
        xxh_u8 const c3 = input[len - 1];
        xxh_u32 const combined = ((xxh_u32)c1<<16) | (((xxh_u32)c2) << 24) | (((xxh_u32)c3) << 0) | (((xxh_u32)len) << 8);
        xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;
        xxh_u64 const keyed = (xxh_u64)combined ^ bitflip;
        xxh_u64 const mixed = keyed * PRIME64_1;
        return XXH3_avalanche(mixed);
    }
}

XXH3_len_4to8_128b()

XXH_FORCE_INLINE XXH128_hash_t XXH3_len_4to8_128b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 1706 of file xxh3.h.

References XXH3_avalanche(), XXH_mult64to128(), and XXH_xorshift64().

Referenced by XXH3_len_0to16_128b().

{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(secret != NULL);
    XXH_ASSERT(4 <= len && len <= 8);
    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;
    {   xxh_u32 const input_lo = XXH_readLE32(input);
        xxh_u32 const input_hi = XXH_readLE32(input + len - 4);
        xxh_u64 const input_64 = input_lo + ((xxh_u64)input_hi << 32);
        xxh_u64 const bitflip = (XXH_readLE64(secret+16) ^ XXH_readLE64(secret+24)) + seed;
        xxh_u64 const keyed = input_64 ^ bitflip;

        /* Shift len to the left to ensure it is even, this avoids even multiplies. */
        XXH128_hash_t m128 = XXH_mult64to128(keyed, PRIME64_1 + (len << 2));

        m128.high64 += (m128.low64 << 1);
        m128.low64  ^= (m128.high64 >> 3);

        m128.low64   = XXH_xorshift64(m128.low64, 35);
        m128.low64  *= 0x9FB21C651E98DF25ULL;
        m128.low64   = XXH_xorshift64(m128.low64, 28);
        m128.high64  = XXH3_avalanche(m128.high64);
        return m128;
    }
}

XXH3_len_4to8_64b()

XXH_FORCE_INLINE XXH64_hash_t XXH3_len_4to8_64b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 699 of file xxh3.h.

References XXH_xorshift64().

Referenced by XXH3_len_0to16_64b().

{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(secret != NULL);
    XXH_ASSERT(4 <= len && len < 8);
    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;
    {   xxh_u32 const input1 = XXH_readLE32(input);
        xxh_u32 const input2 = XXH_readLE32(input + len - 4);
        xxh_u64 const bitflip = (XXH_readLE64(secret+8) ^ XXH_readLE64(secret+16)) - seed;
        xxh_u64 const input64 = input2 + (((xxh_u64)input1) << 32);
        xxh_u64 x = input64 ^ bitflip;
        /* this mix is inspired by Pelle Evensen's rrmxmx */
        x ^= XXH_rotl64(x, 49) ^ XXH_rotl64(x, 24);
        x *= 0x9FB21C651E98DF25ULL;
        x ^= (x >> 35) + len ;
        x *= 0x9FB21C651E98DF25ULL;
        return XXH_xorshift64(x, 28);
    }
}

XXH3_len_9to16_128b()

XXH_FORCE_INLINE XXH128_hash_t XXH3_len_9to16_128b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 1733 of file xxh3.h.

References XXH3_avalanche(), XXH_mult32to64, and XXH_mult64to128().

Referenced by XXH3_len_0to16_128b().

{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(secret != NULL);
    XXH_ASSERT(9 <= len && len <= 16);
    {   xxh_u64 const bitflipl = (XXH_readLE64(secret+32) ^ XXH_readLE64(secret+40)) - seed;
        xxh_u64 const bitfliph = (XXH_readLE64(secret+48) ^ XXH_readLE64(secret+56)) + seed;
        xxh_u64 const input_lo = XXH_readLE64(input);
        xxh_u64       input_hi = XXH_readLE64(input + len - 8);
        XXH128_hash_t m128 = XXH_mult64to128(input_lo ^ input_hi ^ bitflipl, PRIME64_1);
        /*
         * Put len in the middle of m128 to ensure that the length gets mixed to
         * both the low and high bits in the 128x64 multiply below.
         */
        m128.low64  += (xxh_u64)(len - 1) << 54;
        input_hi ^= bitfliph;
        /*
         * Add the high 32 bits of input_hi to the high 32 bits of m128, then
         * add the long product of the low 32 bits of input_hi and PRIME32_2 to
         * the high 64 bits of m128.
         *
         * The best approach to this operation is different on 32-bit and 64-bit.
         */
        if (sizeof(void *) < sizeof(xxh_u64)) { /* 32-bit */
            /*
             * 32-bit optimized version, which is more readable.
             *
             * On 32-bit, it removes an ADC and delays a dependency between the two
             * halves of m128.high64, but it generates an extra mask on 64-bit.
             */
            m128.high64 += (input_hi & 0xFFFFFFFF00000000) + XXH_mult32to64((xxh_u32)input_hi, PRIME32_2);
        } else {
            /*
             * 64-bit optimized (albeit more confusing) version.
             *
             * Uses some properties of addition and multiplication to remove the mask:
             *
             * Let:
             *    a = input_hi.lo = (input_hi & 0x00000000FFFFFFFF)
             *    b = input_hi.hi = (input_hi & 0xFFFFFFFF00000000)
             *    c = PRIME32_2
             *
             *    a + (b * c)
             * Inverse Property: x + y - x == y
             *    a + (b * (1 + c - 1))
             * Distributive Property: x * (y + z) == (x * y) + (x * z)
             *    a + (b * 1) + (b * (c - 1))
             * Identity Property: x * 1 == x
             *    a + b + (b * (c - 1))
             *
             * Substitute a, b, and c:
             *    input_hi.hi + input_hi.lo + ((xxh_u64)input_hi.lo * (PRIME32_2 - 1))
             *
             * Since input_hi.hi + input_hi.lo == input_hi, we get this:
             *    input_hi + ((xxh_u64)input_hi.lo * (PRIME32_2 - 1))
             */
            m128.high64 += input_hi + XXH_mult32to64((xxh_u32)input_hi, PRIME32_2 - 1);
        }
        /* m128 ^= XXH_swap64(m128 >> 64); */
        m128.low64  ^= XXH_swap64(m128.high64);

        {   /* 128x64 multiply: h128 = m128 * PRIME64_2; */
            XXH128_hash_t h128 = XXH_mult64to128(m128.low64, PRIME64_2);
            h128.high64 += m128.high64 * PRIME64_2;

            h128.low64   = XXH3_avalanche(h128.low64);
            h128.high64  = XXH3_avalanche(h128.high64);
            return h128;
    }   }
}

XXH3_len_9to16_64b()

XXH_FORCE_INLINE XXH64_hash_t XXH3_len_9to16_64b	(	const xxh_u8 *	input,
		size_t	len,
		const xxh_u8 *	secret,
		XXH64_hash_t	seed
	)

Definition at line 720 of file xxh3.h.

References XXH3_avalanche(), and XXH3_mul128_fold64().

Referenced by XXH3_len_0to16_64b().

{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(secret != NULL);
    XXH_ASSERT(8 <= len && len <= 16);
    {   xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed;
        xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed;
        xxh_u64 const input_lo = XXH_readLE64(input)           ^ bitflip1;
        xxh_u64 const input_hi = XXH_readLE64(input + len - 8) ^ bitflip2;
        xxh_u64 const acc = len
                          + XXH_swap64(input_lo) + input_hi
                          + XXH3_mul128_fold64(input_lo, input_hi);
        return XXH3_avalanche(acc);
    }
}

XXH3_mergeAccs()

static XXH64_hash_t XXH3_mergeAccs ( const xxh_u64 *XXH_RESTRICT  acc, const xxh_u8 *XXH_RESTRICT  secret, xxh_u64  start  )

static

Definition at line 1332 of file xxh3.h.

References XXH3_avalanche(), and XXH3_mix2Accs().

Referenced by XXH3_128bits_digest(), XXH3_64bits_digest(), XXH3_hashLong_128b_internal(), and XXH3_hashLong_internal().

{
    xxh_u64 result64 = start;

    result64 += XXH3_mix2Accs(acc+0, secret +  0);
    result64 += XXH3_mix2Accs(acc+2, secret + 16);
    result64 += XXH3_mix2Accs(acc+4, secret + 32);
    result64 += XXH3_mix2Accs(acc+6, secret + 48);

    return XXH3_avalanche(result64);
}

XXH3_mix16B()

XXH_FORCE_INLINE xxh_u64 XXH3_mix16B	(	const xxh_u8 *XXH_RESTRICT	input,
		const xxh_u8 *XXH_RESTRICT	secret,
		xxh_u64	seed64
	)

Definition at line 773 of file xxh3.h.

References XXH3_mul128_fold64().

Referenced by XXH128_mix32B(), XXH3_len_129to240_64b(), and XXH3_len_17to128_64b().

{
#if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
  && defined(__i386__) && defined(__SSE2__)  /* x86 + SSE2 */ \
  && !defined(XXH_ENABLE_AUTOVECTORIZE)      /* Define to disable like XXH32 hack */
    /*
     * UGLY HACK:
     * GCC for x86 tends to autovectorize the 128-bit multiply, resulting in
     * slower code.
     *
     * By forcing seed64 into a register, we disrupt the cost model and
     * cause it to scalarize. See `XXH32_round()`
     *
     * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600,
     * XXH3_64bits @ len=240 runs at 4.6 GB/s with Clang 9, but 3.3 GB/s on
     * GCC 9.2, despite both emitting scalar code.
     *
     * GCC generates much better scalar code than Clang for the rest of XXH3,
     * which is why finding a more optimal codepath is an interest.
     */
    __asm__ ("" : "+r" (seed64));
#endif
    {   xxh_u64 const input_lo = XXH_readLE64(input);
        xxh_u64 const input_hi = XXH_readLE64(input+8);
        return XXH3_mul128_fold64(
            input_lo ^ (XXH_readLE64(secret)   + seed64),
            input_hi ^ (XXH_readLE64(secret+8) - seed64)
        );
    }
}

XXH3_mix2Accs()

XXH_FORCE_INLINE xxh_u64 XXH3_mix2Accs	(	const xxh_u64 *XXH_RESTRICT	acc,
		const xxh_u8 *XXH_RESTRICT	secret
	)

Definition at line 1324 of file xxh3.h.

References XXH3_mul128_fold64().

Referenced by XXH3_mergeAccs().

{
    return XXH3_mul128_fold64(
               acc[0] ^ XXH_readLE64(secret),
               acc[1] ^ XXH_readLE64(secret+8) );
}

XXH3_mul128_fold64()

static xxh_u64 XXH3_mul128_fold64 ( xxh_u64  lhs, xxh_u64  rhs  )

static

Definition at line 616 of file xxh3.h.

References XXH_mult64to128().

Referenced by XXH3_len_9to16_64b(), XXH3_mix16B(), and XXH3_mix2Accs().

{
    XXH128_hash_t product = XXH_mult64to128(lhs, rhs);
    return product.low64 ^ product.high64;
}

XXH3_scrambleAcc()

XXH_FORCE_INLINE void XXH3_scrambleAcc	(	void *XXH_RESTRICT	acc,
		const void *XXH_RESTRICT	secret
	)

Definition at line 1111 of file xxh3.h.

References ACC_NB, STRIPE_LEN, XXH_ALIGN(), and XXH_xorshift64().

Referenced by XXH3_consumeStripes(), and XXH3_hashLong_internal_loop().

{
#if (XXH_VECTOR == XXH_AVX2)

    XXH_ASSERT((((size_t)acc) & 31) == 0);
    {   XXH_ALIGN(32) __m256i* const xacc = (__m256i*) acc;
        /* Unaligned. This is mainly for pointer arithmetic, and because
         * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */
        const         __m256i* const xsecret = (const __m256i *) secret;
        const __m256i prime32 = _mm256_set1_epi32((int)PRIME32_1);

        size_t i;
        for (i=0; i < STRIPE_LEN/sizeof(__m256i); i++) {
            /* xacc[i] ^= (xacc[i] >> 47) */
            __m256i const acc_vec     = xacc[i];
            __m256i const shifted     = _mm256_srli_epi64    (acc_vec, 47);
            __m256i const data_vec    = _mm256_xor_si256     (acc_vec, shifted);
            /* xacc[i] ^= xsecret; */
            __m256i const key_vec     = _mm256_loadu_si256   (xsecret+i);
            __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);

            /* xacc[i] *= PRIME32_1; */
            __m256i const data_key_hi = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
            __m256i const prod_lo     = _mm256_mul_epu32     (data_key, prime32);
            __m256i const prod_hi     = _mm256_mul_epu32     (data_key_hi, prime32);
            xacc[i] = _mm256_add_epi64(prod_lo, _mm256_slli_epi64(prod_hi, 32));
        }
    }

#elif (XXH_VECTOR == XXH_SSE2)

    XXH_ASSERT((((size_t)acc) & 15) == 0);
    {   XXH_ALIGN(16) __m128i* const xacc = (__m128i*) acc;
        /* Unaligned. This is mainly for pointer arithmetic, and because
         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */
        const         __m128i* const xsecret = (const __m128i *) secret;
        const __m128i prime32 = _mm_set1_epi32((int)PRIME32_1);

        size_t i;
        for (i=0; i < STRIPE_LEN/sizeof(__m128i); i++) {
            /* xacc[i] ^= (xacc[i] >> 47) */
            __m128i const acc_vec     = xacc[i];
            __m128i const shifted     = _mm_srli_epi64    (acc_vec, 47);
            __m128i const data_vec    = _mm_xor_si128     (acc_vec, shifted);
            /* xacc[i] ^= xsecret[i]; */
            __m128i const key_vec     = _mm_loadu_si128   (xsecret+i);
            __m128i const data_key    = _mm_xor_si128     (data_vec, key_vec);

            /* xacc[i] *= PRIME32_1; */
            __m128i const data_key_hi = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
            __m128i const prod_lo     = _mm_mul_epu32     (data_key, prime32);
            __m128i const prod_hi     = _mm_mul_epu32     (data_key_hi, prime32);
            xacc[i] = _mm_add_epi64(prod_lo, _mm_slli_epi64(prod_hi, 32));
        }
    }

#elif (XXH_VECTOR == XXH_NEON)

    XXH_ASSERT((((size_t)acc) & 15) == 0);

    {   uint64x2_t* xacc       = (uint64x2_t*) acc;
        uint8_t const* xsecret = (uint8_t const*) secret;
        uint32x2_t prime       = vdup_n_u32 (PRIME32_1);

        size_t i;
        for (i=0; i < STRIPE_LEN/sizeof(uint64x2_t); i++) {
            /* xacc[i] ^= (xacc[i] >> 47); */
            uint64x2_t acc_vec  = xacc[i];
            uint64x2_t shifted  = vshrq_n_u64 (acc_vec, 47);
            uint64x2_t data_vec = veorq_u64   (acc_vec, shifted);

            /* xacc[i] ^= xsecret[i]; */
            uint8x16_t key_vec  = vld1q_u8(xsecret + (i * 16));
            uint64x2_t data_key = veorq_u64(data_vec, vreinterpretq_u64_u8(key_vec));

            /* xacc[i] *= PRIME32_1 */
            uint32x2_t data_key_lo, data_key_hi;
            /* data_key_lo = (uint32x2_t) (xacc[i] & 0xFFFFFFFF);
             * data_key_hi = (uint32x2_t) (xacc[i] >> 32);
             * xacc[i] = UNDEFINED; */
            XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi);
            {   /*
                 * prod_hi = (data_key >> 32) * PRIME32_1;
                 *
                 * Avoid vmul_u32 + vshll_n_u32 since Clang 6 and 7 will
                 * incorrectly "optimize" this:
                 *   tmp     = vmul_u32(vmovn_u64(a), vmovn_u64(b));
                 *   shifted = vshll_n_u32(tmp, 32);
                 * to this:
                 *   tmp     = "vmulq_u64"(a, b); // no such thing!
                 *   shifted = vshlq_n_u64(tmp, 32);
                 *
                 * However, unlike SSE, Clang lacks a 64-bit multiply routine
                 * for NEON, and it scalarizes two 64-bit multiplies instead.
                 *
                 * vmull_u32 has the same timing as vmul_u32, and it avoids
                 * this bug completely.
                 * See https://bugs.llvm.org/show_bug.cgi?id=39967
                 */
                uint64x2_t prod_hi = vmull_u32 (data_key_hi, prime);
                /* xacc[i] = prod_hi << 32; */
                xacc[i] = vshlq_n_u64(prod_hi, 32);
                /* xacc[i] += (prod_hi & 0xFFFFFFFF) * PRIME32_1; */
                xacc[i] = vmlal_u32(xacc[i], data_key_lo, prime);
            }
    }   }

#elif (XXH_VECTOR == XXH_VSX)

    XXH_ASSERT((((size_t)acc) & 15) == 0);

    {         xxh_u64x2* const xacc    =       (xxh_u64x2*) acc;
        const xxh_u64x2* const xsecret = (const xxh_u64x2*) secret;
        /* constants */
        xxh_u64x2 const v32  = { 32, 32 };
        xxh_u64x2 const v47 = { 47, 47 };
        xxh_u32x4 const prime = { PRIME32_1, PRIME32_1, PRIME32_1, PRIME32_1 };
        size_t i;
        for (i = 0; i < STRIPE_LEN / sizeof(xxh_u64x2); i++) {
            /* xacc[i] ^= (xacc[i] >> 47); */
            xxh_u64x2 const acc_vec  = xacc[i];
            xxh_u64x2 const data_vec = acc_vec ^ (acc_vec >> v47);

            /* xacc[i] ^= xsecret[i]; */
            xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + i);
            xxh_u64x2 const data_key = data_vec ^ key_vec;

            /* xacc[i] *= PRIME32_1 */
            /* prod_lo = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)prime & 0xFFFFFFFF);  */
            xxh_u64x2 const prod_even  = XXH_vec_mule((xxh_u32x4)data_key, prime);
            /* prod_hi = ((xxh_u64x2)data_key >> 32) * ((xxh_u64x2)prime >> 32);  */
            xxh_u64x2 const prod_odd  = XXH_vec_mulo((xxh_u32x4)data_key, prime);
            xacc[i] = prod_odd + (prod_even << v32);
    }   }

#else   /* scalar variant of Scrambler - universal */

    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64* const xacc = (xxh_u64*) acc;   /* presumed aligned */
    const xxh_u8* const xsecret = (const xxh_u8*) secret;   /* no alignment restriction */
    size_t i;
    XXH_ASSERT((((size_t)acc) & (XXH_ACC_ALIGN-1)) == 0);
    for (i=0; i < ACC_NB; i++) {
        xxh_u64 const key64 = XXH_readLE64(xsecret + 8*i);
        xxh_u64 acc64 = xacc[i];
        acc64 = XXH_xorshift64(acc64, 47);
        acc64 ^= key64;
        acc64 *= PRIME32_1;
        xacc[i] = acc64;
    }

#endif
}

XXH3_update()

XXH_FORCE_INLINE XXH_errorcode XXH3_update	(	XXH3_state_t *	state,
		const xxh_u8 *	input,
		size_t	len,
		XXH3_accWidth_e	accWidth
	)

Definition at line 1558 of file xxh3.h.

References STRIPE_LEN, XXH3_consumeStripes(), XXH3_INTERNALBUFFER_STRIPES, XXH_ERROR, and XXH_OK.

Referenced by XXH3_128bits_update(), and XXH3_64bits_update().

{
    if (input==NULL)
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
        return XXH_OK;
#else
        return XXH_ERROR;
#endif

    {   const xxh_u8* const bEnd = input + len;

        state->totalLen += len;

        if (state->bufferedSize + len <= XXH3_INTERNALBUFFER_SIZE) {  /* fill in tmp buffer */
            XXH_memcpy(state->buffer + state->bufferedSize, input, len);
            state->bufferedSize += (XXH32_hash_t)len;
            return XXH_OK;
        }
        /* input is now > XXH3_INTERNALBUFFER_SIZE */

        #define XXH3_INTERNALBUFFER_STRIPES (XXH3_INTERNALBUFFER_SIZE / STRIPE_LEN)
        XXH_STATIC_ASSERT(XXH3_INTERNALBUFFER_SIZE % STRIPE_LEN == 0);   /* clean multiple */

        /*
         * There is some input left inside the internal buffer.
         * Fill it, then consume it.
         */
        if (state->bufferedSize) {
            size_t const loadSize = XXH3_INTERNALBUFFER_SIZE - state->bufferedSize;
            XXH_memcpy(state->buffer + state->bufferedSize, input, loadSize);
            input += loadSize;
            XXH3_consumeStripes(state->acc,
                               &state->nbStripesSoFar, state->nbStripesPerBlock,
                                state->buffer, XXH3_INTERNALBUFFER_STRIPES,
                                state->secret, state->secretLimit,
                                accWidth);
            state->bufferedSize = 0;
        }

        /* Consume input by full buffer quantities */
        if (input+XXH3_INTERNALBUFFER_SIZE <= bEnd) {
            const xxh_u8* const limit = bEnd - XXH3_INTERNALBUFFER_SIZE;
            do {
                XXH3_consumeStripes(state->acc,
                                   &state->nbStripesSoFar, state->nbStripesPerBlock,
                                    input, XXH3_INTERNALBUFFER_STRIPES,
                                    state->secret, state->secretLimit,
                                    accWidth);
                input += XXH3_INTERNALBUFFER_SIZE;
            } while (input<=limit);
        }

        if (input < bEnd) { /* Some remaining input: buffer it */
            XXH_memcpy(state->buffer, input, (size_t)(bEnd-input));
            state->bufferedSize = (XXH32_hash_t)(bEnd-input);
        }
    }

    return XXH_OK;
}

XXH_ALIGN()

XXH_ALIGN

(

64

)

const

Referenced by XXH3_128bits_digest(), XXH3_64bits_digest(), XXH3_accumulate_512(), XXH3_hashLong_128b_internal(), XXH3_hashLong_128b_withSeed(), XXH3_hashLong_64b_withSeed(), XXH3_hashLong_internal(), and XXH3_scrambleAcc().

XXH_mult64to128()

static XXH128_hash_t XXH_mult64to128 ( xxh_u64  lhs, xxh_u64  rhs  )

static

Definition at line 507 of file xxh3.h.

References XXH_mult32to64.

Referenced by XXH3_len_4to8_128b(), XXH3_len_9to16_128b(), and XXH3_mul128_fold64().

{
    /*
     * GCC/Clang __uint128_t method.
     *
     * On most 64-bit targets, GCC and Clang define a __uint128_t type.
     * This is usually the best way as it usually uses a native long 64-bit
     * multiply, such as MULQ on x86_64 or MUL + UMULH on aarch64.
     *
     * Usually.
     *
     * Despite being a 32-bit platform, Clang (and emscripten) define this type
     * despite not having the arithmetic for it. This results in a laggy
     * compiler builtin call which calculates a full 128-bit multiply.
     * In that case it is best to use the portable one.
     * https://github.com/Cyan4973/xxHash/issues/211#issuecomment-515575677
     */
#if defined(__GNUC__) && !defined(__wasm__) \
    && defined(__SIZEOF_INT128__) \
    || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)

    __uint128_t product = (__uint128_t)lhs * (__uint128_t)rhs;
    XXH128_hash_t const r128 = { (xxh_u64)(product), (xxh_u64)(product >> 64) };
    return r128;

    /*
     * MSVC for x64's _umul128 method.
     *
     * xxh_u64 _umul128(xxh_u64 Multiplier, xxh_u64 Multiplicand, xxh_u64 *HighProduct);
     *
     * This compiles to single operand MUL on x64.
     */
#elif defined(_M_X64) || defined(_M_IA64)

#ifndef _MSC_VER
#   pragma intrinsic(_umul128)
#endif
    xxh_u64 product_high;
    xxh_u64 const product_low = _umul128(lhs, rhs, &product_high);
    XXH128_hash_t const r128 = { product_low, product_high };
    return r128;

#else
    /*
     * Portable scalar method. Optimized for 32-bit and 64-bit ALUs.
     *
     * This is a fast and simple grade school multiply, which is shown below
     * with base 10 arithmetic instead of base 0x100000000.
     *
     *           9 3 // D2 lhs = 93
     *         x 7 5 // D2 rhs = 75
     *     ----------
     *           1 5 // D2 lo_lo = (93 % 10) * (75 % 10) = 15
     *         4 5 | // D2 hi_lo = (93 / 10) * (75 % 10) = 45
     *         2 1 | // D2 lo_hi = (93 % 10) * (75 / 10) = 21
     *     + 6 3 | | // D2 hi_hi = (93 / 10) * (75 / 10) = 63
     *     ---------
     *         2 7 | // D2 cross = (15 / 10) + (45 % 10) + 21 = 27
     *     + 6 7 | | // D2 upper = (27 / 10) + (45 / 10) + 63 = 67
     *     ---------
     *       6 9 7 5 // D4 res = (27 * 10) + (15 % 10) + (67 * 100) = 6975
     *
     * The reasons for adding the products like this are:
     *  1. It avoids manual carry tracking. Just like how
     *     (9 * 9) + 9 + 9 = 99, the same applies with this for UINT64_MAX.
     *     This avoids a lot of complexity.
     *
     *  2. It hints for, and on Clang, compiles to, the powerful UMAAL
     *     instruction available in ARM's Digital Signal Processing extension
     *     in 32-bit ARMv6 and later, which is shown below:
     *
     *         void UMAAL(xxh_u32 *RdLo, xxh_u32 *RdHi, xxh_u32 Rn, xxh_u32 Rm)
     *         {
     *             xxh_u64 product = (xxh_u64)*RdLo * (xxh_u64)*RdHi + Rn + Rm;
     *             *RdLo = (xxh_u32)(product & 0xFFFFFFFF);
     *             *RdHi = (xxh_u32)(product >> 32);
     *         }
     *
     *     This instruction was designed for efficient long multiplication, and
     *     allows this to be calculated in only 4 instructions at speeds
     *     comparable to some 64-bit ALUs.
     *
     *  3. It isn't terrible on other platforms. Usually this will be a couple
     *     of 32-bit ADD/ADCs.
     */

    /* First calculate all of the cross products. */
    xxh_u64 const lo_lo = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF);
    xxh_u64 const hi_lo = XXH_mult32to64(lhs >> 32,        rhs & 0xFFFFFFFF);
    xxh_u64 const lo_hi = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs >> 32);
    xxh_u64 const hi_hi = XXH_mult32to64(lhs >> 32,        rhs >> 32);

    /* Now add the products together. These will never overflow. */
    xxh_u64 const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi;
    xxh_u64 const upper = (hi_lo >> 32) + (cross >> 32)        + hi_hi;
    xxh_u64 const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF);

    XXH128_hash_t r128 = { lower, upper };
    return r128;
#endif
}

XXH_writeLE64()

XXH_FORCE_INLINE void XXH_writeLE64	(	void *	dst,
		xxh_u64	v64
	)

Definition at line 1385 of file xxh3.h.

Referenced by XXH3_initCustomSecret().

{
    if (!XXH_CPU_LITTLE_ENDIAN) v64 = XXH_swap64(v64);
    memcpy(dst, &v64, sizeof(v64));
}

XXH_xorshift64()

XXH_FORCE_INLINE xxh_u64 XXH_xorshift64	(	xxh_u64	v64,
		int	shift
	)

Definition at line 623 of file xxh3.h.

Referenced by XXH3_avalanche(), XXH3_len_4to8_128b(), XXH3_len_4to8_64b(), and XXH3_scrambleAcc().

{
    XXH_ASSERT(0 <= shift && shift < 64);
    return v64 ^ (v64 >> shift);
}