xxhash.c File Reference

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

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)
#define	XXH_rotl64(x, r)
#define	XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()
#define	XXH_STATIC_ASSERT(c)
#define	XXH_get32bits(p)
#define	PROCESS1
#define	PROCESS4
#define	MEM_MODULE
#define	XXH_get64bits(p)
#define	PROCESS1_64
#define	PROCESS4_64
#define	PROCESS8_64

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

Functions
FORCE_INLINE U32	XXH_readLE32_align (const void *ptr, XXH_endianness endian, XXH_alignment align)
FORCE_INLINE U32	XXH_readLE32 (const void *ptr, XXH_endianness endian)
XXH_PUBLIC_API unsigned	XXH_versionNumber (void)
FORCE_INLINE U32	XXH32_endian_align (const void *input, size_t len, U32 seed, XXH_endianness endian, XXH_alignment align)
XXH_PUBLIC_API unsigned int	XXH32 (const void *input, size_t len, unsigned int seed)
	Calculates the 32-bit hash of input using xxHash32.
XXH_PUBLIC_API XXH32_state_t *	XXH32_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH32_freeState (XXH32_state_t *statePtr)
	Frees an XXH32_state_t.
XXH_PUBLIC_API void	XXH32_copyState (XXH32_state_t *dstState, const XXH32_state_t *srcState)
	Copies one XXH32_state_t to another.
XXH_PUBLIC_API XXH_errorcode	XXH32_reset (XXH32_state_t *statePtr, unsigned int seed)
	Resets an XXH32_state_t to begin a new hash.
FORCE_INLINE XXH_errorcode	XXH32_update_endian (XXH32_state_t *state, const void *input, size_t len, XXH_endianness endian)
XXH_PUBLIC_API XXH_errorcode	XXH32_update (XXH32_state_t *state_in, const void *input, size_t len)
	Consumes a block of input to an XXH32_state_t.
FORCE_INLINE U32	XXH32_digest_endian (const XXH32_state_t *state, XXH_endianness endian)
XXH_PUBLIC_API unsigned int	XXH32_digest (const XXH32_state_t *state_in)
	Returns the calculated hash value from an XXH32_state_t.
XXH_PUBLIC_API void	XXH32_canonicalFromHash (XXH32_canonical_t *dst, XXH32_hash_t hash)
	Converts an XXH32_hash_t to a big endian XXH32_canonical_t.
XXH_PUBLIC_API XXH32_hash_t	XXH32_hashFromCanonical (const XXH32_canonical_t *src)
	Converts an XXH32_canonical_t to a native XXH32_hash_t.
FORCE_INLINE U64	XXH_readLE64_align (const void *ptr, XXH_endianness endian, XXH_alignment align)
FORCE_INLINE U64	XXH_readLE64 (const void *ptr, XXH_endianness endian)
FORCE_INLINE U64	XXH64_endian_align (const void *input, size_t len, U64 seed, XXH_endianness endian, XXH_alignment align)
XXH_PUBLIC_API unsigned long long	XXH64 (const void *input, size_t len, unsigned long long seed)
	Calculates the 64-bit hash of input using xxHash64.
XXH_PUBLIC_API XXH64_state_t *	XXH64_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH64_freeState (XXH64_state_t *statePtr)
	Frees an XXH64_state_t.
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_endianness 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_endianness 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)

Macro Definition Documentation

FORCE_INLINE

#define FORCE_INLINE   static

MEM_MODULE

#define MEM_MODULE

PROCESS1

#define PROCESS1

Value:

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

PROCESS1_64

#define PROCESS1_64

Value:

    h64 ^= (*p++) * PRIME64_5; \
    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.

XXH_CPU_LITTLE_ENDIAN

#define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()

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.

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.

XXH_GCC_VERSION

#define XXH_GCC_VERSION   (__GNUC__ * 100 + __GNUC_MINOR__)

XXH_get32bits

#define XXH_get32bits

(

p

)

Value:

XXH_readLE32_align(p, endian, align)

XXH_get64bits

#define XXH_get64bits

(

p

)

Value:

XXH_readLE64_align(p, endian, align)

XXH_rotl32

#define XXH_rotl32	(		x,
			r )

Value:

((x << r) | (x >> (32 - r)))

XXH_rotl64

#define XXH_rotl64	(		x,
			r )

Value:

((x << r) | (x >> (64 - r)))

XXH_STATIC_ASSERT

#define XXH_STATIC_ASSERT

(

c

)

Value:

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

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

Enumeration Type Documentation

XXH_alignment

enum XXH_alignment

Enumerator
XXH_aligned
XXH_unaligned

XXH_endianness

enum XXH_endianness

Enumerator
XXH_bigEndian
XXH_littleEndian

Function Documentation

XXH32_createState()

XXH_PUBLIC_API XXH32_state_t * XXH32_createState

(

void

)

XXH32_digest_endian()

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

XXH32_endian_align()

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

XXH32_update_endian()

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

XXH64_createState()

XXH_PUBLIC_API XXH64_state_t * XXH64_createState

(

void

)

XXH64_digest_endian()

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

XXH64_endian_align()

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

XXH64_update_endian()

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

XXH_readLE32()

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

XXH_readLE32_align()

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

XXH_readLE64()

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

XXH_readLE64_align()

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

XXH_versionNumber()

XXH_PUBLIC_API unsigned XXH_versionNumber

(

void

)