mulxp_hash | String hash functions

mulxp_hash is a C++ library. mulxp_hash has no bugs, it has no vulnerabilities, it has a Permissive License and it has low support. You can download it from GitHub.

Candidate replacements for use with boost::unordered_flat_map from Boost 1.81, instead of the default boost::hash. Might be added as a dedicated boost::string_hash function object for string hashing only, or directly as the implementation underneath boost::hash et al. As a basic primitive, the functions use mulx, a multiplication of two 64 bit numbers yielding a 128 bit result, then combining its two 64 parts with bitwise-xor. mulx has very good combiner properties for its cost (a single mul instruction under x86), and has been popularized by Vladimir Makarov as the basis of his hash function MUM hash. mulxp0_hash is closest to boost::hash from Boost 1.81, and uses the same basic state = combine( state, input ); round, with combine(h, v) being h ^ mulx( h + 1 + v, k ), where k is a constant. Unlike boost::hash, it adds a leading round of scrambling the initial seed, and a trailing round of scrambling the final result. (These are necessary to pass the SMHasher battery of tests.). Since this construction makes the next round dependent on the current one, the loop is latency-bound. The mul instruction has higher throughput than latency, which can be exploited by changing the round to state = combine( state, mix( input ) );, with the combine function cheaper than the mix one, a construct popularized by Austin Appleby's MurmurHash. mulxp1_hash follows this approach, with a round of h ^= mulx( v1 + w, k );, where k is, as before, a constant, and w is a Weyl sequence (a fancy way of saying that w is updated on each iteration by adding a constant to it, w += q;.). On sufficiently long inputs, where the parts outside the loop don't matter, mulxp1_hash is about 2.5 times as fast as mulxp0_hash. (However, long inputs don't really matter for our primary target use case, a hash function for boost::unordered_flat_map, as most keys are small.). mulxp2_hash is a slight variation of mulxp1_hash, using the same round, which basically unrolls the main loop twice, consuming 16 bytes at a time. This makes it slightly (10%) faster on long inputs, but slower on short inputs. The final member of the mulxp family is mulxp3_hash. It has been inspired by the UMAC/NH family of functions started by FARSH, continued with MUM and perfected with wyhash. These consume 16 bytes (two words) of input at a time, v1 and v2, and feed both to the mulx primitive, as in mulx(v1 + k1, v2 + k2), where k1 and k2 are suitably chosen constants that ideally would come from a secret one-time pad. The advantage of this scheme is that the inner loop performs one fewer multiplication per round, which ideally would double the speed. The disadvantage is that if one of the operands to the mulx primitive happens to be zero, the other input word is essentially discarded and does not affect the final hash value. In mulxp3_hash, the round operation is h ^= mulx( v1 + w, v2 + w + k );, where w is a Weyl sequence as above, and k is a constant. This makes mulxp3_hash approximately 1.5 times as fast as mulxp2_hash.