xxhash.c File Reference

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

Go to the source code of this file.

Macros
#define	XXH_ACCEPT_NULL_INPUT_POINTER   0
#define	XXH_FORCE_NATIVE_FORMAT   0
#define	XXH_FORCE_ALIGN_CHECK   1
#define	XXH_STATIC_LINKING_ONLY
#define	FORCE_INLINE   static
#define	XXH_GCC_VERSION   (__GNUC__ * 100 + __GNUC_MINOR__)
#define	XXH_rotl32(x, r)   ((x << r) | (x >> (32 - r)))
#define	XXH_rotl64(x, r)   ((x << r) | (x >> (64 - r)))
#define	XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()
#define	XXH_STATIC_ASSERT(c)   { enum { XXH_sa = 1/(int)(!!(c)) }; } /* use after variable declarations */
#define	XXH_get32bits(p)   XXH_readLE32_align(p, endian, align)
#define	PROCESS1
#define	PROCESS4
#define	MEM_MODULE
#define	XXH_get64bits(p)   XXH_readLE64_align(p, endian, align)
#define	PROCESS1_64
#define	PROCESS4_64
#define	PROCESS8_64

Typedefs
typedef unsigned char	BYTE
typedef unsigned short	U16
typedef unsigned int	U32
typedef unsigned long long	U64

Enumerations
enum	XXH_endianess { XXH_bigEndian =0 , XXH_littleEndian =1 , XXH_bigEndian =0 , XXH_littleEndian =1 }
enum	XXH_alignment { XXH_aligned , XXH_unaligned , XXH_aligned , XXH_unaligned }

