A tight RMR lower bound for randomized mutual exclusion

Proceedings of the Forty-Seventh Annual ACM Symposium on Theory of Computing

Helmi

Highám

et al. 2015

Self Cite

The test-and-set object is a fundamental synchronization primitive for shared memory systems. This paper addresses the number of registers (supporting atomic reads and writes) required to implement a one-shot test-and-set object in the standard asynchronous shared memory model with n processes. The best lower bound is log n − 1 [12, 21] for obstruction-free and deadlock-free implementations, and recently a deterministic obstruction-free implementation using O( √ n) registers was presented [11]. This paper closes the gap between these existing upper and lower bounds by presenting a deterministic obstructionfree implementation of a one-shot test-and-set object from Θ(log n) registers of size Θ(log n) bits. Combining our obstruction-free algorithm with techniques from previous research [11,12], we also obtain a randomized wait-free testand-set algorithm from Θ(log n) registers, with expected step-complexity Θ(log * n) against the oblivious adversary. The core tool in our algorithm is the implementation of a deterministic obstruction-free sifter object, using only 6 registers. If k processes access a sifter, then when they have terminated, at least one and at most (2k + 1)/3 processes return "win" and all others return "lose".

Section: Efficient Siftersmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Test-and-Set in Optimal Space

Proceedings of the Forty-Seventh Annual ACM Symposium on Theory of Computing

Helmi

Highám

et al. 2015

Self Cite

Brief announcement

Proceedings of the 2012 ACM Symposium on Principles of Distributed Computing

Woelfel

2012

Self Cite

The Cache Coherent (CC) and the Distributed Shared Memory (DSM) models are standard shared memory models, and the Remote Memory Reference (RMR) complexity is considered to accurately predict the actual performance of mutual exclusion algorithms in shared memory systems. In [12] we prove a tight lower bound for the RMR complexity of deadlock-free randomized mutual exclusion algorithms in both the CC and the DSM model with an adaptive adversary. Our lower bound establishes that an adaptive adversary can schedule n processes in such a way that each enters the critical section once, and the total number of RMRs is Ω(n log n/ log log n) in expectation. This matches an upper bound of Hendler and Woelfel [14].

Randomized loose renaming in o (log log n ) time

Alistarh

Aspnes

Proceedings of the 2013 ACM Symposium on Principles of Distributed Computing

et al. 2013

Self Cite

Renaming is a classic distributed coordination task in which a set of processes must pick distinct identifiers from a small namespace. In this paper, we consider the time complexity of this problem when the namespace is linear in the number of participants, a variant known as loose renaming. We give a non-adaptive algorithm with O(log log n) (individual) step complexity, where n is a known upper bound on contention, and an adaptive algorithm with step complexity O((log log k) 2 ), where k is the actual contention in the execution. We also present a variant of the adaptive algorithm which requires O(k log log k) total process steps. All upper bounds hold with high probability against a strong adaptive adversary.We complement the algorithms with an Ω(log log n) expected time lower bound on the complexity of randomized renaming using test-and-set operations and linear space. The result is based on a new coupling technique, and is the first to apply to non-adaptive randomized renaming. Since our algorithms use O(n) test-and-set objects, our results provide matching bounds on the cost of loose renaming in this setting.