Results 1 
8 of
8
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
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.
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
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
Associate Team acronym: RADCON Principal investigator (Inria):
"... Over recent years, computing systems have seen a massive increase in parallelism and interconnectivity. Peertopeer systems, adhoc networks, sensor networks, or the “cloud ” are based on highly connected and volatile networks. Individual nodes such as cell phones, desktop computers or high perfor ..."
Abstract
 Add to MetaCart
(Show Context)
Over recent years, computing systems have seen a massive increase in parallelism and interconnectivity. Peertopeer systems, adhoc networks, sensor networks, or the “cloud ” are based on highly connected and volatile networks. Individual nodes such as cell phones, desktop computers or high performance computing systems rely on parallel processing power achieved through multiple processing units. To exploit the power of massive networks or multiple processors, algorithms must cope with the scale and asynchrony of these systems, and their inherent instability, e.g., due to node, link, or processor failures. In this research project we explore randomized algorithms for largescale networks of distributed systems, and for shared memory multiprocessor systems. For largescale networks, decentralized gossip protocols have emerged as a standard approach to achieving faulttolerant communication between nodes with simple and scalable algorithms. We will devise new gossip protocols for various complex distributed tasks, and we will explore the power and limits of gossip protocols in various settings. For shared memory systems, randomized algorithms have proved extremely useful to deal with asynchrony and failures. Sometimes probabilistic algorithms provide the only solution to a problem; sometimes they are more efficient; sometimes they are simply easier to implement. We will devise efficient algorithms for some of the fundamental problems of shared memory computing, such as mutual exclusion, renaming, and consensus.
The LevelArray: A Fast, Practical LongLived Renaming Algorithm
"... AbstractThe longlived renaming problem appears in sharedmemory systems where a set of threads need to register and deregister frequently from the computation, while concurrent operations scan the set of currently registered threads. Instances of this problem show up in concurrent implementations ..."
Abstract
 Add to MetaCart
(Show Context)
AbstractThe longlived renaming problem appears in sharedmemory systems where a set of threads need to register and deregister frequently from the computation, while concurrent operations scan the set of currently registered threads. Instances of this problem show up in concurrent implementations of transactional memory, flat combining, thread barriers, and memory reclamation schemes for lockfree data structures. In this paper, we analyze a randomized solution for longlived renaming. The algorithmic technique we consider, called the LevelArray, has previously been used for hashing and oneshot (singleuse) renaming. Our main contribution is to prove that, in longlived executions, where processes may register and deregister polynomially many times, the technique guarantees constant steps on average and O(log log n) steps with high probability for registering, unit cost for deregistering, and O(n) steps for collect queries, where n is an upper bound on the number of processes that may be active at any point in time. We also show that the algorithm has the surprising property that it is selfhealing: under reasonable assumptions on the schedule, operations running while the data structure is in a degraded state implicitly help the data structure rebalance itself. This subtle mechanism obviates the need for expensive periodic rebuilding procedures. Our benchmarks validate this approach, showing that, for typical use parameters, the average number of steps a process takes to register is less than two and the worstcase number of steps is bounded by six, even in executions with billions of operations. We contrast this with other randomized implementations, whose worstcase behavior we show to be unreliable, and with deterministic implementations, whose cost is linear in n.