Read-only Transactions Research Articles

Read-safe snapshots: An abort/wait-free serializable read method for read-only transactions on mixed OLTP/OLAP workloads

This paper proposes Read-Safe Snapshots (RSS), a concurrency control method that ensures reading the latest serializable version on multiversion concurrency control (MVCC) for read-only transactions without creating any serializability anomaly, thereby enhancing the transaction processing throughput under mixed workloads of online transactional processing (OLTP) and online analytical processing (OLAP). Ensuring serializability for data consistency between OLTP and OLAP is vital to prevent OLAP from obtaining nonserializable results. Existing serializability methods achieve this consistency by making OLTP or OLAP transactions aborts or waits, but these can lead to throughput degradation when implemented for large read sets in read-only OLAP transactions under mixed workloads of the recent real-time analysis applications. To deal with this problem, we present an RSS construction algorithm that does not affect the conventional OLTP performance and simultaneously avoids producing additional aborts and waits. Moreover, the RSS construction method can be easily applied to the read-only replica of a multinode system as well as a single-node system because no validation for serializability is required. Our experimental findings showed that RSS could prevent read-only OLAP transactions from creating anomaly cycles under a multinode environment of master-copy replication, which led to the achievement of serializability with the low overhead of about 15% compared to baseline OLTP/OLAP throughputs under snapshot isolation (SI). The OLTP throughput under our proposed method in a mixed OLTP/OLAP workload was about 45% better than SafeSnapshots, a serializable snapshot isolation (SSI) equipped with a read-only optimization method, and did not degrade the OLAP throughput.

VeriTxn: Verifiable Transactions for Cloud-Native Databases with Storage Disaggregation

Cloud-native databases become increasingly popular while exposing to greater data security and correctness risks. Existing verifiable outsourced databases overlook either the correctness risk of transactions, or the disaggregation architecture: a key design consideration of cloud-native databases for performance and elasticity, or both. We present VeriTxn, a novel cloud-native database that efficiently provides verifiability of transaction correctness. VeriTxn relies on the trusted hardware (i.e., Intel SGX) to enable verifiable transaction processing. We build a page-structure cache in the trusted domain, where transactions can be verified with low, constant overhead. VeriTxn further optimizes the read-only transactions by exploiting disaggregation to fit the read-heavy workload in the cloud. We also integrate our proposal into MySQL, a popular open-source database. We conduct extensive experiments to compare VeriTxn against state-of-the-art verifiable databases and evaluate the performance of VeriTxn on MySQL. The results show that VeriTxn introduces tolerable performance degradation for verifiable transactions, while achieving up to 7.03× and 7.93× higher throughput than Litmus and LedgerDB, and its sustainable performance when integrated with MySQL.

C5

Asynchronously replicated primary-backup databases are commonly deployed to improve availability and offload read-only transactions. To both apply replicated writes from the primary and serve read-only transactions, the backups implement a cloned concurrency control protocol. The protocol ensures read-only transactions always return a snapshot of state that previously existed on the primary. This compels the backup to exactly copy the commit order resulting from the primary's concurrency control. Existing cloned concurrency control protocols guarantee this by limiting the backup's parallelism. As a result, the primary's concurrency control executes some workloads with more parallelism than these protocols. In this paper, we prove that this parallelism gap leads to unbounded replication lag, where writes can take arbitrarily long to replicate to the backup and which has led to catastrophic failures in production systems. We then design C5, the first cloned concurrency protocol to provide bounded replication lag. We implement two versions of C5: Our evaluation in MyRocks, a widely deployed database, demonstrates C5 provides bounded replication lag. Our evaluation in Cicada, a recent in-memory database, demonstrates C5 keeps up with even the fastest of primaries.

Mitigating Conflicting Transactions in Hyperledger Fabric-Permissioned Blockchain for Delay-Sensitive IoT Applications

