The Atomos transactional programming language

Abstract

Atomos is the first programming language with implicit transactions, strong atomicity, and a scalable multiprocessor implementation. Atomos is derived from Java, but replaces its synchronization and conditional waiting constructs with simpler transactional alternatives.The Atomos watch statement allows programmers to specify fine-grained watch sets used with the Atomos retry conditional waiting statement for efficient transactional conflict-driven wakeup even in transactional memory systems with a limited number of transactional contexts. Atomos supports open-nested transactions, which are necessary for building both scalable application programs and virtual machine implementations.The implementation of the Atomos scheduler demonstrates the use of open nesting within the virtual machine and introduces the concept of transactional memory violation handlers that allow programs to recover from data dependency violations without rolling back.Atomos programming examples are given to demonstrate the usefulness of transactional programming primitives. Atomos and Java are compared through the use of several benchmarks. The results demonstrate both the improvements in parallel programming ease and parallel program performance provided by Atomos.

ByteSTM: Virtual Machine-Level Java Software Transactional Memory

“…VM-based STMs, which have been less studied, include [1,10,17,40]. In [17], STM is implemented in C inside the JVM to get benefits of the VM-managed environment.…”

“…Thus, the VM-level implementation choice is to prevent such unrecoverable errors, which are not allowed in a managed environment. [10] presents a new programming language based on Java, called Atomos, and a VM to run it. Standard Java synchronization (i.e., synchronized, wait/notify) is replaced with transactions.…”

“…The VM also has full control of the GC, which means that, the GC's potentially degrading effect on STM performance can be controlled or even eliminated by manually managing the memory needed for transactional support. Moreover, if TM is supported using HTM (as in [10]), then VM is the only appropriate level of abstraction (from a performance standpoint) to exploit that support. Otherwise, if TM is supported at a higher level, the GC will abort transactions when it interrupts them, and language synchronization semantics will contradict with transactional semantics.…”

A Domain Specific Language for Composable Memory Transactions in Java

“…Their Java extension gives an efficient implementation of Hoare's conditional critical regions [11] through transactions, but transactions could not be easily composed. The Atomos language [4] is a Java extension that supports transactions through atomic blocks and also the retry construct to block transactions. Transactions are supported by the Transactional Coherence and Consistency hardware transactional memory model (TCC) [18], and programs are run on a simulator that implements the (TCC) architecture.…”

Automatic Mutual Exclusion and Atomicity Checks

“…For these benefits to be realized, however, advances in low-level implementations of transactions do not suffice. Also needed are corresponding languages and programming techniques (e.g., [9,10,6,3]). …”