Results 1  10
of
40
Software transactional memory for dynamicsized data structures
 IN PROCEEDINGS OF THE 22ND ACM SYMPOSIUM ON PRINCIPLES OF DISTRIBUTED COMPUTING
, 2003
"... We propose a new form of software transactional memory (STM) designed to support dynamicsized data structures, and we describe a novel nonblocking implementation. The nonblocking property we consider is obstructionfreedom. Obstructionfreedom is weaker than lockfreedom; as a result, it admits s ..."
Abstract

Cited by 332 (22 self)
 Add to MetaCart
We propose a new form of software transactional memory (STM) designed to support dynamicsized data structures, and we describe a novel nonblocking implementation. The nonblocking property we consider is obstructionfreedom. Obstructionfreedom is weaker than lockfreedom; as a result, it admits substantially simpler and more efficient implementations. A novel feature of our obstructionfree STM implementation is its use of modular contention managers to ensure progress in practice. We illustrate the utility of our dynamic STM with a straightforward implementation of an obstructionfree redblack tree, thereby demonstrating a sophisticated nonblocking dynamic data structure that would be difficult to implement by other means. We also present the results of simple preliminary performance experiments that demonstrate that an "early release " feature of our STM is useful for reducing contention, and that our STM lends itself to the effective use of modular contention managers.
Transparent Support for WaitFree Transactions
 In Proceedings of the 11th International Workshop on Distributed Algorithms
, 1997
"... . This paper concerns software support for nonblocking transactions in sharedmemory multiprocessors. We present mechanisms that convert sequential transactions into lockfree or waitfree ones. In contrast to some previous mechanisms, ours support transactions for which the set of memory locations ..."
Abstract

Cited by 52 (7 self)
 Add to MetaCart
. This paper concerns software support for nonblocking transactions in sharedmemory multiprocessors. We present mechanisms that convert sequential transactions into lockfree or waitfree ones. In contrast to some previous mechanisms, ours support transactions for which the set of memory locations accessed cannot be determined in advance. Our implementations automatically detect and resolve conflicts between concurrent transactions, and allow transactions that do not conflict to execute in parallel. The key to the efficiency of our waitfree implementation lies in using a lockfree (but not waitfree) multiword compareand swap (MWCAS) operation. By introducing communication between a highlevel helping mechanism and the lockfree MWCAS, we show that an expensive waitfree MWCAS is not necessary to ensure waitfreedom. 1 Introduction The use of locking to coordinate accesses to shared data in multiprocessor applications has a number of associated pitfalls including a lack of concur...
Hundreds of Impossibility Results for Distributed Computing
 Distributed Computing
, 2003
"... We survey results from distributed computing that show tasks to be impossible, either outright or within given resource bounds, in various models. The parameters of the models considered include synchrony, faulttolerance, different communication media, and randomization. The resource bounds refe ..."
Abstract

Cited by 44 (4 self)
 Add to MetaCart
We survey results from distributed computing that show tasks to be impossible, either outright or within given resource bounds, in various models. The parameters of the models considered include synchrony, faulttolerance, different communication media, and randomization. The resource bounds refer to time, space and message complexity. These results are useful in understanding the inherent difficulty of individual problems and in studying the power of different models of distributed computing.
Adaptive Waitfree Algorithms for Lattice Agreement and Renaming (Extended Abstract)
 In Proceedings of the 17th Annual ACM Symposium on Principles of Distributed Computing
, 1998
"... ) Hagit Attiya and Arie Fouren Department of Computer Science The Technion, Haifa 32000, Israel Abstract This paper considers waitfree algorithms whose complexity is constant in the absence of contention, and grows gradually as the number of active processes increases. An algorithm is fast if its ..."
Abstract

Cited by 37 (8 self)
 Add to MetaCart
) Hagit Attiya and Arie Fouren Department of Computer Science The Technion, Haifa 32000, Israel Abstract This paper considers waitfree algorithms whose complexity is constant in the absence of contention, and grows gradually as the number of active processes increases. An algorithm is fast if its complexity depends on the maximal number of active processes, K, and not on the total number of processes in the system, n. An algorithm is adaptive if its complexity depends only on the actual number of active processes, k, which is unknown in advance and may change in different executions of the algorithm. It is shown that two important decision problems, lattice agreement and renaming with linear name space, have adaptive solutions using only read and write operations. An O(k log k) adaptive algorithm for lattice agreement and an O(k log k) adaptive algorithm for (6k \Gamma 1)renaming are presented. These algorithms are constructed from several subalgorithms, which are interesting in t...
An Adaptive Collect Algorithm with Applications
 Distributed Computing
, 2001
"... In a sharedmemory distributed system, n independent asynchronous processes communicate by reading and writing to shared memory. An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number, k, of active processes in the execution; this number is unknown ..."
Abstract

Cited by 32 (10 self)
 Add to MetaCart
