Adaptive Hashing: Faster Hash Functions with Fewer Collisions

Hash tables are ubiquitous, and the choice of hash function, which maps a key to a bucket, is key to their performance. We argue that the predominant approach of fixing the hash function for the lifetime of the hash table is suboptimal and propose adapting it to the current set of keys. In the prevailing view, good hash functions spread the keys ``randomly’’ and are fast to evaluate. General-purpose ones (e.g. Murmur) are designed to do both while remaining agnostic to the distribution of the keys, which limits their bucketing ability and wastes computation. When these shortcomings are recognized, one may specify a hash function more tailored to some assumed key distribution, but doing so almost always introduces an unbounded risk in case this assumption does not bear out in practice. At the other, fully key-aware end of the spectrum, Perfect Hashing algorithms can discover hash functions to bucket a given set of keys optimally, but they are costly to run and require the keys to be known and fixed ahead of time. Our main conceptual contribution is that adapting the hash table’s hash function to the keys online is necessary for the best performance, as adaptivity allows for better bucketing of keys \emph{and} faster hash functions. We instantiate the idea of online adaptation with minimal overhead and no change to the hash table API. The experiments show that the adaptive approach marries the common-case performance of weak hash functions with the robustness of general-purpose ones.

💡 Research Summary

The paper challenges the long‑standing assumption that a hash table’s hash function should remain fixed for the lifetime of the table. It proposes online adaptive hashing, a mechanism that monitors the current key set and dynamically replaces the hash function when the observed collision pattern deviates from the expected uniform distribution. The authors argue that this adaptivity can simultaneously improve bucket balance (fewer collisions) and reduce the computational cost of hashing, thereby delivering the best of both worlds: the speed of simple, weak hash functions and the robustness of general‑purpose, high‑entropy hashes.

The theoretical contribution begins with a simple cost model based on the expected number of key comparisons per lookup. The authors define a bucket‑count vector, a cost of hashes (Definition 2), and a regret metric (Definition 5) that measures the excess cost of a given hash function relative to an ideal perfect hash for the same number of buckets and keys. They prove that a uniform random hash has an expected regret of 0.5 / m (where m is the number of buckets) and that perfect hashing achieves zero regret. This formalism provides a quantitative target for any adaptive scheme.

Two concrete adaptive strategies are presented.

1. String keys – Hash computation is expensive for long strings, so the authors introduce a truncation‑limit technique. Using a variant of the FNV‑1a algorithm, only a limited number of characters from the beginning and the end of the string are processed. The limit is stored per table and increased (doubling) when the chain length in a bucket exceeds a predefined threshold, triggering a rehash. The limit can also be decreased if collisions become rare. Experiments on ~40 000 real Lisp strings show that for small tables (up to a few thousand buckets) the adaptive scheme reduces insertion time by 30‑45 % and lookup time by 20‑30 % compared with the unmodified SBCL hash. When the limit grows to the full string length, performance converges to the baseline, confirming that the adaptive mechanism does not degrade the system.

2. Integer and pointer keys – For keys that follow an arithmetic progression (e.g., sequential object addresses) the authors exploit the fact that, when the bucket count m is a power of two and the step d is odd, the sequence is perfectly distributed modulo m. By computing the largest power‑of‑two divisor s of d, the hash can be reduced to a single right‑shift operation k >> s, which is essentially free on modern CPUs. This yields a perfect hash without any division, dramatically lowering the per‑lookup cost while eliminating collisions. The technique also applies to page‑based memory allocators, where low‑order address bits exhibit regular patterns.

Implementation details are provided for SBCL (a high‑performance Common Lisp). The adaptive logic is inserted into the standard put routine with minimal changes: a check of the current chain length, a possible switch to a “safer” hash function, and a conditional rehash. The authors also discuss how the adaptation cost can be hidden inside the normal table‑resize operation, keeping the overhead negligible.

The experimental section evaluates three workloads: (a) strings, (b) lists (which are hashed by prefix only), and (c) integer/pointer keys. For each, insertion (PUT), successful lookup (GET), and failed lookup (MISS) are timed in nanoseconds. Results confirm that adaptive hashing consistently reduces the regret metric to near‑zero for small to medium table sizes, while larger tables see diminishing returns because rehashes become rare. Notably, for list keys the default truncation length of four elements—originally chosen in SBCL to avoid stack overflow—proved optimal, and the adaptive scheme could increase this limit when needed, achieving up to 60 % speed‑up in pathological test cases.

The paper acknowledges several limitations. The current prototype is tied to SBCL’s hash‑table API; porting to other runtimes would require handling different memory models and hash‑table semantics. The regret‑tracking mechanism itself incurs some memory writes, and the authors do not provide a detailed quantitative analysis of this overhead under high‑throughput workloads. Moreover, the truncation strategy for strings may become ineffective when the dataset contains many very long keys, as the limit eventually reaches the full length and the adaptive benefit disappears.

In conclusion, the authors demonstrate that online adaptation of hash functions is both feasible and beneficial. By coupling a lightweight, data‑driven decision process with simple yet powerful hash transformations (truncation for strings, bit‑shifts for arithmetic keys), they achieve performance close to that of perfect hashing while retaining the flexibility required for dynamic workloads. The work opens several avenues for future research: extending the adaptive framework to other key types (e.g., composite structures), designing more sophisticated regret estimators that incur lower overhead, and integrating the approach into mainstream language runtimes and database engines.