Local Linearizability for Concurrent Container-Type Data Structures

The semantics of concurrent data structures is usually given by a sequential specification and a consistency condition. Linearizability is the most popular consistency condition due to its simplicity and general applicability. Nevertheless, for applications that do not require all guarantees offered by linearizability, recent research has focused on improving performance and scalability of concurrent data structures by relaxing their semantics. In this paper, we present local linearizability, a relaxed consistency condition that is applicable to container-type concurrent data structures like pools, queues, and stacks. While linearizability requires that the effect of each operation is observed by all threads at the same time, local linearizability only requires that for each thread T, the effects of its local insertion operations and the effects of those removal operations that remove values inserted by T are observed by all threads at the same time. We investigate theoretical and practical properties of local linearizability and its relationship to many existing consistency conditions. We present a generic implementation method for locally linearizable data structures that uses existing linearizable data structures as building blocks. Our implementations show performance and scalability improvements over the original building blocks and outperform the fastest existing container-type implementations.

[1]  Dan Alistarh,et al.  The SprayList: a scalable relaxed priority queue , 2015, PPoPP.

[2]  Ana Sokolova,et al.  Fast, multicore-scalable, low-fragmentation memory allocation through large virtual memory and global data structures , 2015, OOPSLA.

[3]  Noam Rinetzky,et al.  Brief announcement: concurrency-aware linearizability , 2014, PODC '14.

[4]  Gil Neiger,et al.  Causal memory: definitions, implementation, and programming , 1995, Distributed Computing.

[5]  Leslie Lamport,et al.  How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs , 2016, IEEE Transactions on Computers.

[6]  Maurice Herlihy,et al.  A Lazy Concurrent List-Based Set Algorithm , 2007, Parallel Process. Lett..

[7]  James R. Goodman,et al.  Cache Consistency and Sequential Consistency , 1991 .

[8]  Erez Petrank,et al.  Wait-free queues with multiple enqueuers and dequeuers , 2011, PPoPP '11.

[9]  Sebastian Burckhardt,et al.  Replicated data types: specification, verification, optimality , 2014, POPL.

[10]  Christoph M. Kirsch,et al.  Fast and Scalable, Lock-Free k-FIFO Queues , 2013, PaCT.

[11]  John Derrick,et al.  Quiescent Consistency: Defining and Verifying Relaxed Linearizability , 2014, FM.

[12]  Constantin Enea,et al.  On Reducing Linearizability to State Reachability , 2015, ICALP.

[13]  D. M. Hutton,et al.  The Art of Multiprocessor Programming , 2008 .

[14]  Radha Jagadeesan,et al.  Between Linearizability and Quiescent Consistency - Quantitative Quiescent Consistency , 2014, ICALP.

[15]  Abdelsalam Heddaya,et al.  Coherence, Non-coherence and Local Consistency in Distributed Shared Memory for Parallel Computing , 1992 .

[16]  Gary J. Nutt,et al.  A unified theory of shared memory consistency , 2002, JACM.

[17]  Christoph M. Kirsch,et al.  A Scalable, Correct Time-Stamped Stack , 2015, POPL.

[18]  Peter Sanders,et al.  MultiQueues: Simpler, Faster, and Better Relaxed Concurrent Priority Queues , 2014, ArXiv.

[19]  Maged M. Michael,et al.  Simple, fast, and practical non-blocking and blocking concurrent queue algorithms , 1996, PODC '96.

[20]  Yehuda Afek,et al.  Quasi-Linearizability: Relaxed Consistency for Improved Concurrency , 2010, OPODIS.

[21]  Maged M. Michael,et al.  Idempotent work stealing , 2009, PPoPP '09.

[22]  David A. Patterson,et al.  Computer Architecture, Fifth Edition: A Quantitative Approach , 2011 .

[23]  Nir Shavit.  Data structures in the multicore age , 2011, CACM.

[24]  Maurice Herlihy,et al.  Counting networks , 1994, JACM.

[25]  Maurice Herlihy,et al.  Linearizability: a correctness condition for concurrent objects , 1990, TOPL.

[26]  Ana Sokolova,et al.  Scal: A Benchmarking Suite for Concurrent Data Structures , 2015, NETYS.

[27]  Yehuda Afek,et al.  Fast concurrent queues for x86 processors , 2013, PPoPP '13.

[28]  Ana Sokolova,et al.  Quantitative relaxation of concurrent data structures , 2013, POPL.

[29]  Ali Sezgin.  Sequential Consistency and Concurrent Data Structures , 2015, ArXiv.

[30]  Rida A. Bazzi,et al.  The power of processor consistency , 1993, SPAA '93.

[31]  Ana Sokolova,et al.  Distributed queues in shared memory: multicore performance and scalability through quantitative relaxation , 2013, CF '13.

[32]  Thomas A. Henzinger,et al.  Aspect-Oriented Linearizability Proofs , 2013, CONCUR.

[33]  Peter W. O'Hearn,et al.  Abstraction for concurrent objects , 2009, Theor. Comput. Sci..