Results 1  10
of
14
The Complexity of Renaming
"... We study the complexity of renaming, a fundamental problem in distributed computing in which a set of processes need to pick distinct names from a given namespace. We prove an individual lower bound of Ω(k) process steps for deterministic renaming into any namespace of size subexponential in k, whe ..."
Abstract

Cited by 15 (10 self)
 Add to MetaCart
(Show Context)
We study the complexity of renaming, a fundamental problem in distributed computing in which a set of processes need to pick distinct names from a given namespace. We 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. This bound is tight: it draws an exponential separation between deterministic and randomized solutions, and implies new tight bounds for deterministic fetchandincrement registers, queues and stacks. The proof of the bound is interesting in its own right, for it relies on the first reduction from renaming to another fundamental problem in distributed computing: mutual exclusion. We complement our 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 applies to randomized algorithms against a strong adversary, and helps derive new global lower bounds for randomized approximate counter and fetchandincrement implementations, all tight within logarithmic factors. 1
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.
Sublogarithmic testandset against a weak adversary
 In Distributed Computing: 25th International Symposium, DISC 2011
"... Abstract. A randomized implementation is given of a testandset register with O(log log n) individual step complexity and O(n) total step complexity against an oblivious adversary. The implementation is linearizable and multishot, and shows an exponential complexity improvement over previous solut ..."
Abstract

Cited by 13 (7 self)
 Add to MetaCart
Abstract. A randomized implementation is given of a testandset register with O(log log n) individual step complexity and O(n) total step complexity against an oblivious adversary. The implementation is linearizable and multishot, and shows an exponential complexity improvement over previous solutions designed to work against a strong adversary. 1
OptimalTime Adaptive Strong Renaming, with Applications to Counting (Extended Abstract)
 PODC 2011, SAN JOSE USA
, 2011
"... We give two new randomized algorithms for strong renaming, both of which work against an adaptive adversary in asynchronous shared memory. The first uses repeated sampling over a sequence of arrays of decreasing size to assign unique names to each of n processes with step complexity O(log³ n). The s ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
(Show Context)
We give two new randomized algorithms for strong renaming, both of which work against an adaptive adversary in asynchronous shared memory. The first uses repeated sampling over a sequence of arrays of decreasing size to assign unique names to each of n processes with step complexity O(log³ n). The second transforms any sorting network into a strong adaptive renaming protocol, with an expected cost equal to the depth of the sorting network. Using an AKS sorting network, this gives a strong adaptive renaming algorithm with step complexity O(log k), where k is the contention in the current execution. We show this to be optimal based on a classic lower bound of Jayanti. We also show that any such strong renaming protocol can be used to build a monotoneconsistent counter with logarithmic step complexity (at the cost of adding a max register) or a linearizable fetchandincrement register (at the cost of increasing the step complexity by a logarithmic factor).
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.
The Strong AtMostOnce Problem
"... Abstract. The atmostonce problem in shared memory asks for the completion of a number of tasks by a set of independent processors while adhering to “at most once ” semantics. Atmostonce algorithms are evaluated in terms of effectiveness, which is a measure that expresses the total number of tas ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. The atmostonce problem in shared memory asks for the completion of a number of tasks by a set of independent processors while adhering to “at most once ” semantics. Atmostonce algorithms are evaluated in terms of effectiveness, which is a measure that expresses the total number of tasks completed atmostonce in the worst case. Motivated by the lack of deterministic solutions with high effectiveness, we study the feasibility of (a close variant of) this problem. The strong at most once problem is solved by an atmostone algorithm when all tasks are performed if no participating processes crash during the execution of the algorithm. We prove that the strong atmostonce problem has consensus number 2. This explains, via impossibility, the lack of waitfree deterministic solutions with high effectiveness for the at most once problem using only read/write atomic registers. We then present the first kadaptive effectiveness optimal randomized solution for the strong atmostonce problem, that has optimal expected work for a nontrivial number of participating processes. Our solution also provides the first kadaptive randomized solution for the WriteAll problem, a dual problem to atmostonce. 1
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