Functions
static void *	XXH_malloc (size_t s)
static void	XXH_free (void *p)
static void *	XXH_memcpy (void *dest, const void *src, size_t size)
static U32	XXH_read32 (const void *memPtr)
static U32	XXH_swap32 (U32 x)
static int	XXH_isLittleEndian (void)
FORCE_INLINE U32	XXH_readLE32_align (const void *ptr, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE U32	XXH_readLE32 (const void *ptr, XXH_endianess endian)
static U32	XXH_readBE32 (const void *ptr)
XXH_PUBLIC_API unsigned	XXH_versionNumber (void)
static U32	XXH32_round (U32 seed, U32 input)
static U32	XXH32_avalanche (U32 h32)
static U32	XXH32_finalize (U32 h32, const void *ptr, size_t len, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE U32	XXH32_endian_align (const void *input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
XXH_PUBLIC_API unsigned int	XXH32 (const void *input, size_t len, unsigned int seed)
XXH_PUBLIC_API XXH32_state_t *	XXH32_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH32_freeState (XXH32_state_t *statePtr)
XXH_PUBLIC_API void	XXH32_copyState (XXH32_state_t *dstState, const XXH32_state_t *srcState)
XXH_PUBLIC_API XXH_errorcode	XXH32_reset (XXH32_state_t *statePtr, unsigned int seed)
FORCE_INLINE XXH_errorcode	XXH32_update_endian (XXH32_state_t *state, const void *input, size_t len, XXH_endianess endian)
XXH_PUBLIC_API XXH_errorcode	XXH32_update (XXH32_state_t *state_in, const void *input, size_t len)
FORCE_INLINE U32	XXH32_digest_endian (const XXH32_state_t *state, XXH_endianess endian)
XXH_PUBLIC_API unsigned int	XXH32_digest (const XXH32_state_t *state_in)
XXH_PUBLIC_API void	XXH32_canonicalFromHash (XXH32_canonical_t *dst, XXH32_hash_t hash)
XXH_PUBLIC_API XXH32_hash_t	XXH32_hashFromCanonical (const XXH32_canonical_t *src)
static U64	XXH_read64 (const void *memPtr)
static U64	XXH_swap64 (U64 x)
FORCE_INLINE U64	XXH_readLE64_align (const void *ptr, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE U64	XXH_readLE64 (const void *ptr, XXH_endianess endian)
static U64	XXH_readBE64 (const void *ptr)
static U64	XXH64_round (U64 acc, U64 input)
static U64	XXH64_mergeRound (U64 acc, U64 val)
static U64	XXH64_avalanche (U64 h64)
static U64	XXH64_finalize (U64 h64, const void *ptr, size_t len, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE U64	XXH64_endian_align (const void *input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
XXH_PUBLIC_API unsigned long long	XXH64 (const void *input, size_t len, unsigned long long seed)
XXH_PUBLIC_API XXH64_state_t *	XXH64_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH64_freeState (XXH64_state_t *statePtr)
XXH_PUBLIC_API void	XXH64_copyState (XXH64_state_t *dstState, const XXH64_state_t *srcState)
XXH_PUBLIC_API XXH_errorcode	XXH64_reset (XXH64_state_t *statePtr, unsigned long long seed)
FORCE_INLINE XXH_errorcode	XXH64_update_endian (XXH64_state_t *state, const void *input, size_t len, XXH_endianess endian)
XXH_PUBLIC_API XXH_errorcode	XXH64_update (XXH64_state_t *state_in, const void *input, size_t len)
FORCE_INLINE U64	XXH64_digest_endian (const XXH64_state_t *state, XXH_endianess endian)
XXH_PUBLIC_API unsigned long long	XXH64_digest (const XXH64_state_t *state_in)
XXH_PUBLIC_API void	XXH64_canonicalFromHash (XXH64_canonical_t *dst, XXH64_hash_t hash)
XXH_PUBLIC_API XXH64_hash_t	XXH64_hashFromCanonical (const XXH64_canonical_t *src)

Variables
static const U32	PRIME32_1 = 2654435761U
static const U32	PRIME32_2 = 2246822519U
static const U32	PRIME32_3 = 3266489917U
static const U32	PRIME32_4 = 668265263U
static const U32	PRIME32_5 = 374761393U
static const U64	PRIME64_1 = 11400714785074694791ULL
static const U64	PRIME64_2 = 14029467366897019727ULL
static const U64	PRIME64_3 = 1609587929392839161ULL
static const U64	PRIME64_4 = 9650029242287828579ULL
static const U64	PRIME64_5 = 2870177450012600261ULL

Macro Definition Documentation

FORCE_INLINE

#define FORCE_INLINE   static

Definition at line 137 of file xxhash.c.

MEM_MODULE

#define MEM_MODULE

Definition at line 589 of file xxhash.c.

PROCESS1

#define PROCESS1

Value:

    h32 += (*p) * PRIME32_5; \
    p++;                     \
    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;

PROCESS1_64

#define PROCESS1_64

Value:

    h64 ^= (*p) * PRIME64_5; \
    p++;                     \
    h64 = XXH_rotl64(h64, 11) * PRIME64_1;

PROCESS4

#define PROCESS4

Value:

    h32 += XXH_get32bits(p) * PRIME32_3; \
    p+=4;                                \
    h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;

PROCESS4_64

#define PROCESS4_64

Value:

    h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; \
    p+=4;                    \
    h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;

PROCESS8_64

#define PROCESS8_64

Value:

    {        \
    U64 const k1 = XXH64_round(0, XXH_get64bits(p)); \
    p+=8;                    \
    h64 ^= k1;               \
    h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; \
}

XXH_ACCEPT_NULL_INPUT_POINTER

#define XXH_ACCEPT_NULL_INPUT_POINTER   0

XXH_FORCE_MEMORY_ACCESS : By default, access to unaligned memory is controlled by memcpy(), which is safe and portable. Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. The below switch allow to select different access method for improved performance. Method 0 (default) : use memcpy(). Safe and portable. Method 1 : __packed statement. It depends on compiler extension (ie, not portable). This method is safe if your compiler supports it, and generally as fast or faster than memcpy. Method 2 : direct access. This method doesn't depend on compiler but violate C standard. It can generate buggy code on targets which do not support unaligned memory accesses. But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) See http://stackoverflow.com/a/32095106/646947 for details. Prefer these methods in priority order (0 > 1 > 2)

XXH_ACCEPT_NULL_INPUT_POINTER : If input pointer is NULL, xxHash default behavior is to dereference it, triggering a segfault. When this macro is enabled, xxHash actively checks input for null pointer. It it is, result for null input pointers is the same as a null-length input.

Definition at line 74 of file xxhash.c.

XXH_CPU_LITTLE_ENDIAN

#define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()

Definition at line 228 of file xxhash.c.

XXH_FORCE_ALIGN_CHECK

#define XXH_FORCE_ALIGN_CHECK   1

XXH_FORCE_ALIGN_CHECK : This is a minor performance trick, only useful with lots of very small keys. It means : check for aligned/unaligned input. The check costs one initial branch per hash; set it to 0 when the input is guaranteed to be aligned, or when alignment doesn't matter for performance.

Definition at line 100 of file xxhash.c.

XXH_FORCE_NATIVE_FORMAT

#define XXH_FORCE_NATIVE_FORMAT   0

XXH_FORCE_NATIVE_FORMAT : By default, xxHash library provides endian-independent Hash values, based on little-endian convention. Results are therefore identical for little-endian and big-endian CPU. This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. Should endian-independence be of no importance for your application, you may set the #define below to 1, to improve speed for Big-endian CPU. This option has no impact on Little_Endian CPU.

Definition at line 86 of file xxhash.c.

XXH_GCC_VERSION

#define XXH_GCC_VERSION   (__GNUC__ * 100 + __GNUC_MINOR__)

Definition at line 190 of file xxhash.c.

XXH_get32bits

#define XXH_get32bits

(

p

)

XXH_readLE32_align(p, endian, align)

Definition at line 291 of file xxhash.c.

XXH_get64bits

#define XXH_get64bits

(

p

)

XXH_readLE64_align(p, endian, align)

Definition at line 701 of file xxhash.c.

XXH_rotl32

#define XXH_rotl32	(		x,
			r
	)		((x << r) | (x >> (32 - r)))

Definition at line 197 of file xxhash.c.

XXH_rotl64

#define XXH_rotl64	(		x,
			r
	)		((x << r) | (x >> (64 - r)))

Definition at line 198 of file xxhash.c.

XXH_STATIC_ASSERT

#define XXH_STATIC_ASSERT

(

c

)

{ enum { XXH_sa = 1/(int)(!!(c)) }; } /* use after variable declarations */

Definition at line 259 of file xxhash.c.

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

Definition at line 119 of file xxhash.c.

Typedef Documentation

BYTE

typedef unsigned char BYTE

Definition at line 154 of file xxhash.c.

U16

typedef unsigned short U16

Definition at line 155 of file xxhash.c.

U32

typedef unsigned int U32

Definition at line 156 of file xxhash.c.

U64

typedef unsigned long long U64

Definition at line 597 of file xxhash.c.

Enumeration Type Documentation

XXH_alignment

enum XXH_alignment

Enumerator
XXH_aligned
XXH_unaligned
XXH_aligned
XXH_unaligned

Definition at line 235 of file xxhash.c.

{ XXH_aligned, XXH_unaligned } XXH_alignment;

XXH_endianess

enum XXH_endianess

Enumerator
XXH_bigEndian
XXH_littleEndian
XXH_bigEndian
XXH_littleEndian

Definition at line 219 of file xxhash.c.

{ XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;

Function Documentation

XXH32()

XXH_PUBLIC_API unsigned int XXH32	(	const void *	input,
		size_t	length,
		unsigned int	seed
	)

XXH32() : Calculate the 32-bit hash of sequence "length" bytes stored at memory address "input". The memory between input & input+length must be valid (allocated and read-accessible). "seed" can be used to alter the result predictably. Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s

Definition at line 395 of file xxhash.c.

{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH32_state_t state;
    XXH32_reset(&state, seed);
    XXH32_update(&state, input, len);
    return XXH32_digest(&state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

References input(), len, XXH32_digest(), XXH32_endian_align(), XXH32_reset(), XXH32_update(), XXH_aligned, XXH_bigEndian, XXH_CPU_LITTLE_ENDIAN, XXH_FORCE_ALIGN_CHECK, XXH_FORCE_NATIVE_FORMAT, XXH_littleEndian, and XXH_unaligned.

XXH32_avalanche()

static U32 XXH32_avalanche ( U32  h32 )

static

Definition at line 281 of file xxhash.c.

{
    h32 ^= h32 >> 15;
    h32 *= PRIME32_2;
    h32 ^= h32 >> 13;
    h32 *= PRIME32_3;
    h32 ^= h32 >> 16;
    return(h32);
}

References PRIME32_2, and PRIME32_3.

Referenced by XXH32_finalize().

XXH32_canonicalFromHash()

XXH_PUBLIC_API void XXH32_canonicalFromHash	(	XXH32_canonical_t *	dst,
		XXH32_hash_t	hash
	)

Default XXH result types are basic unsigned 32 and 64 bits. The canonical representation follows human-readable write convention, aka big-endian (large digits first). These functions allow transformation of hash result into and from its canonical format. This way, hash values can be written into a file or buffer, remaining comparable across different systems.

Definition at line 567 of file xxhash.c.

{
    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
    memcpy(dst, &hash, sizeof(*dst));
}

References dst, memcpy(), XXH_CPU_LITTLE_ENDIAN, XXH_STATIC_ASSERT, and XXH_swap32().

XXH32_copyState()

XXH_PUBLIC_API void XXH32_copyState	(	XXH32_state_t *	dstState,
		const XXH32_state_t *	srcState
	)

Definition at line 435 of file xxhash.c.

{
    memcpy(dstState, srcState, sizeof(*dstState));
}

References memcpy().

XXH32_createState()

XXH_PUBLIC_API XXH32_state_t* XXH32_createState

(

void

)

Definition at line 425 of file xxhash.c.

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

References XXH_malloc().

XXH32_digest()

XXH_PUBLIC_API unsigned int XXH32_digest

(

const XXH32_state_t *

state_in

)

Definition at line 548 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_digest_endian(state_in, XXH_littleEndian);
    else
        return XXH32_digest_endian(state_in, XXH_bigEndian);
}

References XXH32_digest_endian(), XXH_bigEndian, XXH_CPU_LITTLE_ENDIAN, XXH_FORCE_NATIVE_FORMAT, and XXH_littleEndian.

XXH32_digest_endian()

FORCE_INLINE U32 XXH32_digest_endian	(	const XXH32_state_t *	state,
		XXH_endianess	endian
	)

Definition at line 529 of file xxhash.c.

{
    U32 h32;
 
    if (state->large_len) {
        h32 = XXH_rotl32(state->v1, 1)
            + XXH_rotl32(state->v2, 7)
            + XXH_rotl32(state->v3, 12)
            + XXH_rotl32(state->v4, 18);
    } else {
        h32 = state->v3 /* == seed */ + PRIME32_5;
    }
 
    h32 += state->total_len_32;
 
    return XXH32_finalize(h32, state->mem32, state->memsize, endian, XXH_aligned);
}

References PRIME32_5, XXH32_finalize(), XXH_aligned, and XXH_rotl32.

XXH32_endian_align()

FORCE_INLINE U32 XXH32_endian_align	(	const void *	input,
		size_t	len,
		U32	seed,
		XXH_endianess	endian,
		XXH_alignment	align
	)

Definition at line 355 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* bEnd = p + len;
    U32 h32;
 
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
    if (p==NULL) {
        len=0;
        bEnd=p=(const BYTE*)(size_t)16;
    }
#endif
 
    if (len>=16) {
        const BYTE* const limit = bEnd - 15;
        U32 v1 = seed + PRIME32_1 + PRIME32_2;
        U32 v2 = seed + PRIME32_2;
        U32 v3 = seed + 0;
        U32 v4 = seed - PRIME32_1;
 
        do {
            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
        } while (p < limit);
 
        h32 = XXH_rotl32(v1, 1)  + XXH_rotl32(v2, 7)
            + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
    } else {
        h32  = seed + PRIME32_5;
    }
 
    h32 += (U32)len;
 
    return XXH32_finalize(h32, p, len&15, endian, align);
}

References input(), len, limit, NULL, p, PRIME32_1, PRIME32_2, PRIME32_5, v1, XXH32_finalize(), XXH32_round(), XXH_get32bits, and XXH_rotl32.

XXH32_finalize()

static U32 XXH32_finalize ( U32  h32, const void *  ptr, size_t  len, XXH_endianess  endian, XXH_alignment  align  )

static

Definition at line 294 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)ptr;
#define PROCESS1             \
    h32 += (*p) * PRIME32_5; \
    p++;                     \
    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
 
#define PROCESS4                         \
    h32 += XXH_get32bits(p) * PRIME32_3; \
    p+=4;                                \
    h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
 
    switch(len&15)  /* or switch(bEnd - p) */
    {
      case 12:      PROCESS4;
                    /* fallthrough */
      case 8:       PROCESS4;
                    /* fallthrough */
      case 4:       PROCESS4;
                    return XXH32_avalanche(h32);
 
      case 13:      PROCESS4;
                    /* fallthrough */
      case 9:       PROCESS4;
                    /* fallthrough */
      case 5:       PROCESS4;
                    PROCESS1;
                    return XXH32_avalanche(h32);
 
      case 14:      PROCESS4;
                    /* fallthrough */
      case 10:      PROCESS4;
                    /* fallthrough */
      case 6:       PROCESS4;
                    PROCESS1;
                    PROCESS1;
                    return XXH32_avalanche(h32);
 
      case 15:      PROCESS4;
                    /* fallthrough */
      case 11:      PROCESS4;
                    /* fallthrough */
      case 7:       PROCESS4;
                    /* fallthrough */
      case 3:       PROCESS1;
                    /* fallthrough */
      case 2:       PROCESS1;
                    /* fallthrough */
      case 1:       PROCESS1;
                    /* fallthrough */
      case 0:       return XXH32_avalanche(h32);
    }
    assert(0);
    return h32;   /* reaching this point is deemed impossible */
}

References assert(), len, p, PROCESS1, PROCESS4, and XXH32_avalanche().

Referenced by XXH32_digest_endian(), and XXH32_endian_align().

XXH32_freeState()

XXH_PUBLIC_API XXH_errorcode XXH32_freeState

(

XXH32_state_t *

statePtr

)

Definition at line 429 of file xxhash.c.

{
    XXH_free(statePtr);
    return XXH_OK;
}

References XXH_free(), and XXH_OK.

XXH32_hashFromCanonical()

XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical

(

const XXH32_canonical_t *

src

)

Definition at line 574 of file xxhash.c.

{
    return XXH_readBE32(src);
}

References src, and XXH_readBE32().

XXH32_reset()

XXH_PUBLIC_API XXH_errorcode XXH32_reset	(	XXH32_state_t *	statePtr,
		unsigned int	seed
	)

Definition at line 440 of file xxhash.c.

{
    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state));
    state.v1 = seed + PRIME32_1 + PRIME32_2;
    state.v2 = seed + PRIME32_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME32_1;
    /* do not write into reserved, planned to be removed in a future version */
    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
    return XXH_OK;
}

References memcpy(), memset(), PRIME32_1, PRIME32_2, and XXH_OK.

XXH32_round()

static U32 XXH32_round ( U32  seed, U32  input  )

static

Definition at line 272 of file xxhash.c.

{
    seed += input * PRIME32_2;
    seed  = XXH_rotl32(seed, 13);
    seed *= PRIME32_1;
    return seed;
}

References input(), PRIME32_1, PRIME32_2, and XXH_rotl32.

Referenced by XXH32_endian_align(), and XXH32_update_endian().

XXH32_update()

XXH_PUBLIC_API XXH_errorcode XXH32_update	(	XXH32_state_t *	state_in,
		const void *	input,
		size_t	len
	)

Definition at line 517 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
    else
        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
}