Blockchain is a promising emerging technology that is envisioned to play a key role in establishing secure and reliable Internet-of-Things (IoT) ecosystems without the involvement of any third party. Hyperledger Fabric, a permissioned blockchain system that can yield high throughput and low consensus delay, has shown its capability in enhancing security and privacy protection for delay-sensitive IoT services. The literature, however, has not considered the conflicting transaction problem which may substantially limit the system performance and degrade QoS for the end users. In this article, we propose CATP-Fabric, a new blockchain system to address the conflicting transaction problem by reducing the number of potentially conflicting transactions with less overhead. First, the transactions within a block are divided into different groups to facilitate parallel transaction processing. Then, CATP-Fabric filters stale transactions and prioritizes the read-only transactions in each group to eliminate unnecessary overhead. Finally, we formulate the selection of aborting transactions in CATP-Fabric as a binary integer-programming problem and develop a low-complexity optimization algorithm to minimize the number of aborted transactions. Illustrative results show that our proposed CATP-Fabric blockchain system achieves high throughput of successful transactions while maintaining a lower aborting transaction rate compared to the benchmark blockchain systems.

Optimistic Transaction Processing in Deterministic Database

Deterministic databases can improve the performance of distributed workload by eliminating the distributed commit protocol and reducing the contention cost. Unfortunately, the current deterministic scheme does not consider the performance scalability within a single machine. In this paper, we describe a scalable deterministic concurrency control, Deterministic and Optimistic Concurrency Control (DOCC), which is able to scale the performance both within a single node and across multiple nodes. The performance improvement comes from enforcing the determinism lazily and avoiding read-only transaction blocking the execution. The evaluation shows that DOCC achieves 8x performance improvement than the popular deterministic database system, Calvin.

ThespisTRX

Data consistency defines how usable a data set is. Causal consistency is the strongest type of consistency that can be achieved when data is stored in multiple locations, and fault tolerance is desired. Thespis is a middleware that innovatively leverages the Actor model to implement causal consistency over a DBMS, whilst abstracting complexities for application developers behind a REST interface. Following the evaluation of correctness, performance and scalability of Thespis, it is illustrated how a business application can be guaranteed causal consistency, but still encounter Time-To-Check-Time-To-Use (TOCTOU) race conditions. The design and implementation of ThespisTRX is given, which builds upon, and extends, the Thespis middleware to offer read-only transaction capabilities, allowing clients to read a causally-consistent version of multiple data entities. A correctness analysis illustrates how ThespisTRX avoids TOCTOU race conditions, and empirical performance tests show that this can be achieved with minimal overheads.

Causal consistency and latency optimality

Causal consistency is an attractive consistency model for geo-replicated data stores. It is provably the strongest model that tolerates network partitions. It avoids the long latencies associated with strong consistency, and, especially when using read-only transactions (ROTs), it prevents many of the anomalies of weaker consistency models. Recent work has shown that causal consistency allows "latency-optimal" ROTs, that are nonblocking, single-round and single-version in terms of communication. On the surface, this latency optimality is very appealing, as the vast majority of applications are assumed to have read-dominated workloads. In this paper, we show that such "latency-optimal" ROTs induce an extra overhead on writes that is so high that it actually jeopardizes performance even in read-dominated workloads. We show this result from a practical as well as from a theoretical angle. We present the Contrarian protocol that implements "almost latency-optimal" ROTs, but that does not impose on the writes any of the overheads incurred by latency-optimal protocols. In Contrarian, ROTs are nonblocking and single-version, but they require two rounds of client-server communication. We experimentally show that this protocol not only achieves higher throughput, but, surprisingly, also provides better latencies for all but the lowest loads and the most read-heavy workloads. We furthermore prove that the extra overhead imposed on writes by latency-optimal ROTs is inherent, i.e., it is not an artifact of the design we consider, and cannot be avoided by any implementation of latency-optimal ROTs. We show in particular that this overhead grows linearly with the number of clients.

Scheduling of Concurrent Transactions in Broadcasting Environment

