Results 11  20
of
41
A Simple LocalSpin Group Mutual Exclusion Algorithm
 IN PROCEEDINGS OF THE 18TH ANNUAL ACM SYMPOSIUM ON PRINCIPLES OF DISTRIBUTED COMPUTING
, 1999
"... This paper presents a new solution to the group mutual exclusion problem, recently posed by Joung. In this problem, processes repeatedly request access to various "sessions". It is required that distinct processes are not in different sessions concurrently, that multiple processes may be in the sa ..."
Abstract

Cited by 25 (2 self)
 Add to MetaCart
This paper presents a new solution to the group mutual exclusion problem, recently posed by Joung. In this problem, processes repeatedly request access to various "sessions". It is required that distinct processes are not in different sessions concurrently, that multiple processes may be in the same session concurrently, and that each process that tries to enter a session is eventually able to do so. This problem is a generalization of the mutual exclusion and readerswriters problems. Our algorithm and its correctness proof are substantially simpler than Joung's. This simplicity is achieved by building upon known solutions to the more specific mutual exclusion problem. Our algorithm also has various advantages over Joung's, depending on the choice of mutual exclusion algorithm used. These advantages include admitting a process to its session in constant time in the absence of contention, spinning locally in Cache Coherent (CC) and NonUniform Memory Access (NUMA) systems, an...
Laws of Order: Expensive Synchronization in Concurrent Algorithms Cannot be Eliminated
"... Building correct and efficient concurrent algorithms is known to be a difficult problem of fundamental importance. To achieve efficiency, designers try to remove unnecessary and costly synchronization. However, not only is this manual trialanderror process adhoc, time consuming and errorprone, b ..."
Abstract

Cited by 20 (1 self)
 Add to MetaCart
Building correct and efficient concurrent algorithms is known to be a difficult problem of fundamental importance. To achieve efficiency, designers try to remove unnecessary and costly synchronization. However, not only is this manual trialanderror process adhoc, time consuming and errorprone, but it often leaves designers pondering the question of: is it inherently impossible to eliminate certain synchronization, or is it that I was unable to eliminate it on this attempt and I should keep trying? In this paper we respond to this question. We prove that it is impossible to build concurrent implementations of classic and ubiquitous specifications such as sets, queues, stacks, mutual exclusion and readmodifywrite operations, that completely eliminate the use of expensive synchronization. We prove that one cannot avoid the use of either: i) readafterwrite
Bounded Concurrent TimeStamping
 SIAM JOURNAL ON COMPUTING
, 1997
"... We introduce concurrent timestamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous sharedmemory system. Concurrent timestamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
We introduce concurrent timestamping, a paradigm that allows processes to temporally order concurrent events in an asynchronous sharedmemory system. Concurrent timestamp systems are powerful tools for concurrency control, serving as the basis for solutions to coordination problems such as mutual exclusion, lexclusion, randomized consensus, and multiwriter multireader atomic registers. Unfortunately, all previously known methods for implementing concurrent timestamp systems have been theoretically unsatisfying since they require unboundedsize timestamps  in other words, unboundedsize memory. This work presents the first bounded implementation of a concurrent timestamp system, providing a modular unboundedtobounded transformation of the simple unbounded solutions to problems such as those mentioned above. It allows solutions to two formerly open problems, the boundedprobabilistic consensus problem of Abrahamson and the fifolexclusion problem of Fischer, Lynch, Burns and...
The semantics of progress in lockbased transactional memory
 IN: POPL.
, 2009
"... Transactional memory (TM) is a promising paradigm for concurrent programming. Whereas the number of TM implementations is growing, however, little research has been conducted to precisely define TM semantics, especially their progress guarantees. This paper is the first to formally define the progre ..."
Abstract

Cited by 15 (3 self)
 Add to MetaCart
Transactional memory (TM) is a promising paradigm for concurrent programming. Whereas the number of TM implementations is growing, however, little research has been conducted to precisely define TM semantics, especially their progress guarantees. This paper is the first to formally define the progress semantics of lockbased TMs, which are considered the most effective in practice. We use our semantics to reduce the problems of reasoning about the correctness and computability power of lockbased TMs to those of simple trylock objects. More specifically, we prove that checking the progress of any set of transactions accessing an arbitrarily large set of shared variables can be reduced to verifying a simple property of each individual (logical) trylock used by those transactions. We use this theorem to determine the correctness of stateoftheart lockbased TMs and highlight various configuration ambiguities. We also prove that lockbased TMs have consensus number 2. This means that, on the one hand, a lockbased TM cannot be implemented using only readwrite memory, but, on the other hand, it does not need very powerful instructions such as the commonly used compareandswap. We finally use our semantics to formally capture an inherent tradeoff in the performance of lockbased TM implementations. Namely, we show that the space complexity of every lockbased software TM implementation that uses invisible reads is at least exponential in the number of objects accessible to transactions.
Nonatomic Mutual Exclusion with Local Spinning (Extended Abstract)
, 2002
"... We present an Nprocess localspin mutual exclusion algorithm, based on nonatomic reads and writes, in which each process performs \Theta (log N) remote memory references to enter and exit its critical section. This algorithm is derived from Yang and Anderson's atomic treebased localspin algorit ..."
Abstract

Cited by 13 (3 self)
 Add to MetaCart