References input(), len, XXH32_update_endian(), XXH_bigEndian, XXH_CPU_LITTLE_ENDIAN, XXH_FORCE_NATIVE_FORMAT, and XXH_littleEndian.

XXH32_update_endian()

FORCE_INLINE XXH_errorcode XXH32_update_endian	(	XXH32_state_t *	state,
		const void *	input,
		size_t	len,
		XXH_endianess	endian
	)

Definition at line 455 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* const bEnd = p + len;
 
    if (input==NULL)
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
        return XXH_OK;
#else
        return XXH_ERROR;
#endif
 
    state->total_len_32 += (unsigned)len;
    state->large_len |= (len>=16) | (state->total_len_32>=16);
 
    if (state->memsize + len < 16)  {   /* fill in tmp buffer */
        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
        state->memsize += (unsigned)len;
        return XXH_OK;
    }
 
    if (state->memsize) {   /* some data left from previous update */
        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
        {   const U32* p32 = state->mem32;
            state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
            state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
            state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian));
        }
        p += 16-state->memsize;
        state->memsize = 0;
    }
 
    if (p <= bEnd-16) {
        const BYTE* const limit = bEnd - 16;
        U32 v1 = state->v1;
        U32 v2 = state->v2;
        U32 v3 = state->v3;
        U32 v4 = state->v4;
 
        do {
            v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
            v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
            v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
            v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
        } while (p<=limit);
 
        state->v1 = v1;
        state->v2 = v2;
        state->v3 = v3;
        state->v4 = v4;
    }
 
    if (p < bEnd) {
        XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
        state->memsize = (unsigned)(bEnd-p);
    }
 
    return XXH_OK;
}

