DCAS is not a silver bullet for nonblocking algorithm design

Doherty, Simon; Detlefs, David; Groves, Lindsay; Flood, Christine H.; Luchangco, Victor; Martin, Paul; Moir, Mark; Shavit, Nir; Steele, Guy L.

doi:10.1145/1007912.1007945

Cited by 55 publications

(45 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Massalin and Pu [20] implement stacks, queues and linked lists using double compare and swap (DCAS) primitives that are more powerful, but not typically available on modern architectures. In general, writing correct non-blocking algorithms using these primitives is difficult, and bugs in published algorithms have been observed [11]. Our proposed abstractions limit the computations we consider to simple commutative operations for which such correctness concerns are of less importance.…”

Section: Parallelism and Contentionmentioning

confidence: 99%

Automatic contention detection and amelioration for data-intensive operations

Cieslewicz

Ross

Satsumi

et al. 2010

Proceedings of the 2010 ACM SIGMOD International Conference on Management of Data

View full text Add to dashboard Cite

To take full advantage of the parallelism offered by a multicore machine, one must write parallel code. Writing parallel code is difficult. Even when one writes correct code, there are numerous performance pitfalls. For example, an unrecognized data hotspot could mean that all threads effectively serialize their access to the hotspot, and throughput is dramatically reduced. Previous work has demonstrated that database operations suffer from such hotspots when naively implemented to run in parallel on a multi-core processor.In this paper, we aim to provide a generic framework for performing certain kinds of concurrent database operations in parallel. The formalism is similar to user-defined aggregates and Google's MapReduce in that users specify certain functions for parts of the computation that need to be performed over large volumes of data. We provide infrastructure that allows multiple threads on a multi-core machine to concurrently perform read and write operations on shared data structures, automatically mitigating hotspots and other performance hazards.Our goal is not to squeeze the last drop of performance out of a particular platform. Rather, we aim to provide a framework within which a programmer can, without detailed knowledge of concurrent and parallel programming, develop code that efficiently utilizes a multi-core machine.

show abstract

Section: Parallelism and Contentionmentioning

confidence: 99%

Automatic contention detection and amelioration for data-intensive operations

Cieslewicz

Ross

Satsumi

et al. 2010

Proceedings of the 2010 ACM SIGMOD International Conference on Management of Data

View full text Add to dashboard Cite

show abstract

“…They are notoriously difficult to get correct and verify, since they often employ fine-grained synchronization and avoid locking wherever possible. A number of bugs in published algorithms have been reported [10,19]. It is therefore important to develop efficient techniques for verifying conformance to simple abstract specifications of overall functionality, a concurrent implementation of a common data type abstraction, such as a supported in part by the Uppsala Programming for Multicore Architectures Research Center (UPMARC), the Czech Science Foundation (project P103/10/0306), and the CENIIT research organization (project 12.04).…”

Section: Introductionmentioning

confidence: 99%

An Integrated Specification and Verification Technique for Highly Concurrent Data Structures

Abdulla

Haziza

Holík

et al. 2013

Tools and Algorithms for the Construction and Analysis of Systems

View full text Add to dashboard Cite

Abstract. We present a technique for automatically verifying safety properties of concurrent programs, in particular programs which rely on subtle dependencies of local states of different threads, such as lock-free implementations of stacks and queues in an environment without garbage collection. Our technique addresses the joint challenges of infinite-state specifications, an unbounded number of threads, and an unbounded heap managed by explicit memory allocation. Our technique builds on the automata-theoretic approach to model checking, in which a specification is given by an automaton that observes the execution of a program and accepts executions that violate the intended specification. We extend this approach by allowing specifications to be given by a class of infinite-state automata. We show how such automata can be used to specify queues, stacks, and other data structures, by extending a data-independence argument. For verification, we develop a shape analysis, which tracks correlations between pairs of threads, and a novel abstraction to make the analysis practical. We have implemented our method and used it to verify programs, some of which have not been verified by any other automatic method before.

show abstract

“…Even when DCAS (i.e., 2CAS) is used, existing implementations either are inherently sequential [11,12] or allow to access chains of garbage nodes [9].…”

Section: Introductionmentioning

confidence: 99%

“…For example, removing an item from a doublylinked list is easy if one can atomically access three items-the item to be removed and the two items before and after it (cf. [9]). …”

Section: Introductionmentioning

confidence: 99%

“…The SNARK algorithm [8] is an attempt for further improvement that uses only a single DCAS primitive per operation in the best case, instead of two. Unfortunately, SNARK is incorrect [9]; the corrected version allows removed nodes to be accessed from within the deque, thus preventing the garbage collector from reclaiming long chains of unused nodes. Doherty et al [9] even argue that primitives more powerful than DCAS, e.g., 3CAS, are needed in order to obtain simple and ef£cient nonblocking implementations of concurrent data structures.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Built-in Coloring for Highly-Concurrent Doubly-Linked Lists

Attiya

Hillel

2012

Theory Comput Syst

View full text Add to dashboard Cite

Abstract. This paper presents a novel approach for lock-free implementations of concurrent data structures, based on dynamically maintaining a coloring of the data structure's items. Roughly speaking, the data structure's operations are implemented by acquiring virtual locks on several items of the data structure and then making the changes atomically; this simpli£es the design and provides clean functionality. The virtual locks are managed with CAS or DCAS primitives, and helping is used to guarantee progress; virtual locks are acquired according to a coloring order that decreases the length of waiting chains and increases concurrency. Coming back full circle, the legality of the coloring is preserved by having operations correctly update the colors of the items they modify. The bene£ts of the scheme are demonstrated with new nonblocking implementations of doubly-linked list data structures: A DCAS-based implementation of a doubly-linked list allowing insertions and removals anywhere, and CAS-based implementations in which removals are allowed only at the ends of the list (insertions can occur anywhere). The implementations possess several attractive features: they do not bound the list size, they do not leave accessible chains of garbage nodes, and they allow operations to proceed concurrently, without interfering with each other, if they are applied to non-adjacent nodes in the list.

show abstract

DCAS is not a silver bullet for nonblocking algorithm design

Cited by 55 publications

References 19 publications

Automatic contention detection and amelioration for data-intensive operations

Automatic contention detection and amelioration for data-intensive operations

An Integrated Specification and Verification Technique for Highly Concurrent Data Structures

Built-in Coloring for Highly-Concurrent Doubly-Linked Lists

Contact Info

Product

Resources

About