Transactional memory

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

Transaction processing for actions with side effects in transactional memory

Abstract: FIELD: physics, computer engineering.SUBSTANCE: invention relates to microprocessor systems with shared memory. The processing system includes transactional memory, first and second resource managers, and a transaction manager for a concurrent program having a thread including an atomic transaction having an action with a side effect. The first resource manager is configured to enlist in the atomic transaction and manage a resource related to the action with a side effect. The second resource manager is configured to enlist in the atomic transaction and manage the transaction memory. The transaction manager is connected to the first and second resource managers and manager is configured to receive a vote from the first and second resource managers as to whether to commit the transaction. The action with a side effect is postponed until after the transaction commits or applied along with a compensating action to the action with a side effect.EFFECT: high efficiency of managing an atomic transaction having an action with a side effect.20 cl, 3 dwg

On Non-Interference and Locality in Transactional Memory

Abstract: The promise of transactional memory is to make concurrent programming tractable and efficient by allowing the user to assemble sequences of actions in atomic transactions with allor-nothing semantics. It is usually expedcted that transactional memory must ensure that all committed transactions constitute a serial execution respecting the real-time order. In contrast, aborted or incomplete transactions should not “take effect.” But what does “not taking effect” mean exactly? It seems natural to expect that the writes of aborted or incomplete transactions do not appear in the global serial execution, and, thus, no committed transaction can be affected by them. We consider another, less obvious, feature of “not taking effect” called non-interference: aborted or incomplete transactions should not force any other transaction to abort. More precisely, by removing a subset of aborted or incomplete transactions from the history, we should not be able to turn an aborted transaction into a committed one. We show that for a correctness criterion to be implementable in a non-interfering way it is sufficient to be local, i.e., to only require that every transaction can be serialized along with (a subset of) the transactions committed before its last event. For example, opacity requires that all aborted transactions to fit in a single global serialization (along with all the committed transactions) is not local and cannot achieve non-interference. We propose a simple though efficient implementation that satisfies non-interference and local opacity, a novel correctness criterion that is interesting in its own right. In addition to strict serializability, local opacity captures the safety semantics of opacity: aborted transactions do not witness inconsistent states. Regular paper, not eligible for best student paper award ∗Contact author: Sathya Peri, CSE Dept, IIT Patna, Patliputra Colony, Patna 800 013, Bihar, India, Ph: +91-612-2552089

Conditional data caching using transactional memory in a multiprocessor system

Abstract: A multiprocessor system providing transactional memory. A first processor initiates a transaction which includes reading first data into a private cache of the first processor, and performing a write operation on the first data in the private cache of the first processor. In response to detecting that prior to the write operation the first data was last modified by a second processor, the first processor writes the modified first data into a last level cache (LLC) accessible by the multiple processors. The system sets a cache line state index string to indicate that the first data written into the LLC was last modified by the first processor, invalidates the first data in the private cache of the first processor, and commits the transaction to the transactional memory system. This allows more efficient accesses to the data by the multiple processors.

Fault Recovery Based on Transaction Rollback in Transactional Memory

Abstract: This paper addresses the issue of fault tolerance in transactional memory,and proposes a new method of fault recovery based on transaction rollback(FRTR).The method achieves an efficient fault recovery in transactional memory by utilizing the data-versioning mechanism of transactional memory to avoid the extra overhead of saving the checkpoint data.This paper provides the correctness of this method by proving the isolation of the fault tolerant transactional memory.Finally,this paper presents the design of the FRTRs for 5 test programs,including 4 SPLASH-2 benchmarks.The experimental results show compared with the checkpointing mechanism,the FRTR avoids the extra overhead of saving the checkpoint data and has a low overhead of the fault recovery.

Transactional Composition of Nonblocking Data Structures

Abstract: This paper introduces nonblocking transaction composition (NBTC), a new methodology for atomic composition of nonblocking operations on concurrent data structures. Unlike previous software transactional memory (STM) approaches, NBTC leverages the linearizability of existing nonblocking structures, reducing the number of memory accesses that must be executed together, atomically, to only one per operation in most cases (these are typically the linearizing instructions of the constituent operations). Our obstruction-free implementation of NBTC, which we call Medley, makes it easy to transform most nonblocking data structures into transactional counterparts while preserving their liveness and high concurrency. In our experiments, Medley outperforms Lock-Free Transactional Transform (LFTT), the fastest prior competing methodology, by 40--170%. The marginal overhead of Medley's transactional composition, relative to separate operations performed in succession, is roughly 2.2x. For persistent data structures, we observe that failure atomicity for transactions can be achieved "almost for free'' with epoch-based periodic persistence. Toward that end, we integrate Medley with nbMontage, a general system for periodically persistent data structures. The resulting txMontage provides ACID transactions and achieves throughput up to two orders of magnitude higher than that of the OneFile persistent STM system.