References input(), len, limit, NULL, p, unsigned, v1, XXH32_round(), XXH_ERROR, XXH_memcpy(), XXH_OK, and XXH_readLE32().

XXH64()

XXH_PUBLIC_API unsigned long long XXH64	(	const void *	input,
		size_t	length,
		unsigned long long	seed
	)

XXH64() : Calculate the 64-bit hash of sequence of length "len" stored at memory address "input". "seed" can be used to alter the result predictably. This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).

Definition at line 858 of file xxhash.c.

{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH64_state_t state;
    XXH64_reset(&state, seed);
    XXH64_update(&state, input, len);
    return XXH64_digest(&state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

References input(), len, XXH64_digest(), XXH64_endian_align(), XXH64_reset(), XXH64_update(), XXH_aligned, XXH_bigEndian, XXH_CPU_LITTLE_ENDIAN, XXH_FORCE_ALIGN_CHECK, XXH_FORCE_NATIVE_FORMAT, XXH_littleEndian, and XXH_unaligned.

XXH64_avalanche()

static U64 XXH64_avalanche ( U64  h64 )

static

Definition at line 690 of file xxhash.c.

{
    h64 ^= h64 >> 33;
    h64 *= PRIME64_2;
    h64 ^= h64 >> 29;
    h64 *= PRIME64_3;
    h64 ^= h64 >> 32;
    return h64;
}

References PRIME64_2, and PRIME64_3.

Referenced by XXH64_finalize().

XXH64_canonicalFromHash()

XXH_PUBLIC_API void XXH64_canonicalFromHash	(	XXH64_canonical_t *	dst,
		XXH64_hash_t	hash
	)

Definition at line 1020 of file xxhash.c.

{
    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
    memcpy(dst, &hash, sizeof(*dst));
}

References dst, memcpy(), XXH_CPU_LITTLE_ENDIAN, XXH_STATIC_ASSERT, and XXH_swap64().

XXH64_copyState()

XXH_PUBLIC_API void XXH64_copyState	(	XXH64_state_t *	dstState,
		const XXH64_state_t *	srcState
	)

Definition at line 896 of file xxhash.c.

{
    memcpy(dstState, srcState, sizeof(*dstState));
}

References memcpy().

XXH64_createState()

XXH_PUBLIC_API XXH64_state_t* XXH64_createState

(

void

)

Definition at line 886 of file xxhash.c.

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

References XXH_malloc().

XXH64_digest()

XXH_PUBLIC_API unsigned long long XXH64_digest

(

const XXH64_state_t *

state_in

)

Definition at line 1007 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_digest_endian(state_in, XXH_littleEndian);
    else
        return XXH64_digest_endian(state_in, XXH_bigEndian);
}

References XXH64_digest_endian(), XXH_bigEndian, XXH_CPU_LITTLE_ENDIAN, XXH_FORCE_NATIVE_FORMAT, and XXH_littleEndian.

XXH64_digest_endian()

FORCE_INLINE U64 XXH64_digest_endian	(	const XXH64_state_t *	state,
		XXH_endianess	endian
	)

Definition at line 983 of file xxhash.c.

{
    U64 h64;
 
    if (state->total_len >= 32) {
        U64 const v1 = state->v1;
        U64 const v2 = state->v2;
        U64 const v3 = state->v3;
        U64 const v4 = state->v4;
 
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
        h64 = XXH64_mergeRound(h64, v1);
        h64 = XXH64_mergeRound(h64, v2);
        h64 = XXH64_mergeRound(h64, v3);
        h64 = XXH64_mergeRound(h64, v4);
    } else {
        h64  = state->v3 /*seed*/ + PRIME64_5;
    }
 
    h64 += (U64) state->total_len;
 
    return XXH64_finalize(h64, state->mem64, (size_t)state->total_len, endian, XXH_aligned);
}

References PRIME64_5, v1, XXH64_finalize(), XXH64_mergeRound(), XXH_aligned, and XXH_rotl64.

XXH64_endian_align()

FORCE_INLINE U64 XXH64_endian_align	(	const void *	input,
		size_t	len,
		U64	seed,
		XXH_endianess	endian,
		XXH_alignment	align
	)

Definition at line 814 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* bEnd = p + len;
    U64 h64;
 
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
    if (p==NULL) {
        len=0;
        bEnd=p=(const BYTE*)(size_t)32;
    }
#endif
 
    if (len>=32) {
        const BYTE* const limit = bEnd - 32;
        U64 v1 = seed + PRIME64_1 + PRIME64_2;
        U64 v2 = seed + PRIME64_2;
        U64 v3 = seed + 0;
        U64 v4 = seed - PRIME64_1;
 
        do {
            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
        } while (p<=limit);
 
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
        h64 = XXH64_mergeRound(h64, v1);
        h64 = XXH64_mergeRound(h64, v2);
        h64 = XXH64_mergeRound(h64, v3);
        h64 = XXH64_mergeRound(h64, v4);
 
    } else {
        h64  = seed + PRIME64_5;
    }
 
    h64 += (U64) len;
 
    return XXH64_finalize(h64, p, len, endian, align);
}

