We establish a lower bound of 23 N= log log N) remote memory references for N-process mutual exclusion algorithms based on reads, writes, or comparison primitives such as test-and-set and compareand -swap. Our bound improves an earlier lower bound of 32 log N= log log log N) established by Cypher. Our lower bound is of importance for two reasons. First, it almost matches the (log N) time complexity of the best-known algorithms based on reads, writes, or comparison primitives. Second, our lower bound suggests that it is likely that, from an asymptotic standpoint, comparison primitives are no better than reads and writes when implementing local-spin mutual exclusion algorithms. Thus, comparison primitives may not be the best choice to provide in hardware if one is interested in scalable synchronization.

Abstract not found

We present an N-process local-spin mutual exclusion algorithm, based on nonatomic reads and writes, in which each process performs \Theta (log N) remote memory references to enter and exit its critical section. This algorithm is derived from Yang and Anderson's atomic tree-based local-spin algorithm in a way that preserves its time complexity. No atomic read/write algorithm with better asymptotic worst-case time complexity (under the remote-memory-references measure) is currently known. This suggests that atomic memory is not fundamentally required if one is interested in worst-case time complexity. The same cannot be said if one is interested in fast-path algorithms (in which contention-free time complexity is required to be O(1)) or adaptive algorithms (in which time complexity is required to be proportional to the number of contending processes). We show that such algorithms fundamentally require memory accesses to be atomic. In particular, we show that for any N-process nonatomic algorithm, there exists a single-process execution in which the lone competing process executes \Omega (log N / log log N) remote operations to enter its critical section. Moreover, these operations must access \Omega (plog N / log log N) distinct variables, which implies that fast and adaptive algorithms are impossible even if caching techniques are used to avoid accessing the processors-to-memory interconnection network.

We consider the problem of wait-free implementation of a multi-writer snapshot object with m >= 2 components shared by n > m processes. It is known that this can be done using m multi-writer registers. We give a matching lower bound, slightly improving the previous space lower bound. The main focus of the paper, however, is on time complexity. The best known upper bound on the number of steps a process has to take to perform one operation of the snapshot is O(n). When m is much smaller than n, an implementation whose time complexity is a function of m rather than n would be better. We show that this cannot be achieved for any space-optimal implementation: We prove that \Omega\Gamma n) steps are required to perform a SCAN operation in the worst case, even if m = 2. This significantly improves previous \Omega\Gammavio (m; n)) lower bounds. Our proof also yields insight into the structure of any space-optimal implementation, showing that processes simulating the snapshot operations must access the registers in a very constrained way.

A snapshot object consists of a collection of m > 1 components, each capable of storing a value, shared by n processes in an asynchronous shared-memory distributed system. It supports two operations: a process can UPDATE any individual component or atomically SCAN the entire collection to obtain the values of all the components. It is possible to implement a snapshot object using m registers so that each operation takes O(mn) time.

Abstract. This paper introduces a new interesting research question concerning tasks. The weak-test-and-set task has a uniform solution that requires only two Multi-Writer Multi-Reader (MWMR) registers. Recently it was shown that if we take the long-lived version and require a step complexity that is adaptive to interval contention then, like mutual exclusion, no solution with finitely many MWMR registers is possible. Here we show that there are simple tasks which provably cannot be solved uniformly with finitely many MWMR registers. This opens up the research question of when a task is uniformly solvable using only finitely many MWMR registers. 1

An adaptive algorithm, whose step complexity adjusts to the number of active processes, is attractive for situations in which the number of participating processes is highly variable. This paper studies the number and type of multiwriter registers that are needed for adaptive algorithms. We prove that if a collect algorithm is f-adaptive to total contention, namely, its step complexity is f(k), where k is the number of processes that ever tooka step, then it uses Ω(f −1 (n)) multi-writer registers, where n is the total number of processes in the system. Furthermore, we show that competition for the underlying registers is inherent for adaptive collect algorithms. We consider c-write registers, to which at most c processes can be concurrently about to write. Special attention is given to exclusive-write registers, the case c = 1 where no competition is allowed, and concurrent-write registers, the case c = n where any amount of competition is allowed. A collect algorithm is f-adaptive to point contention, if its step complexity is f(k), where k is the maximum number of simultaneously active processes. Such an algorithm is shown to require Ω(f −1 ( n c)) concurrent-write registers, even if an un-limited number of c-write registers are available. A smaller lower bound is also obtained in this situation for collect algorithms that are f-adaptive to total contention. The lower bounds also hold for nondeterministic implementations of sensitive objects from historyless objects. Finally, we present lower bounds on the step complexity in solo executions (i.e., without any contention), when only c-write registers are used: For weaktest&set objects, we log n present an Ω() lower bound. Our lower bound log c+log log n for collect and sensitive objects is Ω ( n−1 c).

Abstract. We introduce a novel term, memory-adaptive, that intuitively captures what it means for a distributed protocol to most efficiently make use of its shared memory. We also prove three results that relate to our memory-adaptive model. In our store/release protocols processors are required to store a value in shared MWMR memory so that it cannot be overwritten until it has been released by the processor. We show that there do not exist uniformly wait-free store/release protocols using only the basic operations read and write that are memory-adaptive to point contention. We further show that there exists a uniformly waitfree store/release protocol using only the basic operations read and write that is memory-adaptive to total contention. We finally show that there exists a uniformly wait-free store/release protocol using only the basic operations read, write, and write-plus that is memory-adaptive to interval contention and time-adaptive to total contention. 1

this paper. Motivated by their first work Moir and Anderson developed renaming algorithms, in the read/write model, when such a bound on the maximum number of processes is known in advance. This led to a sequence of works on the renaming problem in this model [MA95, MG96, BGHM95] that lead to a long-lived (2K \Gamma 1)-renaming algorithm with O(K ) step complexity and O(K space complexity [Moi98]. These works employed various variants of the splitter building block which is a descendant of Lamport's adaptive mutual exclusion algorithm, however the last one [Moi98] depends on an additional work which is the first long-lived renaming algorithm by Burns and Peterson [BP89]

Abstract We consider the time complexity of shared-memory mutual exclusion algorithms based on reads, writes, and comparison primitives under the remote-memory-reference (RMR) time measure. For asynchronous systems, a lower bound of \Omega (log N / log log N) RMRs per critical-section entry has been established in previous work, where N is the number of processes. Also, algorithms with O(log N) time complexity are known. Thus, for algorithms in this class, logarithmic or near-logarithmic RMR time complexity is fundamentally required.