History-Independent Concurrent Hash Tables

TL;DR

This work addresses the privacy and privacy-preserving requirements of concurrent data structures by studying history-independent (HI) dictionaries, focusing on hash tables under concurrency. It introduces a lock-free, state-quiescent HI (SQHI) concurrent hash table built on Robin Hood hashing with 1-lookahead and lightweight helping, achieving linearizability with per-cell storage of two elements and two bits, and an amortized $O(c)$ step complexity when the load is bounded away from 1. A key technical contribution is the lookahead mechanism that enables safe single-cell lookups despite concurrent insertions/deletions, and a detailed propagation framework that avoids information leakage about operation history. The paper also proves a lower bound showing that some per-cell metadata is necessary for SQHI in the concurrent setting, sharply separating HI concurrent hash tables from sequential HI variants, and it argues that Robin Hood hashing (with age-based priority) is essentially the only linear-probing scheme that supports the needed two-cell lookahead property. Overall, the results demonstrate that history independence can be achieved in a highly concurrent setting with modest per-cell storage, while providing fundamental limits that guide future HI concurrent data-structure design.

Abstract

A history-independent data structure does not reveal the history of operations applied to it, only its current logical state, even if its internal state is examined. This paper studies history-independent concurrent dictionaries, in particular, hash tables, and establishes inherent bounds on their space requirements. This paper shows that there is a lock-free history-independent concurrent hash table, in which each memory cell stores two elements and two bits, based on Robin Hood hashing. Our implementation is linearizable, and uses the shared memory primitive LL/SC. The expected amortized step complexity of the hash table is $O(c)$, where $c$ is an upper bound on the number of concurrent operations that access the same element, assuming the hash table is not overpopulated. We complement this positive result by showing that even if we have only two concurrent processes, no history-independent concurrent dictionary that supports sets of any size, with wait-free membership queries and obstruction-free insertions and deletions, can store only two elements of the set and a constant number of bits in each memory cell. This holds even if the step complexity of operations on the dictionary is unbounded.

Figures (2)

• Figure 1: Depiction of the insertion process of element $b$, initiated by operation $\textsf{insert}(b)$, where $b$ is inserted into a cell $A[i] = \langle a, c, \mathit{S}\rangle$ such that $a >_{p_{i}} b >_{p_{i+1}} c$.
• Figure 2: Depiction of the deletion process of element $b$, initiated by operation $\textsf{delete}(b)$.

Theorems & Definitions (91)

• Theorem 1
• Theorem 2
• Lemma 3: BlellochGo07
• Lemma 4
• Lemma 5
• proof
• Lemma 6
• proof
• Lemma 7
• proof