References input(), len, limit, NULL, p, PRIME64_1, PRIME64_2, PRIME64_5, v1, XXH64_finalize(), XXH64_mergeRound(), XXH64_round(), XXH_get64bits, and XXH_rotl64.

XXH64_finalize()

static U64 XXH64_finalize ( U64  h64, const void *  ptr, size_t  len, XXH_endianess  endian, XXH_alignment  align  )

static

Definition at line 704 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)ptr;
 
#define PROCESS1_64          \
    h64 ^= (*p) * PRIME64_5; \
    p++;                     \
    h64 = XXH_rotl64(h64, 11) * PRIME64_1;
 
#define PROCESS4_64          \
    h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; \
    p+=4;                    \
    h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
 
#define PROCESS8_64 {        \
    U64 const k1 = XXH64_round(0, XXH_get64bits(p)); \
    p+=8;                    \
    h64 ^= k1;               \
    h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; \
}
 
    switch(len&31) {
      case 24: PROCESS8_64;
                    /* fallthrough */
      case 16: PROCESS8_64;
                    /* fallthrough */
      case  8: PROCESS8_64;
               return XXH64_avalanche(h64);
 
      case 28: PROCESS8_64;
                    /* fallthrough */
      case 20: PROCESS8_64;
                    /* fallthrough */
      case 12: PROCESS8_64;
                    /* fallthrough */
      case  4: PROCESS4_64;
               return XXH64_avalanche(h64);
 
      case 25: PROCESS8_64;
                    /* fallthrough */
      case 17: PROCESS8_64;
                    /* fallthrough */
      case  9: PROCESS8_64;
               PROCESS1_64;
               return XXH64_avalanche(h64);
 
      case 29: PROCESS8_64;
                    /* fallthrough */
      case 21: PROCESS8_64;
                    /* fallthrough */
      case 13: PROCESS8_64;
                    /* fallthrough */
      case  5: PROCESS4_64;
               PROCESS1_64;
               return XXH64_avalanche(h64);
 
      case 26: PROCESS8_64;
                    /* fallthrough */
      case 18: PROCESS8_64;
                    /* fallthrough */
      case 10: PROCESS8_64;
               PROCESS1_64;
               PROCESS1_64;
               return XXH64_avalanche(h64);
 
      case 30: PROCESS8_64;
                    /* fallthrough */
      case 22: PROCESS8_64;
                    /* fallthrough */
      case 14: PROCESS8_64;
                    /* fallthrough */
      case  6: PROCESS4_64;
               PROCESS1_64;
               PROCESS1_64;
               return XXH64_avalanche(h64);
 
      case 27: PROCESS8_64;
                    /* fallthrough */
      case 19: PROCESS8_64;
                    /* fallthrough */
      case 11: PROCESS8_64;
               PROCESS1_64;
               PROCESS1_64;
               PROCESS1_64;
               return XXH64_avalanche(h64);
 
      case 31: PROCESS8_64;
                    /* fallthrough */
      case 23: PROCESS8_64;
                    /* fallthrough */
      case 15: PROCESS8_64;
                    /* fallthrough */
      case  7: PROCESS4_64;
                    /* fallthrough */
      case  3: PROCESS1_64;
                    /* fallthrough */
      case  2: PROCESS1_64;
                    /* fallthrough */
      case  1: PROCESS1_64;
                    /* fallthrough */
      case  0: return XXH64_avalanche(h64);
    }
 
    /* impossible to reach */
    assert(0);
    return 0;  /* unreachable, but some compilers complain without it */
}

