A time complexity lower bound for randomized implementations of some shared objects

Many recent wait-free implementations are based on a sharedmemory that supports a pair of synchronization operations, known as LL and SC. In this paper, we establish an intrinsic performance limitation of these operations: even the simple wakeup problem [16], which requires some process to detect that all n processes are up, cannot be solved unless some process performs Ω(logn) shared-memory operations. Using this basic result, we derive a Ω(logn) lower bound on the worst-case shared-access time complexity of n-process implementations of several types of objects, including fetch&increment, fetch&multiply, fetch&and, queue, and stack. (The worst-case shared-access time complexity of an implementation is the number of shared-memory operations that a process performs, in the worst-case, in order to complete a single operation on the implementation.) Our lower bound is strong in several ways: it holds even if (1) shared-memory has an infinite number of words, each of unbounded size, (2) shared-memory supports move and swap operations in addition to LL, SC, and validate, (3) implementation employs randomization (in this case, the worst-case expected shared-access time complexity is Ω(log n)), and (4) each process applies only one operation on the implemented object. Finally, the lower bound is tight: if the size of shared registers is not restricted, the universal construction of Afek, Dauber, and Touitou [1] (after two minor modifications) has O(log n) worst-case shared-access time complexity. An n-process universal construction can be instantiated with the sequential specification of any type T to obtain a wait-free implementation of an atomic object of type T that n concurrent processes can share. A universal construction is oblivious if it does not exploit the semantics of the type that it is instantiated with. Our lower bound implies that for any shared object O implemented using any oblivious universal construction, no matter what O’s type is, in the worst-case a process performs Ω(log n) operations on shared∗This work is partially supported by NSF RIA grant CCR9410421. memory in order to complete a single operation on O. Thus, if our goal is to implement shared objects whose operations run in sublogarithmic time (preferably constant time), oblivious universal constructions cannot be useful; the design of sublogarithmic time implementations must necessarily exploit the semantics of the type being implemented.