Mobile computing environment is subject to the constraints of bounded network bandwidth, frequently encountered disconnections, insufficient battery power, and system asymmetry. To meet these constraints and to gain high scalability, data broadcasting has been proposed on data transmission techniques. However, updates made to the database in any broadcast cycle are deferred to the next cycle in order to appear to mobile clients with lower data currency. The main goal of this paper is to enhance the transaction performance processing and database currency. The main approach involves decomposing the main broadcast cycle into a number of sub-cycles, where data items are broadcasted as they were originally sequenced in the main cycle while appearing in the most current versions. A concurrency control method AOCCRBSC is proposed to cope well with the cycle decomposition. The proposed method exploits predeclaration and adapts the AOCCRB method by customizing prefetching, back-off, and partial backward and forward validation techniques. As a result, more than one of the conflicting transactions is allowed to commit at the server in the same broadcast cycle which empowers the processing of both update and read-only transactions and improves data currency.

Partial Rollback-based Scheduling on In-memory Transactional Data Grids

Abstract In-memory transactional data girds, often referred to as NoSQL data grids demand high concurrency for scalability and high performance in data-intensive applications. As an alternative concurrency control model, distributed transactional memory (DTM) promises to alleviate the difficulties of lock-based distributed synchronization. However, if a transaction aborts, DTM suffers from additional communication delays to remotely request and retrieve all its objects again, resulting in degraded performance. To avoid unnecessary aborts, the multi-versioning (MV) model of using multiple object versions in DTM can be considered. MV transactional memory inherently guarantees commits of read-only transactions, but limits concurrency of write transactions. We present a new transactional scheduler, called partial rollback-based transactional scheduler (or PTS), for a multi-versioned DTM model. The model supports multiple object versions to exploit concurrency of read-only transactions, and detects conflicts of write transactions at an object level. Instead of aborting a transaction, PTS assigns backoff times for conflicting transactions, and the transaction is rolled-back partially. We implemented PTS on Infinispan, and conducted comprehensive experimental studies on no and partial replication models. Our implementation reveals that PTS improves transactional throughput over MV-Transactional Forwarding Algorithm without PTS and a scalable one-copy serializable partial replication protocol (SCORe) by as much as 2.4× and 1.3×, respectively.

Enabling Lightweight Transactions with Precision Time

Distributed transactional storage is an important service in today's data centers. Achieving high performance without high complexity is often a challenge for these systems due to sophisticated consistency protocols and multiple layers of abstraction. In this paper we show how to combine two emerging technologies---Software-Defined Flash (SDF) and precise synchronized clocks---to improve performance and reduce complexity for transactional storage within the data center. We present a distributed transactional system (called MILANA) as a layer above a durable multi-version key-value store (called SEMEL) for read-heavy workloads within a data center. SEMEL exploits write behavior of SSDs to maintain a time-ordered sequence of versions for each key efficiently and durably. MILANA adds a variant of optimistic concurrency control above SEMEL's API to service read requests from a consistent snapshot and to enable clients to make fast local commit or abort decisions for read-only transactions. Experiments with the prototype reveal up to 43% lower transaction abort rates using IEEE Precision Time Protocol (PTP) vs. the standard Network Time Protocol (NTP). Under the Retwis benchmark, client-local validation of read-only transactions yields a 35% reduction in latency and 55% increase in transaction throughput.

Enabling Lightweight Transactions with Precision Time

Distributed transactional storage is an important service in today's data centers. Achieving high performance without high complexity is often a challenge for these systems due to sophisticated consistency protocols and multiple layers of abstraction. In this paper we show how to combine two emerging technologies---Software-Defined Flash (SDF) and precise synchronized clocks---to improve performance and reduce complexity for transactional storage within the data center. We present a distributed transactional system (called MILANA) as a layer above a durable multi-version key-value store (called SEMEL) for read-heavy workloads within a data center. SEMEL exploits write behavior of SSDs to maintain a time-ordered sequence of versions for each key efficiently and durably. MILANA adds a variant of optimistic concurrency control above SEMEL's API to service read requests from a consistent snapshot and to enable clients to make fast local commit or abort decisions for read-only transactions. Experiments with the prototype reveal up to 43% lower transaction abort rates using IEEE Precision Time Protocol (PTP) vs. the standard Network Time Protocol (NTP). Under the Retwis benchmark, client-local validation of read-only transactions yields a 35% reduction in latency and 55% increase in transaction throughput.

Fast In-Memory Transaction Processing Using RDMA and HTM