References assert(), len, p, PROCESS1_64, PROCESS4_64, PROCESS8_64, and XXH64_avalanche().

Referenced by XXH64_digest_endian(), and XXH64_endian_align().

XXH64_freeState()

XXH_PUBLIC_API XXH_errorcode XXH64_freeState

(

XXH64_state_t *

statePtr

)

Definition at line 890 of file xxhash.c.

{
    XXH_free(statePtr);
    return XXH_OK;
}

References XXH_free(), and XXH_OK.

XXH64_hashFromCanonical()

XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical

(

const XXH64_canonical_t *

src

)

Definition at line 1027 of file xxhash.c.

{
    return XXH_readBE64(src);
}

References src, and XXH_readBE64().

XXH64_mergeRound()

static U64 XXH64_mergeRound ( U64  acc, U64  val  )

static

Definition at line 682 of file xxhash.c.

{
    val  = XXH64_round(0, val);
    acc ^= val;
    acc  = acc * PRIME64_1 + PRIME64_4;
    return acc;
}

References PRIME64_1, PRIME64_4, val, and XXH64_round().

Referenced by XXH64_digest_endian(), and XXH64_endian_align().

XXH64_reset()

XXH_PUBLIC_API XXH_errorcode XXH64_reset	(	XXH64_state_t *	statePtr,
		unsigned long long	seed
	)

