• Corpus ID: 207863193

Fully-Dynamic Space-Efficient Dictionaries and Filters with Constant Number of Memory Accesses

@article{Bercea2019FullyDynamicSD,
  title={Fully-Dynamic Space-Efficient Dictionaries and Filters with Constant Number of Memory Accesses},
  author={Ioana Orianna Bercea and Guy Even},
  journal={ArXiv},
  year={2019},
  volume={abs/1911.05060}
}
A fully-dynamic dictionary is a data structure for maintaining sets that supports insertions, deletions and membership queries. A filter approximates membership queries with a one-sided error. We present two designs: 1. The first space-efficient fully-dynamic dictionary that maintains both sets and random multisets and supports queries, insertions, and deletions with a constant number of memory accesses in the worst case with high probability. The comparable dictionary of Arbitman, Naor, and… 

Figures and Tables from this paper

A Dynamic Space-Efficient Filter with Constant Time Operations
TLDR
This work presents the first space-efficient dynamic filter with constant time operations in the worst case and employs the classic reduction of Carter et al. (STOC 1978) on a new type of dictionary construction that supports random multisets.
Succinct Filters for Sets of Unknown Sizes
TLDR
This work presents a filter data structure with improvements in two aspects: it has constant worst-case time for all insertions and lookups with high probability; it uses space (1 + o(1))n(log(1/ ) + log logn) bits when n > u0.001, achieving optimal leading constant for all = o( 1).
Succinct Filters for Sets of Unknown Sizes
TLDR
This work presents a filter data structure with improvements in two aspects: - it has constant worst-case time for all insertions and lookups with high probability; and - it uses space $(1+o(1) n(\log (1/\epsilon)+O(\log\log n)$ bits when $n>u^{0.001}$, achieving optimal leading constant for all $\ep silon=o( 1)$.
Prefix Filter: Practically and Theoretically Better Than Bloom
TLDR
The prefix filter is proposed, an incremental filter that addresses the above challenge and its space (in bits) is similar to state-of-the-art dynamic filters; its query throughput is high and is comparable to that of the cuckoo filter; and overall build times faster than those of the vector quotient filter and cuckoff filter.
An extendable data structure for incremental stable perfect hashing
TLDR
This paper presents, as an application, a cyclic sequence of reductions between data structures that lead to the following bootstrapping result: a hash table design that does not need to move elements as its size grows.
Tiny Pointers
TLDR
A comprehensive theory of tiny pointers is developed, and optimal constructions for both fixed-size and variable-size tiny pointers are given, to take a natural space-inefficient solution that uses pointers and make it space-efficient for free.
A separation logic for negative dependence
TLDR
This work designs LINA, a probabilistic separation logic that generalizes the logic of bunched implications to support multiple separating conjunctions, and demonstrates how LINA can verify probabilism properties of hash-based data structures and balls-into-bins processes.
Manycore clique enumeration with fast set intersections
TLDR
This paper proves that the use of hash-join-based set-intersection algorithms within MCE leads to Pareto-optimal implementations in terms of runtime and memory space compared to those based on merge joins, and develops a scalable parallel implementation of MCE that exploits both data and task parallelism.

References

SHOWING 1-10 OF 47 REFERENCES
Succinct Dynamic Dictionaries and Trees
TLDR
It is shown that a binary tree on n nodes, where each node has b = O(lg n)-bit data stored at it, can be maintained under node insertions while supporting navigation in O(1) time and updates in O((lg lg n)1+Ɛ) amortised time, for any constant Ɛ > 0.
De Dictionariis Dynamicis Pauco Spatio Utentibus
We develop dynamic dictionaries on the word RAM that use asymptotically optimal space, up to constant factors, subject to insertions and deletions, and subject to supporting perfect-hashing queries
An Optimal Bloom Filter Replacement Based on Matrix Solving
TLDR
This work suggests a method for holding a dictionary data structure, which maps keys to values, in the spirit of Bloom Filters, and suggests a data structure that requires only nk bits space, has O (n) preprocessing time, and has a O (logn ) query time.
Bloom Filters, Adaptivity, and the Dictionary Problem
TLDR
It is shown that adaptivity can be achieved effectively for free because it is possible to maintain an AMQ that uses the same amount of local space as a non-adaptive AMQ, performs all queries and updates in constant time, and guarantees that each negative query to the dictionary accesses remote storage with probability epsilon, independent of the results of past queries.
LOW REDUNDANCY IN STATIC DICTIONARIES WITH CONSTANT QUERY TIME
TLDR
It is shown that on a unit cost RAM with word size Θ(log |U |), a static dictionary for n-element sets with constant worst case query time can be obtained using B+O(log log |U|)+o(n) bits of storage, where B e is the minimum number of bits needed to represent all nelement subsets of U.
Succinct Data Structures for Retrieval and Approximate Membership
TLDR
It is shown that for any k, query time O(k) can be beachieved using space that is within a factor 1 + e-k of optimal, asymptotically forlarge n.
Backyard Cuckoo Hashing: Constant Worst-Case Operations with a Succinct Representation
TLDR
This paper construction is a two-level variant of cuckoo hashing, augmented with a ``backyard'' that handles a large fraction of the elements, together with a de-amortized perfect hashing scheme for eliminating the dependency on $\boldsymbol{n}$ memory words, and guarantees constant-time operations in the worst case with high probability.
A General-Purpose Counting Filter: Making Every Bit Count
TLDR
A new general-purpose AMQ, the counting quotient filter (CQF), which is small and fast, has good locality of reference, scales out of RAM to SSD, and supports deletions, counting, resizing, merging, and highly concurrent access.
Constant-Time Retrieval with O(log m) Extra Bits
TLDR
This paper presents a method for treating the retrieval problem with overhead ε = O((logm)/m), which corresponds to O(1) extra memory words (O(logm) bits), and an extremely simple, constant-time query operation.
The Bloomier filter: an efficient data structure for static support lookup tables
TLDR
The Bloomier filter is introduced, a data structure for compactly encoding a function with static support in order to support approximate evaluation queries and lower bounds are provided to prove the (near) optimality of the constructions.
...
...