Topic
Transactional memory
About: Transactional memory is a research topic. Over the lifetime, 2365 publications have been published within this topic receiving 60818 citations.
Papers published on a yearly basis
Papers
More filters
••
04 Sep 2013TL;DR: This paper presents an interval-based semantics for programs that execute under TSO memory and include methods for fine-grained expression evaluation, capturing the non-determinism of both concurrency and TSO-related reorderings.
Abstract: Processor cores within modern multicore systems often communicate via shared memory and use (local) store buffers to improve performance. A penalty for this improvement is the loss of Sequential Consistency to weaker memory guarantees that increase the number of possible program behaviours, and hence, require a greater amount of programming effort. This paper formalises the effect of Total Store Order (TSO) memory — a weak memory model that allows a write followed by a read in the program order to be reordered during execution. Although the precise effects of TSO are well-known, a high-level formalisation of programs that execute under TSO has not been developed. We present an interval-based semantics for programs that execute under TSO memory and include methods for fine-grained expression evaluation, capturing the non-determinism of both concurrency and TSO-related reorderings.
10 citations
•
03 Sep 2017
TL;DR: Object-based STMs or OSTMs which operate on higher level objects rather than read/write operations on memory buffers and hence denoted RWSTMs are considered, which could be an efficient means of achieving composability of higher-level operations in the software applications using the concurrent data structures.
Abstract: The major focus of software transaction memory systems (STMs) has been to facilitate the multiprocessor
programming and provide parallel programmers with an abstraction for fast development of the concurrent
and parallel applications. Thus, STMs allow the parallel programmers to focus on the logic of parallel
programs rather than worrying about synchronization.
Heart of such applications is the underlying concurrent data-structure. The design of the underlying
concurrent data-structure is the deciding factor whether the software application would be efficient, scalable
and composable. However, achieving composition in concurrent data structures such that they are efficient as
well as easy to program poses many consistency and design challenges.
We say a concurrent data structure compose when multiple operations from same or different object
instances of the concurrent data structure can be glued together such that the new operation also behaves
atomically. For example, assume we have a linked-list as the concurrent data structure with lookup, insert
and delete as the atomic operations. Now, we want to implement the new move operation, which would delete
a node from one position of the list and would insert into the another or same list. Such a move operation
may not be atomic(transactional) as it may result in an execution where another process may access the
inconsistent state of the linked-list where the node is deleted but not yet inserted into the list. Thus, this
inability of composition in the concurrent data structures may hinder their practical use.
In this context, the property of compositionality provided by the transactions in STMs can be handy.
STMs provide easy to program and compose transactional interface which can be used to develop concurrent
data structures thus the parallel software applications. However, whether this can be achieved efficiently is a
question we would try to answer in this thesis.
Most of the STMs proposed in the literature are based on read/write primitive operations(or methods)
on memory buffers and hence denoted RWSTMs. These lower level read/write primitive operations do not
provide any other useful information except that a write operation always needs to be ordered with any
other read or write. Thus limiting the number of possible concurrent executions. In this thesis, we consider
Object-based STMs or OSTMs which operate on higher level objects rather than read/write operations on
memory locations. The main advantage of considering OSTMs is that with the greater semantic information
provided by the methods of the object, the conflicts among the transactions can be reduced and as a result,
the number of aborts will also be less. This allows for larger number of permissive concurrent executions
leading to more concurrency. Hence, OSTMs could be an efficient means of achieving composability of
higher-level operations in the software applications using the concurrent data structures. This would allow
parallel programmers to leverage underlying multi-core architecture.
To design the OSTM, we have adopted the transactional tree model developed for databases. We extend
the traditional notion of conflicts and legality to higher level operations in STMs which allows efficient
composability. Using these notions we define the standard STM correctness notion of Conflict-Opacity. The
OSTM model can be easily extended to implement concurrent lists, sets, queues or other concurrent data
structures.
We use the proposed theoretical OSTM model to design HT-OSTM - an OSTM with underlying hash table
object. We noticed that major concurrency hot-spot is the chaining data structure within the hash table. So,
we have used Lazyskip-list approach which is time efficient compared to normal lists in terms of traversal
overhead. At the transactional level, we use timestamp ordering protocol to ensure that the executions are
conflict-opaque. We provide a detailed handcrafted proof of correctness starting from operational level to the
transactional level. At the operational level we show that HT-OSTM generates legal sequential history. At
vi
transactional level we show that every such sequential history would be opaque thus co-opaque.
The HT-OSTM exports STM insert, STM lookup and STM delete methods to the programmer
along-with STM begin and STM trycommit. Using these higher level operations user may easily and
efficiently program any parallel software application involving concurrent hash table. To demonstrate the
efficiency of composition we build a test application which executes the number of hash-tab methods (generated
with a given probability) atomically in a transaction. Finally, we evaluate HT-OSTM against ESTM
based hash table of synchrobench and the hash-table designed for RWSTM based on basic time stamp ordering
protocol. We observe that HT-OSTM outperforms ESTM by the average magnitude of 106 transactions
per second(throughput) for both lookup intensive and update intensive work load. HT-OSTM outperforms
RWSTM by 3% & 3.4% update intensive and lookup intensive workload respectively
10 citations
••
26 Oct 2011
TL;DR: This paper analyzes the sources of performance losses in hardware transactional memory and investigates techniques to reduce the losses and proposes the 5C cache-miss classification model that extends the well-established 4C model with a new class of cache misses known as contamination misses.
Abstract: This paper analyzes the sources of performance losses in hardware transactional memory and investigates techniques to reduce the losses. It dissects the root causes of data conflicts in hardware transactional memory systems (HTM) into four classes of conflicts: true sharing, false sharing, silent store, and write-write conflicts. These conflicts can cause performance and energy losses due to aborts and extra communication. To quantify losses, the paper first proposes the 5C cache-miss classification model that extends the well-established 4C model with a new class of cache misses known as contamination misses. The paper also contributes with two techniques for removal of data conflicts: One for removal of false sharing conflicts and another for removal of silent store conflicts. In addition, it revisits and adapts a technique that is able to reduce losses due to both true and false conflicts. All of the proposed techniques can be accommodated in a lazy versioning and lazy conflict resolution HTM built on top of a MESI cache-coherence infrastructure with quite modest extensions. Their ability to reduce performance is quantitatively established, individually as well as in combination. Performance is improved substantially.
10 citations
••
TL;DR: A technique to implement in‐place metadata that does not wrap memory cells is introduced, thus overcoming the bias and allowing STM algorithms to directly access the transactional metadata.
Abstract: SUMMARY
Software transactional memory (STM) algorithms associate metadata with the memory locations accessed during a transaction's lifetime. This metadata may be stored in an external table by resorting to a mapping function that associates the address of a memory cell with the table entry containing the corresponding metadata (out-place or external strategy). Alternatively, the metadata may be stored adjacent to the associated memory cell by wrapping the cell and metadata together (in-place strategy). The implementation techniques to support these two approaches are very different and each STM framework is usually biased towards one of them, only allowing the efficient implementation of STM algorithms which suit one of the approaches and inhibiting a fair comparison with STM algorithms suiting the other. In this paper, we introduce a technique to implement in-place metadata that does not wrap memory cells, thus overcoming the bias and allowing STM algorithms to directly access the transactional metadata. The proposed technique is available as an extension to Deuce and enables the efficient implementation of a wide range of STM algorithms and their fair (unbiased) comparison in a common STM framework. We illustrate the benefits of our approach by analyzing its impact in two popular transactional memory algorithms with several transactional workloads, TL2 and multiversioning, each befitting out-place and in-place, respectively. Copyright © 2013 John Wiley & Sons, Ltd.
10 citations
••
TL;DR: This work presents two simple ways to improve handling of speculative stores--a way to effectively manage lines that exhibit migratory sharing and a way to hide store latency, particularly for those stores that target contended cache lines owned by other concurrent transactions.
Abstract: Hardware transactional memory (HTM) designs are very sensitive to the manner in which speculative updates from transactions are handled in the system. This study highlights how the lack of effective techniques for store management results in a quick degradation in the performance of eager HTM systems with increasing contention and, thus, lends credence to the belief that eager designs do not perform as well as their lazy counterparts when conflicts abound. In this work, we present two simple ways to improve handling of speculative stores--a way to effectively manage lines that exhibit migratory sharing and a way to hide store latency, particularly for those stores that target contended cache lines owned by other concurrent transactions. These two mechanisms yield substantial improvements in execution time when running applications with high contention, allowing eager designs to exceed the performance of lazy ones. Interestingly, the benefits that accrue from these enhancements can be at par with those achieved using more complex system-wide HTM techniques. Coupled with the fact that eager designs are easier to integrate into cache coherent architectures than lazy ones, we claim that with judicious management of stores they represent a more compelling design alternative.
10 citations