Definition at line 901 of file xxhash.c.

{
    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state));
    state.v1 = seed + PRIME64_1 + PRIME64_2;
    state.v2 = seed + PRIME64_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME64_1;
     /* do not write into reserved, planned to be removed in a future version */
    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
    return XXH_OK;
}

References memcpy(), memset(), PRIME64_1, PRIME64_2, and XXH_OK.

XXH64_round()

static U64 XXH64_round ( U64  acc, U64  input  )

static

Definition at line 674 of file xxhash.c.

{
    acc += input * PRIME64_2;
    acc  = XXH_rotl64(acc, 31);
    acc *= PRIME64_1;
    return acc;
}

References input(), PRIME64_1, PRIME64_2, and XXH_rotl64.

Referenced by XXH64_endian_align(), XXH64_mergeRound(), and XXH64_update_endian().

XXH64_update()

XXH_PUBLIC_API XXH_errorcode XXH64_update	(	XXH64_state_t *	state_in,
		const void *	input,
		size_t	len
	)

Definition at line 973 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
    else
        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
}

References input(), len, XXH64_update_endian(), XXH_bigEndian, XXH_CPU_LITTLE_ENDIAN, XXH_FORCE_NATIVE_FORMAT, and XXH_littleEndian.

XXH64_update_endian()

FORCE_INLINE XXH_errorcode XXH64_update_endian	(	XXH64_state_t *	state,
		const void *	input,
		size_t	len,
		XXH_endianess	endian
	)

Definition at line 915 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* const bEnd = p + len;
 
    if (input==NULL)
#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
        return XXH_OK;
#else
        return XXH_ERROR;
#endif
 
    state->total_len += len;
 
    if (state->memsize + len < 32) {  /* fill in tmp buffer */
        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
        state->memsize += (U32)len;
        return XXH_OK;
    }
 
    if (state->memsize) {   /* tmp buffer is full */
        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
        state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
        state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
        state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
        state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
        p += 32-state->memsize;
        state->memsize = 0;
    }
 
    if (p+32 <= bEnd) {
        const BYTE* const limit = bEnd - 32;
        U64 v1 = state->v1;
        U64 v2 = state->v2;
        U64 v3 = state->v3;
        U64 v4 = state->v4;
 
        do {
            v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
            v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
            v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
            v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
        } while (p<=limit);
 
        state->v1 = v1;
        state->v2 = v2;
        state->v3 = v3;
        state->v4 = v4;
    }
 
    if (p < bEnd) {
        XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
        state->memsize = (unsigned)(bEnd-p);
    }
 
    return XXH_OK;
}

References input(), len, limit, NULL, p, unsigned, v1, XXH64_round(), XXH_ERROR, XXH_memcpy(), XXH_OK, and XXH_readLE64().

XXH_free()

static void XXH_free ( void *  p )

static

Definition at line 112 of file xxhash.c.

{ free(p); }

References free(), and p.

Referenced by XXH32_freeState(), and XXH64_freeState().

XXH_isLittleEndian()

static int XXH_isLittleEndian ( void  )

static

Definition at line 223 of file xxhash.c.

{
    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
    return one.c[0];
}

References c.

XXH_malloc()

static void* XXH_malloc ( size_t  s )

static

Modify the local functions below should you wish to use some other memory routines for malloc(), free()

Definition at line 111 of file xxhash.c.

{ return malloc(s); }

References malloc(), and s.

Referenced by XXH32_createState(), and XXH64_createState().

XXH_memcpy()

static void* XXH_memcpy ( void *  dest, const void *  src, size_t  size  )

static

and for memcpy()

Definition at line 115 of file xxhash.c.

{ return memcpy(dest,src,size); }

References dest, memcpy(), and src.

Referenced by XXH32_update_endian(), and XXH64_update_endian().

XXH_read32()

static U32 XXH_read32 ( const void *  memPtr )

static

Definition at line 177 of file xxhash.c.

{
    U32 val;
    memcpy(&val, memPtr, sizeof(val));
    return val;
}

References memcpy(), and val.

Referenced by XXH_readBE32(), and XXH_readLE32_align().

XXH_read64()

static U64 XXH_read64 ( const void *  memPtr )

static

Definition at line 620 of file xxhash.c.

{
    U64 val;
    memcpy(&val, memPtr, sizeof(val));
    return val;
}

References memcpy(), and val.

Referenced by XXH_readBE64(), and XXH_readLE64_align().

XXH_readBE32()

static U32 XXH_readBE32 ( const void *  ptr )

static

Definition at line 250 of file xxhash.c.

{
    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
}

