diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f1a46519..a6f3715a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,10 +23,7 @@ jobs: submodules: recursive - run: cmake ${{ matrix.CMAKE_ARGS }} . - run: make -j4 VERBOSE=1 - - if: ${{ ! contains(matrix.CMAKE_ARGS, 'CMAKE_BUILD_TYPE') }} - run: make -j4 test ARGS=-V - - if: ${{ contains(matrix.CMAKE_ARGS, 'CMAKE_BUILD_TYPE') }} - run: ./SMHasher --test=Sanity,Speed,Cyclic,Zeroes,Seed + - run: make -j4 test ARGS=-V aarch64: runs-on: ubuntu-latest steps: @@ -36,9 +33,10 @@ jobs: submodules: recursive - run: sudo gem install apt-spy2 && sudo apt-spy2 fix - run: sudo apt-get update -y - - run: sudo apt-get install -o Acquire::Retries=5 -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu + - run: sudo apt-get install -o Acquire::Retries=5 -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu qemu-user-static - run: cmake -DCMAKE_TOOLCHAIN_FILE=CMakeARM64Cross.txt - run: make -j4 VERBOSE=1 + - run: make -j4 test ARGS=-V armv7: runs-on: ubuntu-latest steps: @@ -48,9 +46,10 @@ jobs: submodules: recursive - run: sudo gem install apt-spy2 && sudo apt-spy2 fix - run: sudo apt-get update -y - - run: sudo apt-get install -o Acquire::Retries=5 -y gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf + - run: sudo apt-get install -o Acquire::Retries=5 -y gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf qemu-user-static - run: cmake -DCMAKE_TOOLCHAIN_FILE=CMakeARMCross.txt - run: make -j4 VERBOSE=1 + - run: make -j4 test ARGS=-V macOS: name: macOS runs-on: macOS-latest @@ -73,7 +72,7 @@ jobs: submodules: recursive - run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release . - run: cmake --build . --config Release --verbose - - run: Release\SMHasher.exe --test=VerifyAll,Sanity,Speed,Cyclic,Zeroes,Seed + - run: ctest -V mingw: name: mingw runs-on: windows-latest diff --git a/CMakeLists.txt b/CMakeLists.txt index 6fc06284..d5f9cd21 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -60,13 +60,17 @@ elseif ((CMAKE_SYSTEM_PROCESSOR STREQUAL "arm") add_definitions(-DHAVE_NEON) endif() +if ((CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") # GNU and others + OR (CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")) # macOS + set(SYSTEM_PROCESSOR_IS_AARCH64 TRUE) +else() + set(SYSTEM_PROCESSOR_IS_AARCH64 FALSE) +endif() + # TODO: rather parse `$CC -march=native -dM -E - <<< ''` [GH #10] if(NOT CMAKE_CROSSCOMPILING) if(CMAKE_SYSTEM_NAME MATCHES "Linux") - exec_program( - cat ARGS - "/proc/cpuinfo" - OUTPUT_VARIABLE CPUINFO) + file(READ "/proc/cpuinfo" CPUINFO) string(REGEX REPLACE "^.*(sse2).*$" "\\1" SSE_THERE "${CPUINFO}") string(COMPARE EQUAL "sse2" "${SSE_THERE}" SSE2_TRUE) string(REGEX REPLACE "^.*(sse4_2).*$" "\\1" SSE_THERE "${CPUINFO}") @@ -324,7 +328,7 @@ else(AVX512VL_TRUE) endif(AVX512VL_TRUE) if(CMAKE_CROSSCOMPILING) - if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") + if(SYSTEM_PROCESSOR_IS_AARCH64) set(SSE2_FOUND true) set(SSE42_FOUND true) elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") @@ -470,13 +474,13 @@ if(SSE42_FOUND) list(APPEND X86_64ONLY_SRC metrohash/metrohash64crc.cpp metrohash/metrohash128crc.cpp) endif() - if(NOT (CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") AND NOT MSVC) + if(NOT SYSTEM_PROCESSOR_IS_AARCH64 AND NOT MSVC) list(APPEND X86_64ONLY_SRC crc32_hw1.c) endif() else() message(STATUS "32bit only: CMAKE_SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P}") endif() - if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") + if(SYSTEM_PROCESSOR_IS_AARCH64) set(SIPHASH_SRC siphash.c) else() set(SIPHASH_SRC siphash_ssse3.c) @@ -574,7 +578,7 @@ endif() set(BLAKE3_SRC blake3/blake3.c blake3/blake3_dispatch.c blake3/blake3_portable.c) if(SSE42_FOUND) - if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") + if(SYSTEM_PROCESSOR_IS_AARCH64) set(BLAKE3_SRC ${BLAKE3_SRC} blake3/blake3_neon.c) else() set(BLAKE3_SRC ${BLAKE3_SRC} blake3/blake3_sse41.c) @@ -600,6 +604,7 @@ if(SSE42_FOUND AND (CMAKE_SIZEOF_VOID_P EQUAL 8) AND (NOT MSVC)) set(UMASH_SRC umash.c umash.hpp) + add_definitions(-DHAVE_UMASH) endif() set(ASCON_SRC asconhashv12/hash.c) @@ -618,7 +623,7 @@ if(CMAKE_CROSSCOMPILING) unset(PMPML_SRC) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DCROSSCOMPILING") endif() -if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") +if(SYSTEM_PROCESSOR_IS_AARCH64) #HAVE_SSE42 unset(PMPML_SRC) endif() @@ -752,9 +757,21 @@ SET(exectargets ${exectargets} SMHasher) # # target_link_libraries( bittest SMHasherSupport ${CMAKE_THREAD_LIBS_INIT} ) -if(NOT (CMAKE_CROSSCOMPILING)) +set(QEMU_TESTING FALSE) +if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + file(TIMESTAMP "/proc/sys/fs/binfmt_misc/qemu-${CMAKE_SYSTEM_PROCESSOR}" QEMU_TIMESTAMP) + if(QEMU_TIMESTAMP) # file exists + file(READ "/proc/sys/fs/binfmt_misc/qemu-${CMAKE_SYSTEM_PROCESSOR}" QEMU_BINFMT) + if(QEMU_BINFMT MATCHES "^enabled\n") + set(QEMU_TESTING TRUE) + endif() + endif() +endif() + +if(NOT (CMAKE_CROSSCOMPILING) OR QEMU_TESTING) enable_testing() - add_test(VerifyAll SMHasher --test=VerifyAll) + add_test(List SMHasher --list) + add_test(VerifyAll SMHasher --test=VerifyAll --verbose) add_test(Sanity SMHasher --test=Sanity) add_test(Speed SMHasher --test=Speed) add_test(Cyclic SMHasher --test=Cyclic) diff --git a/Hashes.cpp b/Hashes.cpp index dc78a43c..f02bbb53 100644 --- a/Hashes.cpp +++ b/Hashes.cpp @@ -388,7 +388,7 @@ FNV128(uint64_t buf[2], const char *key, int len, uint64_t seed) uint64_t s0 = multhi; // high uint64_t s1 = prime128Lower * buf[1]; // low - s0 += buf[1] << (prime128Shift + prime128Lower * buf[0]); + s0 += (buf[1] << prime128Shift) + prime128Lower * buf[0]; // Update the values buf[1] = s1; @@ -818,7 +818,7 @@ void clhash_init() { void* data = get_random_key_for_clhash(UINT64_C(0xb3816f6a2c68e530), 711); memcpy(clhash_random, data, RANDOM_BYTES_NEEDED_FOR_CLHASH); - free (data); + free_random_key_for_clhash(data); } bool clhash_bad_seeds(std::vector &seeds) { @@ -1150,10 +1150,8 @@ void halftime_hash_seed_init(size_t &seed) static uint8_t tsip_key[16]; void tsip_init() { - uint64_t r = rand_u64(); - memcpy(&tsip_key[0], &r, 8); - r = rand_u64(); - memcpy(&tsip_key[8], &r, 8); + Rand rng(UINT32_C(4044698852)); + rng.rand_p(tsip_key, sizeof(tsip_key)); } void tsip_test(const void *bytes, int len, uint32_t seed, void *out) { @@ -1278,6 +1276,43 @@ void crc32c_pclmul_test(const void *key, int len, uint32_t seed, void *out) #endif #include "hash-garage/nmhash.h" +#define NMHASH32_DESC_STR "NMHASH_LITTLE_ENDIAN:" MACRO_ITOA(NMHASH_LITTLE_ENDIAN) ", " \ + "NMH_VECTOR:" MACRO_ITOA(NMH_VECTOR) ", " \ + "NMH_ACC_ALIGN:" MACRO_ITOA(NMH_ACC_ALIGN) ", " \ + "NMH_RESTRICT:" MACRO_ITOA(NMH_RESTRICT) +const char * const nmhash32_desc("nmhash32, " NMHASH32_DESC_STR); +const char * const nmhash32x_desc("nmhash32x, " NMHASH32_DESC_STR); + +bool nmhash32_broken( void ) { + static bool done = false, result; + if (done) + return result; + + const char entropy[] = "rwgk8M1uxM6XX6c3teQX2yaw8FQWArmcWUSBJ8dcQQJWHYC9Wt2BmpvETxwhYcJTheTbjf49SVRaDJhbEZCq7ki1D6KxpKQSjgwqsiHGSgHLxvPG5kcRnBhjJ1YC8kuh"; + + NMH_ALIGN(NMH_ACC_ALIGN) uint32_t accX[sizeof(NMH_ACC_INIT)/sizeof(*NMH_ACC_INIT)]; + static_assert(sizeof(entropy) >= sizeof(accX), "Need more entropy in entropy[]"); + memcpy(accX, entropy, sizeof(accX)); + + const size_t nbGroups = sizeof(NMH_ACC_INIT) / sizeof(*NMH_ACC_INIT); + size_t i; + + for (i = 0; i < nbGroups * 2; ++i) { + ((uint16_t*)accX)[i] *= ((uint16_t*)__NMH_M1_V)[i]; + } + + // XXX: no memory barrier takes place here, just like in NMHASH32_long_round_scalar() + // and it affects the `acc` result. + + uint32_t acc = 0; + for (i = 0; i < nbGroups; ++i) + acc += accX[i]; + + result = (acc != UINT32_C(0x249abaee)); + done = true; + return result; +} + // objsize: 4202f0-420c7d: 2445 void nmhash32_test ( const void * key, int len, uint32_t seed, void * out ) { *(uint32_t*)out = NMHASH32 (key, (const size_t) len, seed); @@ -1290,6 +1325,14 @@ void nmhash32x_test ( const void * key, int len, uint32_t seed, void * out ) { #ifdef HAVE_KHASHV #include "k-hashv/khashv.h" +#define KHASH_VER_STR "vector:" MACRO_ITOA(KHASH_VECTOR) ", " \ + "scalar:" MACRO_ITOA(KHASHV_SCALAR) ", " \ + "__SSE3__:" MACRO_ITOA(__SSE3__) ", " \ + "__SSE4_1__:" MACRO_ITOA(__SSE4_1__) ", " \ + "__AVX512VL__:" MACRO_ITOA(__AVX512VL__) +const char * const khashv32_desc("Vectorized K-HashV, 32-bit, " KHASH_VER_STR); +const char * const khashv64_desc("Vectorized K-HashV, 64-bit, " KHASH_VER_STR); + khashvSeed khashv_seed; void khashv_seed_init(size_t &seed) { khashv_prep_seed64 (&khashv_seed, seed); @@ -1304,11 +1347,12 @@ void khashv32_test ( const void *key, int len, uint32_t seed, void *out) { } #endif // HAVE_KHASHV -PolymurHashParams g_polymurhashparams = { +#include "polymur-hash/polymur-hash.h" +static PolymurHashParams g_polymurhashparams = { UINT64_C(2172266433527442278), UINT64_C(706663945032637854), UINT64_C(754693428422558902), UINT64_C(9067629717964434866) }; -void polymur_seed_init (size_t &seed) { +void polymur_seed_init (size_t seed) { polymur_init_params_from_seed(&g_polymurhashparams, UINT64_C(0xfedbca9876543210) ^ seed); } diff --git a/Hashes.h b/Hashes.h index a9060006..d1631d75 100644 --- a/Hashes.h +++ b/Hashes.h @@ -1156,14 +1156,14 @@ void farsh256_test ( const void * key, int len, unsigned seed, void * out ); extern "C" { #include "blake3/blake3_impl.h" // The C API, serially - inline void blake3c_test ( const void * key, int len, unsigned seed, void * out ) + inline void blake3c_test ( const void * key, int len, uint32_t seed, void * out ) { blake3_hasher hasher; #if 1 blake3_hasher_init (&hasher); // See GH #168 - hasher.key[0] ^= (uint32_t)seed; - hasher.chunk.cv[0] ^= (uint32_t)seed; + hasher.key[0] ^= seed; + hasher.chunk.cv[0] ^= seed; #else // same speed uint32_t seed_key[8] = {0x6A09E667 ^ (uint32_t)seed, 0xBB67AE85, 0x3C6EF372, @@ -1313,6 +1313,9 @@ extern "C" { void asconhashv12_256 ( const void * key, int len, uint32_t seed, void * out ); } +extern const char * const nmhash32_desc; +extern const char * const nmhash32x_desc; +bool nmhash32_broken ( void ); void nmhash32_test ( const void * key, int len, uint32_t seed, void * out ); void nmhash32x_test ( const void * key, int len, uint32_t seed, void * out ); @@ -1389,16 +1392,15 @@ inline void khash64_test ( const void *key, int len, uint32_t seed, void *out) { #ifndef HAVE_BIT32 void khashv_seed_init(size_t &seed); // call to khashv_hash_vector not inlined. +extern const char * const khashv32_desc; +extern const char * const khashv64_desc; void khashv32_test ( const void *key, int len, uint32_t seed, void *out); void khashv64_test ( const void *key, int len, uint32_t seed, void *out); #endif -#include "polymur-hash/polymur-hash.h" -extern PolymurHashParams g_polymurhashparams; -void polymur_seed_init (size_t &seed); +void polymur_seed_init (size_t seed); void polymur_test ( const void *key, int len, uint32_t seed, void *out); - /* This version of CRC64 can approach HW crc speeds without hardware support, and can be applied to any polynomial. */ #include "crc64.h" diff --git a/Types.h b/Types.h index 3cdae30b..d4d4ef9c 100644 --- a/Types.h +++ b/Types.h @@ -13,6 +13,11 @@ using namespace std; #include +#define MACRO_ITOA_(x) #x +#define MACRO_ITOA(x) MACRO_ITOA_(x) +#define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x]))))) +#define ARRAY_END(x) (&(x)[COUNT_OF(x)]) + //----------------------------------------------------------------------------- // If the optimizer detects that a value in a speed test is constant or unused, // the optimizer may remove references to it or otherwise create code that diff --git a/clhash.c b/clhash.c index 5eddfa5f..ecca8933 100644 --- a/clhash.c +++ b/clhash.c @@ -12,6 +12,9 @@ #ifdef _WIN32 #define posix_memalign(p, a, s) (((*(p)) = _aligned_malloc((s), (a))), *(p) ?0 :errno) +void free_random_key_for_clhash(void *p) { _aligned_free(p); } +#else +void free_random_key_for_clhash(void *p) { free(p); } #endif // computes a << 1 diff --git a/clhash.h b/clhash.h index a81da9a0..1fd949fc 100644 --- a/clhash.h +++ b/clhash.h @@ -51,6 +51,7 @@ uint64_t clhash(const void* random, const char * stringbyte, * Caller is responsible to call "free" on the result. */ void * get_random_key_for_clhash(uint64_t seed1, uint64_t seed2); +void free_random_key_for_clhash(void *); #ifdef __cplusplus } // extern "C" diff --git a/main.cpp b/main.cpp index e1a89838..485303bf 100644 --- a/main.cpp +++ b/main.cpp @@ -109,9 +109,9 @@ HashInfo g_hashes[] = #ifdef __SIZEOF_INT128__ // M. Dietzfelbinger, T. Hagerup, J. Katajainen, and M. Penttonen. A reliable randomized // algorithm for the closest-pair problem. J. Algorithms, 25:19–51, 1997. -{ multiply_shift, 64, 0xFCE355A6, "multiply_shift", "Dietzfelbinger Multiply-shift on strings", POOR, +{ multiply_shift, 64, 0x654E7474, "multiply_shift", "Dietzfelbinger Multiply-shift on strings", POOR, { 0xfffffff0, 0x1fffffff0, 0xb13dea7c9c324e51ULL, 0x75f17d6b3588f843ULL } /* !! all & 0xfffffff0 (2^32 bad seeds) */ }, -{ pair_multiply_shift, 64, 0xD4B20347, "pair_multiply_shift", "Pair-multiply-shift", POOR, +{ pair_multiply_shift, 64, 0x26A5AB8C, "pair_multiply_shift", "Pair-multiply-shift", POOR, { 0xb13dea7c9c324e51ULL, 0x75f17d6b3588f843ULL } }, #endif { crc32, 32, 0x3719DB20, "crc32", "CRC-32 soft", POOR, {} }, @@ -148,12 +148,9 @@ HashInfo g_hashes[] = { edonr224, 224, 0x83A8E7AB, "edonr224", "EDON-R 224", GOOD, {} }, { edonr256, 256, 0x06DD4F96, "edonr256", "EDON-R 256", GOOD, {} }, #endif -#if defined(HAVE_BIT32) && !defined(_WIN32) -# define BLAKE3_VERIF 0x58571F56 -#else -# define BLAKE3_VERIF 0x50E4CD91 -#endif -{ blake3c_test, 256, BLAKE3_VERIF, "blake3_c", "BLAKE3 c", GOOD, {0x6a09e667} }, +// There are certain 32-bit non-Windows machines producing 0x58571F56 as verification value for blake3_c. +// That deserves further investigation. +{ blake3c_test, 256, 0x50E4CD91, "blake3_c", "BLAKE3 c", GOOD, {0x6a09e667} }, #if defined(HAVE_BLAKE3) { blake3_test, 256, 0x0, "blake3", "BLAKE3 Rust", GOOD, {} }, { blake3_64, 64, 0x0, "blake3_64", "BLAKE3 Rust, low 64 bits", GOOD, {} }, @@ -272,7 +269,7 @@ HashInfo g_hashes[] = {0x811c9dc5, 0x23d4a49d} /* !! */ }, { FNV64a_test, 64, 0x103455FC, "FNV64", "Fowler-Noll-Vo hash, 64-bit", POOR, {0x811c9dc5, 0xcbf29ce4, 0x84222325, 0xcbf29ce484222325} /* TODO */}, -{ FNV128_test, 128, 0xBCAA1426, "FNV128", "Go variant of FNV, 128-bit", POOR, {} }, +{ FNV128_test, 128, 0xC6FF4526, "FNV128", "Go variant of FNV, 128-bit", POOR, {} }, #endif { FNV2_test, __WORDSIZE, FNV2_VERIF, "FNV2", "wordwise FNV", POOR, {} }, { fletcher2_test, 64, 0x890767C0, "fletcher2", "fletcher2 ZFS", POOR, {0UL} /* !! */ }, @@ -319,12 +316,12 @@ HashInfo g_hashes[] = { jodyhash64_test, 64, 0xC1CBFA34, "jodyhash64", "jodyhash, 64-bit (v7.1)", POOR, {} }, #endif { lookup3_test, 32, 0x3D83917A, "lookup3", "Bob Jenkins' lookup3", POOR, {0x21524101} /* !! */}, -#ifdef __aarch64__ +#if defined(CHAR_MIN) && CHAR_MIN == 0 // Well-defined "char is unsigned" case. #define SFAST_VERIF 0x6306A6FE -#else +#elif CHAR_MIN < 0 // UB in SuperFastHash: (negative-signed << N) #define SFAST_VERIF 0x0C80403A #endif -{ SuperFastHash_test, 32, SFAST_VERIF,"superfast", "Paul Hsieh's SuperFastHash", POOR, {0x0} /* !! */}, +{ SuperFastHash_test, 32, SFAST_VERIF,"superfast", "Paul Hsieh's SuperFastHash, CHAR_MIN:" MACRO_ITOA(CHAR_MIN), POOR, {0x0} /* !! */}, { MurmurOAAT_test, 32, 0x5363BD98, "MurmurOAAT", "Murmur one-at-a-time", POOR, {0x0 /*, 0x5bd1e995*/} /* !! */ }, { Crap8_test, 32, 0x743E97A1, "Crap8", "Crap8", POOR, {/*0x83d2e73b, 0x97e1cc59*/} }, @@ -588,7 +585,7 @@ HashInfo g_hashes[] = { fasthash64_test, 64, 0xA16231A7, "fasthash64", "fast-hash 64bit", GOOD, {0x880355f21e6d1965ULL} }, // different verif on gcc vs clang { floppsyhash_64, 64, 0x0, "floppsyhash", "slow hash designed for floating point hardware", GOOD, {} }, -{ chaskey_test, 64, 0x81A90131, "chaskey", "mouha.be/chaskey/ with added seed support", GOOD, {} }, +{ chaskey_test, 64, 0xBB4F6706, "chaskey", "mouha.be/chaskey/ with added seed support", GOOD, {} }, { siphash_test, 64, 0xC58D7F9C, "SipHash", "SipHash 2-4 - SSSE3 optimized", GOOD, {} }, { halfsiphash_test, 32, 0xA7A05F72, "HalfSipHash", "HalfSipHash 2-4, 32bit", GOOD, {} }, { GoodOAAT_test, 32, 0x7B14EEE5, "GoodOAAT", "Small non-multiplicative OAAT", GOOD, {0x3b00} }, @@ -602,7 +599,7 @@ HashInfo g_hashes[] = // as in rust and swift: { siphash13_test, 64, 0x29C010BF, "SipHash13", "SipHash 1-3 - SSSE3 optimized", GOOD, {} }, #ifndef _MSC_VER -{ tsip_test, 64, 0x8E48155B, "TSip", "Damian Gryski's Tiny SipHash variant", GOOD, {} }, +{ tsip_test, 64, 0x5C2395A5, "TSip", "Damian Gryski's Tiny SipHash variant", GOOD, {} }, #ifdef HAVE_INT64 { seahash_test, 64, 0xF0374078, "seahash", "seahash (64-bit, little-endian)", GOOD, {} }, { seahash32low, 32, 0x712F0EE8, "seahash32low","seahash - lower 32bit", GOOD, {} }, @@ -689,7 +686,7 @@ HashInfo g_hashes[] = { SpookyV2_128_test, 128, 0x893CFCBE, "SpookyV2_128", "Bob Jenkins' SpookyV2, 128-bit result", GOOD, {} }, { pengyhash_test, 64, 0x1FC2217B, "pengyhash", "pengyhash", GOOD, {} }, { mx3hash64_test, 64, 0x4DB51E5B, "mx3", "mx3 64bit", GOOD, {0x10} /* !! and all & 0x10 */}, -#if defined(HAVE_SSE42) && (defined(__x86_64__) || defined(__aarch64__)) && !defined(_MSC_VER) +#ifdef HAVE_UMASH { umash32, 32, 0x9451AF3B, "umash32", "umash 32", GOOD, {0x90e37057} /* !! */}, { umash32_hi, 32, 0x0CC4850F, "umash32_hi", "umash 32 hi", GOOD, {} }, { umash, 64, 0x161495C6, "umash64", "umash 64", GOOD, {} }, @@ -754,21 +751,16 @@ HashInfo g_hashes[] = { rapidhash_test, 64, 0xAF404C4B, "rapidhash", "rapidhash v1", GOOD, {}}, { rapidhash_unrolled_test, 64, 0xAF404C4B, "rapidhash_unrolled", "rapidhash v1 - unrolled", GOOD, {}}, #endif -{ nmhash32_test, 32, 0x12A30553, "nmhash32", "nmhash32", GOOD, {}}, -{ nmhash32x_test, 32, 0xA8580227, "nmhash32x", "nmhash32x", GOOD, {}}, +{ nmhash32_test, 32, nmhash32_broken() ? 0U : 0x12A30553, "nmhash32", nmhash32_desc, GOOD, {}}, +{ nmhash32x_test, 32, nmhash32_broken() ? 0U : 0xA8580227, "nmhash32x", nmhash32x_desc, GOOD, {}}, #ifdef HAVE_KHASHV -#ifdef __clang__ // also gcc 9.4 -#define KHASHV32_VERIF 0xB69DF8EB -#define KHASHV64_VERIF 0xA6B7E55B -#else // new gcc-11 -#define KHASHV32_VERIF 0 /* 0x9A8F7952 */ -#define KHASHV64_VERIF 0 /* 0X90A2A4F9 */ -#endif -{ khashv32_test, 32, KHASHV32_VERIF, "k-hashv32", "Vectorized K-HashV, 32-bit", GOOD, {}}, -{ khashv64_test, 64, KHASHV64_VERIF, "k-hashv64", "Vectorized K-HashV, 64-bit", GOOD, {}}, +// There are certain GCC versions producing 0x9A8F7952 and 0X90A2A4F9 as verification values +// for k-hashv32 and k-hashv64. That deserves further investigation. +{ khashv32_test, 32, 0xB69DF8EB, "k-hashv32", khashv32_desc, GOOD, {}}, +{ khashv64_test, 64, 0xA6B7E55B, "k-hashv64", khashv64_desc, GOOD, {}}, #endif { komihash_test, 64, 0x8157FF6D, "komihash", "komihash 5.10", GOOD, {} }, -{ polymur_test, 64, 0x4F894810, "polymur", "github.com/orlp/polymur-hash v1", GOOD, {} }, +{ polymur_test, 64, 0x4F894810, "polymur", "github.com/orlp/polymur-hash v1, __SIZEOF_INT128__:" MACRO_ITOA(__SIZEOF_INT128__), GOOD, {} }, }; HashInfo * findHash ( const char * name ) @@ -921,13 +913,6 @@ bool Hash_Seed_init (pfHash hash, size_t seed) { #if defined(HAVE_SSE42) && defined(__x86_64__) else if (hash == clhash_test) clhash_seed_init(seed); -# ifndef _MSC_VER - else if (hash == umash32 || - hash == umash32_hi || - hash == umash || - hash == umash128) - umash_seed_init(seed); -# endif else if (hash == halftime_hash_style64_test || hash == halftime_hash_style128_test || hash == halftime_hash_style256_test || hash == halftime_hash_style512_test) halftime_hash_seed_init(seed); @@ -935,13 +920,17 @@ bool Hash_Seed_init (pfHash hash, size_t seed) { else if(hash == hashx_test) hashx_seed_init(info, seed); */ - else if(hash == polymur_test) - polymur_seed_init(seed); -# ifdef HAVE_KHASHV +#endif +#ifdef HAVE_UMASH + else if (hash == umash32 || hash == umash32_hi || hash == umash || hash == umash128) + umash_seed_init(seed); +#endif +#ifdef HAVE_KHASHV else if(hash == khashv64_test || hash == khashv32_test) khashv_seed_init(seed); -# endif #endif + else if(hash == polymur_test) + polymur_seed_init(seed); else return false; return true; @@ -992,6 +981,8 @@ void test ( hashfunc hash, HashInfo* info ) if(g_testVerifyAll) { + for (HashInfo *i = g_hashes; i != ARRAY_END(g_hashes); i++) + Hash_init(i); // init all the hashes, not just `info` printf("[[[ VerifyAll Tests ]]]\n\n"); fflush(NULL); SelfTest(g_drawDiagram); printf("PASS\n\n"); fflush(NULL); // if not it does exit(1)