Results 1  10
of
13
On the time and space complexity of randomized testandset
 In Proc. of 31st PODC
, 2012
"... We study the time and space complexity of randomized TestAndSet (TAS) implementations from atomic read/write registers in asynchronous shared memory models with n processes. We present an adaptive TAS algorithm with an expected (individual) step complexity of O(log ∗ k), for contention k, against ..."
Abstract

Cited by 14 (7 self)
 Add to MetaCart
(Show Context)
We study the time and space complexity of randomized TestAndSet (TAS) implementations from atomic read/write registers in asynchronous shared memory models with n processes. We present an adaptive TAS algorithm with an expected (individual) step complexity of O(log ∗ k), for contention k, against the oblivious adversary, improving a previous (nonadaptive) upper bound of O(log log n) (Alistarh and Aspnes, 2011). We also present a modified version of the adaptive RatRace TAS algorithm (Alistarh et al., 2010), which improves the space complexity from O(n3) to O(n), while maintaining logarithmic expected step complexity against the adaptive adversary. We complement this upper bound with an Ω(logn) lower bound on the space complexity of any TAS algorithm that has the nondeterministic solotermination property (which is a weaker progress condition than waitfreedom). No nontrivial lower bounds on the space requirements of TAS were known prior to this work.
Faster randomized consensus with an oblivious adversary
, 2012
"... Two new algorithms are given for randomized consensus in a sharedmemory model with an oblivious adversary. Each is based on a new construction of a conciliator, an object that guarantees termination and validity, but that only guarantees agreement with constant probability. The first conciliator as ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
(Show Context)
Two new algorithms are given for randomized consensus in a sharedmemory model with an oblivious adversary. Each is based on a new construction of a conciliator, an object that guarantees termination and validity, but that only guarantees agreement with constant probability. The first conciliator assumes unitcost snapshots and achieves agreement among n processes with probability 1 − ɛ in O(log ∗ n + log(1/ɛ)) steps for each process. The second uses ordinary multiwriter registers, and achieves agreement with probability 1 − ɛ in O(log log n + log(1/ɛ)) steps. Combining these constructions with known results gives randomized consensus for arbitrarily many possible input values using unitcost snapshots in O(log ∗ n) expected steps and randomized consensus for up to O(log n log log n) possible input values using ordinary registers in O(log log n) expected steps. The possibility of further improvement is considered.
An O (√n) Space Bound for ObstructionFree Leader Election
 DISC 27TH INTERNATIONAL SYMPOSIUM ON DISTRIBUTED COMPUTING
, 2013
"... We present a deterministic obstructionfree implementation of leader election from O (√n) atomic O(log n)bit registers in the standard asynchronous shared memory system with n processes. We provide also a technique to transform any deterministic obstructionfree algorithm, in which any process can ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
We present a deterministic obstructionfree implementation of leader election from O (√n) atomic O(log n)bit registers in the standard asynchronous shared memory system with n processes. We provide also a technique to transform any deterministic obstructionfree algorithm, in which any process can finish if it runs for b steps without interference, into a randomized waitfree algorithm for the oblivious adversary, in which the expected step complexity is polynomial in n and b. This transformation allows us to combine our obstructionfree algorithm with the leader election algorithm by Giakkoupis and Woelfel [21], to obtain a fast randomized leader election (and thus testandset) implementation from O (√n) O(log n)bit registers, that has expected step complexity O(log ∗ n) against the oblivious adversary. Our algorithm provides the first sublinear space upper bound for obstructionfree leader election. A lower bound of Ω(log n) has been known since 1989 [29]. Our research is also motivated by the longstanding open problem whether there is an obstructionfree consensus algorithm which uses fewer than n registers.
Tight Bounds for Asynchronous Renaming
, 2011
"... This paper presents the first tight bounds on the complexity of sharedmemory renaming, a fundamental problem in distributed computing in which a set of processes need to pick distinct identifiers from a small namespace. We first prove an individual lower bound of Ω(k) process steps for deterministi ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
This paper presents the first tight bounds on the complexity of sharedmemory renaming, a fundamental problem in distributed computing in which a set of processes need to pick distinct identifiers from a small namespace. We first prove an individual lower bound of Ω(k) process steps for deterministic renaming into any namespace of size subexponential in k, where k is the number of participants. The bound is tight: it draws an exponential separation between deterministic and randomized solutions, and implies new tight bounds for deterministic concurrent fetchandincrement counters, queues and stacks. The proof is based on a new reduction from renaming to another fundamental problem in distributed computing: mutual exclusion. We complement this individual bound with a global lower bound of Ω(k log(k/c)) on the total step complexity of renaming into a namespace of size ck, for any c ≥ 1. This result applies to randomized algorithms against a strong adversary, and helps derive new global lower bounds for randomized approximate counter implementations, that are tight within logarithmic factors. On the algorithmic side, we give a protocol that transforms any sorting network into a strong adaptive renaming algorithm, with expected cost equal to the depth of the sorting network. This gives a tight adaptive renaming algorithm with expected step complexity O(log k), where k is the contention in the current execution. This algorithm is the first to achieve sublinear time, and it is timeoptimal as per our randomized lower bound. Finally, we use this renaming protocol to build monotoneconsistent counters with logarithmic step complexity and linearizable fetchandincrement registers with polylogarithmic cost.
Randomized Mutual Exclusion with Constant Amortized RMR Complexity on the DSM
"... Abstract—In this paper we settle an open question by determining the remote memory reference (RMR) complexity of randomized mutual exclusion, on the distributed shared memory model (DSM) with atomic registers, in a weak but natural (and stronger than oblivious) adversary model. In particular, we p ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract—In this paper we settle an open question by determining the remote memory reference (RMR) complexity of randomized mutual exclusion, on the distributed shared memory model (DSM) with atomic registers, in a weak but natural (and stronger than oblivious) adversary model. In particular, we present a mutual exclusion algorithm that has constant expected amortized RMR complexity and is deterministically deadlock free. Prior to this work, no randomized algorithm with o(logn / log logn) RMR complexity was known for the DSM model. Our algorithm is fairly simple, and compares favorably with one by Bender and Gilbert [11] for the CC model, which has expected amortized RMR complexityO(log2 logn) and provides only probabilistic deadlock freedom. KeywordsMutual exclusion; RMR complexity; shared memory; oblivious adversary; DSM I.
TestandSet in Optimal Space
"... The testandset 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 oneshot testandset object in the standard asynchronous shared memory model with n processes. The ..."
Abstract
 Add to MetaCart
