Tiny Pointers

Abstract: This paper introduces a new data-structural object that we call the tiny pointer. In many applications, traditional $\log n $-bit pointers can be replaced with $o (\log n )$-bit tiny pointers at the cost of only a constant-factor time overhead. We develop a comprehensive theory of tiny pointers, and give optimal constructions for both fixed-size tiny pointers (i.e., settings in which all of the tiny pointers must be the same size) and variable-size tiny pointers (i.e., settings in which the average tiny-pointer size must be small, but some tiny pointers can be larger). If a tiny pointer references an element in an array filled to load factor $1 - 1 / k$, then the optimal tiny-pointer size is $\Theta(\log \log \log n + \log k) $ bits in the fixed-size case, and $ \Theta (\log k) $ expected bits in the variable-size case. Our tiny-pointer constructions also require us to revisit several classic problems having to do with balls and bins; these results may be of independent interest. Using tiny pointers, we revisit five classic data-structure problems: the data-retrieval problem, succinct dynamic binary search trees, space-efficient stable dictionaries, space-efficient dictionaries with variable-size keys, and the internal-memory stash problem. These are all well-studied problems, and in each case tiny pointers allow for us to take a natural space-inefficient solution that uses pointers and make it space-efficient for free.

• The paper introduces "tiny pointers," a data structure technique compressing traditional $\log n$-bit pointers to $o(\log n)$ bits with constant-factor time overhead by leveraging prior information via a dereference table.
• It establishes tight asymptotic bounds showing fixed-size tiny pointers require $\Omega(\log\log\log n + \log \delta^{-1})$ bits, while variable-size ones achieve an optimal expected size of $O(1 + \log\delta^{-1})$ for load factor $1-\delta$.
• Tiny pointers enable significant improvements in data structures, offering applications like succinct binary search trees, space-efficient dictionaries supporting variable sizes or stable configurations, and optimized internal-memory stashes for external data.

This paper introduces the concept of a "tiny pointer," a novel data-structural object designed to compress traditional $\log n$-bit pointers into $o(\log n)$ bits, incurring only a constant-factor time overhead. The paper establishes a comprehensive theory of tiny pointers and presents optimal constructions for both fixed-size and variable-size tiny pointers. It also revisits classic problems related to balls and bins.

The core idea behind tiny pointers is to exploit prior information about a pointer, such as the identity of its owner, to circumvent the information-theoretic $\log n$ lower bound. The paper introduces the concept of a dereference table, comprising algorithms for allocation, dereferencing, and freeing tiny pointers, along with an array $A$ and associated metadata $M$. The dereference table stores $b$-bit values in an array of $nb$ bits and utilizes $O(n)$ bits of metadata. It is said to support a load factor of $1 - \delta$ if it can store $(1 - \delta)n$ values simultaneously.

The paper presents tradeoffs between the load factor $o(\log n)$0 and the tiny-pointer size $o(\log n)$1. For fixed-size tiny pointers, the optimal size is $o(\log n)$2 bits when the array is filled to a load factor of $o(\log n)$3. For variable-size tiny pointers, the expected size is $o(\log n)$4 bits under the same load factor.

The paper outlines five applications of tiny pointers to classic data-structure problems:

• Storing $o(\log n)$5 $o(\log n)$6-bit values for $o(\log n)$7 keys with constant-time modifications/queries in $o(\log n)$8 bits, for any constant $o(\log n)$9, by storing a tiny pointer of expected size $\log n$0 with each key. Here, $\log n$1 represents the $\log n$2-th iterated logarithm.
• Making any binary search tree succinct with constant-factor time overhead, achieving $\log n$3 bits of optimal space with $\log n$4-time modifications, even for rotation-based trees like splay trees and red-black trees.
• Creating stable fixed-capacity key-value dictionaries (where items do not move after insertion) with constant-time overhead and $\log n$5 space overhead.
• Enabling key-value dictionaries with uniform-size values to support arbitrary-size values with constant-time overhead, consuming an additional $\log n$6 bits per $\log n$7-bit value for any constant $\log n$8.
• Maintaining an internal-memory stash of size $\log n$9 bits for an external-memory array $A$0 of size $A$1 containing up to $A$2 key-value pairs, allowing constant-time computation of any key-value pair's location in $A$3 without I/O operations.

Constructing Optimal Tiny Pointers

The paper establishes tight asymptotic bounds for the relationship between tiny-pointer size $A$4 and the dereference-table load factor $A$5.

For fixed-size tiny pointers, a lower bound of $A$6 exists on the tiny-pointer size $A$7 for any load factor $A$8. Conversely, a fixed tiny-pointer size of $A$9 is achievable, and a lower bound confirms the tightness of this tradeoff curve.

For variable-size tiny pointers, the $M$0 barrier can be overcome. The paper demonstrates that for any load factor $M$1, an average tiny-pointer size of $M$2 is attainable, and this tradeoff curve is tight for all $M$3. The construction provides a strong concentration bound on each tiny pointer's size: for an expected size of $M$4, the probability of a tiny pointer exceeding $M$5 for any $M$6 diminishes doubly exponentially in $M$7. The dereference-table constructions guarantee constant-time operations with high probability (w.h.p.), specifically $M$8.

Relationship to Balls and Bins

The paper reinterprets the tiny-pointer results in the context of balls and bins, improving bounds for dynamic load balancing under specific parameter conditions.

In this context, keys are viewed as balls assigned to distinct bins. Each ball $M$9 has a probe sequence $b$0 of bins where it can be placed. Supporting tiny pointers of size $b$1 is equivalent to maintaining a dynamic balls-to-bins assignment such that each ball $b$2 is in some bin $b$3 satisfying $b$4.

