[Paper Review] Proust: A Design Space for Highly-Concurrent Transactional Data Structures

Thomas Dickerson, Paul Gazzillo+2 more|arXiv (Cornell University)|Feb 16, 2017

Distributed systems and fault tolerance29 references3 citations

TL;DR

Proust introduces a framework for transforming existing thread-safe concurrent data structures into transactional ones with minimal false conflicts by leveraging operation commutativity and integrating with underlying STM systems. It generalizes boosting and predication through a design space of conflict abstractions and update strategies, enabling high concurrency and reuse of well-engineered libraries without rewriting from scratch.

ABSTRACT

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 paper introduces Proust, a framework for the design and implementation of transactional data structures. Proust is designed to maximize re-use of existing well-engineered by providing transactional "wrappers" to make existing thread-safe concurrent data structures transactional. Proustian objects are also integrated with an underling STM system, allowing them to take advantage of well-engineered STM conflict detection mechanisms. Proust generalizes and unifies prior approaches such as boosting and predication.

Motivation & Objective

• Address the limitation of STM systems in supporting concurrent data structure libraries due to false conflicts from read/write set tracking.
• Overcome the need to rewrite existing thread-safe data structures from scratch to support transactional semantics.
• Generalize prior approaches like boosting and predication into a unified, extensible design space for transactional data structures.
• Enable reuse of well-engineered concurrent data structures by providing transactional wrappers that minimize false conflicts.
• Provide a systematic methodology for choosing transactional APIs based on conflict resolution and update strategies, tailored to different STMs and workloads.

Proposed method

• Define a conflict abstraction that maps semantic conflict relationships in data types to concrete conflict detection mechanisms in STM.
• Use operation commutativity—expressed as pairwise or abstract state element commutativity—as the foundation for reducing false conflicts.
• Integrate with existing STM systems to leverage their conflict detection and rollback mechanisms, avoiding reinvention.
• Support two update strategies: operation inverses (for eager rollback) and shadow copies (for lazy replay), with optimizations like memoized replays.
• Enable automatic or conservative approximation of commutativity using SMT solvers or two-phase locks to reduce design complexity.
• Implement a prototype in ScalaSTM to evaluate performance and scalability across different configurations (e.g., eager/lazy, optimistic/pessimistic).

Experimental results

Research questions

• RQ1 How can existing thread-safe concurrent data structures be wrapped into transactional objects with minimal false conflicts?
• RQ2 What design principles enable the integration of semantic conflict information into generic STM systems?
• RQ3 How do different combinations of conflict resolution (optimistic/pessimistic) and update strategies (eager/lazy) affect performance and correctness?
• RQ4 Can Proust achieve competitive performance with specialized STM solutions like predication while supporting arbitrary data types?
• RQ5 To what extent can commutativity relationships be automatically inferred or approximated to reduce manual specification?

Key findings

• Proustian maps outperform traditional STM implementations under increasing contention due to reduced false conflicts, especially with optimized update strategies.
• The Eager/Optimistic configuration, though not fully opaque under CCSTM, showed no correctness violations in benchmarks, suggesting practical viability.
• Performance degrades with higher object update rates (increased o), as log replay costs grow proportionally with the number of updates, unlike predication’s location-based replay.
• Memoizing shadow copies enables replay of only final state changes, significantly improving performance in synthetic update workloads.
• Proust achieves scalability competitive with specialized approaches like predication, but with broader applicability beyond sets and maps.
• The framework enables reuse of existing concurrent data structure libraries without rewriting, reducing engineering cost while maintaining high concurrency.