Transactional memory

About: Transactional memory is a research topic. Over the lifetime, 2365 publications have been published within this topic receiving 60818 citations.

A novel mechanism for enhancing software transactional memory

Abstract: This paper proposes efficient object-based implementations for Software Transactional Memory (stm). The proposed implementations are based on using multiple versions of the transactional objects to increase the concurrency of stm execution. In this work, we propose 3 algorithms for enhancing concurrency in stm. We also propose a new approach for determining the optimal number of versions to keep. Finally, we present experimental results that show the efficiency of the proposed implementations.

Software Transactional Memory in Pure Python

Abstract: There has been a growing interest in programming models for concurrency. Strategies for dealing with shared data amongst parallel threads of execution include immutable (as in Erlang) and locked (as in Python) data structures. A third option exists, called transactional memory (as in Haskell), which includes thread-local journaling for operations on objects which are both mutable and globally shared. Here, we present TraM, a pure Python implementation of the TL2 algorithm for software transactional memory.

Hierarchical Transactional Memory Protocol for Distributed Mixed-Criticality Embedded Systems

Abstract: Transactional memories with support for real-time and reliability requirements are a research challenge for the deployment in safety-critical embedded systems. In addition, at present there are no transactional-memory architectures considering hierarchical systems of networked multi-core chips with both on-chip and off-chip networks. The presented work offers a predictable transactional memory solution for hierarchical distributed systems by executing a transactional memory protocol spanning both on-chip and off-chip networks to manage the memory operations of the cores at different multi-core chips. This includes relocating memory pages between the local caches at cores and the external memories while preserving the mixed-criticality requirements of the distributed system. The proposed protocol provides temporal predictability, fault isolation and bounded execution time assurances for safety-critical applications. An automotive use case with a simulation framework serves for the evaluation of the proposed solution.

Efficient partial roll-backing mechanism for transactional memory systems

Abstract: Transactional memory systems promise to reduce the burden of exposing thread-level parallelism in programs by relieving programmers from analyzing complex inter-thread dependences in detail. By encapsulating large program code blocks and executing them as atomic blocks, dependence checking is deferred to run-time. One of many conflicting transactions will then be committed whereas the others will have to roll-back and re-execute. In current proposals, a checkpoint is taken at the beginning of the atomic block and all execution can be wasted even if the conflicting access happens at the end of the atomic block. In this paper, we propose a novel scheme that (1) predicts when the first conflicting access occurs and (2) inserts a checkpoint before it is executed. When the prediction is correct, the only execution discarded is the one that has to be re-done. When the prediction is incorrect, the whole transaction has to be re-executed just as before. Overall, we find that our scheme manages to maintain high prediction accuracy and leads to a quite significant reduction in the number of lost cycles due to roll-backs; the geometric mean speedup across five applications is 16%.

Reducing Rollbacks of Transactional Memory Using Ordered Shared Locks

Abstract: Transactional Memory (TM) is a concurrency control mechanism that aims to simplify concurrent programming with reasonable scalability. Programmers can simply specify the code regions that access the shared data, and then a TM system executes them as transactions. However, programmers often need to modify the application logic to achieve high scalability on TM. If there is any variable that is frequently updated in many transactions, the program does not scale well on TM. We propose an approach that uses ordered shared locks in TM systems to improve the scalability of such programs. The ordered shared locks allow multiple transactions to update a shared variable concurrently without causing rollbacks or blocking until other transactions finish. Our approach improves the scalability of TM by applying the ordered shared locks to variables that are frequently updated in many transactions, while being accessed only once in each transaction. We implemented our approach on a software TM (STM) system for Java. In our experiments, it improved the performance of an hsqldb benchmark by 157% on 8 threads and by 45% on 16 threads compared to the original STM system.