Composable memory transactions

@article{Harris2008ComposableMT,  title={Composable memory transactions},  author={Tim Harris and Simon Marlow and Simon L. Peyton Jones and Maurice Herlihy},  journal={Commun. ACM},  year={2008},  volume={51},  pages={91-100},  url={https://api.semanticscholar.org/CorpusID:53245159}}
This paper presents a concurrency model, based on transactional memory, that offers far richer composition, and describes modular forms of blocking and choice that were inaccessible in earlier work.

Figures from this paper

46 Citations

A graded monad for deadlock-free concurrency (functional pearl)

A new type-oriented framework for writing shared memory multithreaded programs that the Haskell type system guarantees are deadlock-free and which grades within the type specify which locks it acquires and releases.

Modular transactional memory

Modular Transactional Memory is presented, the framework which allows programmers to extend STM with concurrency control algorithms tailored to the data structures they use in concurrent programs, and two example structures: a finite map which allows concurrent transactions to operate on disjoint sets of keys, and a non-deterministic channel which supports concurrent sources and sinks.

Futures and promises in Haskell and Scala

A simple core language is introduced based on which a rich set of future and promise features can be derived via shared-state concurrency making either use of Software Transactional Memory, an elementary lock-based primitive, or an atomic compare-and-swap operation.

The Future of Synchronization on Multicores: The multicore transformation (Ubiquity symposium)

Maurice Herlihy proposes replacing locks with transactions, and discusses adapting the well-established concept of data base transactions to multicore systems and shared main memory.

Software Transactions Meet First-Class Continuations

This work considers how transactions interact with first-class continuations, and presents a design meeting this need, addressing both escaping from and reentering the dynamic extent of a transaction.

Formalizing determinacy of concurrent revisions

An Isabelle/HOL formalization of the concurrency control model’s operational semantics and proof of determinacy is described and subtle ambiguities in the operational semantics are discussed and resolved.

A Functional Semantics for the Awkward Squad

This work provides a functional specification of three central components of Peyton Jones’s awkw ard squad: teletype IO, mutable state, and concurrency, and demonstrates how these specifications may be used in tandem with QuickCheck to autom atically test complex pointer algorithms and concurrent programs.

Compositional Formal Analysis for Concurrent Object-Oriented Languages

This thesis develops and formally investigates different static analysis methods for various concurrency-related problems in concurrent object-oriented programming languages to guarantee the absence of common concurrence-related errors, hence contribute to the quality of concurrent programs.

Last-use opacity: a strong safety property for transactional memory with prerelease support

Last-use opacity and strong last- use opacity are introduced, a pair of new TM safety properties meant to be a compromise between strong properties like opacity and minimal ones like serializability, which eliminate all but a small class of benign inconsistent views and pose no stringent conditions on transactions.

User-Level Transaction Scheduling in Haskell

This work presents four transactional schedulers implemented entirely in Haskell using different abstraction levels and presents, despite the inherent overhead of high-level implementations, a reduction in the conflict rates.

48 References

Composable memory transactions

This paper presents a new concurrency model, based on transactional memory, that offers far richer composition, and describes new modular forms of blocking and choice that have been inaccessible in earlier work.

Semantics of transactional memory and automatic mutual exclusion

This paper develops semantics and type systems for the constructs of the Automatic Mutual Exclusion (AME) programming model and model STM systems that use in-place update, optimistic concurrency, lazy conflict detection, and roll-back.

Asynchronous exceptions in Haskell

This work extends the earlier work on synchronous exceptions to Haskell to support asynchronous exceptions, and introduces scoped combinators for blocking and unblocking asynchronous interrupts, along with a somewhat surprising semantics for operations that can suspend.

Language support for lightweight transactions

This work argues that these problems can be addressed by moving to a declarative style of concurrency control in which programmers directly indicate the safety properties that they require, which is easier for mainstream programmers to use, prevents lock-based priority-inversion and deadlock problems and can offer performance advantages.

High-level small-step operational semantics for transactions

This work presents a family of formal languages that model a wide variety of behaviors for software transactions, and proves some key language-equivalence theorems to confirm that under sufficient static restrictions, no program can determine whether the language implementation uses weak isolation or strong isolation.

Concurrent Haskell

This work has developed a freely-available implementation of Concurrent Haskell, and is now using it as a substrate for a graphical user interface toolkit.

Transactional memory with data invariants

STM Haskell is extended to dynamically evaluate check statements atomically with the user’s updates: the result is that the authors can identify precisely which update is the first one to break an invariant.

Programming with transactional coherence and consistency (TCC)

Two basic programming language constructs for decomposing programs into transactions, a loop conversion syntax and a general transaction-forking mechanism are described, so that writing correct parallel programs requires only small, incremental changes to correct sequential programs.

Imperative functional programming

We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system,…

Transactional Monitors for Concurrent Objects

It is shown that transactional monitors are competitive with mutual- exclusion synchronization and can outperform lock-based approaches up to five times on a wide range of workloads.

Related Papers

Showing 1 through 3 of 0 Related Papers