In a sharedmemory distributed system, n independent asynchronous processes communicate by reading and writing to shared memory. An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number, k, of active processes in the execution; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are inherently waitfree, providing faulttolerance in the presence of an arbitrary number of crash failures and different processes' speed. A waitfree adaptive collect algorithm with O(k) step complexity is presented, together with its applications in waitfree adaptive algorithms for atomic snapshots, immediate snapshots and renaming. Keywords: contentionsensitive complexity, waitfree algorithms, asynchronous sharedmemory systems, read/write registers, atomic snapshots, immediate atomic snapshots, renaming. Work supported by the fund for the promotion of research in the Technion. y Department of Computer Science, The Technion, Haifa 32000, Israel. hagit@cs.technion.ac.il. z Department of Computer Science, The Technion, Haifa 32000, Israel. leonf@cs.technion.ac.il. x Computer Science Department, UCLA. eli@cs.ucla.edu. 1
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...
A Time Complexity Lower Bound for Randomized Implementations of Some Shared Objects
 In Symposium on Principles of Distributed Computing
, 1998
"... Many recent waitfree implementations are based on a sharedmemory that supports a pair of synchronization operations, known as LL and SC. In this paper, we establish an intrinsic performance limitation of these operations: even the simple wakeup problem [16], which requires some process to detect th ..."
Abstract

Cited by 22 (1 self)
 Add to MetaCart
Many recent waitfree implementations are based on a sharedmemory that supports a pair of synchronization operations, known as LL and SC. In this paper, we establish an intrinsic performance limitation of these operations: even the simple wakeup problem [16], which requires some process to detect that all n processes are up, cannot be solved unless some process performs#for n) sharedmemory operations. Using this basic result, we derive a#230 n) lower bound on the worstcase sharedaccess time complexity of nprocess implementations of several types of objects, including fetch&increment, fetch&multiply, fetch&and, queue, and stack. (The worstcase sharedaccess time complexity of an implementation is the number of sharedmemory operations that a process performs, in the worstcase, in order to complete a single operation on the implementation.) Our lower bound is strong in several ways: it holds even if (1) sharedmemory has an infinite number of words, each of unbounded size, (2) sh...
Adaptive and Efficient Algorithms for Lattice Agreement and Renaming
 SIAM J. Comput
, 1998
"... In a sharedmemory system, n independent asynchronous processes, with distinct names in the range {0, ..., N  1}, communicate by reading and writing to shared registers. An algorithm is waitfree if a process completes its execution regardless of the behavior of other processes. This paper consider ..."
Abstract

Cited by 22 (7 self)
 Add to MetaCart
In a sharedmemory system, n independent asynchronous processes, with distinct names in the range {0, ..., N  1}, communicate by reading and writing to shared registers. An algorithm is waitfree if a process completes its execution regardless of the behavior of other processes. This paper considers waitfree algorithms whose complexity adjusts to the level of contention in the system: An algorithm is adaptive (to total contention) if its step complexity depends only on the actual number of active processes, k; this number is unknown in advance and may change in different executions of the algorithm. Adaptive algorithms are presented for two important decision problems, lattice agreement and (6k  1)renaming; the step complexity of both algorithms is O(k log k). An interesting component of the (6k  1)renaming algorithm is an O(N) algorithm for (2k  1)renaming; this improves on the best previously known (2k  1)renaming algorithm, which has O(Nnk) s...
Adaptive LongLived Renaming Using Bounded Memory (Extended Abstract)
 PROC. OF THE 40TH IEEE ANN. SYMP. ON FOUNDATIONS OF COMPUTER SCIENCE
, 1999
"... This paper addresses the properties and design of longlived adaptive algorithms in the read/write shared memory model. In particular we present adaptive and longlived algorithms that adapt to the point contention of an operation while using only a bounded amount of memory. We believe the techn ..."
Abstract

Cited by 19 (7 self)
 Add to MetaCart
This paper addresses the properties and design of longlived adaptive algorithms in the read/write shared memory model. In particular we present adaptive and longlived algorithms that adapt to the point contention of an operation while using only a bounded amount of memory. We believe the techniques and building blocks developed here to be of further use in the design of adaptive and longlived algorithms. We use the renaming problem as a testcase to demonstrate the new techniques and properties. Three new implementations of adaptive, waitfree, and longlived renaming in the read/write shared memory model are presented. Unlike previous algorithms [1] the three algorithms require a bounded number of registers and adapt to the point contention of an operation. The two previous algorithms presented in [1] either adapt to the point contention or use a bounded size memory...
Adaptive LongLived Renaming with Read and Write Operations
, 1999
"... This paper presents an adaptive algorithm for longlived renaming using only read and write operations. A process p i obtains a new name in the range f1; : : : ; k(2k \Gamma 1)g, where k is the maximal number of processes simultaneously participating with p i ; the number of steps performed by p i ..."
Abstract

Cited by 18 (3 self)
 Add to MetaCart
This paper presents an adaptive algorithm for longlived renaming using only read and write operations. A process p i obtains a new name in the range f1; : : : ; k(2k \Gamma 1)g, where k is the maximal number of processes simultaneously participating with p i ; the number of steps performed by p i is O(k 2 log k). The range of names is reduced to f1; : : : ; 6k \Gamma 1g, by employing the algorithm of Burns and Peterson. 1 Introduction Distributed coordination algorithms are designed to accommodate a large number of processes, each with a distinct identifier; in order to coordinate, processes must obtain uptodate information from each other. A waitfree algorithm guarantee that a process completes its operation within a finite number of its own steps regardless of the behavior of other processes; in a typical waitfree algorithm, information is collected by reading from an array indexed with process' identifiers. This scheme is an overkill in a welldesigned system where often ...