Transactional memory (TM) is an appealing abstraction for programming multi-core systems. Potential target applications for TM, such as business software and video games, are likely to involve complex data structures and large transactions, requiring specific software solutions (STM). So far, however, STMs have been mainly evaluated and optimized for smaller scale benchmarks. We revisit the main STM design choices from the perspective of complex workloads and propose a new STM, which we call SwissTM. In short, SwissTM is lock- and word-based and uses (1) optimistic (commit-time) conflict detection for read/write conflicts and pessimistic (encounter-time) conflict detection for write/write conflicts, as well as (2) a new two-phase contention manager that ensures the progress of long transactions while inducing no overhead on short ones. SwissTM outperforms state-of-theart STM implementations, namely RSTM, TL2, and TinySTM, in our experiments on STMBench7, STAMP, Lee-TM and red-black tree benchmarks. Beyond SwissTM, we present the most complete evaluation to date of the individual impact of various STM design choices on the ability to support the mixed workloads of large applications.

Transactional workloads are a hallmark of modern OLTP and Web applications, ranging from electronic commerce and banking to online shopping. Often, the database at the core of these applications is the performance bottleneck. Given the limited resources available to the database, transaction execution times can vary wildly as they compete and wait for critical resources. As the competitor is “only a click away, ” valuable (high-priority) users must be ensured consistently good performance via QoS and transaction prioritization. This paper analyzes and proposes prioritization for transactional workloads in traditional database systems (DBMS). This work first performs a detailed bottleneck analysis of resource usage by transactional workloads on commercial and noncommercial DBMS (IBM DB2, PostgreSQL, Shore) under a range of configurations. Second, this work implements and evaluates the performance of several preemptive and non-preemptive DBMS prioritization policies in PostgreSQL and Shore. The primary contributions of this work include (i) understanding the bottleneck resources in transactional DBMS workloads and (ii) a demonstration that prioritization in traditional DBMS can provide 2x–5x improvement for high-priority transactions using simple scheduling policies, without expense to lowpriority transactions. 1.

Multiversion two-phase locking (MV2PL) has been incorporated in some commercial transaction processing systems to support the serializable execution of queries. A drawback to this algorithm is the potentially high cost that it adds to maintain and access prior versions of data In this paper, we present a new multiversion locking algorithm, multiversion query locking (MVQL), that reduces the cost of versioning by accepting weaker forms of consistency for queries than MV2PL. Nevertheless, queries are guaranteed to see transactionconsistent data. We present results from a detailed performance study that show that, under a wide range of conditions, MVQL provides higher throughput to queries and update transactions with a lower storage cost than MV2PL. In the worst case, the performance of MVQL approaches that of MV2PL. 1.

A number of multiversion concurrency control algorithms have been proposed in the past few yes.rs. These algorithms use previous versions of data items in order to improve the level of achievable concurrency. This paper describes a simulation study of the performance of several multiversion concurrency control algorithms, investigating the extent to which they provide increases in the level of concurrency and also the CPU, I/O, and storage costs resulting from the use of multiple versions. The multiversion algorithms are compared with regard to performance with their single-version counterparts and also with each other. It is shown that each multiversion algorithm offers significant performance improvements despite the additional disk accesses involved in accessing old versions of data; the nature of the improvement depends on the algorithm in question. It is also shown that the storage overhead for maintaining old versions that may be required by ongoing transactions is not all that large under most circumstances. Finally, it is demonstrated that it is important for version maintenance to be implemented efficiently, as otherwise the cost of maintaining old versions could outweigh their concurrency benefits.

This paper has two main contributions. First, we present a comprehensive model for nested transaction systems. The model allows rigorous proofs of a wide variety of transaction-processing algorithms in a single uniform framework. The model generalizes most previous work on concurrency control to encompass nested transactions and type-specific concurrency control algorithms. We used the model to define correctness for nested transaction systems and also to discuss alternative correctness criteria. Second, we present a new concurrency control and recovery algorithm for abstract data types in a nested transaction system and prove it correct. The algorithm, which generalizes an algorithm developed by Weihl [42, 39] to handle nested transactions, uses commutativity properties of operations to achieve high levels of concurrency. The results of operations, in addition to their names and arguments, can be used in checking for conflicts, further increasing concurrency. As part of our development of the general model, we present a theorem that provides a general sufficient condition for a transaction-processing algorithm to be correct. This condition is analogous to the "absence of cycles" condition used in the more classical work on concurrency control (e.g., see [7]). We use the condition as the basis of the correctness proof of the algorithms presented in this paper. We have also used it in other work to prove the correctness of other algorithms. For example, in [2], we prove the correctness of Reed's multi-version timesta?ping algorithm [34] and of a type-specific variation of Reed's algorithm that uses the semantics of operations to permit more concurrency. The description and correctness proof of our algorithm are modular. We consider a system structure consisting of many o...

