Showing papers on "Multiversion concurrency control published in 2014"
Posted Content•
TL;DR: Bohm as mentioned in this paper is a concurrency control protocol for main-memory multi-versioned database systems that guarantees serializable execution while ensuring that reads never block writes and does not require reads to perform any book-keeping whatsoever.
Abstract: Multi-versioned database systems have the potential to significantly increase the amount of concurrency in transaction processing because they can avoid read-write conflicts. Unfortunately, the increase in concurrency usually comes at the cost of transaction serializability. If a database user requests full serializability, modern multi-versioned systems significantly constrain read-write concurrency among conflicting transactions and employ expensive synchronization patterns in their design. In main-memory multi-core settings, these additional constraints are so burdensome that multi-versioned systems are often significantly outperformed by single-version systems.
We propose Bohm, a new concurrency control protocol for main-memory multi-versioned database systems. Bohm guarantees serializable execution while ensuring that reads never block writes. In addition, Bohm does not require reads to perform any book-keeping whatsoever, thereby avoiding the overhead of tracking reads via contended writes to shared memory. This leads to excellent scalability and performance in multi-core settings. Bohm has all the above characteristics without performing validation based concurrency control. Instead, it is pessimistic, and is therefore not prone to excessive aborts in the presence of contention. An experimental evaluation shows that Bohm performs well in both high contention and low contention settings, and is able to dramatically outperform state-of-the-art multi-versioned systems despite maintaining the full set of serializability guarantees.
84 citations
24 Feb 2014
TL;DR: In this article, snapshot isolation transactional memory (SHM) is proposed to reduce the number of aborted transactions by up to 20x in some cases by exploiting snapshots, an established database model of transactions and only need to abort on write-write conflicts.
Abstract: Transactional memory represents an attractive conceptual model for programming concurrent applications. Unfortunately, high transaction abort rates can cause significant performance degradation. Conventional transactional memory realizations not only pessimistically abort transactions on every read-write conflict but also because of false sharing, cache evictions, TLB misses, page faults and interrupts. Consequently, the use of transactions needs to be restricted to a very small number of operations to achieve predictable performance, thereby, limiting its benefit to programming simplification. In this paper, we investigate snapshot isolation transactional memory in which transactions operate on memory snapshots that always guarantee consistent reads. By exploiting snapshots, an established database model of transactions, transactions can ignore read-write conflicts and only need to abort on write-write conflicts. Our implementation utilizes a memory controller that supports multiversion memory, to efficiently support snapshotting in hardware.We show that snapshot isolation can reduce the number of aborts in some cases by three orders of magnitude and improve performance by up to 20x.
47 citations
01 Aug 2014
TL;DR: A novel kV-Indirection structure is described to enable efficient (parallelizable) optimistic and pessimistic multi-version concurrency control by utilizing the old versions of records to provide direct access to the recent changes of records without the need of temporal indexes.
Abstract: In multi-version databases, updates and deletions of records by transactions require appending a new record to tables rather than performing in-place updates. This mechanism incurs non-negligible performance overhead in the presence of multiple indexes on a table, where changes need to be propagated to all indexes. Additionally, an uncommitted record update will block other active transactions from using the index to fetch the most recently committed values for the updated record. In general, in order to support snapshot isolation and/or multi-version concurrency, either each active transaction is forced to search a database temporary area (e.g., roll-back segments) to fetch old values of desired records, or each transaction is forced to scan the entire table to find the older versions of the record in a multi-version database (in the absence of specialized temporal indexes).In this work, we describe a novel kV-Indirection structure to enable efficient (parallelizable) optimistic and pessimistic multi-version concurrency control by utilizing the old versions of records (at most two versions of each record) to provide direct access to the recent changes of records without the need of temporal indexes. As a result, our technique results in higher degree of concurrency by reducing the clashes between readers and writers of data and avoiding extended lock delays. We have a working prototype of our concurrency model and kV-Indirection structure in a commercial database and conducted an extensive evaluation to demonstrate the benefits of our multi-version concurrency control, and we obtained orders of magnitude speed up over the single-version concurrency control.
44 citations
TL;DR: C-AMAT, a new performance metric, accounts for concurrency at both the component and system levels for modern memory design for contemporary cache technologies that increasingly rely on access concurrency.
Abstract: Traditional memory performance metrics, such as average memory access time (AMAT), are designed for sequential data accesses and can prove misleading for contemporary cache technologies that increasingly rely on access concurrency. C-AMAT, a new performance metric, accounts for concurrency at both the component and system levels for modern memory design.
37 citations
Patent•
14 Mar 2014
TL;DR: In this article, techniques and solutions for performing transactions within a database system that stores database data using a row store and a column store are presented. But they do not address the problem of atomically changing the state of the transaction object.
Abstract: Techniques and solutions are provided for performing transactions within a database system that stores database data using a row store and a column store. For example, a transaction that performs operations to update data in both the row store and the column store can use the same transaction object. The state of the transaction can be atomically changed. For example, the state of the transaction object can be atomically changed from uncommitted to committed (e.g., set to a commit identifier to represent the committed state).
36 citations
01 Jan 2014
TL;DR: The sequentially constructive model of computation (SC MoC) presented here harnesses the synchronous execution model to achieve deterministic concurrency while addressing concerns that synchronous languages are unnecessarily restrictive and difficult to adopt.
Abstract: Synchronous languages ensure determinate concurrency, but at the price of restrictions on what programs are considered valid, or constructive. Meanwhile, sequential languages such as C and Java offer an intuitive, familiar programming paradigm but provide no guarantees with regard to determinate concurrency. The sequentially constructive (SC) model of computation (MoC) presented here harnesses the synchronous execution model to achieve determinate concurrency while taking advantage of familiar, convenient programming paradigms from sequential languages. In essence, the SC MoC extends the classical synchronous MoC by allowing variables to be read and written in any order and multiple times as long as sequentiality expressed in the program provides sufficient scheduling information to rule out race conditions. This allows to use programming patterns familiar from sequential programming, such as testing and later setting the value of a variable, which are forbidden in the standard synchronous MoC. The SC MoC is a conservative extension in that programs considered constructive in the common synchronous MoC are also SC and retain the same semantics. In this paper, we investigate classes of shared variable accesses, define SC-admissible scheduling as a restriction of “free scheduling,” derive the concept of sequential constructiveness, and present a priority-based scheduling algorithm for analyzing and compiling SC programs efficiently.
33 citations
TL;DR: Control transactions without compromising their simplicity for the sake of expressiveness, application concurrency, or performance.
Abstract: Control transactions without compromising their simplicity for the sake of expressiveness, application concurrency, or performance
27 citations
Patent•
25 Nov 2014
TL;DR: In this article, the authors present a system, method, and computer program product embodiment for garbage collection in a database management system with a multi-version concurrency control (MVCC) block.
Abstract: Disclosed herein are system, method, and computer program product embodiments for performing garbage collection in a database management system with a multi-version concurrency control. An embodiment operate by qualifying a multi-version concurrency control (MVCC) block for garbage collection, where the MVCC block includes multiple cells, each cell corresponding to a row of a table that was acted on by a transaction. Determining that the MVCC block can be garbage collected based on MVCC information in the MVCC block, where the MVCC information includes information that determines whether changes made to rows in the multiple cells are visible in a database management system. Based on the determining, garbage collecting the MVCC block.
26 citations
Patent•
25 Nov 2014
TL;DR: In this article, a row state block is computed based on the row position of the row, and at least one other block is accessed, based in part on row state, to obtain at least 1 timestamp from the computed offset based on a row.
Abstract: An operation on a row of a table of a database is initiated. Thereafter, a multi-version concurrency control (MVCC) object is accessed to identify blocks associated with the row position of the row using bitwise operations. Subsequently, a row state block computed based on the row position of the row is accessed to determine a row state for the row. At least one other block is accessed, based in part on the row state, to obtain at least one timestamp from the computed offset based on the row. Next, the at least one timestamp is stored or retrieved. Related apparatus, systems, techniques and articles are also described.
23 citations
TL;DR: This model has been implemented in a lightweight software transactional memory system, TinySTM, and has been evaluated on a set of benchmarks obtaining an important performance improvement over the baseline TM system.
Abstract: This article describes a transactional memory execution model intended to exploit maximum parallelism from sequential and multithreaded programs. A program code section is partitioned into chunks that will be mapped onto threads and executed transactionally. These transactions run concurrently and out of order, trying to exploit maximum parallelism but managed by a specific fully distributed commit control to meet data dependencies. To accomplish correct parallel execution, a partial precedence order relation is derived from the program code section and/or defined by the programmer. When a conflict between chunks is eagerly detected, the precedence order relation is used to determine the best policy to solve the conflict that preserves the precedence order while maximizing concurrency. The model defines a new transactional state called executed but not committed. This state allows exploiting concurrency on two levels: intrathread and interthread. Intrathread concurrency is improved by having pending uncommitted transactions while executing a new one in the same thread. The new state improves interthread concurrency because it permits out-of-order transaction commits regarding the precedence order. Our model has been implemented in a lightweight software transactional memory system, TinySTM, and has been evaluated on a set of benchmarks obtaining an important performance improvement over the baseline TM system.
20 citations
TL;DR: An extension of Discrete-Event Systems theory to handle dynamically instantiated and terminated threads is proposed, which makes use of elements of Dynamic DES theory to model threads whose lifetimes can be arbitrary.
Patent•
22 Dec 2014
TL;DR: In this paper, the authors present a system, method, and computer program product for garbage collection on a multi-version concurrency control information in the database management system, which operates by determining when a row manipulated by a write transaction is visible to a plurality of readers accessing a table that includes the row.
Abstract: Disclosed herein are system, method, and computer program product embodiments for performing garbage collection on a multi-version concurrency control information in the database management system. An embodiment operates by determining, using multi-version concurrency control (MVCC) information, when a row manipulated by a write transaction is visible to a plurality of readers accessing a table that includes the row. The MVCC information for the row includes at least a creation timestamp, a destruction timestamp and a row state. Once the row is visible to the plurality of readers, garbage collecting at least the creation timestamp or the destruction timestamp in the MVCC information. After the creation timestamp or destruction timestamp have been garbage collected, the plurality of readers use the row state to determine accessibility of the row in the table.
TL;DR: The paper presents a method of reasoning about the behaviour of asynchronous programs in denotational models designed with metric spaces and continuation semantics for concurrency.
Abstract: The paper presents a method of reasoning about the behaviour of asynchronous programs in denotational models designed with metric spaces and continuation semantics for concurrency.
19 May 2014
TL;DR: A novel dynamic concurrency control technique which can significantly improve performance as well as resource utilization for software Transactional Memory applications at higher core counts and can actually improve upon the performance of the oracle chosen specification by more than 10% for certain applications through dynamic adaptation to available parallelism.
Abstract: Software Transactional Memory (STM) systems provide an easy to use programming model for concurrent code and have been found suitable for parallelizing many applications providing performance gains with minimal programmer effort. With increasing core counts on modern processors one would expect increasing benefits. However, we observe that running STM applications on higher core counts is sometimes, in fact, detrimental to performance. This is due to the larger number of conflicts that arise with a larger number of parallel cores. As the number of cores available on processors steadily rise, a larger number of applications are beginning to exhibit these characteristics. In this paper we propose a novel dynamic concurrency control technique which can significantly improve performance (up to 50%) as well as resource utilization (up to 85%) for these applications at higher core counts. Our technique uses ideas borrowed from TCP's network congestion control algorithm and uses self-induced concurrency fluctuations to dynamically monitor and match varying concurrency levels in applications while minimizing global synchronization. Our flux-based feedback-driven concurrency control technique is capable of fully recovering the performance of the best statically chosen concurrency specification (as chosen by an oracle) regardless of the initial specification for several real world applications. Further, our technique can actually improve upon the performance of the oracle chosen specification by more than 10% for certain applications through dynamic adaptation to available parallelism. We demonstrate our approach on the STAMP benchmark suite while reporting significant performance and resource utilization benefits. We also demonstrate significantly better performance when comparing against state of the art concurrency control and scheduling techniques. Further, our technique is programmer friendly as it requires no changes to application code and no offline phases.
19 May 2014
TL;DR: A new class of Serializable SI algorithms (SSI) has been proposed to achieve serializable execution while still allowing concurrency between reads and updates.
Abstract: Since 1990's, Snapshot Isolation (SI) has been widely studied, and it was successfully deployed in commercial and open-source database engines. Berenson et al. showed that data consistency can be violated under SI. Recently, a new class of Serializable SI algorithms (SSI) has been proposed to achieve serializable execution while still allowing concurrency between reads and updates.
24 Mar 2014
TL;DR: A new debug approach for MPSoCs that combines dynamic analysis and the benefits of virtual platforms is proposed that enables automatic exploration of SW behavior, identifies problematic concurrent interactions, provokes possibly erroneous executions and detects concurrency bugs.
Abstract: Writing correct parallel software for modern multi-processor systems-on-chip (MPSoCs) is a complicated task. Programmers can rarely anticipate all possible external and internal interactions in complex concurrent systems. Concurrency bugs originating from races and improper synchronization are difficult to understand and reproduce. Furthermore, traditional debug and verification practices for embedded systems lack support to address this issue efficiently. For instance, programmers still need to step through several executions until finding a buggy state or analyze complex traces, which results in productivity losses. This paper proposes a new debug approach for MPSoCs that combines dynamic analysis and the benefits of virtual platforms. All in all, it (i) enables automatic exploration of SW behavior, (ii) identifies problematic concurrent interactions, (iii) provokes possibly erroneous executions and, ultimately, (iv) detects concurrency bugs. The approach is demonstrated on an industrial-strength virtual platform with a full Linux operating system and real-world parallel benchmarks.
TL;DR: A theoretical testing framework and a test generation algorithm for concurrent systems specified with true‐concurrency models, such as Petri nets or networks of automata, allowing to deal with strong and weak concurrency.
Abstract: We propose a theoretical testing framework and a test generation algorithm for concurrent systems specified with true-concurrency models, such as Petri nets or networks of automata The semantic model of computation of such formalisms is labelled event structures, which allow to represent concurrency explicitly We introduce the notions of strong and weak concurrency: strongly concurrent events must be concurrent in the implementation, while weakly concurrent ones may eventually be ordered The ioco type conformance relations for sequential systems rely on the observation of sequences of actions and blockings; thus, they are not capable of capturing and exploiting concurrency of non-sequential behaviours We propose an extension of ioco for labelled event structures, named co-ioco, allowing to deal with strong and weak concurrency We extend the notions of test cases and test execution to labelled event structures and give a test generation algorithm building a complete test suite for co-ioco Copyright © 2014 John Wiley & Sons, Ltd
TL;DR: A new technique called External Lock Manager (ELM) is introduced, which prevents many anomalies that appear in other isolation levels, but it still can result in non-serializable executions, in which database integrity constraints can be violated.
TL;DR: A comparison of the behaviour and performance of three concurrency control mechanisms commonly adopted in distributed databases for OLTP operational systems of enterprises in terms of throughput rates achieved with varying transaction size and contention is presented.
Abstract: —Concurrency control (CC) in distributed and multidimensional databases is becoming more important due to recent increase in high-volume data storage with increasing online transaction processing (OLTP) requirements for medium and large organisations. This paper examines three concurrency control mechanisms commonly adopted and analyses their performance in distributed databases for OLTP operational systems of enterprises. The three CC mechanisms investigated are, two phase locking (2PL), wait depth limited (WDL) and optimistic concurrency control. These CC mechanisms have been studied well in disk-based systems. However, with the recent advances of cost-effective main memory or in-memory storage that can support much higher transaction rates than disk-based systems, there is sufficient motivation to re-investigate the performance of such CC mechanisms in diverse processor configurations. This paper presents a comparison of their behaviour and performance in terms of throughput rates achieved with varying transaction size and contention. The outcome of this study has resulted in further research proposals for improving the performance of these CC mechanisms for OLTP databases.
Dissertation•
19 Aug 2014
TL;DR: This research aims to demonstrate the efforts towards in-situ applicability of EMMARM, which aims to provide real-time information about concrete mechanical properties of EMTs to help in the diagnosis of central nervous system disorders.
Abstract: ACKNOWLEDGEMENTS First of all, I must express my utmost gratitude to my advisor, Dr. Mary Jean Harrold, for her unlimited support. Mary Jean helped me in all aspects of research from finding a research topic to writing a good research paper. Also, she gave me advice to be a good researcher as well as a good person. I am deeply indebted to Dr. Richard Vuduc. Rich has been a good research mentor from the early stage of my Ph.D. After Mary Jean's passing, he graciously took me as his student and guided me to finish the Ph.D. journey. Naik, and Milos Prvulovic, for their useful comments to complete this research. Especially , I thank Mark for giving me an opportunity to work at a research lab and for showing me his outlook to research. advice has helped me since even when I struggled during my Ph.D.
TL;DR: This survey explores concurrency control models and evaluates how their characteristics contribute positively or negatively to the support for structured communication, focusing the evaluation on reasonability, which determines how easily programmers can reason about a concurrent program's execution.
Patent•
25 Nov 2014TL;DR: In this paper, a sound and maximal causal model with control flow information for maximum concurrency error detection in general multithreaded programs is proposed, based on or integrated with the sequential consistency model, and form the basis for a formula including branch and order variables as first-order logical constraints solvable by an SMT solver.
Abstract: Disclosed systems and methods incorporate a sound and maximal causal model with control flow information for maximum concurrency error detection in general multithreaded programs. The maximal causal model may be based on or integrated with the sequential consistency model, and form the basis for a formula including branch and order variables as first-order logical constraints solvable by an SMT solver for detection or prediction of concurrency errors. The disclosed systems and methods also relate to predictive trace analysis (PTA) for predicting generic concurrency properties using local traces (as opposed to a global trace) through the threads of a multithreaded program. By uniformly modeling violations of concurrency properties and the thread causality as constraints over events, and using an SMT solver, the systems and methods predict property violations allowed by the causal model.
29 Sep 2014
TL;DR: A practical and precise isolation technique for concurrent bugs called Pinso is proposed that seeks to exploit the non-deterministic nature of concurrency bugs and accurately find the root causes of program error, to further help developers maintain concurrent programs.
Abstract: Concurrent programs are known to be difficult to test and maintain. These programs often fail because of concurrency bugs caused by non-deterministic interleavings among shared memory accesses. Even though a concurrency bug can be detected, it is still hard to isolate the root cause of the bug, due to the challenge in understanding the complex thread interleavings or schedules. In this paper, we propose a practical and precise isolation technique for concurrent bugs called Pinso that seeks to exploit the non-deterministic nature of concurrency bugs and accurately find the root causes of program error, to further help developers maintain concurrent programs. Pinso profiles runtime inter-thread interleavings based on a set of summarized memory access patterns, and then, isolates suspicious interleaving patterns in the triaging phase. Using a filtration-oriented scheduler, Pinso effectively eliminates false positives that are irrelevant to the bug. We evaluate Pinso with 11 real-world concurrency bugs, including single- and multi-variable violation, from sever/desktop concurrent applications (MySQL, Apache, and several others). Experiments indicate that our tool accurately isolates the root causes of all the bugs.
07 Apr 2014
TL;DR: This paper presents comparison of the recent concurrency control methods considering the above mentioned parameters about delay, performance, waiting time and number of message exchanges while maintaining correctness.
Abstract: In today's world many of researches have been done on distributed databases. The main issue in distributed databases is to maintain consistency in databases. To maintain consistency in database, correctness criteria must be met. Many of the concurrency control methods are presented earlier, but they have problems about delay, performance, waiting time and number of message exchanges while maintaining correctness. Our paper presents comparison of the recent concurrency control methods considering the above mentioned parameters.
TL;DR: In this paper, the authors perform an in-depth study of concurrency abstractions provided by the Clojure language and study all pairwise combinations of the abstractions, noting which ones compose without issues, and which do not.
Abstract: In the past decades, many different programming models for managing concurrency in applications have been proposed, such as the actor model, Communicating Sequential Processes, and Software Transactional Memory. The ubiquity of multi-core processors has made harnessing concurrency even more important. We observe that modern languages, such as Scala, Clojure, or F#, provide not one, but multiple concurrency models that help developers manage concurrency. Large end-user applications are rarely built using just a single concurrency model. Programmers need to manage a responsive UI, deal with file or network I/O, asynchronous workflows, and shared resources. Different concurrency models facilitate different requirements. This raises the issue of how these concurrency models interact, and whether they are composable. After all, combining different concurrency models may lead to subtle bugs or inconsistencies.
In this paper, we perform an in-depth study of the concurrency abstractions provided by the Clojure language. We study all pairwise combinations of the abstractions, noting which ones compose without issues, and which do not. We make an attempt to abstract from the specifics of Clojure, identifying the general properties of concurrency models that facilitate or hinder composition.
Journal Article•
TL;DR: In a distributed database environment, where the data is spread across several sites there are many concerns to deal with such as concurrency control, deadlock.
Abstract: In a distributed database environment, where the data is spread across several sites there are many concerns to deal with such as concurrency control, deadlock.
Patent•
12 Sep 2014
TL;DR: In this article, methods and systems for real-time transactional database transformation implemented as part of a real time database management system are described. But they do not describe the underlying architecture of the system.
Abstract: Methods and systems are disclosed for real-time transactional database transformation implemented as part of a real-time transactional database management system.
DOI•
01 Jan 2014
TL;DR: A list of popular concurrency patterns is selected and several are implemented as a reusable Eiffel library and described some of the challenges when programming in SCOOP for the first time and provide solutions.
Abstract: The wide distribution of multi-core processors increasingly forces programmers to deal with concurrency. Parallel programming is not easy, but there are many well-known patterns at hand to help developers. SCOOP, an extension to the Eiffel programming language, provides an alternative approach to concurrent programming compared to the threading model used in many other languages. There is little experience in implementing and using concurrency patterns in SCOOP however. We have investigated which patterns are used in practice and compiled a detailed list of pattern descriptions. From this list we selected several popular concurrency patterns and implemented them as a reusable Eiffel library. A small performance comparison shows that the new library is faster and more robust for large data sets than a raw SCOOP solution. We also describe some of the challenges when programming in SCOOP for the first time and provide solutions.