scispace - formally typeset
Search or ask a question
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
More filters
Patent
Justin Gottschlich1, Gilles Pokam, Shiliang Hu, Rolf Kassa, Youfeng Wu, Irina Calciu 
23 Mar 2015
TL;DR: In this paper, a hybrid transactional memory (HyTM) that includes HTM and a program debugger is used to replay a program that includes an HTM instruction and that has been executed.
Abstract: A system is disclosed that includes a processor and a dynamic random access memory (DRAM). The processor includes a hybrid transactional memory (HyTM) that includes hardware transactional memory (HTM), and a program debugger to replay a program that includes an HTM instruction and that has been executed has been executed using the HyTM. The program debugger includes a software emulator that is to replay the HTM instruction by emulation of the HTM. Other embodiments are disclosed and claimed.

5 citations

Book ChapterDOI
31 Aug 2015
TL;DR: In this paper, the authors explore the inherent time and space complexity of lock-based transactional memory TMs, with a focus on the most popular class of progressive lockbased TMs and derive that a progressive TM might enforce a read-only transaction to perform a quadratic in the number of the data items it reads and access a linear number of distinct memory locations.
Abstract: Transactional memory TM allows concurrent processes to organize sequences of operations on shared data items into atomic transactions. A transaction may commit, in which case it appears to have executed sequentially or it may abort, in which case no data item is updated. The TM programming paradigm emerged as an alternative to conventional fine-grained locking techniques, offering ease of programming and compositionality. Though typically themselves implemented using locks, TMs hide the inherent issues of lock-based synchronization behind a nice transactional programming interface. In this paper, we explore inherent time and space complexity of lock-based TMs, with a focus of the most popular class of progressive lock-based TMs. We derive that a progressive TM might enforce a read-only transaction to perform a quadratic in the number of the data items it reads number of steps and access a linear number of distinct memory locations, closing the question of inherent cost of read validation in TMs. We then show that the total number of remote memory references RMRs that take place in an execution of a progressive TM in which n concurrent processes perform transactions on a single data item might reach $$\varOmega n \log n$$, which appears to be the first RMR complexity lower bound for transactional memory.

5 citations

01 Jun 2011
TL;DR: Manchester University Transactions for Scala (MUTS), which instead adds keywords to the Scala compiler to allow for the implementation of transactions through traditional block syntax such as that used in “while” statements, has the potential to be used as a light-weight way of adding support for additional Scala functionality to the compiler.
Abstract: In this paper we argue that the current approaches to implementing transactional memory in Scala, while very clean, adversely affect the programmability, readability and maintainability of transactional code. These problems occur out of a desire to avoid making modifications to the Scala compiler. As an alternative we introduce Manchester University Transactions for Scala (MUTS), which instead adds keywords to the Scala compiler to allow for the implementation of transactions through traditional block syntax such as that used in “while” statements. This allows for transactions that do not require a change of syntax style and do not restrict their granularity to whole classes or methods. While implementing MUTS does require some changes to the compiler’s parser, no further changes are required to the compiler. This is achieved by the parser describing the transactions in terms of existing constructs of the abstract syntax tree, and the use of Java Agents to rewrite to resulting class files once the compiler has completed. In addition to being an effective way of implementing transactional memory, this technique has the potential to be used as a light-weight way of adding support for additional Scala functionality to the Scala compiler.

5 citations

Proceedings ArticleDOI
27 Oct 2010
TL;DR: An analytical model of the execution of transactional memory (TM) systems employs queuing theory to analyze the impact of an essential set of TM design parameters including the conflict rate, number of checkpoints, and implementation overhead, etc.
Abstract: In this paper, we develop an analytical model of the execution of transactional memory (TM) systems. This model employs queuing theory to analyze the impact of an essential set of TM design parameters including the conflict rate, number of checkpoints, and implementation overhead, etc. The model is validated via extensive experiments. To demonstrate the effectiveness of the model, we further study the performance impact of two factors. Our study shows that, for a given TM-based program, the frequency of performing checkpoint can be carefully chosen to minimize the mean transaction completion time. Our study also demonstrated the importance of reducing implementation overhead.

5 citations

Proceedings ArticleDOI
Remigius Meier1, Armin Rigo
28 Jul 2014
TL;DR: It is argued that software-based TM systems are the most promising, especially since they also enable the introduction of large, parallelisable atomic blocks as a better synchronisation mechanism in the language.
Abstract: Dynamic languages became very popular in recent years. At some point, the need for concurrency arose, and many of them made the choice to use a single global interpreter lock (GIL) to synchronise the interpreter in a multithreading scenario. This choice, however, makes it impossible to actually run code in parallel.Here we want to compare different approaches to replacing the GIL with a technology that allows parallel execution. We look at fine-grained locking, shared-nothing, and transactional memory (TM) approaches. We argue that software-based TM systems are the most promising, especially since they also enable the introduction of large, parallelisable atomic blocks as a better synchronisation mechanism in the language.

5 citations


Network Information
Related Topics (5)
Compiler
26.3K papers, 578.5K citations
87% related
Cache
59.1K papers, 976.6K citations
86% related
Parallel algorithm
23.6K papers, 452.6K citations
84% related
Model checking
16.9K papers, 451.6K citations
84% related
Programming paradigm
18.7K papers, 467.9K citations
83% related
Performance
Metrics
No. of papers in the topic in previous years
YearPapers
202316
202240
202129
202063
201970
201888