| /* |
| xxHash - Extremely Fast Hash algorithm |
| Header File |
| Copyright (C) 2012-2016, Yann Collet. |
| |
| BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions are |
| met: |
| |
| * Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the following disclaimer |
| in the documentation and/or other materials provided with the |
| distribution. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| You can contact the author at : |
| - xxHash source repository : https://github.com/Cyan4973/xxHash |
| */ |
| |
| /* Notice extracted from xxHash homepage : |
| |
| xxHash is an extremely fast Hash algorithm, running at RAM speed limits. |
| It also successfully passes all tests from the SMHasher suite. |
| |
| Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz) |
| |
| Name Speed Q.Score Author |
| xxHash 5.4 GB/s 10 |
| CrapWow 3.2 GB/s 2 Andrew |
| MumurHash 3a 2.7 GB/s 10 Austin Appleby |
| SpookyHash 2.0 GB/s 10 Bob Jenkins |
| SBox 1.4 GB/s 9 Bret Mulvey |
| Lookup3 1.2 GB/s 9 Bob Jenkins |
| SuperFastHash 1.2 GB/s 1 Paul Hsieh |
| CityHash64 1.05 GB/s 10 Pike & Alakuijala |
| FNV 0.55 GB/s 5 Fowler, Noll, Vo |
| CRC32 0.43 GB/s 9 |
| MD5-32 0.33 GB/s 10 Ronald L. Rivest |
| SHA1-32 0.28 GB/s 10 |
| |
| Q.Score is a measure of quality of the hash function. |
| It depends on successfully passing SMHasher test set. |
| 10 is a perfect score. |
| |
| A 64-bits version, named XXH64, is available since r35. |
| It offers much better speed, but for 64-bits applications only. |
| Name Speed on 64 bits Speed on 32 bits |
| XXH64 13.8 GB/s 1.9 GB/s |
| XXH32 6.8 GB/s 6.0 GB/s |
| */ |
| |
| #ifndef XXHASH_H_5627135585666179 |
| #define XXHASH_H_5627135585666179 1 |
| |
| #if defined (__cplusplus) |
| extern "C" { |
| #endif |
| |
| |
| /* **************************** |
| * Definitions |
| ******************************/ |
| #include <stddef.h> /* size_t */ |
| typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; |
| |
| |
| /* **************************** |
| * API modifier |
| ******************************/ |
| /** XXH_PRIVATE_API |
| * This is useful to include xxhash functions in `static` mode |
| * in order to inline them, and remove their symbol from the public list. |
| * Methodology : |
| * #define XXH_PRIVATE_API |
| * #include "xxhash.h" |
| * `xxhash.c` is automatically included. |
| * It's not useful to compile and link it as a separate module. |
| */ |
| #ifdef XXH_PRIVATE_API |
| # ifndef XXH_STATIC_LINKING_ONLY |
| # define XXH_STATIC_LINKING_ONLY |
| # endif |
| # if defined(__GNUC__) |
| # define XXH_PUBLIC_API static __inline __attribute__((unused)) |
| # elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) |
| # define XXH_PUBLIC_API static inline |
| # elif defined(_MSC_VER) |
| # define XXH_PUBLIC_API static __inline |
| # else |
| # define XXH_PUBLIC_API static /* this version may generate warnings for unused static functions; disable the relevant warning */ |
| # endif |
| #else |
| # define XXH_PUBLIC_API /* do nothing */ |
| #endif /* XXH_PRIVATE_API */ |
| |
| /*!XXH_NAMESPACE, aka Namespace Emulation : |
| |
| If you want to include _and expose_ xxHash functions from within your own library, |
| but also want to avoid symbol collisions with other libraries which may also include xxHash, |
| |
| you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library |
| with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values). |
| |
| Note that no change is required within the calling program as long as it includes `xxhash.h` : |
| regular symbol name will be automatically translated by this header. |
| */ |
| #ifdef XXH_NAMESPACE |
| # define XXH_CAT(A,B) A##B |
| # define XXH_NAME2(A,B) XXH_CAT(A,B) |
| # define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber) |
| # define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32) |
| # define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState) |
| # define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState) |
| # define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset) |
| # define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update) |
| # define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest) |
| # define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState) |
| # define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash) |
| # define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical) |
| # define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64) |
| # define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState) |
| # define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState) |
| # define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset) |
| # define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update) |
| # define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest) |
| # define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState) |
| # define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash) |
| # define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical) |
| #endif |
| |
| |
| /* ************************************* |
| * Version |
| ***************************************/ |
| #define XXH_VERSION_MAJOR 0 |
| #define XXH_VERSION_MINOR 6 |
| #define XXH_VERSION_RELEASE 2 |
| #define XXH_VERSION_NUMBER (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE) |
| XXH_PUBLIC_API unsigned XXH_versionNumber (void); |
| |
| |
| /*-********************************************************************** |
| * 32-bits hash |
| ************************************************************************/ |
| typedef unsigned int XXH32_hash_t; |
| |
| /*! XXH32() : |
| Calculate the 32-bits 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 */ |
| XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed); |
| |
| /*====== Streaming ======*/ |
| typedef struct XXH32_state_s XXH32_state_t; /* incomplete type */ |
| 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* dst_state, const XXH32_state_t* src_state); |
| |
| XXH_PUBLIC_API XXH_errorcode XXH32_reset (XXH32_state_t* statePtr, unsigned int seed); |
| XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length); |
| XXH_PUBLIC_API XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr); |
| |
| /* |
| These functions generate the xxHash of an input provided in multiple segments. |
| Note that, for small input, they are slower than single-call functions, due to state management. |
| For small input, prefer `XXH32()` and `XXH64()` . |
| |
| XXH state must first be allocated, using XXH*_createState() . |
| |
| Start a new hash by initializing state with a seed, using XXH*_reset(). |
| |
| Then, feed the hash state by calling XXH*_update() as many times as necessary. |
| Obviously, input must be allocated and read accessible. |
| The function returns an error code, with 0 meaning OK, and any other value meaning there is an error. |
| |
| Finally, a hash value can be produced anytime, by using XXH*_digest(). |
| This function returns the nn-bits hash as an int or long long. |
| |
| It's still possible to continue inserting input into the hash state after a digest, |
| and generate some new hashes later on, by calling again XXH*_digest(). |
| |
| When done, free XXH state space if it was allocated dynamically. |
| */ |
| |
| /*====== Canonical representation ======*/ |
| |
| typedef struct { unsigned char digest[4]; } XXH32_canonical_t; |
| 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); |
| |
| /* Default result type for XXH functions are primitive unsigned 32 and 64 bits. |
| * The canonical representation uses 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 / memory, and remain comparable on different systems and programs. |
| */ |
| |
| |
| #ifndef XXH_NO_LONG_LONG |
| /*-********************************************************************** |
| * 64-bits hash |
| ************************************************************************/ |
| typedef unsigned long long XXH64_hash_t; |
| |
| /*! XXH64() : |
| Calculate the 64-bits 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-bits systems, but slower on 32-bits systems (see benchmark). |
| */ |
| XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed); |
| |
| /*====== Streaming ======*/ |
| typedef struct XXH64_state_s XXH64_state_t; /* incomplete type */ |
| 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* dst_state, const XXH64_state_t* src_state); |
| |
| XXH_PUBLIC_API XXH_errorcode XXH64_reset (XXH64_state_t* statePtr, unsigned long long seed); |
| XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length); |
| XXH_PUBLIC_API XXH64_hash_t XXH64_digest (const XXH64_state_t* statePtr); |
| |
| /*====== Canonical representation ======*/ |
| typedef struct { unsigned char digest[8]; } XXH64_canonical_t; |
| 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); |
| #endif /* XXH_NO_LONG_LONG */ |
| |
| |
| #ifdef XXH_STATIC_LINKING_ONLY |
| |
| /* ================================================================================================ |
| This section contains definitions which are not guaranteed to remain stable. |
| They may change in future versions, becoming incompatible with a different version of the library. |
| They shall only be used with static linking. |
| Never use these definitions in association with dynamic linking ! |
| =================================================================================================== */ |
| |
| /* These definitions are only meant to make possible |
| static allocation of XXH state, on stack or in a struct for example. |
| Never use members directly. */ |
| |
| struct XXH32_state_s { |
| unsigned total_len_32; |
| unsigned large_len; |
| unsigned v1; |
| unsigned v2; |
| unsigned v3; |
| unsigned v4; |
| unsigned mem32[4]; /* buffer defined as U32 for alignment */ |
| unsigned memsize; |
| unsigned reserved; /* never read nor write, will be removed in a future version */ |
| }; /* typedef'd to XXH32_state_t */ |
| |
| #ifndef XXH_NO_LONG_LONG /* remove 64-bits support */ |
| struct XXH64_state_s { |
| unsigned long long total_len; |
| unsigned long long v1; |
| unsigned long long v2; |
| unsigned long long v3; |
| unsigned long long v4; |
| unsigned long long mem64[4]; /* buffer defined as U64 for alignment */ |
| unsigned memsize; |
| unsigned reserved[2]; /* never read nor write, will be removed in a future version */ |
| }; /* typedef'd to XXH64_state_t */ |
| #endif |
| |
| #ifdef XXH_PRIVATE_API |
| # include "xxhash.c" /* include xxhash function bodies as `static`, for inlining */ |
| #endif |
| |
| #endif /* XXH_STATIC_LINKING_ONLY */ |
| |
| |
| #if defined (__cplusplus) |
| } |
| #endif |
| |
| #endif /* XXHASH_H_5627135585666179 */ |
