Results 1  10
of
14
Fast Randomized TestandSet and Renaming ⋆
"... Abstract. 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 ..."
Abstract

Cited by 8 (7 self)
 Add to MetaCart
Abstract. 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. 1
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 5 (3 self)
 Add to MetaCart
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).
Efficient MultiWord Locking Using Randomization
, 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 3 (0 self)
 Add to MetaCart
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.
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
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
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
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
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
46 CHAPTER 5. SHARED MEMORY
"... (and return false), even if the value read by the loadlink has since been restored. • The power of RMW operations can be measured with the socalled consensusnumber: The consensusnumber k of a RMW operation defines whether one can solve consensus for k processes. Testandset for instance has cons ..."
Abstract
 Add to MetaCart
(and return false), even if the value read by the loadlink has since been restored. • The power of RMW operations can be measured with the socalled consensusnumber: The consensusnumber k of a RMW operation defines whether one can solve consensus for k processes. Testandset for instance has consensusnumber 2 (one can solve consensus with 2 processes, but not 3), whereas the consensusnumber of compareandswap is infinite. It can be shown that the power of a shared memory system is determined by the consensusnumber (“universality of consensus”.) This insight has a remarkable theoretical and practical impact. In practice for instance, after this was known, hardware designers stopped developing shared memory systems supporting weak RMW operations. • Many of the results derived in the message passing model have an equivalent in the shared memory model. Consensus for instance is traditionally studied in the shared memory model.
Tight Bounds for Asynchronous Renaming ∗
"... 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
 Add to MetaCart
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. 1