Efficient Fetch-and-Increment

Abstract

Abstract.A Fetch&Inc object stores a non-negative integer and supports a single operation, fi, that returns the value of the object and increments it. Such objects are used in many asynchronous shared memory algorithms, such as renaming, mutual exclusion, and barrier synchronization. We present an efficient implementation of a wait-free Fetch&Inc object from registers and load-linked/store-conditional (ll/sc) objects. In a system with p processes, every fi operation finishes in O(log 2 p) steps, and only a polynomial number of registers and O(log p)-bit ll/sc objects are needed. The maximum number of fi operations that can be supported is limited only by the maximum integer that can be stored in a shared register. This is the first wait-free implementation of a Fetch&Inc object that achieves both poly-logarithmic step complexity and polynomial space complexity, but does not require unrealistically large ll/sc objects or registers.

Group Mutual Exclusion by Fetch-and-increment

“…The operation F &I (x ) sets the value of x to x + 1 and returns the old value of x. Compared to the F &A operation, F &I is easier to implement efficiently in both hardware and software (Ellen et al 2012;Freudenthal and Gottlieb 1991). The popular approach to design concurrent data structures is to use the most powerful synchronization primitive, namely compare-and-swap (CAS), mainly to avoid hotspot operations such as incrementing a contented shared counter.…”

“…Since the GME algorithms presented in this article require a higher level atomic instruction F &I , we compare them only with the GME algorithms requiring higher-level atomic instructions presented in the literature (Bhatt and Huang 2010;Blelloch et al 2003;Danek and Hadzilacos 2004). First, our algorithm uses the F &I instruction, which is easier to implement efficiently in both hardware and software (Ellen et al 2012;Freudenthal and Gottlieb 1991) than T &S, CAS, and F &A. All other algorithms in this class proposed in the literature use either CAS, F &A, and CAS or F &A and T &S. Second, our algorithms are simple, elegant, and scalable.…”