Efficient Wait-Free Linearizable Implementations of Approximate Bounded Counters Using Read-Write Registers
Colette Johnen, Adnane Khattabi, Alessia Milani, Jennifer L. Welch
TL;DR
The paper tackles the problem of implementing a wait-free linearizable k-multiplicative-accurate m-bounded Counter in asynchronous shared memory using read-write registers. It proposes three bucket-based algorithms that exploit max-registers and local batching to expose increments, achieving dramatically faster Read operations while maintaining correctness under the multiplicative approximation. Read complexities reach O(log log m) or O(log log_k m) with Increment complexities given by O(min or max expressions depending on k), and space usage is tuned via bucket counts and bounds. The work provides rigorous linearizability proofs and detailed complexity analyses, highlighting tradeoffs across k, m, and n and establishing new worst-case guarantees for approximate counters in the bounded setting.
Abstract
Relaxing the sequential specification of a shared object is a way to obtain an implementation with better performance compared to implementing the original specification. We apply this approach to the Counter object, under the assumption that the number of times the Counter is incremented in any execution is at most a known bound $m$. We consider the $k$-multiplicative-accurate Counter object, where each read operation returns an approximate value that is within a multiplicative factor $k$ of the accurate value. More specifically, a read is allowed to return an approximate value $x$ of the number $v$ of increments previously applied to the counter such that $v/k \le x \le vk$. We present three algorithms to implement this object in a wait-free linearizable manner in the shared memory model using read-write registers. All the algorithms have read operations whose worst-case step complexity improves exponentially on that for an exact $m$-bounded counter (which in turn improves exponentially on that for an exact unbounded counter). Two of the algorithms have read step complexity that is asymptotically optimal. The algorithms differ in their requirements on $k$, step complexity of the increment operation, and space complexity.