Search

International audience; Scaling ACID transactions in a cloud database is hard, and providing elastic scalability even harder. In this paper, we present our solution for elastic scalable transaction processing in LeanXcale, an industrial-strength NewSQL database system. Unlike previous solutions, it does not require any hardware assistance. Yet, it does scales linearly to 100s of servers. LeanXcale supports non-intrusive elasticity and can move data partitions without hurting the quality of service of transaction management. We show the correctness of LeanXcale transaction management. Finally, we provide a thorough performance evaluation of our solution on Amazon Web Services (AWS) shared cloud instances. The results show linear scalability, e.g., 5 million TPC-C NewOrder TPM with 200 nodes, which is greater than the TPC-C throughput obtained by the 9th highest result in all history using dedicated hardware used exclusively (not shared like in our evaluation) for the benchmark. Furthermore, the efficiency in terms of TPM per core is double that of the two top TPC-C results (also the only results in a cloud).

Modern DBMSes are designed to support many transactions running simultaneously. DBMS thrashing is indicated by the existence of a sharp drop in transaction throughput. Thrashing behavior in DBMSes is a serious concern to database administrators (DBAs) as well as to DBMS implementers. From an engineering perspective, therefore, it is of critical importance to understand the causal factors of DBMS thrashing. However, understanding the origin of thrashing in modern DBMSes is challenging, due to many factors that may interact with each other.This article aims to better understand the thrashing phenomenon across multiple DBMSes. We identify some of the underlying causes of DBMS thrashing. We then propose a novel structural causal model to explicate the relationships between various factors contributing to DBMS thrashing. Our model derives a number of specific hypotheses to be subsequently tested across DBMSes, providing empirical support for this model as well as important engineering implications for improvements in transaction processing. HighlightsWe propose a novel structural causal model to explain the origins of DBMS thrashing.We presenta space of hypotheses thatcan refine and supportthe proposed model.We extend a recent DBMS-centric research infrastructure for thrashing experiments.We propose a novelanalysis protocolthat can be applied to obtained thrashing data.We suggest engineering implications to DBMS developers and DBAs for better performance.

An outlier is defined as an observation that is significantly different from the other data in its set. An auditor will employ many techniques, processes and tools to identify these entries, and data mining is one such medium through which the auditor can analyze information. The enormous amount of information contained within transactional processing systems׳ logs means that auditors must employ automated systems for anomalous data detection. Several data mining algorithms have been tested, especially those that deal specifically with classification and outlier detection. A group of these previously described algorithms was selected for use in designing and developing a process to assist the auditor in anomalous data detection within audit logs. We have been successful in creating and ratifying an outlier detection process that works in the alphanumeric fields of the audit logs from an information system, thus constituting a useful tool for system auditors performing data analysis tasks.

The throughput of a transaction processing system can be improved by decomposing transactions into steps and allowing the steps of concurrent transactions to be interleaved. In some cases all interleavings are assumed to be acceptable; in others certain interleavings are forbidden. In this paper we describe a new concurrency control that guarantees that only acceptable interleavings occur. We describe the implementation of the new control within the CA-Open Ingres tm database management system and experiments that were run to evaluate its effectiveness using the TPC-C tm Benchmark Transactions. The experiments demonstrate up to 80% improvement when lock contention is high, when long running transactions are a part of the transaction suite, and/or when sufficient system resources are present to support the additional concurrency that the new control allows. Finally, we describe a new correctness criterion that is weaker than serializability and yet guarantees that the specifications of all transactions are met. The criterion can be used to determine the acceptable interleavings for a particular application. The specification of these interleavings can serve as input to the new control.

The concept of transaction is a basic one in database theory. Yet, in some cases the atomicity of a transaction may be relaxed. This happens either to avoid the damage inflicted by the fact that many data elements are locked in long transactions, or to support different view-points of the database that may relax atomicity constraints. This paper defines the concept of transaction, in the environment of PARDES—an intelligent active database and outlines a model in which different modes of consistency co-exist as local decisions. These modes are defined and analyzed. Among the basic modes are: fully consistent (consistent at all times), quasi consistent (eventually consistent) and loosely consistent (failures in derivations are not compensated). This is an extension to the active database definition language that enables the support of implementation considerations using high-level abstractions.

Autonomous multidatabases, Computer Aided Design (CAD) databases, and Object Oriented Databases have requirements which traditional transactions cannot meet. Users of these advanced applications are more sophisticated than users envisioned for On Line Transaction Processing (OLTP) applications a few decades ago. The need to relax the properties of complex database transactions is urgent. Frameworks for flexible transaction systems are needed. This paper is a step towards this objective. This paper addresses the formalization of a new transaction model called Flex transactions, along with execution control and analysis protocols. The algorithm is formalized through the use of Predicate Transition Nets (PTN) and reachability trees.

The goal of checkpointing in database management systems is to save database states on a separate secure device so that the database can be recovered when errors and failures occur. Recent study shows the possibility of a checkpointing mechanism that does not interfere with the transaction processing, and yet achieves the global consistency of the checkpoints. The motivation of non-interfering checkpointing is to improve the system availability. Although the property of non-interference is highly desirable in many applications of distributed database systems, where restricting transaction activity during the checkpointing operation is not feasible, it makes checkpointing complicated and increases the workload of the system. In this paper, we study the practicality of a non-interfering checkpointing algorithm by analyzing the extra workload of the system

Optimistic concurrency control schemes allow uncontrolled access to shared data objects during transaction processing under the explicit assumption that read and write conflicts among transactions are rare events. Before a transaction commits, the DBMS has to validate that no conflict has occurred. Conflict resolution mainly relies on transaction abort. Two different optimistic concurrency control schemes are introduced and compared to each other. The problems of implementing such schemes and their implications on DBMS processing is investigated in some detail. A number of general properties of optimistic concurrency control schemes is derived, and their advantages and drawbacks w.r.t. two-phase locking approaches are discussed.

A distributed transaction system manages information that is dispersed over a number of storage devices. This paper deals with an experimental transaction system designed to satisfy real-time constraints through distributed control of the executions of transactions. Of interest is the correctness of the algorithm for distributed control. Demonstrating the correctness involves showing that the algorithm guarantees the consistency of distributed data, and equally importantly, that every transaction will eventually terminate. Proof of consistency is based on the notion of serializability of transactions while proof of termination is based on the conflict resolution and failure recovery strategies employed by the transaction system.

In the private workspace model of concurrency control the transaction management component of a database management system maintains a private workspace for each transaction. Data items accessed by a transaction, regardless of the access mode, are cached in the workspace. At transaction commit time, its updates are made permananet in the database. In this paper we want to focus our attention on the private workspace model as a framework for the design of concurrency control algorithms which do not require ww synchronization. We present a Two Phase Locking (2PL) derivative called Workspace 2PL (W2PL) and show that in a system employing W2PL no ww synchronization is needed and more importantly, no transaction will restart on a READ request. Furthermore, under the No Blind Writes assumption we can guarantee that no READ request will cause a transaction to starve, thus no Reader will be restarted or starved.