References XXH_CPU_LITTLE_ENDIAN, XXH_read32(), and XXH_swap32().

Referenced by XXH32_hashFromCanonical().

XXH_readBE64()

static U64 XXH_readBE64 ( const void *  ptr )

static

Definition at line 660 of file xxhash.c.

{
    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
}

References XXH_CPU_LITTLE_ENDIAN, XXH_read64(), and XXH_swap64().

Referenced by XXH64_hashFromCanonical().

XXH_readLE32()

FORCE_INLINE U32 XXH_readLE32	(	const void *	ptr,
		XXH_endianess	endian
	)

Definition at line 245 of file xxhash.c.

{
    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
}

References XXH_readLE32_align(), and XXH_unaligned.

XXH_readLE32_align()

FORCE_INLINE U32 XXH_readLE32_align	(	const void *	ptr,
		XXH_endianess	endian,
		XXH_alignment	align
	)

Definition at line 237 of file xxhash.c.

{
    if (align==XXH_unaligned)
        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
    else
        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
}

References XXH_littleEndian, XXH_read32(), XXH_swap32(), and XXH_unaligned.

XXH_readLE64()

FORCE_INLINE U64 XXH_readLE64	(	const void *	ptr,
		XXH_endianess	endian
	)

Definition at line 655 of file xxhash.c.

{
    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
}

References XXH_readLE64_align(), and XXH_unaligned.

XXH_readLE64_align()

FORCE_INLINE U64 XXH_readLE64_align	(	const void *	ptr,
		XXH_endianess	endian,
		XXH_alignment	align
	)

Definition at line 647 of file xxhash.c.

{
    if (align==XXH_unaligned)
        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
    else
        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
}

References XXH_littleEndian, XXH_read64(), XXH_swap64(), and XXH_unaligned.

XXH_swap32()

static U32 XXH_swap32 ( U32  x )

static

Definition at line 206 of file xxhash.c.

{
    return  ((x << 24) & 0xff000000 ) |
            ((x <<  8) & 0x00ff0000 ) |
            ((x >>  8) & 0x0000ff00 ) |
            ((x >> 24) & 0x000000ff );
}

References x.

Referenced by XXH32_canonicalFromHash(), XXH_readBE32(), and XXH_readLE32_align().

XXH_swap64()

static U64 XXH_swap64 ( U64  x )

static

Definition at line 634 of file xxhash.c.

{
    return  ((x << 56) & 0xff00000000000000ULL) |
            ((x << 40) & 0x00ff000000000000ULL) |
            ((x << 24) & 0x0000ff0000000000ULL) |
            ((x << 8)  & 0x000000ff00000000ULL) |
            ((x >> 8)  & 0x00000000ff000000ULL) |
            ((x >> 24) & 0x0000000000ff0000ULL) |
            ((x >> 40) & 0x000000000000ff00ULL) |
            ((x >> 56) & 0x00000000000000ffULL);
}

References x.

Referenced by XXH64_canonicalFromHash(), XXH_readBE64(), and XXH_readLE64_align().

XXH_versionNumber()

XXH_PUBLIC_API unsigned XXH_versionNumber

(

void

)

Definition at line 260 of file xxhash.c.

{ return XXH_VERSION_NUMBER; }

References XXH_VERSION_NUMBER.

Variable Documentation

PRIME32_1

const U32 PRIME32_1 = 2654435761U

static

Definition at line 266 of file xxhash.c.

Referenced by XXH32_endian_align(), XXH32_reset(), and XXH32_round().

PRIME32_2

const U32 PRIME32_2 = 2246822519U

static

Definition at line 267 of file xxhash.c.

Referenced by XXH32_avalanche(), XXH32_endian_align(), XXH32_reset(), and XXH32_round().

PRIME32_3

const U32 PRIME32_3 = 3266489917U

static

Definition at line 268 of file xxhash.c.

Referenced by XXH32_avalanche().

PRIME32_4

const U32 PRIME32_4 = 668265263U

static

Definition at line 269 of file xxhash.c.

PRIME32_5

const U32 PRIME32_5 = 374761393U

static

Definition at line 270 of file xxhash.c.

Referenced by XXH32_digest_endian(), and XXH32_endian_align().

PRIME64_1

const U64 PRIME64_1 = 11400714785074694791ULL

static

Definition at line 668 of file xxhash.c.

Referenced by XXH64_endian_align(), XXH64_mergeRound(), XXH64_reset(), and XXH64_round().

PRIME64_2

const U64 PRIME64_2 = 14029467366897019727ULL

static

Definition at line 669 of file xxhash.c.

Referenced by XXH64_avalanche(), XXH64_endian_align(), XXH64_reset(), and XXH64_round().

PRIME64_3

const U64 PRIME64_3 = 1609587929392839161ULL

static

Definition at line 670 of file xxhash.c.

Referenced by XXH64_avalanche().

PRIME64_4

const U64 PRIME64_4 = 9650029242287828579ULL

static

Definition at line 671 of file xxhash.c.

Referenced by XXH64_mergeRound().

PRIME64_5

const U64 PRIME64_5 = 2870177450012600261ULL

static

Definition at line 672 of file xxhash.c.

Referenced by XXH64_digest_endian(), and XXH64_endian_align().