The mutual exclusion problem: part I—a theory of interprocess communication
Journal of the ACM (JACM)
Efficient synchronization of multiprocessors with shared memory
PODC '86 Proceedings of the fifth annual ACM symposium on Principles of distributed computing
Hierarchical correctness proofs for distributed algorithms
PODC '87 Proceedings of the sixth annual ACM Symposium on Principles of distributed computing
Algorithms for parallel memory allocation
International Journal of Parallel Programming
Efficient synchronization primitives for large-scale cache-coherent multiprocessors
ASPLOS III Proceedings of the third international conference on Architectural support for programming languages and operating systems
Adaptive backoff synchronization techniques
ISCA '89 Proceedings of the 16th annual international symposium on Computer architecture
Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
Introduction to algorithms
A methodology for implementing highly concurrent data structures
PPOPP '90 Proceedings of the second ACM SIGPLAN symposium on Principles & practice of parallel programming
Low contention linearizable counting
SFCS '91 Proceedings of the 32nd annual symposium on Foundations of computer science
STOC '92 Proceedings of the twenty-fourth annual ACM symposium on Theory of computing
Counting networks with arbitrary fan-out
SODA '92 Proceedings of the third annual ACM-SIAM symposium on Discrete algorithms
Contention in shared memory algorithms
STOC '93 Proceedings of the twenty-fifth annual ACM symposium on Theory of computing
Diffracting trees (preliminary version)
SPAA '94 Proceedings of the sixth annual ACM symposium on Parallel algorithms and architectures
Journal of the ACM (JACM)
Coins, weights and contention in balancing networks
PODC '94 Proceedings of the thirteenth annual ACM symposium on Principles of distributed computing
A combinatorial treatment of balancing networks
PODC '94 Proceedings of the thirteenth annual ACM symposium on Principles of distributed computing
ACM Transactions on Computer Systems (TOCS)
The serializability of concurrent database updates
Journal of the ACM (JACM)
ACM Transactions on Programming Languages and Systems (TOPLAS)
A new solution of Dijkstra's concurrent programming problem
Communications of the ACM
Algorithms for Scalable Synchronization on Shared-Memory Multiproceessors
Algorithms for Scalable Synchronization on Shared-Memory Multiproceessors
Small-depth counting networks and related topics
Small-depth counting networks and related topics
An inherent bottleneck in distributed counting
PODC '97 Proceedings of the sixteenth annual ACM symposium on Principles of distributed computing
Sequentially consistent versus linearizable counting networks
Proceedings of the eighteenth annual ACM symposium on Principles of distributed computing
Proceedings of the twentieth annual ACM symposium on Principles of distributed computing
Threshold counters with increments and decrements
Theoretical Computer Science
Public data structures: counters as a special case
Theoretical Computer Science
The Impact of Timing on Linearizability in Counting Networks
IPPS '97 Proceedings of the 11th International Symposium on Parallel Processing
DISC '01 Proceedings of the 15th International Conference on Distributed Computing
A Combinatorial Characterization of Properties Preserved by Antitokens
Euro-Par '00 Proceedings from the 6th International Euro-Par Conference on Parallel Processing
Operation-valency and the cost of coordination
Proceedings of the twenty-second annual symposium on Principles of distributed computing
Hundreds of impossibility results for distributed computing
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Distributed Computing
Linear Lower Bounds on Real-World Implementations of Concurrent Objects
FOCS '05 Proceedings of the 46th Annual IEEE Symposium on Foundations of Computer Science
The cost of concurrent, low-contention Read&Modify&Write
Theoretical Computer Science - Foundations of software science and computation structures
SNZI: scalable NonZero indicators
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
Theoretical Computer Science
Constructing shared objects that are both robust and high-throughput
DISC'06 Proceedings of the 20th international conference on Distributed Computing
Beyond expert-only parallel programming?
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability
A case for relativistic programming
Proceedings of the 2012 ACM workshop on Relaxing synchronization for multicore and manycore scalability
DISC'12 Proceedings of the 26th international conference on Distributed Computing
Lightweight contention management for efficient compare-and-swap operations
Euro-Par'13 Proceedings of the 19th international conference on Parallel Processing
Hi-index | 0.00 |
The counting problem requires n asynchronous processes to assign themselves successive values. A solution is linearizable if the order of the values assigned reflects the real-time order in which they were requested. Linearizable counting lies at the heart of concurrent time-stamp generation, as well as concurrent implementations of shared counters, FIFO buffers, and similar data structures. We consider solutions to the linearizable counting problem in a multiprocessor architecture in which processes communicate by applying read-modify-write operations to a shared memory. Linearizable counting algorithms can be judged by three criteria: the memory contention produced, whether processes are required to wait for one another, and how long it takes a process to choose a value (the latency). A solution is ideal if it has low contention, low latency, and it eschews waiting. The conventional software solution, where processes synchronize at a single variable, avoids waiting and has low latency, but has high contention. In this paper we give two new constructions based on counting networks, one with low latency and low contention, but that requires processes to wait for one another, and one with low contention and no waiting, but that has high latency. Finally, we prove that these trade-offs are inescapable: an ideal linearizable counting algorithm is impossible. Since ideal non-linearizable counting algorithms exist, these results establish a substantial complexity gap between linearizable and non-linearizable counting.