The dynamic aspect of the problem arises from the repeated insertion, removal, and reinsertion of balls over time. The paper introduces techniques that allow for small probe complexity (and thus small tiny pointers) for an arbitrary sequence of ball insertions and removals.

Applications to Data Structures

The paper outlines five applications of tiny pointers in more detail. The applications include the classic data-structural problem of storing a dynamic set of values associated with keys, black-box transformations that remove space inefficiency from large classes of data structures, and a new data structure for a classic problem in external-memory storage.

Overcoming the $b$5-bit Lower Bound for the Cost of Data Retrieval

The first application revisits the classic data-retrieval problem, where a data structure stores a $b$6-bit value for each of the $b$7-bit keys in some set $b$8 and answers queries to retrieve the value associated with a given key. By modifying the specification of the retrieval problem, the $b$9-wasted-bits-per-item lower bound can be dissolved. The paper introduces the relaxed retrieval problem, in which, when the user inserts a key/value pair $nb$0, they are given back a small hint $nb$1 (tiny retriever) that they are responsible for storing. Later, when the user wishes to recover the value $nb$2 for $nb$3, they present both the key $nb$4 and the hint $nb$5 to the retrieval data structure. Tiny retrievers of expected size $nb$6 are constructed, supporting queries in constant time (with high probability). Using time $nb$7 for insertions/deletions, the size of the data structure becomes $nb$8 bits.

Succinct Rotation-Based Binary Search Trees

The paper gives a randomized black-box approach for transforming dynamic binary search trees into succinct data structures. For $nb$9 keys in the succinct search tree, each of which is $O(n)$0 bits long, the size of the succinct search tree will be $O(n)$1 bits. The transformation induces only a constant-factor time overhead on query operations, and only an $O(n)$2-factor time overhead on tree modifications.

Space-Efficient Stable Dictionaries

The paper introduces a black-box approach for transforming any fixed-capacity key-value dictionary into a stable dictionary with the same operation set and only a constant-factor time overhead. If the original dictionary stores $O(n)$3-bit values, the new stable dictionary stores $O(n)$4-bit values, and uses an additive $O(n)$5-bit space overhead per value.

Space-Efficient Dictionaries with Variable-Size Values

The paper introduces a black-box approach for transforming any key-value dictionary (designed to store fixed-size values) into a dictionary that can store different-sized values for different keys. The resulting data structure induces a constant-factor time overhead and offers a space overhead of only $O(n)$6 bits for each value $O(n)$7, where $O(n)$8 is the $O(n)$9-th iterated logarithm and $1 - \delta$0 is an arbitrary constant.

An Optimal Internal-Memory Stash

The paper revisits one of the oldest problems in external-memory data structures: maintaining a small internal-memory stash that allows direct location of elements in a large external-memory array. By combining tiny pointers with modern techniques for constructing space-efficient filters, the paper constructs a stash of size $1 - \delta$1 bits that supports constant-time operations in the RAM model (with high probability) and supports arbitrary sequences of insertions/deletions/queries.

Preliminaries

A dereference table with $1 - \delta$2-bit-values is a data structure that supports the following operations:

• $1 - \delta$3: Creates a new dereference table, and returns a pointer to an array with $1 - \delta$4 slots, each of size $1 - \delta$5 bits. This array is called the store.
• $1 - \delta$6: Given a key $1 - \delta$7, allocates a slot in the store to $1 - \delta$8, and returns a bit string $1 - \delta$9, called a tiny pointer.
• $(1 - \delta)n$0: Given a key $(1 - \delta)n$1 and a tiny pointer $(1 - \delta)n$2, returns the index of the slot allocated to $(1 - \delta)n$3 in the store.
• $(1 - \delta)n$4: Given a key $(1 - \delta)n$5 and a tiny pointer $(1 - \delta)n$6, deallocates slot $(1 - \delta)n$7 from $(1 - \delta)n$8.

The dereference table may store metadata in order to perform updates efficiently. Metadata can either be stored as part of the store, or in an auxiliary data structure that is permitted to consume up to $(1 - \delta)n$9 bits.

Any implementation of a dereference table must also specify an additional parameter $o(\log n)$00 dictating how full the table is allowed to be. The dereference table can support up to $o(\log n)$01 allocations at a time.

Upper Bound for Fixed-Size Pointers

The paper proves that for every $o(\log n)$02 there is a dereference table that succeeds on each allocation w.h.p., has load factor at least $o(\log n)$03, has constant-time updates w.h.p., and has tiny pointers of size $o(\log n)$04.

Upper Bounds for Variable-Sized Pointers

The paper proves that for every $o(\log n)$05, there exists a dereference table that succeeds on each allocation w.h.p., has load factor at least $o(\log n)$06, has constant-time updates w.h.p., and has tiny pointer size $o(\log n)$07, where $o(\log n)$08 is a random variable such that $o(\log n)$09 for all $o(\log n)$10.

Lower Bounds

The paper proves that the bounds in the upper-bound theorems are tight. Specifically, if a dereference table supports variable-sized tiny pointers of expected size $o(\log n)$11 and load factor $o(\log n)$12, then $o(\log n)$13. Additionally, if a dereference table supports fixed-sized tiny pointers of size $o(\log n)$14 and load factor $o(\log n)$15, then $o(\log n)$16.

Dynamic Balls and Bins

The paper improves the state of the art for the classic dynamic load balancing problem. It introduces a bin-selection rule with $o(\log n)$17 hash functions that achieves maximum load $o(\log n)$18. The construction can be reinterpreted as a result about probe-complexity of balls-and-bins schemes with bins of capacity $o(\log n)$19, giving the first dynamic ball-allocation scheme to offer $o(\log n)$20 average probe complexity in the setting where there are up to $o(\log n)$21 balls present in the system at a time.