log.hashmap

-------------------------------------------------------------------------------
--- Testing crc32_hw1 "Faster Adler SSE4.2 crc32 in HW" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     472.007 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  299.321 cycles/op (4.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    315.075 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 184.953 cycles/op (1.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.944398 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing crc64_hw "SSE4.2 crc64 in HW" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     440.855 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  272.939 cycles/op (3.5 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    287.566 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 150.615 cycles/op (1.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.829399 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing fibonacci "wordwise Fibonacci" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     1566.734 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  1373.518 cycles/op (7.8 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    1474.228 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 755.133 cycles/op (4.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 4.045195 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FNV1a "Fowler-Noll-Vo hash, 32-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     468.528 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  299.136 cycles/op (3.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    314.812 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 178.737 cycles/op (1.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.933166 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FNV1A_Totenschiff "FNV1A_Totenschiff_v1 64-bit sanmayce" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     454.261 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  302.464 cycles/op (5.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    317.836 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 188.192 cycles/op (2.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.953325 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FNV1A_Pippip_Yurii "FNV1A-Pippip_Yurii 32-bit sanmayce" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     426.515 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  297.155 cycles/op (3.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    320.770 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 185.937 cycles/op (1.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.950629 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FNV1a_YT "FNV1a-YoshimitsuTRIAD 32-bit sanmayce" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     466.319 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  307.358 cycles/op (10.8 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    309.675 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 207.813 cycles/op (32.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.997819 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FNV64 "Fowler-Noll-Vo hash, 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     472.815 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  299.097 cycles/op (4.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    315.657 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 167.143 cycles/op (2.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.913021 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FNV2 "wordwise FNV" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     463.853 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  287.857 cycles/op (6.5 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    291.424 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 157.379 cycles/op (3.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.867694 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing fletcher2 "fletcher2 ZFS" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     727.298 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  534.865 cycles/op (5.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    587.129 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 303.709 cycles/op (4.6 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.614423 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing fletcher4 "fletcher4 ZFS" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     459.257 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  278.285 cycles/op (4.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    269.195 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 148.676 cycles/op (2.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.836881 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing bernstein "Bernstein, 32-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     466.831 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  304.784 cycles/op (5.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    368.154 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 206.737 cycles/op (8.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.010442 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing sdbm "sdbm as in perl5" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     465.119 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  311.851 cycles/op (7.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    361.575 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 205.147 cycles/op (11.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.005689 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing x17 "x17" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     492.107 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  339.567 cycles/op (17.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    380.023 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 207.182 cycles/op (11.6 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.057891 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing JenkinsOOAT "Bob Jenkins' OOAT as in perl 5.18" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     542.862 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  384.718 cycles/op (23.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    418.914 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 226.876 cycles/op (10.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.181151 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing JenkinsOOAT_perl "Bob Jenkins' OOAT as in old perl5" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     501.482 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  325.340 cycles/op (3.8 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    377.211 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 200.984 cycles/op (7.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.023765 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing HalfSipHash "HalfSipHash 2-4, 32bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     531.576 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  363.342 cycles/op (7.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    505.823 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 250.739 cycles/op (3.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.191772 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing SipHash13 "SipHash 1-3 - SSSE3 optimized" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     530.627 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  366.620 cycles/op (5.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    497.117 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 267.616 cycles/op (25.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.231552 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing MicroOAAT "Small non-multiplicative OAAT (by funny-falcon)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     508.673 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  352.353 cycles/op (26.8 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    355.817 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 198.061 cycles/op (3.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.065561 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing jodyhash32 "jodyhash, 32-bit (v5)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     458.022 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  302.460 cycles/op (9.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    350.795 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 197.124 cycles/op (2.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.971731 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing jodyhash64 "jodyhash, 64-bit (v5)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     453.341 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  292.799 cycles/op (5.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    290.434 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 167.687 cycles/op (3.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.899403 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing lookup3 "Bob Jenkins' lookup3" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     474.408 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  305.841 cycles/op (3.6 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    338.835 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 188.512 cycles/op (4.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.963008 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing superfast "Paul Hsieh's SuperFastHash" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     472.170 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  311.974 cycles/op (8.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    353.719 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 186.176 cycles/op (3.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.973017 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing MurmurOAAT "Murmur one-at-a-time" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     495.993 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  322.154 cycles/op (4.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    360.359 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 193.548 cycles/op (2.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.011177 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Crap8 "Crap8" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     460.115 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  302.877 cycles/op (3.6 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    361.995 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 200.398 cycles/op (3.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.979462 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing xxHash32 "xxHash, 32-bit for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     479.315 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  302.704 cycles/op (4.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    370.985 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 190.144 cycles/op (4.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.967312 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Murmur2 "MurmurHash2 for x86, 32-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     470.068 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  304.189 cycles/op (8.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    361.152 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 180.195 cycles/op (3.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.945690 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Murmur2A "MurmurHash2A for x86, 32-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     478.966 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  305.255 cycles/op (3.9 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    359.345 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 195.236 cycles/op (3.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.980718 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Murmur2B "MurmurHash64A for x64, 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     469.488 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  293.196 cycles/op (2.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    327.004 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 167.834 cycles/op (2.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.901348 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Murmur2C "MurmurHash64B for x86, 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     474.794 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  295.987 cycles/op (2.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    331.916 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 162.745 cycles/op (2.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.897437 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Murmur3C "MurmurHash3 for x86, 128-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     519.207 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  329.472 cycles/op (2.5 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    415.172 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 212.121 cycles/op (2.6 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.053387 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing PMurHash32 "Shane Day's portable-ized MurmurHash3 for x86, 32-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     496.061 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  336.146 cycles/op (2.9 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    362.616 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 200.564 cycles/op (2.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.045390 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Murmur3A "MurmurHash3 for x86, 32-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     479.594 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  304.099 cycles/op (1.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    374.589 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 203.397 cycles/op (6.2 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.999060 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Murmur3F "MurmurHash3 for x64, 128-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     492.589 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  313.079 cycles/op (7.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    324.009 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 184.736 cycles/op (11.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.964748 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash64_1 "MetroHash64_1 for 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     499.659 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  313.079 cycles/op (3.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    313.994 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 171.058 cycles/op (2.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.943962 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash64_2 "MetroHash64_2 for 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     501.232 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  313.607 cycles/op (3.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    306.318 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 169.458 cycles/op (4.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.944908 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash128_1 "MetroHash128_1 for 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     537.323 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  377.566 cycles/op (17.9 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    395.007 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 224.065 cycles/op (15.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.162416 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash128_2 "MetroHash128_2 for 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     534.934 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  347.651 cycles/op (3.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    369.711 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 211.067 cycles/op (2.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.085056 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash64crc_1 "MetroHash64crc_1 for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     500.404 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  317.050 cycles/op (6.5 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    299.696 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 173.343 cycles/op (6.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.951700 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash64crc_2 "MetroHash64crc_2 for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     504.542 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  322.399 cycles/op (6.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    340.074 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 179.841 cycles/op (1.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.978667 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash128crc_1 "MetroHash128crc_1 for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     538.520 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  348.190 cycles/op (3.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    411.824 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 227.094 cycles/op (6.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.116087 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing metrohash128crc_2 "MetroHash128crc_2 for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     550.278 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  357.495 cycles/op (8.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    386.261 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 216.471 cycles/op (6.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.109578 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing cmetrohash64_1o "cmetrohash64_1 (shorter key optimized) , 64-bit for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     505.321 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  310.832 cycles/op (3.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    368.708 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 174.251 cycles/op (1.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.947355 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing cmetrohash64_1 "cmetrohash64_1, 64-bit for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     502.150 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  310.775 cycles/op (3.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    343.504 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 174.253 cycles/op (2.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.945764 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing cmetrohash64_2 "cmetrohash64_2, 64-bit for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     495.138 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  312.020 cycles/op (2.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    339.722 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 175.390 cycles/op (1.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.949991 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing City64noSeed "Google CityHash64 without seed (default version, misses one final avalanche)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     518.409 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  315.563 cycles/op (2.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    403.024 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 198.952 cycles/op (2.6 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.001048 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing City64 "Google CityHash64WithSeed (old)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     517.135 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  343.953 cycles/op (2.6 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    373.060 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 211.807 cycles/op (5.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.076930 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing falkhash "falkhash.asm with aesenc, 64-bit for x64" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     685.461 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  502.936 cycles/op (16.8 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    687.253 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 363.270 cycles/op (4.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.678236 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing farmhash128_c "farmhash128_with_seed (C99)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     557.531 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  385.913 cycles/op (2.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    478.927 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 258.953 cycles/op (2.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.247460 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FarmHash128 "Google FarmHash128WithSeed" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     508.671 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  343.212 cycles/op (3.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    404.968 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 222.320 cycles/op (3.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.102901 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha2_atonce128 "Fast Positive Hash (portable, aims 64-bit, little-endian)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     489.624 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  322.999 cycles/op (4.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    380.388 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 201.798 cycles/op (3.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.019257 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha2_stream128 "Fast Positive Hash (portable, aims 64-bit, little-endian)" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     612.925 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  429.222 cycles/op (10.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    566.334 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 295.901 cycles/op (6.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.396317 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Spooky128 "Bob Jenkins' SpookyHash, 128-bit result" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     564.349 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  354.190 cycles/op (4.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    430.340 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 216.432 cycles/op (7.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.112236 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing xxh3 "xxHash v3, 64-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     485.281 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  316.154 cycles/op (5.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    323.262 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 211.219 cycles/op (12.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.020475 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing xxh3low "xxHash v3, 64-bit, low 32-bits part" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     501.583 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  340.705 cycles/op (21.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    348.826 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 205.651 cycles/op (3.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.059195 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing xxh128 "xxHash v3, 128-bit" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     492.367 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  322.713 cycles/op (2.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    346.861 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 196.597 cycles/op (4.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.008984 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing xxh128low "xxHash v3, 128-bit, low 64-bits part" POOR

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     490.783 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  316.180 cycles/op (3.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    358.519 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 197.958 cycles/op (3.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.998895 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing SipHash "SipHash 2-4 - SSSE3 optimized" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     597.255 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  426.239 cycles/op (3.8 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    564.304 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 300.593 cycles/op (2.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.400839 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing HighwayHash64 "Google HighwayHash (portable with dylib overhead)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     563.810 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  384.476 cycles/op (5.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    557.915 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 261.599 cycles/op (2.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.251646 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing TSip "Damian Gryski's Tiny SipHash variant" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     489.368 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  326.125 cycles/op (3.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    385.711 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 204.562 cycles/op (2.4 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.031542 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing seahash "seahash (portable, 64-bit, little-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     504.822 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  334.790 cycles/op (4.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    391.914 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 204.838 cycles/op (3.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.048547 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing seahash32low "seahash - lower 32bit" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     504.874 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  348.996 cycles/op (11.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    446.779 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 242.364 cycles/op (8.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.140592 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing GoodOAAT "Small non-multiplicative OAAT" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     507.989 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  347.070 cycles/op (13.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    402.976 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 223.568 cycles/op (3.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.104208 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing fasthash32 "fast-hash 32bit" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     516.432 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  333.592 cycles/op (2.5 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    410.238 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 214.532 cycles/op (2.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.065274 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing fasthash64 "fast-hash 64bit" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     517.198 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  320.550 cycles/op (2.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    358.160 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 190.234 cycles/op (3.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.994660 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing MUM "github.com/vnmakarov/mum-hash" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     531.814 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  323.046 cycles/op (3.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    346.016 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 182.932 cycles/op (2.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.987450 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing MUMlow "github.com/vnmakarov/mum-hash" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     523.317 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  346.369 cycles/op (7.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    411.675 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 221.417 cycles/op (2.8 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.100013 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing mirhash "mirhash" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     503.475 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  311.659 cycles/op (2.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    341.963 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 176.798 cycles/op (6.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.952831 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing mirhash32low "mirhash - lower 32bit" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     506.247 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  327.267 cycles/op (8.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    382.642 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 200.928 cycles/op (2.2 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.027251 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing mirhashstrict "mirhashstrict (portable, 64-bit, little-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     520.059 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  332.008 cycles/op (4.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    355.659 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 190.696 cycles/op (2.6 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.019657 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing mirhashstrict32low "mirhashstrict - lower 32bit" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     516.026 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  336.597 cycles/op (2.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    403.940 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 218.745 cycles/op (2.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.080054 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing City32 "Google CityHash32WithSeed (old)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     508.697 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  341.003 cycles/op (2.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    396.996 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 231.307 cycles/op (2.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.108749 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing City64low "Google CityHash64WithSeed (low 32-bits)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     528.145 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  375.734 cycles/op (13.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    417.654 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 237.238 cycles/op (8.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.181815 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing City128 "Google CityHash128WithSeed (old)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     564.070 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  360.137 cycles/op (4.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    413.551 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 231.100 cycles/op (2.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.145521 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing CityCrc128 "Google CityHashCrc128WithSeed SSE4.2 (old)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     526.584 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  360.902 cycles/op (2.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    449.864 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 249.244 cycles/op (4.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.180469 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FarmHash32 "Google FarmHash32WithSeed" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     531.939 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  370.711 cycles/op (6.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    413.718 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 236.953 cycles/op (9.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.173487 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing FarmHash64 "Google FarmHash64WithSeed" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     521.092 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  354.083 cycles/op (2.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    388.586 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 219.017 cycles/op (2.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.110907 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing farmhash32_c "farmhash32_with_seed (C99)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     533.062 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  361.287 cycles/op (2.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    416.113 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 234.147 cycles/op (2.1 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.153759 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing farmhash64_c "farmhash64_with_seed (C99)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     558.566 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  366.487 cycles/op (2.4 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    465.515 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 248.894 cycles/op (1.6 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.193160 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing xxHash64 "xxHash, 64-bit" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     518.137 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  321.493 cycles/op (3.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    375.272 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 182.942 cycles/op (1.3 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.985357 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Spooky32 "Bob Jenkins' SpookyHash, 32-bit result" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     526.494 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  353.851 cycles/op (7.8 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    411.963 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 222.957 cycles/op (5.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.114509 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing Spooky64 "Bob Jenkins' SpookyHash, 64-bit result" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     529.408 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  353.754 cycles/op (10.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    432.474 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 214.230 cycles/op (4.2 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.099190 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing clhash "carry-less mult. hash -DBITMIX (64-bit for x64, SSE4.2)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     547.047 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  371.005 cycles/op (6.6 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    480.752 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 248.113 cycles/op (5.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.215484 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha2_atonce "Fast Positive Hash (portable, aims 64-bit, little-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     538.426 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  318.806 cycles/op (11.5 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    362.111 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 205.946 cycles/op (7.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.023042 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha2_stream "Fast Positive Hash (portable, aims 64-bit, little-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     553.846 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  381.386 cycles/op (7.9 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    476.031 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 267.505 cycles/op (16.6 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.249032 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha1_64le "Fast Positive Hash (portable, aims 64-bit, little-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     529.479 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  347.106 cycles/op (12.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    348.373 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 202.740 cycles/op (8.0 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.063722 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha1_64be "Fast Positive Hash (portable, aims 64-bit, big-engian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     487.841 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  306.308 cycles/op (3.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    345.368 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 183.918 cycles/op (2.7 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.957467 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha0_32le "Fast Positive Hash (portable, aims 32-bit, little-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     478.000 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  307.284 cycles/op (2.7 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    363.071 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 193.813 cycles/op (2.2 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.975927 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha0_32be "Fast Positive Hash (portable, aims 32-bit, big-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     488.975 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  318.521 cycles/op (3.0 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    371.159 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 197.005 cycles/op (4.2 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 1.004320 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha0_aes_noavx "Fast Positive Hash (machine-specific, requires AES-NI)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     471.613 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  307.552 cycles/op (3.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    325.380 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 180.063 cycles/op (2.2 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.951661 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing t1ha0_aes_avx1 "Fast Positive Hash (machine-specific, requires AES-NI & AVX)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     469.387 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  302.787 cycles/op (2.3 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    331.197 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 182.168 cycles/op (3.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.948063 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing wyhash "wyhash v3 (portable, 64-bit, little-endian)" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     474.041 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  289.310 cycles/op (2.2 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    353.154 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 170.137 cycles/op (2.5 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.899942 seconds
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--- Testing wyhash32low "wyhash v3 - lower 32bit" GOOD

[[[ 'Hashmap' Speed Tests (when inlined) ]]]

std::unordered_map
Init std HashMapTest:     475.545 cycles/op (102401 inserts, 1% deletions)
Running std HashMapTest:  300.889 cycles/op (3.1 stdv)

greg7mdp/parallel-hashmap
Init fast HashMapTest:    370.367 cycles/op (102401 inserts, 1% deletions)
Running fast HashMapTest: 193.016 cycles/op (3.9 stdv)  ....... PASS


Input vcode 0x00000001, Output vcode 0x00000001, Result vcode 0x00000001
Verification value is 0x00000001 - Testing took 0.961336 seconds
-------------------------------------------------------------------------------