smhasher
1.0.0
| Função hash | MiB/s | ciclo./hash | ciclo./mapa | tamanho | Problemas de qualidade |
|---|---|---|---|---|---|
| não fazendo nada32 | 11149460.06 | 4h00 | - | 13 | semente ruim 0, teste NOP |
| não fazendo nada64 | 11787676.42 | 4h00 | - | 13 | semente ruim 0, teste NOP |
| não fazendo nada128 | 11745060,76 | 4.06 | - | 13 | semente ruim 0, teste NOP |
| NOP_OAAT_read64 | 11372846.37 | 14h00 | - | 47 | teste NOP |
| BadHash | 769,94 | 73,97 | - | 47 | semente ruim 0, teste FALHA |
| sumhash | 10699,57 | 29,53 | - | 363 | semente ruim 0, teste FALHA |
| somahash32 | 42877,79 | 23.12 | - | 863 | UB, teste FALHA |
| multiplicar_shift | 8026.77 | 26.05 | 226,80 (8) | 345 | sementes ruins & 0xfffffff0, falha na maioria dos testes |
| pair_multiply_shift | 3716,95 | 40,22 | 186,34 (3) | 609 | falha na maioria dos testes |
| -------------------------- | |||||
| crc32 | 383,12 | 134,21 | 257,50 (11) | 422 | inseguro, colisões 8590x, distribuição, PerlinNoise |
| md5_32 | 350,53 | 644,31 | 894,12 (10) | 4419 | |
| md5_64 | 351.01 | 656,67 | 897,43 (12) | 4419 | |
| md5-128 | 350,89 | 681,88 | 894,03 (13) | 4419 | |
| sha1_32 | 353.03 | 1385,80 | 1759,94 (5) | 5126 | Sanidade, cíclico baixo32, distribuição de 36,6% |
| sha1_64 | 353.03 | 1385,80 | 1759,94 (5) | 5126 | Sanidade, cíclico baixo32, distribuição de 36,6% |
| sha1-160 | 364,95 | 1470,55 | 1794.16 (13) | 5126 | Pente/Cíclico baixo32 |
| sha2-224 | 147,13 | 1354,81 | 1589,92 (12) | Pente baixo32 | |
| sha2-224_64 | 147,60 | 1360,10 | 1620,93 (13) | Cíclico baixo32 | |
| sha2-256 | 147,80 | 1374,90 | 1606.06 (16) | ||
| sha2-256_64 | 148.01 | 1376,34 | 1624,71 (16) | ||
| sha1ni | 1601.21 | 174.16 | 397,28 (6) | 989 | inseguro, sanidade, permutação, zeros, específico da máquina |
| sha1ni_32 | 1576.17 | 174.04 | 405,56 (6) | 989 | específico da máquina |
| sha2ni-256 | 1527,38 | 184,35 | 404,40 (4) | 4241 | inseguro, sanidade, permutação, zeros, específico da máquina |
| sha2ni-256_64 | 1501,85 | 186,20 | 407,96 (5) | 4241 | Zeros, específicos da máquina |
| blake3_c | 1288,84 | 357,69 | 582,89 (6) | sem portabilidade de 32 bits | |
| rmd128 | 290,90 | 710,49 | 965,55 (6) | ||
| rmd160 | 202.16 | 1045,79 | 1287,74 (16) | Cíclico hi32 | |
| rmd256 | 364,81 | 584,86 | 835,02 (11) | ||
| edonr224 | 864,69 | 303,42 | 526,94 (6) | ||
| edonr256 | 847,85 | 305,79 | 510.01 (4) | ||
| blake2s-128 | 295,30 | 698,09 | 1059,24 (51) | ||
| blake2s-160 | 215.01 | 1026,74 | 1239,54 (11) | ||
| blake2s-224 | 207.06 | 1063,86 | 1236,50 (20) | ||
| blake2s-256 | 215,28 | 1014,88 | 1230,38 (28) | ||
| blake2s-256_64 | 211.52 | 1044.22 | 1228,43 (8) | ||
| blake2b-160 | 356,08 | 1236,84 | 1458,15 (12) | ||
| blake2b-224 | 356,59 | 1228,50 | 1425,87 (16) | ||
| blake2b-256 | 355,97 | 1232.22 | 1443,31 (19) | ||
| blake2b-256_64 | 356,97 | 1222,76 | 1435.03 (9) | ||
| asconhashv12 | 144,98 | 885.02 | 1324,23 (38) | 4341 | |
| asconhashv12_64 | 159,68 | 386,90 | 480,86 (4) | 6490 | |
| sha3-256 | 100,58 | 3877.18 | 4159,79 (37) | PerlinNoise | |
| sha3-256_64 | 100,57 | 3.909,00 | 4174,63 (16) | PerlinNoise | |
| hasshe2 | 2773,89 | 64,35 | 282,30 (3) | 445 | Permutação, Dois Bytes, Zeros, Semente |
| poli_1_mersenne | 1369.21 | 61,59 | 248,86 (4) | 479 | falha na maioria dos testes |
| poli_2_mersenne | 1364.03 | 70h30 | 261,00 (6) | 479 | |
| poli_3_mersenne | 1342,82 | 80,22 | 268,79 (2) | 479 | |
| poli_4_mersenne | 1343,19 | 89,13 | 277,52 (3) | 479 | |
| tabulação32 | 5781.16 | 40,00 | 241,79 (10) | 848 | colisões |
| tabulação | 7875.01 | 39,95 | 249,49 (3) | 554 | |
| crc32_hw | 6244,38 | 41,23 | 226,80 (2) | 653 | inseguro, 100% de polarização, colisões, distribuição, BIC, específico da máquina (SSE4.2/NEON) |
| crc32_hw1 | 7569,29 | 49.07 | 233,75 (3) | 671 | inseguro, 100% de polarização, colisões, distribuição, BIC, específico da máquina (x86 SSE4.2) |
| crc64_hw | 6143,62 | 40,48 | 223,13 (2) | 652 | inseguro, 100% de polarização, colisões, distribuição, BIC, específico da máquina (SSE4.2/NEON) |
| crc32_pclmul | - | - | - | inseguro, 100% de polarização, colisões, distribuição, BIC, específico da máquina (x86 SSE4.2+PCLMUL) | |
| o1hash | 11629440.57 | 18h15 | 199,35 (2) | 101 | inseguro, sem sementes, zeros, falha em todos os testes |
| Fibonacci | 16878,32 | 22,94 | 803.18 (15) | 1692 | UB, zeros, falha em todos os testes |
| FNV1a | 760,52 | 73,83 | 254,29 (5) | 204 | semente ruim, zeros, falha em todos os testes |
| FNV1A_Totenschiff | 6274,78 | 26.23 | 251,13 (2) | 270 | UB, zeros, falha em todos os testes |
| FNV1A_Pippip_Yurii | 6172.14 | 27h55 | 244,80 (2) | 147 | UB, sanidade, falha em todos os testes |
| FNV1a_YT | 13486,49 | 30h50 | 237,43 (4) | 321 | semente ruim, UB, falha em todos os testes |
| FNV2 | 6171,60 | 32h20 | 208,59 (4) | 278 | falha em todos os testes |
| FNV64 | 774,37 | 72,43 | 201,15 (2) | 79 | falha em todos os testes |
| FNV128 | 390,14 | 136,42 | 289,00 (3) | 171 | falha em todos os testes |
| k-hash32 | 2230,42 | 53.05 | 264,64 (3) | 808 | inseguro, zeros, UB, sementes ruins, falha em todos os testes |
| k-hash64 | 2451,88 | 48,66 | 249,44 (2) | 609 | inseguro, zeros, UB, sementes ruins, falha em todos os testes |
| Fletcher2 | 15552,61 | 20.61 | 335,31 (3) | 248 | semente ruim 0, UB, falha em todos os testes |
| Fletcher4 | 15556,93 | 20h60 | 358,60 (3) | 371 | semente ruim 0, UB, falha em todos os testes |
| Bernstein | 1045,97 | 58,31 | 225,78 (3) | 41 | semente ruim 0, falha em todos os testes |
| sdbm | 784,83 | 68,57 | 222,68 (5) | 41 | semente ruim 0, falha em todos os testes |
| x17 | 748,75 | 74,13 | 236,00 (10) | 79 | Viés de 99,98%, falha em todos os testes |
| liberdade | 628,66 | 84,95 | 225,07 (4) | 37 | inseguro, 100% tendencioso, falha em todos os testes, semente ruim |
| gcc | 611,69 | 86,47 | 231,51 (5) | 39 | inseguro, 100% tendencioso, falha em todos os testes, semente ruim |
| JenkinsOOAT | 627,64 | 107.04 | 252,79 (3) | 153 | semente ruim 0, viés de 53,5%, falha em todos os testes |
| JenkinsOOAT_perl | 608.10 | 94,17 | 254,09 (4) | 65 | semente ruim 0, viés de 1,5-11,5%, colisões de 7,2x, BIC, LongNeighbours |
| MicroOAAT | 701,35 | 76,68 | 251.01 (3) | 68 | 100% viés, distribuição, BIC |
| pearsonhash64 | 434,17 | 124,14 | 230,79 (4) | Apenas Avalanche, Seed, SSSE3. MSVC quebrado | |
| pearsonhash128 | 434,23 | 121,34 | 221.03 (7) | Apenas Avalanche, Seed, SSSE3. MSVC quebrado | |
| pearsonhash256 | 444,08 | 119.11 | 229,75 (4) | Apenas Avalanche, Seed, SSSE3. MSVC quebrado | |
| VHASH_32 | 13053,40 | 65,84 | 289,86 (3) | 1231 | sanidade, Semente, MomentChi2 |
| VHASH_64 | 13465,50 | 63,88 | 286,38 (5) | 1231 | sanidade, Semente, Esparso |
| farsh32 | 27038.23 | 66,88 | 278,89 (5) | 944 | inseguro: AppendedZeroes, colisões+viés, MomentChi2, LongNeighbors |
| farsh64 | 13829,32 | 112,46 | 332,59 (3) | 944 | inseguro: AppendedZeroes, colisões+viés, MomentChi2, LongNeighbors |
| farsh128 | 6878,88 | 233,35 | 384,85 (3) | 944 | inseguro: AppendedZeroes, colisões+bias, permut,combin,2bytes,zeroes,PerlinNoise |
| farsh256 | 3467,37 | 440,40 | 593,57 (5) | 944 | inseguro: AppendedZeroes, colisões+bias, permut,combin,2bytes,zeroes,PerlinNoise |
| jodyhash32 | 1794,34 | 41.12 | 235,12 (4) | 102 | polarização, colisões, distribuição, BIC LongNeighbours |
| jodyhash64 | 4813.10 | 40,72 | 239,22 (6) | 118 | viés, colisões, distribuição, BIC, LongNeighbours |
| pesquisa3 | 2.475,35 | 39,65 | 240,10 (3) | 341 | UB, viés de 28%, colisões, distribuição de 30%, BIC |
| super rápido | 2058.22 | 49,56 | 254,12 (3) | 210 | UB, semente ruim 0, viés de 91%, colisões de 5.273,01x, distribuição de 37%, BIC |
| MurmurOAAT | 506,66 | 103,33 | 236,89 (3) | 47 | semente ruim 0, colisões, distribuição de 99,998%, BIC, LongNeighbors |
| Porcaria8 | 3041.14 | 37,25 | 247,87 (4) | 342 | UB, viés de 2,42%, colisões, distribuição de 2% |
| Murmúrio1 | 2.027,85 | 48,51 | 253,34 (3) | 358 | UB, 1 seed ruim, colisões 511x, Diff, BIC |
| Murmúrio2 | 3089.18 | 41.22 | 238,42 (4) | 358 | UB, 1 semente ruim, 1,7% de viés, 81x coll, 1,7% de distribuição, BIC |
| Murmúrio2A | 3.087,98 | 45,90 | 238,54 (4) | 407 | UB, 1 seed ruim, viés de 12,7%, LongNeighbors |
| Murmúrio2B | 5919.38 | 38.18 | 215,96 (3) | 433 | UB, viés de 1,8%, colisões, distribuição de 3,4%, BIC |
| Murmúrio2C | 3810,98 | 49.09 | 218,51 (3) | 444 | UB, 2 ^ 32 sementes ruins, 91% de viés, colisões, distr, BIC, LongNeighbors |
| Murmúrio3A | 2.982,67 | 49.08 | 245,78 (4) | 351 | UB, 1 semente ruim, Momento Chi2 69 |
| PMurHash32 | 3005,85 | 48,88 | 242,38 (3) | 1862 | 1 semente ruim, Momento Chi2 69 |
| Murmúrio3C | 4833,18 | 56,87 | 250,47 (6) | 859 | UB, LongNeighbors, Texto, DiffDist |
| mirhash32low | 6145,39 | 36,95 | 235,09 (4) | 1112 | UB, 4 sementes ruins, Cyclic, LongNeighbours, específico da máquina (32/64 difere) |
| PMPML_32 | 6639,68 | 45,33 | 257,45 (3) | 1084 | Avalanche >512, sem sementes: Seed, BIC, MomentChi2, PerlinNoise |
| PMPML_64 | 9833,77 | 50,00 | 251,64 (6) | 1305 | sem sementes: Seed, MomentChi2, BIC |
| xxHash32 | 5865,17 | 49,20 | 242,74 (3) | 738 | LongNeighbors, colisões com diferença de 4 bits, MomentChi2 220 |
| metrohash64 | 14741,56 | 39,44 | 215,76 (2) | 624 | UB, LongNeighbors, BIC |
| metrohash64_1 | 14298,77 | 40,31 | 223,25 (4) | 624 | UB, LongNeighbors, BIC, MomentChi2 |
| metrohash64crc_1 | 6.929,69 | 44,65 | 223,68 (3) | 632 | UB, Cyclic 8/8 byte, DiffDist, BIC, MomentChi2, específico da máquina (SSE4.2/NEON) |
| metrohash64crc_2 | 8150,65 | 43,72 | 219,45 (5) | 632 | UB, byte cíclico 8/8, DiffDist, BIC, específico da máquina (SSE4.2/NEON) |
| cmetrohash64_1o | 14921,73 | 38,95 | 213,25 (2) | 3506 | UB, LongNeighbors, BIC, MomentChi2 |
| cmetrohash64_1 | 14151,73 | 40,90 | 211,89 (2) | 652 | UB, LongNeighbors, BIC, MomentChi2 |
| City64noSeed | 14209.19 | 31,80 | 225,90 (5) | 1038 | Avalanche, esparso, dois bytes, MomentChi2, semente |
| Cidade64 | 13887,84 | 46,32 | 239,77 (3) | 1120 | Esparso, dois bytes |
| t1ha1_64le | 13442,64 | 31.41 | 219,58 (3) | 517 | Avalanche |
| t1ha1_64be | 11586.02 | 32,74 | 232,55 (3) | 555 | Avalanche |
| t1ha0_32le | 7401.21 | 48,27 | 238,99 (3) | 509 | Vizinhos esparsos e longos |
| t1ha0_32be | 6217,37 | 50,66 | 244,51 (3) | 533 | Vizinhos esparsos e longos |
| t1ha2_stream | 14011.63 | 80,72 | 275,17 (3) | 1665 | Esparso, Permutação, LongNeighbours |
| t1ha2_stream128 | 13136.06 | 97,80 | 306.11 (7) | 1665 | Esparso, Permutação, LongNeighbours |
| aesnihash | 5579.32 | 56,83 | 258,71 (5) | 1209 | falha em muitos testes, específico da máquina (x64 AES-NI) |
| falkhash | 50631,69 | 123.02 | 322,14 (7) | 264 | Esparso, LongNeighbors, específico da máquina (x64 AES-NI) |
| MeowHash | 29969,40 | 64,96 | 274,29 (4) | 1764 | Esparso, invertível, específico da máquina (x64 AES-NI) |
| MeowHash64low | 29485,59 | 65,98 | 278,05 (3) | 1764 | Esparso, invertível, específico da máquina (x64 AES-NI) |
| MeowHash32low | 26944,58 | 65,95 | 292,79 (9) | 1764 | Esparso, invertível, específico da máquina (x64 AES-NI) |
| -------------------------------------- | |||||
| tifuhash_64 | 35,60 | 1679.52 | 1212,75 (15) | 276 | Cíclico baixo32 |
| floppsyhash | 35,72 | 1868,92 | 1411.07 (7) | 623 | |
| divisor de feixe | 789,22 | 682,45 | 1150,33 (26) | 4203 | UB |
| discohash1 | 4131.12 | 199,00 | 398,35 (5) | 1294 | |
| discohash1-128 | 4072,95 | 234,17 | 438,43 (5) | 1294 | |
| discohash2 | 3.986,52 | 207,52 | 421,99 (2) | 1294 | |
| discohash2-128 | 4094,73 | 236,61 | 433,35 (4) | 1294 | |
| discoNONG | 3698,45 | 399,67 | 597,78 (9) | sementes ruins | |
| chaskey | 1143.05 | 113,70 | 294,43 (4) | 1609 | PerlinNoise |
| Sip Hash | 943,53 | 147,15 | 338,74 (4) | 1071 | |
| HalfSipHash | 1141,57 | 79,65 | 263,96 (3) | 700 | zeros |
| BomOAAT | 743,81 | 85,62 | 231,22 (3) | 237 | |
| pearsonbhash64 | 1794,83 | 97,80 | 268,90 (8) | 683 | |
| pearsonbhash128 | 1691,62 | 104,57 | 272,38 (4) | 1134 | |
| pearsonbhash256 | 1442,59 | 126.04 | 309,34 (4) | 844 | |
| prvhash64_64m | 3077.18 | 47,31 | 241,92 (3) | 349 | |
| prvhash64_64 | 3015.08 | 48.03 | 240,64 (3) | 384 | |
| prvhash64_128 | 3353,81 | 67,64 | 266,32 (2) | 718 | |
| prvhash64s_64 | 6591,34 | 273,50 | 464,65 (3) | 2640 | |
| prvhash64s_128 | 6581,40 | 333,83 | 528,07 (5) | 2799 | |
| SipHash13 | 1812,75 | 106,56 | 310,76 (5) | 778 | Viés de 0,9% |
| TSip | 4233.17 | 53,31 | 249,19 (3) | 519 | !msvc |
| marshmallow | 8261,80 | 58,94 | 256,08 (4) | 871 | PerlinNoise, !msvc |
| seahash32low | 8266.17 | 58,90 | 290,21 (16) | 871 | PerlinNoise 32, !msvc |
| clhash | 18703.04 | 70,19 | 282,12 (6) | 1809 | PerlinNoise, específico da máquina (x64 SSE4.2) |
| RodoviaHash64 | 6242,58 | 99,55 | 248,41 (3) | 2546 | |
| Murmúrio3F | 7623,44 | 52,69 | 221,87 (3) | 699 | UB |
| MÃE | 9563,99 | 34,99 | 228,55 (5) | 1912 | UB, muitas sementes ruins, específico da máquina (32/64 difere) |
| MUMbaixo | 9261,89 | 36.17 | 247,66 (4) | 1912 | UB, 5 sementes ruins |
| xmsx32 | 2039.10 | 46,39 | 249,30 (7) | 192 | 2 sementes ruins |
| Mirhash | 6139.07 | 37.02 | 209,47 (3) | 1112 | UB, 2 ^ 36 sementes ruins, LongNeighbours, específico da máquina (32/64 difere) |
| Mirhashstrict | 3549.01 | 49,99 | 224,91 (2) | 1112 | |
| mirhashstrict32low | 3441,35 | 50,60 | 247,19 (3) | 1112 | 1 semente ruim, MomentChi2 9 |
| fasthash32 | 6128.28 | 40h30 | 241,64 (4) | 566 | UB |
| fasthash64 | 5818,92 | 38,70 | 220,74 (2) | 509 | UB |
| aesni | 31232.34 | 29.21 | 230,14 (4) | 519 | específico da máquina (x64 AES-NI) |
| aesni-baixo | 31221.14 | 29,64 | 226,18 (3) | 519 | específico da máquina (x64 AES-NI) |
| mx3 | 9034,90 | 48,71 | 227,89 (2) | 734 | UB |
| pengyhash | 13428,80 | 74,24 | 275,42 (5) | 421 | |
| Cidade32 | 5551.28 | 54,40 | 261,64 (2) | 1319 | |
| Cidade64low | 13904.10 | 46,24 | 260,08 (3) | 1120 | |
| Cidade128 | 14031,96 | 89.09 | 290,05 (10) | 1841 | |
| CidadeCrc128 | 7916.44 | 55,50 | 240,79 (2) | 295 | |
| FarmHash32 | 21755,58 | 47,54 | 258,35 (3) | 11489 | específico da máquina (x64 SSE4/AVX) |
| FarmHash64 | 12845,53 | 47.11 | 251,58 (3) | 3758 | |
| FazendaHash128 | 13913,65 | 70,25 | 263,06 (3) | 163 | |
| farmhash32_c | 21601.86 | 47,38 | 273,00 (3) | 762 | específico da máquina (x64 SSE4/AVX) |
| farmhash64_c | 12834.10 | 47,23 | 246,20 (2) | 3688 | |
| farmhash128_c | 13753,24 | 68,96 | 263,76 (3) | 1890 | |
| metrohash64_2 | 14316,37 | 40,23 | 218,28 (3) | 627 | UB, LongNeighbors |
| cmetrohash64_2 | 14294.26 | 40,76 | 221,40 (4) | 655 | Vizinhos Longos |
| metrohash128 | 15634,66 | 73,28 | 261,23 (4) | 773 | UB, LongNeighbors |
| metrohash128_1 | 15806,97 | 72h30 | 260,90 (4) | 773 | UB, LongNeighbors |
| metrohash128_2 | 15822,60 | 72h30 | 255,34 (3) | 773 | UB, LongNeighbors |
| metrohash128crc_1 | 8009.23 | 78,72 | 281,55 (13) | 723 | UB, específico da máquina (SSE4.2/NEON) |
| metrohash128crc_2 | 7878.22 | 79,90 | 275,22 (4) | 723 | UB, específico da máquina (SSE4.2/NEON) |
| xxHash64 | 12108.87 | 49,78 | 228,83 (2) | 1999 | |
| Assustador32 | 13108,95 | 56,27 | 255,36 (3) | 2221 | UB |
| Assustador64 | 13529,36 | 58,76 | 236,31 (3) | 2221 | UB |
| Assustador128 | 11781,35 | 58,91 | 242,91 (3) | 2221 | UB |
| AssustadorV2_32 | 13529.16 | 55,55 | 248,37 (4) | 2069 | |
| AssustadorV2_64 | 12678,82 | 56,71 | 243,21 (4) | 2069 | |
| AssustadorV2_128 | 13512,82 | 58,33 | 244,56 (5) | 2069 | |
| ahash64 | 9862,62 | 27.32 | 181,68 (1) | 412 | ferrugem |
| xxh3 | 21033,55 | 29h48 | 226,77 (4) | 744 | DiffDist bit 7 w. 36 bits, BIC |
| xxh3low | 17093.19 | 30,57 | 242,07 (7) | 756 | |
| xxh128 | 18802.16 | 32,37 | 234,30 (4) | 1012 | |
| xxh128low | 18833,05 | 32h30 | 234,68 (3) | 1012 | |
| t1ha2_atonce | 13854,44 | 37,92 | 233,54 (2) | 541 | Zeros baixos3 |
| t1ha2_atonce128 | 14148.42 | 55,70 | 253,74 (6) | 613 | Vizinhos Longos |
| t1ha0_aes_noavx | 27231,59 | 37,70 | 236,10 (3) | 925 | LongNeighbours, específico da máquina (x86 AES-NI) |
| t1ha0_aes_avx1 | 22714,85 | 48.12 | 226,52 (16) | 843 | LongNeighbours, específico da máquina (x64 AVX.txt) |
| t1ha0_aes_avx2 | 56919.46 | 36,70 | 233,14 (2) | 792 | LongNeighbors, específico da máquina (x64 AVX2) |
| wyhash32 | 2532,89 | 48,40 | 484,57 (1) | 426 | 4 sementes ruins e quebradas, 32 bits |
| wyhash32low | 22393,77 | 29.04 | 243,40 (3) | 474 | 5 sementes ruins |
| wyhash | 22540.23 | 28,87 | 236,16 (8) | 474 | |
| hash rápido | 23789,79 | 22h80 | 138,71 (7) | 574 | |
| rapidhash_unrolled | 23892,88 | 23h41 | 139,47 (12) | 782 | |
| umash32 | 21427,57 | 42.12 | 255,55 (5) | 1530 | |
| umash32_oi | 21483.12 | 42,65 | 251,09 (4) | 1530 | |
| umash64 | 21690.08 | 41,67 | 238.01 (4) | 1530 | |
| umash128 | 13211,88 | 43,37 | 237,40 (3) | 1530 | |
| intervalo_hash64 | 4735,63 | 99,90 | 315,34 (3) | 2911 | |
| intervalo_hash128 | 17534,53 | 97,97 | 311.10 (4) | 2462 | |
| intervalo_hash256 | 18003.39 | 99,46 | 315,09 (3) | 2622 | |
| intervalo_hash512 | 10890,15 | 118.05 | 333,45 (3) | 3550 | |
| nmhash32 | 12969,62 | 55,88 | 265,69 (4) | 2445 | |
| nmhash32x | 12775.08 | 42,66 | 246,05 (3) | 1494 | |
| k-hashv32 | 9181.87 | 52,76 | 245,14 (3) | 1280 | |
| k-hashv64 | 7850,92 | 46,94 | 193,94 (1) | 1279 | |
| komihash | 12242,78 | 33.02 | 236,07 (2) | 1323 | |
| polímero | 9676,33 | 42,70 | 246,53 (3) | 1128 |
As variantes da tabela classificável:
Padrão AMD Ryzen 5 3350G 3,6 GHz
Intel i5-2300 2,8 GHz
Intel i5-2300 2,8 GHz 32 bits
AMD Ryzen 3 3200U 3,5 GHz
Mac Air i7-4650
Cortex-A53 2 GHz (Sony XPeria L4)
Eu adicionei alguns hashes assistidos por SSE e variantes rápidas de Intel/arm CRC32-C, AES e SHA HW. Veja também o antigo https://github.com/aappleby/smhasher/wiki, o fork melhorado, mas não mantido https://github.com/demerphq/smhasher, e a nova versão melhorada SMHasher3 https://gitlab.com/ fwojcik/smhasher3.
Portanto, as funções hash mais rápidas em x86_64 sem problemas de qualidade são:
rapidhash (um wyhash melhorado)
xxh3low
wyhash
umash (mesmo universal!)
ahash64
t1ha2_atonce
komihash
FarmHash ( não portátil, muito específico da máquina: 64 vs 32 bits, gcc antigo, ... )
intervalo_hash128
Assustador32
pengyhash
nmhash32
mx3
MUM/mir ( resultados diferentes em arcos de 32/64 bits, muitas sementes ruins para filtrar )
fasthash32
Funções hash para tabelas de símbolos ou tabelas hash normalmente usam hashes de 32 bits, para bancos de dados, sistemas de arquivos e somas de verificação de arquivos normalmente de 64 ou 128 bits, para criptografia agora começando com 256 bits.
O tamanho médio típico da chave em perl5 é 20, o mais comum 4. Semelhante para todas as outras linguagens dinâmicas. Consulte github.com/rurban/perl-hash-stats
Quando usado em uma tabela hash, o cache de instruções geralmente supera a CPU e o rendimento medido aqui. Em meus testes, o menor FNV1A supera o crc32_hw1 mais rápido com tabelas hash Perl 5. Mesmo que essas funções hash piores levem a mais colisões, a vantagem geral de velocidade e capacidade inline superam a qualidade um pouco pior. Veja, por exemplo, Uma análise sete-dimensional de métodos de hash e suas implicações no processamento de consultas para uma visão geral concisa das melhores estratégias de tabela de hash, confirmando que o hashing Mult mais simples (bernstein, FNV*, x17, sdbm) sempre supera as "melhores" funções de hash (Tabulation, Murmur, Farm, ...) quando usado em uma tabela hash.
As funções hash rápidas testadas aqui são recomendáveis tão rápidas para resumos de arquivos e talvez bancos de dados maiores, mas não para tabelas hash de 32 bits. Os "problemas de qualidade" levam a uma distribuição menos uniforme, ou seja, mais colisões e pior desempenho, mas raramente estão relacionados a ataques reais de segurança, apenas o segundo teste de sanidade AppendZeroes contra � é relevante para a segurança.
MiB/s: A média do teste de velocidade de chave em massa para alinhamentos 0-7 com chaves de 262.144 bytes. Quanto mais alto, melhor.
cycl./hash: A média do teste de velocidade de chave pequena para chaves de 1 a 31 bytes. Quanto menor, melhor.
cycl./map: O resultado do teste Hashmap para /usr/dict/words com consultas rápidas de obtenção de hashmap C++, com o desvio padrão entre colchetes. Isso testa a inlinabilidade da função hash na prática (veja o tamanho). Quanto menor, melhor.
size: O tamanho do objeto em bytes no AMD64. Isto afeta a inlinabilidade, por exemplo, em tabelas hash. Quanto menor, melhor.
Problemas de qualidade: veja as falhas no documento vinculado. Quanto menos, melhor.
https://github.com/martinus/better-faster-stronger-mixer Misturadores. E em seu blog os melhores benchmarks de hashmap C++.
http://nohatcoder.dk/2019-05-19-1.html fornece uma nova e útil classificação de nível de hash 1-5.
http://www.strchr.com/hash_functions lista outros benchmarks e qualidade das funções hash mais simples e rápidas.
http://bench.cr.yp.to/primitives-hash.html lista os benchmarks de todos os hashes seguros testados atualmente.
http://valerieaurora.org/hash.html Vida útil das funções hash criptográficas
Os ataques à tabela hash descritos no SipHash contra City, Murmur ou Perl JenkinsOAAT ou no Hash Function Lounge não estão incluídos aqui. Listamos alguns ataques conhecidos em GH #186.
Tal prevenção de ataques não pode ser o problema da função hash, mas apenas do esquema de resolução de colisão da tabela hash. Você pode atacar todas as funções de hash, mesmo as melhores e mais seguras, se detectar a semente, por exemplo, a partir de recursos (errados) de linguagem, ataques de canal lateral, tempos de colisão e independentemente da ordem de classificação, portanto, você precisa proteger sua colisão esquema de tratamento do pior caso O(n), ou seja, encadeamento separado com listas vinculadas. O encadeamento de listas vinculadas permite altos fatores de carga, mas é muito hostil ao cache. O único esquema de lista vinculada recomendável é incorporar a chave ou hash no array. Hoje em dia todo mundo usa endereçamento aberto rápido, mesmo que o fator de carga precise ser de aproximadamente 50%, a menos que você use Cuckoo Hashing.
Ou seja, o uso de SipHash para sua tabela hash em Python 3.4, Ruby, Rust, Systemd, OpenDNS, Haskell e OpenBSD é puro teatro de segurança. SipHash não é seguro o suficiente para fins de segurança e não é rápido o suficiente para uso geral. A geração de força bruta de ~32k colisões precisa de 2 a 4m para todos esses hashes. siphash sendo o mais lento precisa de no máximo 4m, outros normalmente no máximo 2m30s, com <10s para ataques práticos de colisão de 16k com todas as funções hash. Usar Murmur geralmente é mais lento que um simples Mult, mesmo no pior dos casos. A segurança comprovada é apenas hashing uniforme, ou seja, 2-5 Mult ou Tabulação independentes, ou usando um esquema de colisão logarítmica garantida (uma árvore) ou um esquema de colisão linear, como swisstable/folly-F14, Robin Hood ou Cuckoo hashing com contagem de colisões.
Mais uma observação sobre segurança: hoje em dia até o SHA1 pode ser resolvido em um solucionador, como o Z3 (ou outros mais rápidos) para ataques práticos de colisão de tabelas hash (ou seja, 14-20 bits). Todas as funções hash com menos de 160 bits testadas aqui não podem ser consideradas “seguras”.
O ataque de vulnerabilidade '�' com chaves binárias é testado no 2º teste Sanity Zero.
Nossos hashes criptográficos são reforçados com uma semente size_t adicionada, misturada no estado inicial, e as versões que exigem preenchimento de zero são reforçadas adicionando o len também, para evitar colisões com AppendedZeroes para o preenchimento. As implementações do libtomcrypt já fornecem isso, mas outras talvez não. Sem isso, essas funções cripto-hash são inadequadas para tarefas normais, pois é trivial criar colisões por preenchimento ou sementes ruins.
O testsuite oficial da função hash do NIST não faz testes estatísticos tão extensos para procurar intervalos fracos nos bits. Além disso, a criptografia não altera o estado inicial, o que fazemos aqui para nossa semente aleatória de 32 bits. A criptografia se preocupa principalmente com chave irreversível -> funções hash sem alterar o estado fixo inicial e ataques de tempo/canal lateral.
O "Programa de Validação de Algoritmo Criptográfico" (CAVP) do NIST envolve o teste das implementações de algoritmos criptográficos aprovados pelo FIPS e recomendados pelo NIST. Durante a competição NIST SHA-3, a metodologia de teste foi emprestada do "CAVP", já que os KATs e MCTs do SHA-3 Competition Test Suite foram baseados nos testes CAVP para SHA-2. Além disso, o “Teste de Mensagem Extremamente Longa”, não presente no CAVP para SHA-2, exigia que os remetentes gerassem o valor hash correspondente a uma mensagem com comprimento de 1 GiB. “NIST - Cryptographic Algorithm Validation Program (CAVP)”, junho de 2017. Disponível: http://csrc.nist.gov/groups/STM/cavp (Nenhum código-fonte de teste fornecido, apenas descrições de alto nível)
Dois outros testes independentes de terceiros encontraram um grande número de bugs e pontos fracos nos candidatos SHA3. "Encontrando bugs em implementações de funções hash criptográficas", Nicky Mouha, Mohammad S Raunak, D. Richard Kuhn e Raghu Kacker, 2017. https://eprint.iacr.org/2017/891.pdf
Talvez pesquisadores independentes devessem se unir para fazer uma rodada pública melhor de SHA-4, com base em melhores e mais métodos de teste, código-fonte aberto para os testes e usando práticas padrão da indústria, como valgrind, address-sanitizer e ubsan para detectar bugs óbvios .
Sementes ruins
As funções hash normalmente são inicializadas com uma semente aleatória. Mas alguns valores iniciais podem levar a funções hash ruins, independentemente da chave. No caso normal com sementes aleatórias, a probabilidade de tais sementes ruins é muito baixa, como 2 ^ 32 ou 2 ^ 64. Uma aplicação prática precisa saber se existem sementes ruins e escolher outra. Veja, por exemplo, mirhash_seed_init() e mirhash_bad_seeds() em Hashes.h . Observe que uma semente ruim não é realmente um problema quando você a ignora durante a inicialização. Ainda pode ser uma função hash BOA ou recomendada. Mas uma semente ruim de 0 levando a colisões é considerada um bug, uma função hash ruim.
Testamos os segredos internos, se eles serão multiplicados por 0. Isso também é chamado de "multiplicação cegante". main.cpp lista alguns segredos para cada função hash que testamos. A função <hash>_bad_seeds() lista as sementes ruins confirmadas.
Cuidados especiais devem ser tomados com CRC, a maioria das variantes de FNV1, Fletcher, Jenkins. E com BONS hashes, a maioria das variantes do MUM, como mirhash, MUM, wyhash.
Independentemente disso, quando o invasor conhece a semente, isso levará a ataques DDOS. Mesmo com hashes criptográficos em hashtables power2.
Problemas típicos de comportamento indefinido ( UB ):
Desalinhado
Muitos hashes de palavras (ao contrário do processamento seguro de bytes) não verificam o buffer de entrada para alinhamento adequado de palavras, o que falhará com ubsan ou Sparc. palavra sendo int32_t ou int64_t ou até mais. Em alguns hardwares RISC antigos, isso será um erro de BUS, você pode até deixar o Intel HW gerar esse erro de barramento definindo algum sinalizador de CPU. Mas geralmente usar acessos desalinhados é bom.
Estes são: mx3, Spooky, mirhash ( mas não estrito ), MUM, fasthash, Murmur3*, Murmur2*, metrohash* (todos menos cmetro*), Crap8, beamsplitter, lookup3, fletcher4, fletcher2, todas as variantes sanmayce FNV1a_ (FNV1a_YT, FNV1A_Pippip_Yurii, FNV1A_Totenschiff, ...), fibonacci.
A mitigação usual é verificar o alinhamento do buffer no chamador, fornecer um loop de pré-processamento para o prefixo desalinhado ou copiar todo o buffer em uma nova área alinhada. Coloque esse código extra dentro de #ifdef HAVE_ALIGNED_ACCESS_REQUIRED .
oob - Fora dos limites
Algumas funções hash assumem um buffer de entrada preenchido que pode ser acessado além de seu comprimento até o tamanho da palavra. Isso permite um processamento de loop mais rápido, já que nenhum segundo loop ou tabela de switch é necessário para o restante, mas requer um ambiente de chamada cooperativo e, como tal, é considerado trapaça.
Estouro de número inteiro assinado
Um erro de tipo simples, esse hash precisa usar tipos inteiros não assinados internamente, para evitar comportamento indefinido e inconsistente. ou seja, SuperFastHash: estouro de número inteiro assinado: -2147483641 + -113 não pode ser representado no tipo 'int'
deslocamento de estouro de expoente
Com: FNV1A_Pippip_Yurii, FNV1A_Totenschiff, pair_multiply_shift, sumhash32 shift expoente 64 é muito grande para tipo de 64 bits 'long unsigned int'
