Algorithms for mutual exclusion
Algorithms for mutual exclusion
Disjoint-access-parallel implementations of strong shared memory primitives
PODC '94 Proceedings of the thirteenth annual ACM symposium on Principles of distributed computing
The serializability of concurrent database updates
Journal of the ACM (JACM)
A new solution of Dijkstra's concurrent programming problem
Communications of the ACM
The Performance of Spin Lock Alternatives for Shared-Memory Multiprocessors
IEEE Transactions on Parallel and Distributed Systems
Compilation techniques for explicitly parallel programs
Compilation techniques for explicitly parallel programs
On the correctness of transactional memory
Proceedings of the 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming
On obstruction-free transactions
Proceedings of the twentieth annual symposium on Parallelism in algorithms and architectures
Permissiveness in Transactional Memories
DISC '08 Proceedings of the 22nd international symposium on Distributed Computing
The semantics of progress in lock-based transactional memory
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Inherent limitations on disjoint-access parallel implementations of transactional memory
Proceedings of the twenty-first annual symposium on Parallelism in algorithms and architectures
Flat combining and the synchronization-parallelism tradeoff
Proceedings of the twenty-second annual ACM symposium on Parallelism in algorithms and architectures
DISC'09 Proceedings of the 23rd international conference on Distributed computing
Brief announcement: view transactions: transactional model with relaxed consistency checks
Proceedings of the 29th ACM SIGACT-SIGOPS symposium on Principles of distributed computing
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
Single-version STMs can be multi-version permissive
ICDCN'11 Proceedings of the 12th international conference on Distributed computing and networking
Time and Space Lower Bounds for Implementations Using k-CAS
IEEE Transactions on Parallel and Distributed Systems
| Hi-index | 0.00 |
The promise of software transactional memory (STM) is to combine an easy-to-use programming interface with an efficient utilization of the concurrent-computing abilities provided by modern machines. But does this combination come with an inherent cost? We evaluate the cost of concurrency by measuring the amount of expensive synchronization that must be employed in an STM implementation that ensures positive concurrency, i.e., allows for concurrent transaction processing in some executions. We focus on two popular progress conditions that provide positive concurrency: progressiveness and permissiveness. We show that in permissive STMs, providing a very high degree of concurrency, a transaction may perform a linear number of expensive synchronization patterns with respect to its read-set size. In contrast, progressive STMs provide a very small degree of concurrency but, as we demonstrate, can be implemented using at most one expensive synchronization pattern per transaction. However, we show that even in progressive STMs, a transaction has to "protect" (e.g., by using locks or strong synchronization primitives) a linear amount of data with respect to its write-set size. Our results suggest that achieving high degrees of concurrency in STM implementations may bring a considerable synchronization cost.