Efficient Wait-Free Linearizable Implementations of Approximate Bounded Counters Using Read-Write Registers
<|reference_start|>Efficient Wait-Free Linearizable Implementations of Approximate Bounded Counters Using Read-Write Registers: 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.<|reference_end|>
@article{johnen2024efficient,
    title={Efficient Wait-Free Linearizable Implementations of Approximate Bounded
  Counters Using Read-Write Registers},
    author={Colette Johnen, Adnane Khattabi, Alessia Milani, Jennifer L. Welch},
    journal={arXiv preprint arXiv:2402.14120},
    year={2024},
    archivePrefix={arXiv},
    eprint={2402.14120},
    primaryClass={cs.DC}
}