scispace - formally typeset
Open AccessBook ChapterDOI

SMV: selective multi-versioning STM

Reads0
Chats0
TLDR
It is shown that the memory consumption of algorithms keeping a constant number of versions per object might grow exponentially with the number of objects, while SMV operates successfully even in systems with stringent memory constraints.
Abstract
We present Selective Multi-Versioning (SMV), a new STM that reduces the number of aborts, especially those of long read-only transactions. SMV keeps old object versions as long as they might be useful for some transaction to read. It is able to do so while still allowing reading transactions to be invisible by relying on automatic garbage collection to dispose of obsolete versions. SMV is most suitable for read-dominated workloads, for which it performs better than previous solutions. It has an up to ×7 throughput improvement over a single-version STMand more than a two-fold improvement over an STMkeeping a constant number of versions per object. We show that the memory consumption of algorithms keeping a constant number of versions per object might grow exponentially with the number of objects, while SMV operates successfully even in systems with stringent memory constraints.

read more

Content maybe subject to copyright    Report

Citations
More filters
Journal Article

A Lazy Snapshot Algorithm with Eager Validation

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.
Proceedings ArticleDOI

On maintaining multiple versions in STM

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.
Proceedings ArticleDOI

Transactional data structure libraries

TL;DR: This work designs and implements a library supporting transactions on any number of maps, sets, and queues, and treats stand-alone data structure operations as first class citizens, and allows them to execute with virtually no overhead, at the speed of the original data structure library.
Proceedings ArticleDOI

KiWi: A Key-Value Map for Scalable Real-Time Analytics

TL;DR: KiWi is presented, the first atomic KV-map to efficiently support simultaneous large scans and real-time access and optimizes memory management jointly with data structure access and is compared to state-of-the-art solutions.
Book ChapterDOI

A TimeStamp Based Multi-version STM Algorithm

TL;DR: This paper presents a time-stamp based multiversion STM system that satisfies opacity and is easy to implement, and formally proves the correctness of the proposedSTM system.
References
More filters
Book

The Java Language Specification

TL;DR: The Java Language Specification, Second Edition is the definitive technical reference for the Java programming language and provides complete, accurate, and detailed coverage of the syntax and semantics of the Java language.
Book

Concurrency Control and Recovery in Database Systems

TL;DR: In this article, the design and implementation of concurrency control and recovery mechanisms for transaction management in centralized and distributed database systems is described. But this can lead to interference between queries and updates.
Proceedings ArticleDOI

Transactional memory: architectural support for lock-free data structures

TL;DR: Simulation results show that transactional memory matches or outperforms the best known locking techniques for simple benchmarks, even in the absence of priority inversion, convoying, and deadlock.
Proceedings ArticleDOI

Software transactional memory

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.
Book

The Art of Multiprocessor Programming

TL;DR: Transactional memory as discussed by the authors is a computational model in which threads synchronize by optimistic, lock-free transactions, and there is a growing community of researchers working on both software and hardware support for this approach.