Abstract—Counting Bloom Filters (CBFs) are widely used in networking device algorithms. They implement fast set representations to support membership queries with limited error, and support element deletions unlike Bloom Filters. However, they also consume significant amounts of memory. In this paper we introduce a new general method based on variable increments to improve the efficiency of CBFs and their variants. Unlike CBFs, at each packet arrival, the hashed counters increase by a hashed variable increment instead of a unit increment. Then, to query a packet, the exact value of a counter is considered and not just its positiveness. We present two simple schemes based on this method. We demonstrate that this method can always achieve a lower false positive rate and a lower overflow probability bound than CBF in large systems. We also show how it can be easily implemented in hardware, with limited added complexity and memory overhead. We also explain how this method can extend many variants of CBF that have been published in the literature. Last, using simulations, we show how it can improve the false positive rate of CBFs by up to an order of magnitude given the same amount of memory.

Abstract—In this paper, we uncover the Bloom paradox in Bloom filters: sometimes, it is better to disregard the query results of Bloom filters, and in fact not to even query them, thus making them useless. We first analyze conditions under which the Bloom paradox occurs in a Bloom filter, and demonstrate that it depends on the a priori probability that a given element belongs to the represented set. We show that the Bloom paradox also applies to Counting Bloom Filters (CBFs), and depends on the product of the hashed counters of each element. In addition, both for Bloom filters and CBFs, we suggest improved architectures that deal with the Bloom paradox. We also provide fundamental memory lower bounds required to support element queries with limited false-positive and false-negative rates. Last, using simulations, we verify our theoretical results, and show that our improved schemes can lead to a significant improvement in the performance of Bloom filters and CBFs. A. The Bloom Paradox

Abstract — We show that when memory is bounded, i.e. buckets are finite, dynamic hash tables that allow insertions and deletions behave significantly worse than their static counterparts that only allow insertions. This behavior differs from previous results in which, when memory is unbounded, the two models behave similarly. We show the decrease in performance in dynamic hash tables using several hash-table schemes. We also provide tight upper and lower bounds on the achievable overflow fractions in these schemes. Finally, we propose an architecture with contentaddressable memory (CAM), which mitigates this decrease in performance. A. Background I.

Although NAND flash-based solid-state drives (SSDs) excel magnetic disks in several aspects, the costs of write operations have been limiting their performance. The overheads of write operations are exacerbated by the fixed write unit (page) of flash memory, which is much larger than the sector size in magnetic disks. A write request from a file system, with a data size smaller than a page, becomes a full page write in SSDs. With the page size hidden internally in SSDs, file systems and applications may not be optimized to a fixed page size. Furthermore, to increase the density and bandwidth of flash memory, page sizes in SSDs have been increasing. In this paper, we propose a sector-level data management mechanism for SSDs, called sector log. Sector log manages a small part of NAND flash memory in SSDs with sectorlevel mapping, and stores sub-page writes more efficiently than conventional SSDs. While current small DRAM buffers cannot absorb the working set of sub-page writes for certain applications, sector log uses ample persistent storage in flash memory. With the sector mapping mechanism, sector log provides a sector-accessible block device abstraction upon page-managed flash memory.