Transactional memory

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

Inside Time-based Software Transactional Memory

Abstract: We present a comprehensive analysis and experimental evaluation of time-based validation techniques for Software Transactional Memory (STM). Time-based validation techniques emerge recently as an effective way to reduce the validation overhead for STM systems. In a time-based strategy, information based on global time enables the system to avoid a full validation pass in many cases where it can quickly prove that no consistency violation is possible given the time information for the current transaction and the object it is attempting to open. We show that none of the current timebased strategies offers the best performance across various applications and thread counts. We also show an adaptive technique which has the potential to achieve an overall best performance based on time information and show some preliminary results we have.

Hardware Transactional Memory as Anti-analysis Technique for Software Protectors

Abstract: Software protectors aim to shield executable file against reversing and cracking, by implementing sophisticated mechanisms capable of hiding real binary code and by inserting, inside an executable file, pieces of control code created to reconstruct software to its original state only during execution. This process of hiding and restoring protected bytes is composed by complex code fragments which perform all essential operations, keeping in general a constant structure for all protected software. The goal of this paper is to enhance security of these types of software against crackers, using Hardware Transactional Memories (HTM) by exploiting their features in a way for which they were not designed for. The proposed methodology offers a good level of defence of the protector core part by implementing new specific checks which use hardware processor features, ensuring reliability and a good level of performance with respect to different software implementations and which can be inserted inside a just present chain of checks, enhancing whole programs protection.

Micro-transactions for concurrent data structures

Abstract: SUMMARY Transactional memory is a promising technique for enforcing disciplined access to shared data in a multiprocessor system. Transactional memory simplifies the implementation of a variety of concurrent data structures. In this paper, we study the benefits of a modest, real-time aware, hardware implementation of transactional memory that we call micro-transactions. In particular, we argue that hardware support for micro-transactions allows us to efficiently implement certain data structures. Those data structures are difficult to realize with the atomic operations provided by stock hardware and provide real-time guarantees for those operations. Our main implementation platform is the Java Optimized Processor system, a field-programmable gate array (FPGA) implementation of the Java virtual machine, optimized for real-time Java. We report on the performance of data structures implemented with locks, atomic instructions, and micro-transactions. Our results suggest that transactional memory is an interesting alternative to traditional concurrency control mechanisms. Copyright © 2012 John Wiley & Sons, Ltd.

Scalable and Robust Snapshot Isolation for High-Performance Storage Engines

Abstract: MVCC-based snapshot isolation promises that read queries can proceed without interfering with concurrent writes. However, as we show experimentally, in existing implementations a single long-running query can easily cause transactional throughput to collapse. Moreover, existing out-of-memory commit protocols fail to meet the scalability needs of modern multi-core systems. In this paper, we present three complementary techniques for robust and scalable snapshot isolation in out-of-memory systems. First, we propose a commit protocol that minimizes cross-thread communication for better scalability, avoids touching the write set on commit, and enables efficient fine-granular garbage collection. Second, we introduce the Graveyard Index, an auxiliary data structure that moves logically-deleted tuples out of the way of operational transactions. Third, we present an adaptive version storage scheme that enables fast garbage collection and improves scan performance of frequently-modified tuples. All techniques are engineered to scale well on multi-core processors, and together enable robust performance for complex hybrid workloads.