Severe data contention may exist between short update transactions and long read-only queries if both are to access the same database through a conventional concurrency control method. In this paper, we present dynamic finite versioning (DFV) schemes to effectively support concurrent processing of transactions and queries. Without acquiring locks, queries read from a small, fixed number of dynamically derived, transaction-consistent, but maybe slightly obsolete, logical snapshots of the database. On the other hand, transactions access the most up-to-date data in the database without data contention from queries. Intermediate versions created between snapshots are automatically discarded. Furthermore, dirty pages updated by active transactions are allowed to be written back into the database before commitment (i.e., the STEAL policy), and at the same time, consistent logical snapshots can be advanced automatically without quiescing the ongoing transactions or queries. 1 Introduction C...

In this paper, we analyze the performance of dynamic finite versioning (DFV) schemes for concurrent transaction and query processing, where a finite number of consistent snapshots can be derived for query access. We develop analytical models based on a renewal process approximation to evaluate the performance of DFV using M 2 snapshots. The storage overhead and obsolescence faced by queries are measured. Simulation is used to validate the analytical models and to evaluate the trade-offs between various strategies for advancing snapshots when M ? 2. The results show that (1) the analytical models match closely with simulation; (2) both the storage overhead and obsolescence are sensitive to the snapshot-advancing strategies, especially for M ? 2 snapshots; and (3) generally speaking, increasing the number of snapshots demonstrates a trade-off between storage overhead and query obsolescence. For cases with skewed access or low update rates, a moderate increase in the number of snapshots ...

Abstract not found

Snapshot isolation (SI) provides significantly improved concurrency over 2PL, allowing reads to be non-blocking. Unfortunately, it can also lead to non-serializable executions in general. Despite this, it is widely used, supported in many commercial databases, and is in fact the highest available level of consistency in Oracle and PostgreSQL. Sufficient conditions for detecting whether SI anomalies could occur in a given set of transactions were presented recently, and extended to necessary conditions for transactions without predicate reads. In this paper we address several issues in extending the earlier theory to practical detection/correction of anomalies. We first show how to mechanically find a set of programs which is large enough so that we ensure that all executions will be free of SI anomalies, by modifying these programs appropriately. We then address the problem of false positives, i.e., transaction programs wrongly identified as possibly leading to anomalies, and present techniques that can significantly reduce such false positives. Unlike earlier work, our techniques are designed to be automated, rather than manually carried out. We describe a tool which we are developing to carry out this task. The tool operates on descriptions of the programs either taken from the application code itself, or taken from SQL query traces. It can be used with any database system. We have used our tool on two real world applications in production use at IIT Bombay, and detected several anomalies, some of which have caused real world problems. We believe such a tool will be invaluable for ensuring safe execution of the large number of applications which are already running under SI. 1.

Materialized views in data warehouses are maintained incrementally, for reasons of efficiency, to present the latest updates to the users. These views are used by many warehouse readers (users) to execute OLAP queries by running several reader sessions and these views are maintained periodically by maintenance transactions. Therefore, there is an inherent problem of maintaining these views while the reader sessions continue to receive consistent data from these views. In this paper, we discuss a method that allows warehouse maintenance transactions to run concurrently with the reader sessions. Concurrency allows the readers to read the data from the views while the maintenance transaction updates these views. In our proposed method we create additional versions of views dynamically that contain only the modified tuples of the views and provide a mechanism to collapse these versions into the views periodically when there are no reader sessions accessing the views. These versions allow the reader sessions to access the old and the new information. The collapsing of the views is done by a low priority process executing periodically. 1.