Results 11  20
of
22
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.
SoloValency and the Cost of Coordination
, 2007
"... This paper introduces solovalency, a variation on the valency proof technique originated by Fischer, Lynch, and Paterson. The new technique focuses on critical events that influence the responses of solo runs by individual operations, rather than on critical events that influence a protocol’s singl ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
This paper introduces solovalency, a variation on the valency proof technique originated by Fischer, Lynch, and Paterson. The new technique focuses on critical events that influence the responses of solo runs by individual operations, rather than on critical events that influence a protocol’s single decision value. It allows us to derive √ n lower bounds on the time to perform an operation for lockfree implementations of concurrent objects such as linearizable queues, stacks, sets, hash tables, counters, approximate agreement, and more. Time is measured as the number of distinct base objects accessed and the number of stalls caused by contention in accessing memory, incurred by a process as it performs a single operation. We introduce the influence level metric that quantifies the extent to which the response of a solo execution of one process can be changed by other processes. We then prove the existence of a relationship between the space complexity, latency, contention and influence level of all lockfree object implementations. Our results are broad in that they hold for implementations that may use any collection of readmodifywrite operations in addition to read and write, and in that they apply even if base objects have unbounded size. 1
Lower bounds in distributed computing
, 2008
"... Distributed computing is the study of achieving cooperative behavior between independent computing processes with possibly conflicting goals. Distributed computing is ubiquitous in the Internet, wireless networks, multicore and multiprocessor computers, teams of mobile robots, etc. In this thesis, ..."
Abstract
 Add to MetaCart
Distributed computing is the study of achieving cooperative behavior between independent computing processes with possibly conflicting goals. Distributed computing is ubiquitous in the Internet, wireless networks, multicore and multiprocessor computers, teams of mobile robots, etc. In this thesis, we study two fundamental distributed computing problems, clock synchronization and mutual exclusion. Our contributions are as follows. 1. We introduce the gradient clock synchronization (GCS) problem. As in traditional clock synchronization, a group of nodes in a bounded delay communication network try to synchronize their logical clocks, by reading their hardware clocks and exchanging messges. We say the distance between two nodes is the uncertainty in message delay between the nodes, and we say the clock skew between the nodes is their difference in logical clock values. GCS studies clock skew as a function of distance. We show that surprisingly, every clock synchronization log D algorithm exhibits some execution in which two nodes at distance one apart have Ω( log log D)
On the complexity of implementing . . .
, 2003
"... We consider shared memory systems in which asynchronous processes cooperate with each other by communicating via shared data objects, such as counters, queues, stacks, and priority queues. The common approach to implementing such shared objects is based on locking: To perform an operation on a share ..."
Abstract
 Add to MetaCart
We consider shared memory systems in which asynchronous processes cooperate with each other by communicating via shared data objects, such as counters, queues, stacks, and priority queues. The common approach to implementing such shared objects is based on locking: To perform an operation on a shared object, a process obtains a lock, accesses the object, and then releases the lock. Locking, however, has several drawbacks, including convoying, priority inversion, and deadlocks. Furthermore, lockbased implementations are not faulttolerant: if a process crashes while holding a lock, other processes can end up waiting forever for the lock. Waitfree linearizable implementations were conceived to overcome most of the above drawbacks of locking. A waitfree implementation guarantees that if a process repeatedly takes steps, then its operation on the implemented data object will eventually complete, regardless of whether other processes are slow, or fast, or have crashed. In this thesis, we first present an efficient waitfree linearizable implementation of a class of object types, called closed and closable types, and then prove time and space lower bounds on waitfree linearizable implementations of another class of object types, called perturbable types.
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.
Efficient FetchandIncrement ⋆
"... Abstract. A Fetch&Inc object stores a nonnegative integer and supports a single operation, fi, that returns the value of the object and increments it. Such objects are used in many asynchronous shared memory algorithms, such as renaming, mutual exclusion, and barrier synchronization. We present ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. A Fetch&Inc object stores a nonnegative integer and supports a single operation, fi, that returns the value of the object and increments it. Such objects are used in many asynchronous shared memory algorithms, such as renaming, mutual exclusion, and barrier synchronization. We present an efficient implementation of a waitfree Fetch&Inc object from registers and loadlinked/storeconditional (ll/sc) objects. In a system with p processes, every fi operation finishes in O(log 2 p) steps, and only a polynomial number of registers and O(log p)bit ll/sc objects are needed. The maximum number of fi operations that can be supported is limited only by the maximum integer that can be stored in a shared register. This is the first waitfree implementation of a Fetch&Inc object that achieves both polylogarithmic step complexity and polynomial space complexity, but does not require unrealistically large ll/sc objects or registers. 1
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.