CMS: Checkpoint-Based Multi-versioning System for Software Transactional Memory
01 Jan 2018-pp 471-482
TL;DR: It is formally prove that CMS complies useless-prefix garbage collection (UP-GC), and on the basis of number of memory accesses for searching consistent version, CMS performs better in comparison with conventional multi-version permissive STM.
Abstract: In this paper, we propose a novel checkpoint-based multi-versioning concurrency control system (CMS) for software transactional memory (STM). A checkpoint is defined to refer a set of versions. CMS maintains a list of live read-only transactions for every checkpoint. An appropriate object versioning technique decides on how many older versions are to be kept or to be removed. Moreover, the proposed method does not require any global synchronization point, such as centralized logical clock for versioning. Due to its efficient garbage-collecting mechanism, CMS is suitable for both read and write-dominated workload. We formally prove that CMS complies useless-prefix garbage collection (UP-GC). On the basis of number of memory accesses for searching consistent version, CMS performs better in comparison with conventional multi-version permissive STM.
Citations
More filters
Journal Article•
TL;DR: This paper formally introduces a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent and demonstrates that the performance is quite competitive by comparing other STMs with an STM that uses the algorithm.
Abstract: Most high-performance software transactional memories (STM) use optimistic invisible reads. Consequently, a transaction might have an inconsistent view of the objects it accesses unless the consistency of the view is validated whenever the view changes. Although all STMs usually detect inconsistencies at commit time, a transaction might never reach this point because an inconsistent view can provoke arbitrary behavior in the application (e.g., enter an infinite loop). In this paper, we formally introduce a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent. Validating previously accessed objects is not necessary for that, however, it can be used on-demand to prolong the view's validity. We demonstrate both formally and by measurements that the performance of our approach is quite competitive by comparing other STMs with an STM that uses our algorithm.
220 citations
01 Sep 2016
TL;DR: This paper addresses the synchronization aspect for multiple concurrent threads in a Remote Healthcare System under development by using checkpoint-based multi-versioning Software Transactional Memory for application domain to achieve non-blocking process synchronization.
Abstract: This paper addresses the synchronization aspect for multiple concurrent threads in a Remote Healthcare System (RHS) under development. Resources like data files are shared by multiple stakeholders and users including doctors, trained paramedic staff, patient party or even Government agencies collecting statistical and demographic data. In the system under trial, medical kiosks are setup at distant places where patients visit and their complaints are recorded by trained caregivers. Later, doctor accesses such data from the system, makes a diagnosis and suggests prescriptions accordingly. In such a set-up, it is quite often that more than one users access the same shared resource simultaneously. In conventional lock-based process synchronization, such concurrent processes are blocked by the process holding a lock over the files. The major contribution of this paper is to use checkpoint-based multi-versioning Software Transactional Memory for our application domain to achieve non-blocking process synchronization. With help of multi-versioning technique the proposed method is also able to reduce number of expensive remote validations as well as transactional aborts. Experimental verification finds that proposed method yields higher throughput in comparison to clairvoyant type multi-version concurrency control mechanism.
2 citations
Cites background from "CMS: Checkpoint-Based Multi-version..."
...Patients and Government organizations are involve in the readoperations on database....
[...]
...Index Terms—Concurrency Control, Software Transactional Memory, STM, Multi-versioning STM, Remote Healthcare System....
[...]
References
More filters
20 Aug 1995
TL;DR: STM is used to provide a general highly concurrent method for translating sequential object implementations to non-blocking ones based on implementing a k-word compare&swap STM-transaction, a novel software method for supporting flexible transactional programming of synchronization operations.
Abstract: As we learn from the literature, flexibility in choosing synchronization operations greatly simplifies the task of designing highly concurrent programs. Unfortunately, existing hardware is inflexible and is at best on the level of a Load–Linked/Store–Conditional operation on a single word. Building on the hardware based transactional synchronization methodology of Herlihy and Moss, we offer software transactional memory (STM), a novel software method for supporting flexible transactional programming of synchronization operations. STM is non-blocking, and can be implemented on existing machines using only a Load–Linked/Store–Conditional operation. We use STM to provide a general highly concurrent method for translating sequential object implementations to non-blocking ones based on implementing a k-word compare&swap STM-transaction. Empirical evidence collected on simulated multiprocessor architectures shows that our method always outperforms the non-blocking translation methods in the style of Barnes, and outperforms Herlihy’s translation method for sufficiently large numbers of processors. The key to the efficiency of our software-transactional approach is that unlike Barnes style methods, it is not based on a costly “recursive helping” policy.
1,369 citations
18 Sep 2006
TL;DR: In this article, the authors propose a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent, which can be used on-demand to prolong the view's validity.
Abstract: Most high-performance software transactional memories (STM) use optimistic invisible reads. Consequently, a transaction might have an inconsistent view of the objects it accesses unless the consistency of the view is validated whenever the view changes. Although all STMs usually detect inconsistencies at commit time, a transaction might never reach this point because an inconsistent view can provoke arbitrary behavior in the application (e.g., enter an infinite loop). In this paper, we formally introduce a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent. Validating previously accessed objects is not necessary for that, however, it can be used on-demand to prolong the view's validity. We demonstrate both formally and by measurements that the performance of our approach is quite competitive by comparing other STMs with an STM that uses our algorithm.
221 citations
Journal Article•
TL;DR: This paper formally introduces a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent and demonstrates that the performance is quite competitive by comparing other STMs with an STM that uses the algorithm.
Abstract: Most high-performance software transactional memories (STM) use optimistic invisible reads. Consequently, a transaction might have an inconsistent view of the objects it accesses unless the consistency of the view is validated whenever the view changes. Although all STMs usually detect inconsistencies at commit time, a transaction might never reach this point because an inconsistent view can provoke arbitrary behavior in the application (e.g., enter an infinite loop). In this paper, we formally introduce a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent. Validating previously accessed objects is not necessary for that, however, it can be used on-demand to prolong the view's validity. We demonstrate both formally and by measurements that the performance of our approach is quite competitive by comparing other STMs with an STM that uses our algorithm.
220 citations
TL;DR: This paper proposes the use of Versioned Boxes, which keep a history of values, as the basis for language-level memory transactions, which may improve significantly the concurrency on applications which have longer transactions and a high read/write ratio.
Abstract: In this paper, we propose the use of Versioned Boxes, which keep a history of values, as the basis for language-level memory transactions. Unlike previous work on software transactional memory, in our proposal read-only transactions never conflict with any other concurrent transaction. This may improve significantly the concurrency on applications which have longer transactions and a high read/write ratio.Furthermore, we discuss how we can reduce transaction conflicts by delaying computations and re-executing only parts of a transaction in case of a conflict. We propose two language-level abstractions to support these strategies: the per-transaction boxes and the restartable transactions.Finally, we lay out the basis for a more generic model, which better supports fine-grained restartable transactions. The goal of this new model is to generalize the previous two abstractions to reduce conflicts.
175 citations
25 Jul 2010
TL;DR: This paper studies inherent properties of STMs that use multiple versions to guarantee successful commits of all read-only transactions, and presents an STM algorithm using visible reads that efficiently garbage collects useless object versions.
Abstract: An effective way to reduce the number of aborts in software transactional memory (STM) is to keep multiple versions of transactional objects. In this paper, we study inherent properties of STMs that use multiple versions to guarantee successful commits of all read-only transactions. We first show that these STMs cannot be disjoint-access parallel. We then consider the problem of garbage collecting old object versions, and show that no STM can be optimal in the number of previous versions kept. Moreover, we show that garbage collecting useless versions is impossible in STMs that implement invisible reads. Finally, we present an STM algorithm using visible reads that efficiently garbage collects useless object versions.
117 citations