DrTM is a fast in-memory transaction processing system that exploits advanced hardware features such as remote direct memory access (RDMA) and hardware transactional memory (HTM). To achieve high efficiency, it mostly offloads concurrency control such as tracking read/write accesses and conflict detection into HTM in a local machine and leverages the strong consistency between RDMA and HTM to ensure serializability among concurrent transactions across machines. To mitigate the high probability of HTM aborts for large transactions, we design and implement an optimized transaction chopping algorithm to decompose a set of large transactions into smaller pieces such that HTM is only required to protect each piece. We further build an efficient hash table for DrTM by leveraging HTM and RDMA to simplify the design and notably improve the performance. We describe how DrTM supports common database features like read-only transactions and logging for durability. Evaluation using typical OLTP workloads including TPC-C and SmallBank shows that DrTM has better single-node efficiency and scales well on a six-node cluster; it achieves greater than 1.51, 34 and 5.24, 138 million transactions per second for TPC-C and SmallBank on a single node and the cluster, respectively. Such numbers outperform a state-of-the-art single-node system (i.e., Silo) and a distributed transaction system (i.e., Calvin) by at least 1.9X and 29.6X for TPC-C.

GMU: Genuine Multiversion Update-Serializable Partial Data Replication

In this article we introduce GMU, a genuine partial replication protocol for transactional systems, which exploits an innovative, highly scalable, distributed multiversioning scheme. Unlike existing multiversion-based solutions, GMU does not rely on any global logical clock, which may represent a contention point and a major impairment to system scalability. Also, GMU never aborts read-only transactions and spares them from undergoing distributed validation schemes. This makes GMU particularly efficient in presence of read-intensive workloads, as typical of a wide range of real-world applications. GMU guarantees the Extended Update Serializability (EUS) isolation level. This consistency criterion is particularly attractive as it is sufficiently strong to ensure correctness even for very demanding applications (such as TPC-C), but is also weak enough to allow efficient and scalable implementations, such as GMU. Further, unlike several relaxed consistency models proposed in literature, EUS shows simple and intuitive semantics, thus being an attractive consistency model for ordinary programmers. We integrated GMU in a popular open source in-memory transactional data grid, namely Infinispan. On the basis of a wide experimental study performed on heterogeneous platforms and using industry standard benchmarks (namely TPC-C and YCSB), we show that GMU achieves almost linear scalability and that it introduces reduced overhead, with respect to solutions ensuring non-serializable semantics, in a wide range of workloads.

WFR-TM: Wait-free readers without sacrificing speculation of writers

Transactional Memory (TM) is a promising concurrent programming paradigm which employs transactions to achieve synchronization in accessing common data known as transactional variables. A transaction may either commit, making its updates to transactional variables visible, or abort, discarding its updates.We introduce WFR-TM, a TM algorithm which attempts to combine the advantages of pessimistic and optimisticTM. In a pessimistic TM, no transaction ever aborts; however, current pessimistic TM implementations, execute update transactions sequentially, decreasing the degree of achieved parallelism. In optimistic TM, transactions are executed concurrently and they commit if they have encountered no conflict during their execution.In WFR-TM, read-only transactions not only are wait-free, but also they never execute expensive synchronization operations (like CAS, LL/SC, etc.). This is achieved without sacrificing the parallelism between update transactions. Update transactions synchronize pessimistically with concurrently executed read-only transactions but they synchronize optimistically with each other.

Serializable snapshot isolation in PostgreSQL

This paper describes our experience implementing PostgreSQL's new serializable isolation level. It is based on the recently-developed Serializable Snapshot Isolation (SSI) technique. This is the first implementation of SSI in a production database release as well as the first in a database that did not previously have a lock-based serializable isolation level. We reflect on our experience and describe how we overcame some of the resulting challenges, including the implementation of a new lock manager, a technique for ensuring memory usage is bounded, and integration with other PostgreSQL features. We also introduce an extension to SSI that improves performance for read-only transactions. We evaluate PostgreSQL's serializable isolation level using several benchmarks and show that it achieves performance only slightly below that of snapshot isolation, and significantly outperforms the traditional two-phase locking approach on read-intensive workloads.

A Single-Version STM that Is Multi-Versioned Permissive

