|
| XXH_PUBLIC_API unsigned int | XXH32 (const void *input, size_t len, unsigned int seed) |
| |
| static U32 | XXH32_avalanche (U32 h32) |
| |
| XXH_PUBLIC_API void | XXH32_canonicalFromHash (XXH32_canonical_t *dst, XXH32_hash_t hash) |
| |
| XXH_PUBLIC_API void | XXH32_copyState (XXH32_state_t *dstState, const XXH32_state_t *srcState) |
| |
| XXH_PUBLIC_API XXH32_state_t * | XXH32_createState (void) |
| |
| XXH_PUBLIC_API unsigned int | XXH32_digest (const XXH32_state_t *state_in) |
| |
| FORCE_INLINE U32 | XXH32_digest_endian (const XXH32_state_t *state, XXH_endianess endian) |
| |
| FORCE_INLINE U32 | XXH32_endian_align (const void *input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align) |
| |
| static U32 | XXH32_finalize (U32 h32, const void *ptr, size_t len, XXH_endianess endian, XXH_alignment align) |
| |
| XXH_PUBLIC_API XXH_errorcode | XXH32_freeState (XXH32_state_t *statePtr) |
| |
| XXH_PUBLIC_API XXH32_hash_t | XXH32_hashFromCanonical (const XXH32_canonical_t *src) |
| |
| XXH_PUBLIC_API XXH_errorcode | XXH32_reset (XXH32_state_t *statePtr, unsigned int seed) |
| |
| static U32 | XXH32_round (U32 seed, U32 input) |
| |
| XXH_PUBLIC_API XXH_errorcode | XXH32_update (XXH32_state_t *state_in, const void *input, size_t len) |
| |
| FORCE_INLINE XXH_errorcode | XXH32_update_endian (XXH32_state_t *state, const void *input, size_t len, XXH_endianess endian) |
| |
| XXH_PUBLIC_API unsigned long long | XXH64 (const void *input, size_t len, unsigned long long seed) |
| |
| static U64 | XXH64_avalanche (U64 h64) |
| |
| XXH_PUBLIC_API void | XXH64_canonicalFromHash (XXH64_canonical_t *dst, XXH64_hash_t hash) |
| |
| XXH_PUBLIC_API void | XXH64_copyState (XXH64_state_t *dstState, const XXH64_state_t *srcState) |
| |
| XXH_PUBLIC_API XXH64_state_t * | XXH64_createState (void) |
| |
| XXH_PUBLIC_API unsigned long long | XXH64_digest (const XXH64_state_t *state_in) |
| |
| FORCE_INLINE U64 | XXH64_digest_endian (const XXH64_state_t *state, XXH_endianess endian) |
| |
| FORCE_INLINE U64 | XXH64_endian_align (const void *input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align) |
| |
| static U64 | XXH64_finalize (U64 h64, const void *ptr, size_t len, XXH_endianess endian, XXH_alignment align) |
| |
| XXH_PUBLIC_API XXH_errorcode | XXH64_freeState (XXH64_state_t *statePtr) |
| |
| XXH_PUBLIC_API XXH64_hash_t | XXH64_hashFromCanonical (const XXH64_canonical_t *src) |
| |
| static U64 | XXH64_mergeRound (U64 acc, U64 val) |
| |
| XXH_PUBLIC_API XXH_errorcode | XXH64_reset (XXH64_state_t *statePtr, unsigned long long seed) |
| |
| static U64 | XXH64_round (U64 acc, U64 input) |
| |
| XXH_PUBLIC_API XXH_errorcode | XXH64_update (XXH64_state_t *state_in, const void *input, size_t len) |
| |
| FORCE_INLINE XXH_errorcode | XXH64_update_endian (XXH64_state_t *state, const void *input, size_t len, XXH_endianess endian) |
| |
| static void | XXH_free (void *p) |
| |
| static int | XXH_isLittleEndian (void) |
| |
| static void * | XXH_malloc (size_t s) |
| |
| static void * | XXH_memcpy (void *dest, const void *src, size_t size) |
| |
| static U32 | XXH_read32 (const void *memPtr) |
| |
| static U64 | XXH_read64 (const void *memPtr) |
| |
| static U32 | XXH_readBE32 (const void *ptr) |
| |
| static U64 | XXH_readBE64 (const void *ptr) |
| |
| FORCE_INLINE U32 | XXH_readLE32 (const void *ptr, XXH_endianess endian) |
| |
| FORCE_INLINE U32 | XXH_readLE32_align (const void *ptr, XXH_endianess endian, XXH_alignment align) |
| |
| FORCE_INLINE U64 | XXH_readLE64 (const void *ptr, XXH_endianess endian) |
| |
| FORCE_INLINE U64 | XXH_readLE64_align (const void *ptr, XXH_endianess endian, XXH_alignment align) |
| |
| static U32 | XXH_swap32 (U32 x) |
| |
| static U64 | XXH_swap64 (U64 x) |
| |
| XXH_PUBLIC_API unsigned | XXH_versionNumber (void) |
| |
| #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 71 of file xxhash.c.
| #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 83 of file xxhash.c.
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.
The default return values from XXH functions are unsigned 32 and 64 bit integers.
The canonical representation uses big endian convention, the same convention as human-readable numbers (large digits first).
This way, hash values can be written into a file or buffer, remaining comparable across different systems.
The following functions allow transformation of hash values to and from their canonical format.
Definition at line 565 of file xxhash.c.
