Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Journal of the ACM (JACM)
Simple, fast, and practical non-blocking and blocking concurrent queue algorithms
PODC '96 Proceedings of the fifteenth annual ACM symposium on Principles of distributed computing
Proceedings of the 14th ACM SIGPLAN symposium on Principles and practice of parallel programming
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 1
Flat combining and the synchronization-parallelism tradeoff
Proceedings of the twenty-second annual ACM symposium on Parallelism in algorithms and architectures
Scalable producer-consumer pools based on elimination-diffraction trees
Euro-Par'10 Proceedings of the 16th international Euro-Par conference on Parallel processing: Part II
Data structures in the multicore age
Communications of the ACM
Laws of order: expensive synchronization in concurrent algorithms cannot be eliminated
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
quasi-linearizability: relaxed consistency for improved concurrency
OPODIS'10 Proceedings of the 14th international conference on Principles of distributed systems
A lock-free algorithm for concurrent bags
Proceedings of the twenty-third annual ACM symposium on Parallelism in algorithms and architectures
EnerJ: approximate data types for safe and general low-power computation
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
Scalability versus semantics of concurrent FIFO queues
Proceedings of the 30th annual ACM SIGACT-SIGOPS symposium on Principles of distributed computing
Fast and scalable rendezvousing
DISC'11 Proceedings of the 25th international conference on Distributed computing
Incorrect systems: it's not the problem, it's the solution
Proceedings of the 49th Annual Design Automation Conference
Performance, scalability, and semantics of concurrent FIFO queues
ICA3PP'12 Proceedings of the 12th international conference on Algorithms and Architectures for Parallel Processing - Volume Part I
How FIFO is your concurrent FIFO queue?
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability
Proceedings of the ACM International Conference on Computing Frontiers
Hi-index | 0.00 |
There is a trade-off between performance and correctness in implementing concurrent data structures. Better performance may be achieved at the expense of relaxing correctness, by redefining the semantics of data structures. We address such a redefinition of data structure semantics and present a systematic and formal framework for obtaining new data structures by quantitatively relaxing existing ones. We view a data structure as a sequential specification S containing all "legal" sequences over an alphabet of method calls. Relaxing the data structure corresponds to defining a distance from any sequence over the alphabet to the sequential specification: the k-relaxed sequential specification contains all sequences over the alphabet within distance k from the original specification. In contrast to other existing work, our relaxations are semantic (distance in terms of data structure states). As an instantiation of our framework, we present two simple yet generic relaxation schemes, called out-of-order and stuttering relaxation, along with several ways of computing distances. We show that the out-of-order relaxation, when further instantiated to stacks, queues, and priority queues, amounts to tolerating bounded out-of-order behavior, which cannot be captured by a purely syntactic relaxation (distance in terms of sequence manipulation, e.g. edit distance). We give concurrent implementations of relaxed data structures and demonstrate that bounded relaxations provide the means for trading correctness for performance in a controlled way. The relaxations are monotonic which further highlights the trade-off: increasing k increases the number of permitted sequences, which as we demonstrate can lead to better performance. Finally, since a relaxed stack or queue also implements a pool, we actually have new concurrent pool implementations that outperform the state-of-the-art ones.