Results 1  10
of
15
Gossip Protocols for Renaming and Sorting
 DISC 27TH INTERNATIONAL SYMPOSIUM ON DISTRIBUTED COMPUTING
, 2013
"... We devise efficient gossipbased protocols for some fundamental distributed tasks. The protocols assume an nnode network supporting pointtopoint communication, and in every round, each node exchanges information of size O(log n) bits with (at most) one other node. We first consider the renaming ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
We devise efficient gossipbased protocols for some fundamental distributed tasks. The protocols assume an nnode network supporting pointtopoint communication, and in every round, each node exchanges information of size O(log n) bits with (at most) one other node. We first consider the renaming problem, that is, to assign distinct IDs from a small ID space to all nodes of the network. We propose a renaming protocol that divides the ID space among nodes using a natural push or pull approach, achieving logarithmic round complexity with ID space {1,..., (1 + ɛ)n}, for any fixed ɛ> 0. A variant of this protocol solves the tight renaming problem, where each node obtains a unique ID in {1,..., n}, in O(log² n) rounds. Next we study the following sorting problem. Nodes have consecutive IDs 1 up to n, and they receive numerical values as inputs. They then have to exchange those inputs so that in the end the input of rank k is located at the node with ID k. Jelasity and Kermarrec [20] suggested a simple and natural protocol, where nodes exchange values with peers chosen uniformly at random, but it is not hard to see that this protocol requires Ω(n) rounds. We prove that the same protocol works in O(log² n) rounds if peers are chosen according to a nonuniform power law distribution.
PThe SprayList: A Scalable Relaxed Priority Queue ∗
"... on sis te nt * Complete * ..."
(Show Context)
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
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.
Early Deciding Synchronous Renaming in O(log f) Rounds or Less
"... Abstract. Renaming is a fundamental problem in distributed computing, in which a set of n processes need to pick unique names from a namespace of limited size. In this paper, we present the first earlydeciding upper bounds for synchronous renaming, in which the running time adapts to the actual num ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Renaming is a fundamental problem in distributed computing, in which a set of n processes need to pick unique names from a namespace of limited size. In this paper, we present the first earlydeciding upper bounds for synchronous renaming, in which the running time adapts to the actual number of failures f in the execution. We show that, surprisingly, renaming can be solved in constant time if the number of failures f is limited to O ( √ n), while for general f ≤ n − 1 renaming can always be solved in O(log f) communication rounds. In the waitfree case, i.e. for f = n − 1, our upper bounds match the Ω(log n) lower bound of Chaudhuri et al. [13]. 1
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.
Lower bounds for restricteduse objects
 In TwentyFourth ACM Symposium on Parallel Algorithms and Architectures
, 2012
"... ABSTRACT Concurrent objects play a key role in the design of applications for multicore architectures, making it imperative to precisely understand their complexity requirements. For some objects, it is known that implementations can be significantly more efficient when their usage is restricted. ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
ABSTRACT Concurrent objects play a key role in the design of applications for multicore architectures, making it imperative to precisely understand their complexity requirements. For some objects, it is known that implementations can be significantly more efficient when their usage is restricted. However, apart from the specific restriction of oneshot implementations, where each process may apply only a single operation to the object, very little is known about the complexities of objects under general restrictions. This paper draws a more complete picture by defining a large class of objects for which an operation applied to the object can be "perturbed" L consecutive times, and proving lower bounds on the time and space complexity of deterministic implementations of such objects. This class includes boundedvalue max registers, limiteduse approximate and exact counters, and limiteduse collect and compareandswap objects; L depends on the number of times the object can be accessed or the maximum value it supports. For implementations that use only historyless primitives, we prove lower bounds of Ω(min(log L, n)) on the worstcase step complexity of an operation, where n is the number of processes; we also prove lower bounds of Ω(min(L, n)) on the space complexity of these objects. When arbitrary primitives can be used, we prove that either some operation incurs Ω(min(log L, n)) memory stalls or some operation performs Ω(min(log L, n)) steps. * Supported in part by the Israel Science Foundation (grant number 1227/10). † Supported by the Simons Postdoctoral Fellows Program ‡ Supported in part by the Israel Science Foundation (grant number 1227/10). Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. In addition to these deterministic lower bounds, the paper establishes a lower bound on the expected step complexity of restricteduse randomized approximate counting in a weak oblivious adversary model.
The SprayList: A Scalable Relaxed Priority Queue
, 2015
"... Highperformance concurrent priority queues are essential for applications such as task scheduling and discrete event simulation. Unfortunately, even the best performing implementations do not scale past a number of threads in the single digits. This is because of the sequential bottleneck in access ..."
Abstract
 Add to MetaCart
(Show Context)
Highperformance concurrent priority queues are essential for applications such as task scheduling and discrete event simulation. Unfortunately, even the best performing implementations do not scale past a number of threads in the single digits. This is because of the sequential bottleneck in accessing the elements at the head of the queue in order to perform a DeleteMin operation. In this thesis, we present the SprayList, a scalable priority queue with relaxed ordering semantics. Starting from a nonblocking SkipList, the main innovation behind our design is that the DeleteMin operations avoid a sequential bottleneck by “spraying ” themselves onto the head of the SkipList list in a coordinated fashion. The spraying is implemented using a carefully designed random walk, so that DeleteMin returns an element among the first
Randomized loose renaming in O(log log n) time Randomized Loose Renaming in O(log log n) Time
"... 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 renamin ..."
Abstract
 Add to MetaCart
(Show Context)
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 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. 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 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.
Randomized Loose Renaming in O(log log n) Time (Extended Abstract)
, 2013
"... 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)²), 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 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
, 2013
"... 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)²), 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.