Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Programming Languages and Systems (TOPLAS)
A methodology for implementing highly concurrent data objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
A method for implementing lock-free shared-data structures
SPAA '93 Proceedings of the fifth annual ACM symposium on Parallel algorithms and architectures
Are wait-free algorithms fast?
Journal of the ACM (JACM)
The synergy between non-blocking synchronization and operating system structure
OSDI '96 Proceedings of the second USENIX symposium on Operating systems design and implementation
Universal operations: unary versus binary
PODC '96 Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing
Disentangling multi-object operations (extended abstract)
PODC '97 Proceedings of the sixteenth annual ACM symposium on Principles of distributed computing
Thread scheduling for multiprogrammed multiprocessors
Proceedings of the tenth annual ACM symposium on Parallel algorithms and architectures
Atomic Snapshots in O (n log n) Operations
SIAM Journal on Computing
ACM Transactions on Computer Systems (TOCS)
Proceedings of the twelfth annual ACM symposium on Parallel algorithms and architectures
The Art of Computer Programming, 2nd Ed. (Addison-Wesley Series in Computer Science and Information
The Art of Computer Programming, 2nd Ed. (Addison-Wesley Series in Computer Science and Information
Non-blocking Synchronization and System Design
Non-blocking Synchronization and System Design
Correction of a Memory Management Method for Lock-Free Data Structures
Correction of a Memory Management Method for Lock-Free Data Structures
Proceedings of the twentieth annual ACM symposium on Principles of distributed computing
Safe memory reclamation for dynamic lock-free objects using atomic reads and writes
Proceedings of the twenty-first annual symposium on Principles of distributed computing
Proceedings of the twenty-first annual symposium on Principles of distributed computing
The Repeat Offender Problem: A Mechanism for Supporting Dynamic-Sized, Lock-Free Data Structures
DISC '02 Proceedings of the 16th International Conference on Distributed Computing
A Practical Multi-word Compare-and-Swap Operation
DISC '02 Proceedings of the 16th International Conference on Distributed Computing
ECOOP '02 Proceedings of the 16th European Conference on Object-Oriented Programming
Distributed Computing - Special issue: Selected papers from PODC '01
Obstruction-Free Synchronization: Double-Ended Queues as an Example
ICDCS '03 Proceedings of the 23rd International Conference on Distributed Computing Systems
DCAS is not a silver bullet for nonblocking algorithm design
Proceedings of the sixteenth annual ACM symposium on Parallelism in algorithms and architectures
Nonblocking memory management support for dynamic-sized data structures
ACM Transactions on Computer Systems (TOCS)
CheckFence: checking consistency of concurrent data types on relaxed memory models
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Lock-free deques and doubly linked lists
Journal of Parallel and Distributed Computing
Scalable nonblocking concurrent objects for mission critical code
Proceedings of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications
DCAS-based concurrent deques supporting bulk allocation
DCAS-based concurrent deques supporting bulk allocation
The repeat offender problem: a mechanism for supporting dynamic-sized lock-free data structures
The repeat offender problem: a mechanism for supporting dynamic-sized lock-free data structures
Verifying Concurrent Data Structures by Simulation
Electronic Notes in Theoretical Computer Science (ENTCS)
Simplifying concurrent algorithms by exploiting hardware transactional memory
Proceedings of the twenty-second annual ACM symposium on Parallelism in algorithms and architectures
Nonblocking algorithms and backward simulation
DISC'09 Proceedings of the 23rd international conference on Distributed computing
Lock-free dynamically resizable arrays
OPODIS'06 Proceedings of the 10th international conference on Principles of Distributed Systems
Built-in coloring for highly-concurrent doubly-linked lists
DISC'06 Proceedings of the 20th international conference on Distributed Computing
Checking a multithreaded algorithm with +CAL
DISC'06 Proceedings of the 20th international conference on Distributed Computing
Lock-free and practical doubly linked list-based deques using single-word compare-and-swap
OPODIS'04 Proceedings of the 8th international conference on Principles of Distributed Systems
Dynamic synthesis for relaxed memory models
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Communications of the ACM
Communications of the ACM
Hi-index | 0.03 |
The computer industry is examining the use of strong synchronization operations such as double compare-and-swap (DCAS) as a means of supporting non-blocking synchronization on tomorrow's multiprocessor machines. However, before such a primitive will be incorporated into hardware design, its utility needs to be proven by developing a body of effective non-blocking data structures using DCAS.In a previous paper, we presented two linearizable non-blocking implementations of concurrent deques (double-ended queues) using the DCAS operation. These improved on previous algorithms by nearly always allowing unimpeded concurrent access to both ends of the deque while correctly handling the difficult boundary cases when the deque is empty or full. A remaining open question was whether, using DCAS, one can design a non-blocking implementation of concurrent deques that allows dynamic memory allocation but also uses only a single DCAS per push or pop in the best case.This paper answers that question in the affirmative. We present a new non-blocking implementation of concurrent deques using the DCAS operation. This algorithm provides the benefits of our previous techniques while overcoming drawbacks. Like our previous approaches, this implementation relies on automatic storage reclamation to ensure that a storage node is not reclaimed and reused until it can be proved that the node is not reachable from any thread of control. This algorithm uses a linked-list representation with dynamic node allocation and therefore does not impose a fixed maximum capacity on the deque. It does not require the use of a "spare bit" in pointers. In the best case (no interference), it requires only one DCAS per push and one DCAS per pop. We also sketch a proof of correctness.