* DISCLAIMER: There are known *seed-dependent* multicollisions here due to * multiplication by zero, affecting hashes of lengths 17 to 240. * * How

* This is a fast avalanche stage, * suitable when input bits are already partially mixed */

* longCommandWArg(): * Checks if *stringPtr is the same as longCommand. * If yes, @return 1 and advances *stringPtr to the position which immediatel

! * readU64FromChar(): * Allows and interprets K, KB, KiB, M, MB and MiB suffix. * Will also modify `*stringPtr`, advancing it to the position wher

! @copydoc XXH32_avalanche */

! @copydoc XXH32_round */

! * @brief Calculates a 32-bit to 64-bit long multiply. * * Implemented as a macro. * * Wraps `__emulu` on MSVC x86 because it tends to call `__a

! Seems to produce slightly better code on GCC for some reason. */

note: not thread safe */

! * @internal * @brief Mixes all bits to finalize the hash. * * The final mix ensures that all input bits have a chance to impact any bit in * th

* longCommandWArg(): * Checks if *stringPtr is the same as longCommand. * If yes, @return 1 and advances *stringPtr to the position which immediatel

! * readIntFromChar(): * Allows and interprets K, KB, KiB, M, MB and MiB suffix. * Will also modify `*stringPtr`, advancing it to position where it

! * @internal * @brief Normal stripe processing routine. * * This shuffles the bits so that any bit from @p input impacts several bits in * @p ac

! * @brief Calculates a 64->128-bit long multiply. * * Uses `__uint128_t` and `_umul128` if available, otherwise uses a scalar * version. * * @p

* Force direct memory access. Only works on CPU which support unaligned memory * access in hardware. */

Force direct memory access. Only works on CPU which support unaligned memory access in hardware */

* isCommand(): * Checks if string is the same as longCommand. * If yes, @return 1, otherwise @return 0 */

! * @internal * @brief Consumes a block of data for XXH32(). * * @return the end input pointer. */

! * @internal * @brief Processes a large input for XXH3_update() and XXH3_digest_long(). * * Unlike XXH3_hashLong_internal_loop(), this can proces

! * @brief Calculates a 64-bit to 128-bit multiply, then XOR folds it. * * The reason for the separate function is to prevent passing too many stru

! * @internal * @brief Consumes a block of data for XXH64(). * * @return the end input pointer. */

! * Performs an unaligned vector load and byte swaps it on big endian. */

modified from https://github.com/going-digital/Prime64

warning : this function will stop program execution if outcome is invalid ! * check outcome validity first, using BMK_isValid_runResult() *

! * @internal * @brief The implementation for @ref XXH32(). * * @param input , len , seed Directly passed from @ref XXH32(). * @param align Wheth

! * @internal * @brief Processes the last 0-15 bytes of @p ptr. * * There may be up to 15 bytes remaining to consume from the input. * This final

! * @internal * @brief Sets up the initial accumulator state for XXH32(). */

! * @internal * @brief Merges the accumulator lanes together for XXH32() */

! * @internal * @brief Scalar round for @ref XXH3_accumulate_512_scalar(). * * This is extracted to its own function because the NEON path uses a

! * @internal * @brief The implementation for @ref XXH64(). * * @param input , len , seed Directly passed from @ref XXH64(). * @param align Wheth

! * @internal * @brief Processes the last 0-31 bytes of @p ptr. * * There may be up to 31 bytes remaining to consume from the input. * This final

! * @internal * @brief Sets up the initial accumulator state for XXH64(). */

! * @internal * @brief Merges the accumulator lanes together for XXH64() */

gcc needs inline assembly */ Adapted from https://github.com/google/highwayhash/blob/master/highwayhash/hh_vsx.h. */

assumption: (htype*)hTablePtr[index] is valid */

* Returns 1 if the queue is full and 0 otherwise. * * When queueSize is 1 (pool was created with an intended queueSize of 0), * then a queue is emp

initFn will be measured once, benchFn will be measured `nbLoops` times */ initFn is optional, provide NULL if none */ benchFn must return a size_t val

Tells if nb of seconds set in timedFnState for all runs is spent. * note : this function will return 1 if BMK_benchFunctionTimed() has actually error

Nb of combinations of m bits in a register of n bits */

* Check if provided 64-bit hash is a collision candidate * Requires the slot to be occupied by at least 2 candidates. * return >0 if hash is a colli

* Attach hash to a slot * return: Nb of potential collision candidates detected * 0: position not yet occupied * 2: position prev

! POOL_join() : Shutdown the queue, wake any sleeping threads, and join all of the threads. */

@return : 0 on success, 1 on error */

returns time span in microseconds */

====== Canonical representation ======*/ ! @ingroup XXH3_family */

This prototype is compatible with stdlib's qsort(). * @return : >0 if *h128_1 > *h128_2 * <0 if *h128_1 < *h128_2 * =0 if *h1

return : 1 is equal, 0 if different */ ! @ingroup XXH3_family */

* Assumption: `secret` size is >= XXH3_SECRET_SIZE_MIN */