We present an Nprocess localspin mutual exclusion algorithm, based on nonatomic reads and writes, in which each process performs \Theta (log N) remote memory references to enter and exit its critical section. This algorithm is derived from Yang and Anderson's atomic treebased localspin algorithm in a way that preserves its time complexity. No atomic read/write algorithm with better asymptotic worstcase time complexity (under the remotememoryreferences measure) is currently known. This suggests that atomic memory is not fundamentally required if one is interested in worstcase time complexity. The same cannot be said if one is interested in fastpath algorithms (in which contentionfree time complexity is required to be O(1)) or adaptive algorithms (in which time complexity is required to be proportional to the number of contending processes). We show that such algorithms fundamentally require memory accesses to be atomic. In particular, we show that for any Nprocess nonatomic algorithm, there exists a singleprocess execution in which the lone competing process executes \Omega (log N / log log N) remote operations to enter its critical section. Moreover, these operations must access \Omega (plog N / log log N) distinct variables, which implies that fast and adaptive algorithms are impossible even if caching techniques are used to avoid accessing the processorstomemory interconnection network.
Lamport on Mutual Exclusion: 27 Years of Planting Seeds
 In 20th ACM Symposium on Principles of Distributed Computing
, 2001
"... Mutual exclusion is a topic that Leslie Lamport has returned to many times throughout his career. This article, which is being written in celebration of Lamport's sixtieth birthday, is an attempt to survey some of his many contributions to research on this topic. ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
Mutual exclusion is a topic that Leslie Lamport has returned to many times throughout his career. This article, which is being written in celebration of Lamport's sixtieth birthday, is an attempt to survey some of his many contributions to research on this topic.
Dijkstra's SelfStabilizing Algorithm in Unsupportive Environments
 Proc. Fifth Workshop SelfStabilizing Systems (WSS 2001
, 2001
"... The rst selfstabilizing algorithm published by Dijkstra in 1973 assumed the existence of a central daemon, that activates one processor at time to change state as a function of its own state and the state of a neighbor. Subsequent research has reconsidered this algorithm without the assumption ..."
Abstract

Cited by 9 (2 self)
 Add to MetaCart
The rst selfstabilizing algorithm published by Dijkstra in 1973 assumed the existence of a central daemon, that activates one processor at time to change state as a function of its own state and the state of a neighbor. Subsequent research has reconsidered this algorithm without the assumption of a central daemon, and under dierent forms of communication, such as the model of link registers. In all of these investigations, one common feature is the atomicity of communication, whether by shared variables or read/write registers. This paper weakens the atomicity assumptions for the communication model, proposing versions of Dijkstra's algorithm that tolerate various weaker forms of atomicity, including cases of regular and safe registers. The paper also presents an implementation of Dijkstra's algorithm based on registers that have probabilistically correct behavior, which requires a notion of weak stabilization, where Markov chains are used to evaluate the probability to be in a safe con guration.
SelfStabilizing lExclusion
, 2001
"... Our work presents a selfstabilizing solution to the lexclusion problem. This problem is a wellknown generalization of the mutualexclusion problem in which up to l, but never more than l, processes are allowed simultaneously in their critical sections. Selfstabilization means that even when trans ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
Our work presents a selfstabilizing solution to the lexclusion problem. This problem is a wellknown generalization of the mutualexclusion problem in which up to l, but never more than l, processes are allowed simultaneously in their critical sections. Selfstabilization means that even when transient failures occur and some processes crash, the system finally resumes its regular and correct behavior. The model of communication assumed here is that of shared memory, in which processes use singlewriter multiplereader regular registers.
Lower Bounds in Distributed Computing
, 2000
"... This paper discusses results that say what cannot be computed in certain environments or when insucient resources are available. A comprehensive survey would require an entire book. As in Nancy Lynch's excellent 1989 paper, \A Hundred Impossibility Proofs for Distributed Computing" [86], we shall re ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
This paper discusses results that say what cannot be computed in certain environments or when insucient resources are available. A comprehensive survey would require an entire book. As in Nancy Lynch's excellent 1989 paper, \A Hundred Impossibility Proofs for Distributed Computing" [86], we shall restrict ourselves to some of the results we like best or think are most important. Our aim is to give you the avour of the results and some of the techniques that have been used. We shall also mention some interesting open problems and provide an extensive list of references. The focus will be on results from the past decade.
Group Mutual Exclusion in Tree Networks
 Journal of Information Science and Engineering
, 2003
"... The group mutual exclusion (GME) problem deals with sharing a set of (m) mutually exclusive resources among all (n) processes of a network. Processes are allowed to be in a critical section simultaneously provided they request the same resource. We present three group mutual exclusion solutions for ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
The group mutual exclusion (GME) problem deals with sharing a set of (m) mutually exclusive resources among all (n) processes of a network. Processes are allowed to be in a critical section simultaneously provided they request the same resource. We present three group mutual exclusion solutions for tree networks. All three solutions do not use process identifiers and use bounded size messages. They achieve the best contextswitch complexity, which is O(min(n, m)). The first solution uses a fixed root of the tree and uses 0 to O(n) messages per critical section entry. This solution supports an unbounded degree of concurrency, thus providing the maximum resource utilization. The second solution also uses a fixed root, but uses a reduced number of messages for the critical section entry. It generates an average of O(log n) messages per critical section entry and also allows an unbounded degree of concurrency. We remove the restriction of using a fixed root in the third solution in addition to maintaining all other desirable properties of the second solution.