We present PermiSTM, a single-version STM that satisfies a practical notion of permissiveness, usually associated with keeping many versions: it never aborts read-only transactions, and it aborts other transactions only due to a conflicting transaction (writing to a common data item), thereby avoiding spurious aborts. PermiSTM also avoids unnecessary contention on the memory, being disjoint-access parallel.

Inherent Limitations on Disjoint-Access Parallel Implementations of Transactional Memory

Transactional memory (TM) is a popular approach for alleviating the difficulty of programming concurrent applications; TM guarantees that a transaction, consisting of a sequence of operations, appear to be executed atomically. Two fundamental properties of TM implementations are disjoint-access parallelism and the invisibility of read operations. Disjoint access parallelism ensures that operations on disconnected data do not interfere, and thus it is critical for TM scalability. The invisibility of read operations means that their implementation does not write to the memory, thereby reducing memory contention. This paper proves an inherent tradeoff for implementations of transactional memories: they cannot be both disjoint-access parallel and have read-only transactions that are invisible and always terminate successfully. In fact, a lower bound of Ω(t) is proved on the number of writes needed in order to implement a read-only transaction of t items, which successfully terminates in a disjoint-access parallel TM implementation. The results assume strict serializability and thus hold under the assumption of opacity. It is shown how to extend the results to hold also for weaker consistency conditions, snapshot isolation and serializability.

A formal characterization of SI-based ROWA replication protocols

Snapshot isolation (SI) is commonly used in some commercial DBMSs with a multiversion concurrency control mechanism since it never blocks read-only transactions. Recent database replication protocols have been designed using SI replicas where transactions are firstly executed in a delegate replica and their updates (if any) are propagated to the rest of the replicas at commit time; i.e. they follow the Read One Write All (ROWA) approach. This paper provides a formalization that shows the correctness of abstract protocols which cover these replication proposals. These abstract protocols differ in the properties demanded for achieving a global SI level and those needed for its generalized SI (GSI) variant — allowing reads from old snapshots. Additionally, we propose two more relaxed properties that also ensure a global GSI level. Thus, some applications can further optimize their performance in a replicated system while obtaining GSI.

Speculation-based protocols for improving the performance of read-only transactions

A read-only transaction (ROT) does not modify any data. The main issues regarding processing of ROTs are correctness, data currency and performance. Even though the popular two-phase locking (2PL) protocol processes the ROTs correctly with no correctness related issues, its performance deteriorates as data contention increases. Snapshot isolation (SI)-based protocols have been proposed in the literature to improve the performance. However, the SI-based protocols compromise both correctness and data currency aspects. In the literature, speculative locking (SL) approach has been proposed to improve the transaction performance in online transaction processing environments. In this paper, we have proposed efficient speculation-based protocols to improve the performance of ROTs by exploiting features specific to ROT environment. The performance results show that the proposed protocols improve the performance of ROTs over 2PL and SI-based protocols with manageable extra processing resources. Further, the proposed protocols process transactions without any correctness and data currency related issues.

A Multiversion Optimistic Concurrency Control Protocol in Mobile Broadcast Environments

This paper presents MVOCC-MDA-2PV (multiversion optimistic concurrency control with multiversion dynamic adjustment using two-phase validation) protocol for processing mobile real-time transaction in mobile broadcast environments. Transaction validation is performed at two phases: pre-validation and final validation. At the mobile herts (MHs), all mobile transactions (MT) perform pre-validation of transactions by using backward validation mechanism. The pre-validation process is carried out against committed transactions at the server in the last broadcast cycle. Such an early data conflict detection feature can save processing and communication resources. Transactions that survive in pre-validation must be submitted to the server for final validation. The MHs do not need to synchronize with each other and servers for data conflict detection. The protocol can eliminate conflicts between mobile read-only and mobile update transactions, and resolve data conflicts flexibly using multiversion dynamic adjustment of serialization order to avoid unnecessary restarts of transactions. For a mobile ready-only transaction, it can be committed locally in the MH if it passes all the pre-validation in the course of it execution. Respond time of mobile read-only transactions (MROT) is greatly improved. The results of experiment show that the new protocol proposed offers better performance in terms of miss rate and commit rate.