A quotient filter is a cache efficient AMQ data structure. Depending on the fill degree of the filter most insertions and queries only need to access one or two consecutive cache lines. This makes quotient filters fast compared to the more commonly used Bloom filters that incur multiple cache misses. However, concurrent Bloom filters are easy to implement and can be implemented lock-free while concurrent quotient filters are not as simple. Usually concurrent quotient filters work by using an external array of locks -- each protecting a region of the table. Accessing this array incurs one additional cache miss per operation. We propose a new locking scheme that has no memory overhead. Using this new locking scheme we achieve 1.8 times higher speedups than with the common external locking scheme.
Another advantage of quotient filters over Bloom filters is that a quotient filter can change its size when it is becoming full. We implement this growing technique for our concurrent quotient filters and adapt it in a way that allows unbounded growing while keeping a bounded false positive rate. We call the resulting data structure a fully expandable quotient filter. Its design is similar to scalable Bloom filters, but we exploit some concepts inherent to quotient filters to improve the space efficiency and the query speed.
We also propose quotient filter variants that are aimed to reduce the number of status bits (2-status-bit variant) or to simplify concurrent implementations (linear probing quotient filter). The linear probing quotient filter even leads to a lock-free concurrent filter implementation. This is especially interesting, since we show that any lock-free implementation of another common quotient filter variant would incur significant overheads in the form of additional data fields or multiple passes over the accessed data.
[1]
John D. Owens,et al.
Quotient Filters: Approximate Membership Queries on the GPU
,
2018,
2018 IEEE International Parallel and Distributed Processing Symposium (IPDPS).
[2]
Clerry,et al.
Compact Hash Tables Using Bidirectional Linear Probing
,
1984,
IEEE Trans. Computers.
[3]
David Hutchison,et al.
Scalable Bloom Filters
,
2007,
Inf. Process. Lett..
[4]
Donald E. Knuth,et al.
The Art of Computer Programming: Volume 3: Sorting and Searching
,
1998
.
[5]
Michael A. Bender,et al.
A General-Purpose Counting Filter: Making Every Bit Count
,
2017,
SIGMOD Conference.
[6]
Xiaozhou Li,et al.
Algorithmic improvements for fast concurrent Cuckoo hashing
,
2014,
EuroSys '14.
[7]
Nhan Nguyen,et al.
Lock-Free Cuckoo Hashing
,
2014,
2014 IEEE 34th International Conference on Distributed Computing Systems.
[8]
Mahmood Ahmadi,et al.
Deep Packet Inspection Using Quotient Filter
,
2016,
IEEE Communications Letters.
[9]
Salvatore Pontarelli,et al.
Adaptive Cuckoo Filters
,
2017,
ALENEX.
[10]
Donald E. Knuth,et al.
The art of computer programming: sorting and searching (volume 3)
,
1973
.
[11]
Alex D. Breslow,et al.
Morton filters: fast, compressed sparse cuckoo filters
,
2019,
The VLDB Journal.
[12]
J. Ian Munro,et al.
Robin hood hashing
,
1985,
26th Annual Symposium on Foundations of Computer Science (sfcs 1985).
[13]
Bin Fan,et al.
Cuckoo Filter: Practically Better Than Bloom
,
2014,
CoNEXT.
[14]
Michael A. Bender,et al.
Don't Thrash: How to Cache Your Hash on Flash
,
2011,
Proc. VLDB Endow..
[15]
Peter Sanders,et al.
Concurrent Hash Tables
,
2019,
ACM Transactions on Parallel Computing.