Renaming in an asynchronous environment
Journal of the ACM (JACM)
C interfaces and implementations: techniques for creating reusable software
C interfaces and implementations: techniques for creating reusable software
ACM Transactions on Computer Systems (TOCS)
Synchronization and concurrency in user-level software systems
Synchronization and concurrency in user-level software systems
Communications of the ACM - Security in the Browser
The Art of Multiprocessor Programming
The Art of Multiprocessor Programming
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
Brief announcement: multilane - a concurrent blocking multiset
Proceedings of the twenty-third annual ACM symposium on Parallelism in algorithms and architectures
Fast and scalable rendezvousing
DISC'11 Proceedings of the 25th international conference on Distributed computing
| Hi-index | 0.00 |
In a synchronous queue, producers and consumers handshake to exchange data. Recently, new scalable unfair synchronous queues were added to the Java JDK 6.0 to support high performance thread pools. This paper applies flat-combining to the problem of designing a synchronous queue algorithm. We first use the original flat-combining algorithm, a single "combiner" thread acquires a global lock and services the other threads' combined requests with very low synchronization overheads. As we show, this single combiner approach delivers superior performance up to a certain level of concurrency, but unfortunately does not continue to scale beyond that point. In order to continue to deliver scalable performance as concurrency increases, we introduce a new parallel flat-combining algorithm. The new algorithm dynamically adds additional concurrently executing flat-combiners that coordinate their work. It enjoys the low coordination overheads of sequential flat combining, with the added scalability that comes with parallelism. Our novel unfair synchronous queue using parallel flat combining exhibits scalability far and beyond that of the JDK 6.0 algorithm: it matches it in the case of a single producer and consumer, and is superior throughout the concurrency range, delivering up to 11 (eleven) times the throughput at high concurrency.