Correct transactional memory systems (TMs) must address the possibility that a speculative transaction may read mutually inconsistent values from memory and then perform an operation that violates the underlying language semantics. TMs for managed languages can leverage type safety, just-in-time compilation, and fully monitored exceptions to sandbox transactions, isolating the rest of the system from damaging effects of inconsistent speculation. In contrast, TMs for unmanaged languages that lack these properties typically avoid erroneous behavior by validating a transaction's view

/pdf/sandboxing-transactional-memory-1q4fuvcj7e.pdf

Sandboxing transactional memory

Control transactions without compromising their simplicity for the sake of expressiveness, application concurrency, or performance

/pdf/democratizing-transactional-programming-rr0ueyljnx.pdf

Democratizing transactional programming

Transactional Memory (TM) has received a lot of attention as a programming API for concurrent programs on emerging multicore architectures. If the transactional programming model is to realize its promise of simplifying the problem of writing correct and scalable concurrent programs, debuggers will have to change. In this paper, we introduce tm db, an open-source library to provide debuggers with a general debugging support for transactional programs. The library helps debuggers provide programmers with generic transactional debugging features, independent of the particular TM’s runtime internals. In addition, it provides TM designers with a well defined interface for transactional debugging support. We discuss the basic debugging features we believe are essential to debug transactional programs, how they are provided by the library, and how they integrate into a general debugging infrastructure.

tm_db: A Generic Debugging Library for Transactional Programs

/pdf/software-transactional-memory-building-blocks-31f5ppfhcn.pdf

Software Transactional Memory Building Blocks

The transaction abstraction is arguably one of the most appealing middleware paradigms. It lies typically between the programmer of a concurrent or distributed application on the one hand, and the operating system with the underlying network on the other hand. It encapsulates the complex internals of failure recovery and concurrency control, significantly simplifying thereby the life of a non-expert programmer.Yet, some programmers are indeed experts and, for those, the transaction abstraction turns out to be inherently restrictive in its classic form. We argue for a genuine democratization of the paradigm, with different transactional semantics to be used by different programmers and composed within the same application.

/pdf/democratizing-transactional-programming-37ky3if918.pdf

The adoption of multi- and many-core architectures for mainstream computing undoubtedly brings profound changes in the way software is developed In particular, the use of fine grained locking as the multi-core programmer's coordination methodology is considered by more and more experts as a dead-end The transactional memory (TM) programming paradigm is a strong contender to become the approach of choice for replacing locks and implementing atomic operations in concurrent programming Combining sequences of concurrent operations into atomic transactions allows a great reduction in the complexity of both programming and verification, by making parts of the code appear to execute sequentially without the need to program using fine-grained locking Transactions remove from the programmer the burden of figuring out the interaction among concurrent operations that happen to conflict when accessing the same locations in memory The EU-funded FP7 VELOX project designs, implements and evaluates an integrated TM stack, spanning from programming language to the hardware support, and including runtime and libraries, compilers, and application environments This paper presents an overview of the VELOX TM stack and its associated challenges and contributions

/pdf/the-velox-transactional-memory-stack-525888pjot.pdf

W M Moreira

Papers

The Velox Transactional Memory Stack