xxHash | Extremely fast non-cryptographic hash algorithm | Hashing library

The following macros can be set at compilation time to modify libxxhash’s behavior. They are generally disabled by default. When compiling the Command Line Interface xxhsum with make, the following environment variables can also be set : - DISPATCH=1 : use xxh_x86dispatch.c, to automatically select between scalar, sse2, avx2 or avx512 instruction set at runtime, depending on local host. This option is only valid for x86/x64 systems.
XXH_INLINE_ALL: Make all functions inline, with implementations being directly included within xxhash.h. Inlining functions is beneficial for speed on small keys. It’s extremely effective when key length is expressed as a compile time constant, with performance improvements observed in the +200% range . See [this article](https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html) for details.
XXH_PRIVATE_API: same outcome as XXH_INLINE_ALL. Still available for legacy support. The name underlines that XXH_* symbols will not be exported.
XXH_NAMESPACE: Prefixes all symbols with the value of XXH_NAMESPACE. This macro can only use compilable character set. Useful to evade symbol naming collisions, in case of multiple inclusions of xxHash’s source code. Client applications still use the regular function names, as symbols are automatically translated through xxhash.h.
XXH_FORCE_MEMORY_ACCESS: The default method 0 uses a portable memcpy() notation. Method 1 uses a gcc-specific packed attribute, which can provide better performance for some targets. Method 2 forces unaligned reads, which is not standards compliant, but might sometimes be the only way to extract better read performance. Method 3 uses a byteshift operation, which is best for old compilers which don’t inline memcpy() or big-endian systems without a byteswap instruction
XXH_FORCE_ALIGN_CHECK: Use a faster direct read path when input is aligned. This option can result in dramatic performance improvement when input to hash is aligned on 32 or 64-bit boundaries, when running on architectures unable to load memory from unaligned addresses, or suffering a performance penalty from it. It is (slightly) detrimental on platform with good unaligned memory access performance (same instruction for both aligned and unaligned accesses). This option is automatically disabled on x86, x64 and aarch64, and enabled on all other platforms.
XXH_VECTOR : manually select a vector instruction set (default: auto-selected at compilation time). Available instruction sets are XXH_SCALAR, XXH_SSE2, XXH_AVX2, XXH_AVX512, XXH_NEON and XXH_VSX. Compiler may require additional flags to ensure proper support (for example, gcc on linux will require -mavx2 for AVX2, and -mavx512f for AVX512).
XXH_NO_PREFETCH : disable prefetching. Some platforms or situations may perform better without prefetching. XXH3 only.
XXH_PREFETCH_DIST : select prefetching distance. For close-to-metal adaptation to specific hardware platforms. XXH3 only.
XXH_NO_INLINE_HINTS: By default, xxHash uses __attribute__((always_inline)) and __forceinline to improve performance at the cost of code size. Defining this macro to 1 will mark all internal functions as static, allowing the compiler to decide whether to inline a function or not. This is very useful when optimizing for smallest binary size, and is automatically defined when compiling with -O0, -Os, -Oz, or -fno-inline on GCC and Clang. This may also increase performance depending on compiler and architecture.
XXH32_ENDJMP: Switch multi-branch finalization stage of XXH32 by a single jump. This is generally undesirable for performance, especially when hashing inputs of random sizes. But depending on exact architecture and compiler, a jump might provide slightly better performance on small inputs. Disabled by default.
XXH_NO_STDLIB: Disable invocation of <stdlib.h> functions, notably malloc() and free(). libxxhash's XXH*_createState() will always fail and return NULL. But one-shot hashing (like XXH32()) or streaming using statically allocated states still work as expected. This build flag is useful for embedded environments without dynamic allocation.
XXH_STATIC_LINKING_ONLY: gives access to internal state declaration, required for static allocation. Incompatible with dynamic linking, due to risks of ABI changes.
XXH_NO_XXH3 : removes symbols related to XXH3 (both 64 & 128 bits) from generated binary. Useful to reduce binary size, notably for applications which do not use XXH3.
XXH_NO_LONG_LONG: removes compilation of algorithms relying on 64-bit types (XXH3 and XXH64). Only XXH32 will be compiled. Useful for targets (architectures and compilers) without 64-bit support.
XXH_IMPORT: MSVC specific: should only be defined for dynamic linking, as it prevents linkage errors.
XXH_CPU_LITTLE_ENDIAN: By default, endianness is determined by a runtime test resolved at compile time. If, for some reason, the compiler cannot simplify the runtime test, it can cost performance. It’s possible to skip auto-detection and simply state that the architecture is little-endian by setting this macro to 1. Setting it to 0 states big-endian.
XXH_DEBUGLEVEL : When set to any value >= 1, enables assert() statements. This (slightly) slows down execution, but may help finding bugs during debugging sessions.