Hash tables collide because they map an enormous set of possible keys into a finite set of slots: different keys can land at the same starting position, even when the hash function is working as intended. Robin Hood hashing manages contention by favoring the entry that has traveled farther through the table; Swiss Tables use compact per-slot metadata and SIMD comparisons to screen candidates. Both designs relate to memory locality, but neither guarantees a particular cache-line footprint or is universally faster.
Why collisions happen
A hash function turns a key into a hash value, and a hash table uses that value to choose a position in a finite array. Since the possible keys outnumber the available positions, distinct keys can map to the same starting slot. This is expected, not by itself evidence of a broken hash function.
As an Amazon Associate I earn from qualifying purchases.
There are two related cases: different keys may produce the same full hash value, or they may produce different hash values that map to the same table index. Either way, an open-addressed table must resolve the conflict by following a probe sequence through other positions. Collisions can affect the number of positions inspected, especially as the table fills, but do not make the table incorrect.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Robin Hood hashing changes who keeps a contested slot
Robin Hood hashing is an open-addressing strategy that considers how far each entry has traveled from its original position. When a new entry encounters one that is closer to its own starting point, the more-displaced entry can take that slot and the other entry continues probing. The aim is to reduce variation in probe distances, not to eliminate collisions.
#1 Best Overall
The National Institute of Standards and Technology summarizes the rule in its Dictionary of Algorithms and Data Structures entry for Robin Hood hashing: “In case of collision, the item with the longer probe sequence stays in the position.” The name is a mnemonic for taking a position from an entry that has traveled less far and giving it to one that has traveled farther.
A 2018 paper describes Robin Hood hashing as an open-addressed method that moves entries to reduce variance in distances from their original indices, and discusses cache locality in memory-bound work. That does not specify one universal deletion or probe-termination policy: implementations can make different choices around the core insertion idea. The paper, “Concurrent Robin Hood Hashing”, provides that academic context.
Swiss Tables use metadata to filter candidates
Swiss Tables, as described by Abseil, split a 64-bit hash into two parts. H1 is used to find a table position; H2 is a 7-bit fingerprint stored in one byte of metadata for each slot. Abseil describes the table as holding “a densely packed array of metadata, containing presence information for entries in the table.” Abseil’s Swiss Tables Design Notes explain the layout.
On lookup, H1 leads the search to a group of slots. The table compares the sought H2 fingerprint with the group’s metadata, then performs full key-equality checks only for slots whose fingerprints match. If no key matches, it probes another group. Abseil describes using SIMD instructions for these metadata comparisons, including an implementation example that compares 16 candidate metadata bytes in a few instructions. That is a design description, not a promise that every processor or lookup has the same cost.
Metadata also distinguishes empty slots from deleted ones. A deleted slot cannot end a search: an entry being sought may have been displaced beyond it. An empty slot can end the probe because no entry on that search path was placed farther along. Treating a deleted marker as empty could make an existing key unreachable. The distinctions are documented in the Swiss Tables Design Notes.
Swiss Tables and Robin Hood hashing describe different design ideas, rather than two names for the same mechanism. Robin Hood hashing is an insertion policy for managing probe distances; Swiss Tables’ documented approach uses compact fingerprints to filter candidate slots. A comparison between those ideas does not establish that every Swiss Table uses Robin Hood insertion, or that every Robin Hood table uses Swiss-style metadata.
What CPU cache lines have to do with it
A cache line is the unit of data transferred between memory and a processor cache. When a lookup touches nearby data in a compact layout, it may make better use of data brought into cache than a lookup that jumps among widely separated locations. This is the locality connection: it concerns how data is arranged and accessed, not a guarantee that an operation fits in one cache line.
Free tools Windows power users keep installed
One-click scans. No signup required.
Swiss Tables keep metadata compact and together so a group of candidates can be screened, while Abseil’s flat containers store values directly in the table. The Robin Hood hashing paper discusses cache locality as a relevant property for memory-bound work. These design properties can help locality, but the available descriptions establish neither a fixed number of cache misses per operation nor a universal performance ranking. Cache-line size and actual behavior depend on the processor, and lookup costs also depend on table layout, occupancy, key and value sizes, hash distribution, compiler, and workload.
Best Value
Choosing a table design for a workload
Do not choose between these designs from the algorithm name alone. Start with the constraints and measure the implementation under the workload it will serve.
Quick Recap
- Operation mix: frequent lookups, insertions, and deletions stress different parts of a table’s behavior.
- Occupancy and growth: a table’s density and resizing behavior affect probe work and memory use.
- Value layout: Abseil’s flat containers store values inline in the table; its node containers allocate values in separate nodes. Inline storage can reduce indirection, while separate nodes offer a different storage tradeoff. Neither layout is best for every requirement. See Abseil’s container guide.
- Hash distribution: Abseil advises that entropy be distributed across the hash bit space, since Swiss Tables use different portions for positioning and fingerprints. Its
absl::Hashframework supports standard and user-defined types and is the default for Swiss Tables. Design details and Abseil’s 2018 overview explain the hash relationship. Abseil also notes that its underlying hash algorithm can change without user-code changes, including for performance improvements or to defend against some hash-flooding attacks; this is not a security guarantee for every hash table or configuration. - Memory and API needs: account for allocation patterns, pointer indirection, and whether your program depends on references or pointers remaining stable as the table changes.
- Measured behavior: compare throughput and tail latency on the target processor, compiler, data, and operation mix. The cited sources do not provide a same-workload benchmark that establishes a winner between Robin Hood implementations and Swiss Tables.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