(Show Context)
The testandset 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 oneshot testandset object in the standard asynchronous shared memory model with n processes. The best lower bound is logn − 1 [12, 21] for obstructionfree and deadlockfree implementations, and recently a deterministic obstructionfree 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 oneshot testandset object from Θ(logn) registers of size Θ(logn) bits. Combining our obstructionfree algorithm with techniques from previous research [11, 12], we also obtain a randomized waitfree testandset algorithm from Θ(logn) registers, with expected stepcomplexity Θ(log ∗ n) against the oblivious adversary. The core tool in our algorithm is the implementation of a deterministic obstructionfree sifter object, using only 6 registers. If k processes access a sifter, then when they have terminated, at least one and at most b(2k + 1)/3c processes return “win ” and all others return “lose”.
Randomized Loose Renaming in O(log logn) Time [Extended Abstract]
"... 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 giv ..."
Abstract
 Add to MetaCart
(Show Context)
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 nonadaptive algorithm with O(log logn) (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 logn) expected time lower bound on the complexity of randomized renaming using testandset operations and linear space. The result is based on a new coupling technique, and is the first to apply to nonadaptive randomized renaming. Since our algorithms use O(n) testandset objects, our results provide matching bounds on the cost of loose renaming in this setting.
Sublogarithmic Randomized Loose Renaming
"... 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 ..."
Abstract
 Add to MetaCart
(Show Context)
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 nonadaptive 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. Both bounds hold with high probability against a strong adaptive adversary. The running time improvement over previously known solutions is exponential. We complement the algorithms with an Ω(log log n) expected time lower bound on the complexity of randomized renaming using testandset operations and linear space. The result is based on a new coupling technique, and is the first to apply to nonadaptive randomized renaming. 1
Notes on Randomized Algorithms CS 469/569: Fall 2014
, 2014
"... Table of contents i List of figures xi List of tables xii List of algorithms xiii ..."
Abstract
 Add to MetaCart
(Show Context)
Table of contents i List of figures xi List of tables xii List of algorithms xiii
The Renaming Problem: Recent Developments and Open Questions
"... The theory of distributed computing centers around a set of fundamental problems, also known as tasks, usually considered in variants of the two classic models of distributed computation: asynchronous sharedmemory and asynchronous messagepassing [50]. These fundamental ..."
Abstract
 Add to MetaCart
(Show Context)
The theory of distributed computing centers around a set of fundamental problems, also known as tasks, usually considered in variants of the two classic models of distributed computation: asynchronous sharedmemory and asynchronous messagepassing [50]. These fundamental