Results 1  10
of
22
Fast Randomized TestandSet and Renaming
"... Most people believe that renaming is easy: simply choose a name at random; if more than one process selects the same name, then try again. We highlight the issues that occur when trying to implement such a scheme and shed new light on the readwrite complexity of randomized renaming in an asynchron ..."
Abstract

Cited by 7 (6 self)
 Add to MetaCart
(Show Context)
Most people believe that renaming is easy: simply choose a name at random; if more than one process selects the same name, then try again. We highlight the issues that occur when trying to implement such a scheme and shed new light on the readwrite complexity of randomized renaming in an asynchronous environment. At the heart of our new perspective stands an adaptive implementation of a randomized testandset object, that has polylogarithmic step complexity per operation, with high probability. Interestingly, our implementation is anonymous, as it does not require process identifiers. Based on this implementation, we present two new randomized renaming algorithms. The first ensures a tight namespace of n names using O(n log 4 n) total steps, with high probability. This significantly improves on the complexity of the best previously known namespaceoptimal algorithms. The second algorithm achieves a namespace of size k(1 + ɛ) using O(k log 4 k / log 2 (1 + ɛ)) total steps, both with high probability, where k is the total contention in the execution. It is the first adaptive randomized renaming algorithm, and it improves on existing deterministic solutions by providing a smaller namespace, and by lowering step complexity.
Asynchronous Exclusive Selection
"... The distributed setting of this paper is an asynchronous system consisting of n processes prone to crashes and a number of shared readwrite registers. We consider problems regarding assigning integer values to processes in an exclusive way, in the sense that no integer is assigned to two distinct p ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
The distributed setting of this paper is an asynchronous system consisting of n processes prone to crashes and a number of shared readwrite registers. We consider problems regarding assigning integer values to processes in an exclusive way, in the sense that no integer is assigned to two distinct processes. In the problem of renaming, any k ≤ n processes, that hold original names from a range [N] = {1,..., N}, contend to acquire unique integers as new names in a smaller range [M] using some r shared registers. When k and N are known, our waitfree solution operates in O(log k(log N + log k log log N)) local steps, for M = O(k), and with r = O(k log N) auxiliary shared registers. Processes obtain new k names by exploring their neighbors in bipartite graphs of suitable expansion properties, with nodes representing names and processes competing for the name of each visited node.} local steps are required in the worst case to waitfree solve renaming, when k and N are known and r and M are given constraints. We give a fully adaptive solution, with neither k nor N known, having M = 8k − lg k − 1 as a bound on the range of new names, operating in O(k) steps and using O(n 2) registers. We apply renaming algorithms to obtain solutions to the Store&Collect problem. When both k and N are known, then storing can be performed in O(log k(log N + log k log log N)) steps and collecting in O(k) steps, for r = O(k log(N/k)) registers. We consider the problem UnboundedNaming in which processes repeatedly require new names, while no name can be reused once assigned, so that infinitely many integers need to be exclusively assigned as names. For no fixed integer i can one guarantee in a waitfree manner that i is eventually assigned to be a name, so some integers may never be used; the upper bound on the number of such unused integers is used as a measure of quality of a solution. We show that UnboundedNaming is solvable in a nonblocking way with at most n −1 integers never assigned as names, which is best possible, and in a waitfree manner with at most n(n − 1) values never assigned as names.
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 4 (2 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).
R.: Efficient multiword locking using randomization
 In: Proceedings of the 24th Annual ACM Symposium on Principles of Distributed Computing (PODC
, 2005
"... In this paper we examine the general multiword lock problem, where processes are allowed to multilock arbitrary registers. Aiming for a highly efficient solution we propose a randomized algorithm which successfully breaks long dependency chains, the crucial factor for slowing down an execution. In ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
In this paper we examine the general multiword lock problem, where processes are allowed to multilock arbitrary registers. Aiming for a highly efficient solution we propose a randomized algorithm which successfully breaks long dependency chains, the crucial factor for slowing down an execution. In the analysis we focus on the 2word lock problem and show that in this special case an execution of our algorithm takes with high probability at most time O(Δ 3 log n / log log n), where n is the number of registers and Δ the maximal number of processes interested in the same register (the contention). Furthermore, we implemented our algorithm for the general multiword lock problem on an SGI Origin2000 machine, demonstrating that our algorithm is not only of theoretical interest. Categories and Subject Descriptors
Can Memory be used adaptively by Uniform Algorithms
 Proc. 9th International Conference on Principles of Distributed Systems (OPODIS
, 2005
"... Abstract. We introduce a novel term, memoryadaptive, that intuitively captures what it means for a distributed protocol to most efficiently make use of its shared memory. We also prove three results that relate to our memoryadaptive model. In our store/release protocols processors are required to ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We introduce a novel term, memoryadaptive, that intuitively captures what it means for a distributed protocol to most efficiently make use of its shared memory. We also prove three results that relate to our memoryadaptive model. In our store/release protocols processors are required to store a value in shared MWMR memory so that it cannot be overwritten until it has been released by the processor. We show that there do not exist uniformly waitfree store/release protocols using only the basic operations read and write that are memoryadaptive to point contention. We further show that there exists a uniformly waitfree store/release protocol using only the basic operations read and write that is memoryadaptive to total contention. We finally show that there exists a uniformly waitfree store/release protocol using only the basic operations read, write, and writeplus that is memoryadaptive to interval contention and timeadaptive to total contention. 1
Chapter 5 Shared Memory
"... In distributed computing, various different models exist. So far, the focus of the course was on looselycoupled distributed systems such as the Internet, where nodes asynchronously communicate by exchanging messages. The “opposite” model is a tightlycoupled parallel computer where nodes access a c ..."
Abstract
 Add to MetaCart
In distributed computing, various different models exist. So far, the focus of the course was on looselycoupled distributed systems such as the Internet, where nodes asynchronously communicate by exchanging messages. The “opposite” model is a tightlycoupled parallel computer where nodes access a common
Slightly smaller splitter networks
, 2010
"... The classic renaming protocol of Moir and Anderson [4] uses a network of Θ(n 2) splitters to assign unique names to n processes with unbounded initial names. We show how to reduce this bound to Θ(n 3/2) splitters. 1 ..."
Abstract
 Add to MetaCart
(Show Context)
The classic renaming protocol of Moir and Anderson [4] uses a network of Θ(n 2) splitters to assign unique names to n processes with unbounded initial names. We show how to reduce this bound to Θ(n 3/2) splitters. 1
Brief Announcement: An Efficient LongLived Adaptive Collect Algorithm ⋆
"... Abstract. We present a new longlived, efficient, adaptive collect algorithm. Namely, our algorithm adapts to Kcontention it has the property that if during an operation the interval contention k exceeds a predetermined constant K the step complexity is O(N). If, it falls below K, the processors e ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We present a new longlived, efficient, adaptive collect algorithm. Namely, our algorithm adapts to Kcontention it has the property that if during an operation the interval contention k exceeds a predetermined constant K the step complexity is O(N). If, it falls below K, the processors executions will eventually have adaptive step complexity of O(k 3). Moreover, for K such that K 3 ≤ N our algorithm requires only O(N 2) shared memory registers. 1
Adaptive Algorithms using Bounded Memory are Inherently NonUniform
"... Abstract. Distributed protocols that run in dynamic environments such as the Internet are often not able to use an upper bound on the number of potentially participating processes. In these settings adaptive and uniform algorithms are desirable where the step complexity of all operations is a functi ..."
Abstract
 Add to MetaCart
Abstract. Distributed protocols that run in dynamic environments such as the Internet are often not able to use an upper bound on the number of potentially participating processes. In these settings adaptive and uniform algorithms are desirable where the step complexity of all operations is a function of the number of concurrently participating processes (adaptive) and the algorithm does not need to know an upper bound on the number of participating processes (uniform). Adaptive algorithms, however, are generally not adaptive with respect to their memory consumption if no upper bound on the number of participating processes is known in advance they require unbounded MWMR registers and an unbounded number of such registers (even if only finitely many distinct processes appear), making them impractical for real systems. In this paper we ask whether this must be the case: Can adaptive algorithms where no upper bound on the number of participating processes is known in advance be uniformly implemented with finite memory (if only finitely many distinct processes keep reappearing)? We will show that in the dynamic setting it is impossible to implement longlived adaptive splitters, collect and renaming with infinitely many bounded MWMR registers, making such adaptive algorithms impractical in dynamic settings. On the positive side we provide algorithms that implement a longlived uniform adaptive splitter if unbounded registers are available and that implement a nonuniform adaptive splitter with finitely many bounded registers if an upper bound on the number of participating processes is known in advance. 1