Brief Announcement: Proust: A Design Space for Highly-Concurrent Transactional Data Structures

  title={Brief Announcement: Proust: A Design Space for Highly-Concurrent Transactional Data Structures},
  author={Thomas D. Dickerson and Paul Gazzillo and Eric Koskinen and Maurice Herlihy},
  journal={Proceedings of the ACM Symposium on Principles of Distributed Computing},
Most STM systems are poorly equipped to support libraries of concurrent data structures. One reason is that they typically detect conflicts by tracking transactions' read sets and write sets, an approach that often leads to false conflicts. A second is that existing data structures and libraries often need to be rewritten from scratch to support transactional conflict detection and rollback. This brief announcement introduces Proust, a framework for the design and implementation of… 

Figures from this paper

Using Nesting to Push the Limits of Transactional Data Structure Libraries
This paper builds a Java TDSL with built-in support for nesting in a number of data structures, and shows that the library outperforms TL2 twofold without nesting, and by up to 16x when nesting is used.
Lock-free transactional vector
This work presents the first lock-free transactional vector, which pre-processes transactions to reduce shared memory access and simplify access logic, and generally offers better scalability than STM and STO, and competitive performance with Transactional Boosting, but with additionalLock-free guarantees.
Conflict Abstractions and Shadow Speculation for Optimistic Transactional Objects
Concurrent data structures implemented with software transactional memory (STM) perform poorly when operations which do not conflict in the definition of the abstract data type nonetheless incur
Fast Snapshottable Concurrent Braun Heaps
This paper proposes a new concurrent heap algorithm, based on a stateless shape property, which efficiently maintains balance during insert and removeMin operations implemented with hand-over-hand
It is formally proved that both local and distributed Python STM implementations are serializable by constructing their push/pull model and by showing that the push/ Pull model satisfies the correctness criteria for the relevant push/ pull semantic rules.


Type-aware transactions for faster concurrent code
A new software transactional memory (STM) is built that tracks abstract operations on transactional datatypes' implementations, which can use datatype semantics, and new commit protocol features, to reduce bookkeeping, limit false conflicts, and implement efficient concurrency control.
Transactional predication: high-performance concurrent sets and maps for STM
Transactional predication, a method for building transactional maps and sets on top of an underlying non-composable concurrent map, is introduced, and an experimental evaluation shows that predication has better performance than existing transactional collection algorithms across a range of workloads.
Transactional collection classes
The results show that easier-to-use long transactions can still allow programs to deliver scalable performance by simply wrapping existing data structures with transactional collection classes, without the need for custom implementations or knowledge of data structure internals.
Committing conflicting transactions in an STM
This paper provides a safety proof for the dependence-aware model and describes the first application of dependence tracking to software transactional memory (STM) design and implementation, quantifying how dependence tracking converts certain types of transactional conflicts into successful commits.
NOrec: streamlining STM by abolishing ownership records
An ownership-record-free software transactional memory (STM) system that combines extremely low overhead with unusually clean semantics is presented, and the experience suggests that NOrec may be an ideal candidate for such a software system.
Software transactional memories for Scala
CCSTM: A Library-Based STM for Scala
CCSTM is introduced, a library-based software transactional memory (STM) for Scala that uses a novel hybrid of static and dynamic transaction scoping to retain composability while avoiding the barrier overheads that would otherwise result from an implementation as an unprivileged library.
Software transactional memory for dynamic-sized data structures
A new form of software transactional memory designed to support dynamic-sized data structures, and a novel non-blocking implementation of this STM that uses modular contention managers to ensure progress in practice.
Open nesting in software transactional memory
New language constructs to support open nesting in Java are described, and it is demonstrated how these constructs can be mapped efficiently to existing STM data structures, demonstrating how open nesting can enhance application scalability.
On the correctness of transactional memory
Opacity is defined as a property of concurrent transaction histories and its graph theoretical interpretation is given and it is proved that every single-version TM system that uses invisible reads and does not abort non-conflicting transactions requires, in the worst case, k steps for an operation to terminate.