2PC+: A High Performance Protocol for Distributed Transactions of Micro-service Architecture

Multi-Version Concurrency Control (MVCC) is a database management technique that enables concurrent access to a database while maintaining consistency and isolation between transactions. By maintaining multiple versions of records, MVCC allows readers to access older versions of data while writers update the current version, ensuring that each transaction gets a consistent snapshot of the data without being blocked by others. This reduces the need for locks, allowing higher concurrency and better performance, especially in read-heavy environments. Each transaction is assigned a timestamp to determine which version of the data it can access, and older versions are eventually cleaned up through garbage collection. While MVCC provides high throughput and scalability, it introduces storage overhead due to the need to store multiple versions and can become complex as the number of versions grows. Additionally, MVCC can face issues like phantom reads and write skew, especially in transactions with complex interactions. Despite these challenges, MVCC is widely used in distributed and relational database systems, such as PostgreSQL and MySQL, to provide efficient concurrency control and ensure consistency without the need for heavy locking mechanisms. MVCC is particularly effective in environments where read and write operations are frequent, as it minimizes contention between transactions. By enabling transactions to work with a snapshot of the data, it avoids conflicts that would otherwise arise from simultaneous read and write operations. However, one downside is that the system must manage and track the various versions of each record, which can result in additional overhead for both storage and garbage collection. In some systems, when the number of versions becomes large, it may impact the system’s overall performance. It is especially beneficial in systems where many transactions read the same data concurrently while only a few perform updates. As database systems continue to evolve, improvements in MVCC implementations, such as optimized garbage collection, are helping to mitigate its limitations and enhance scalability. In conclusion, MVCC strikes a balance between concurrency and consistency, making it an ideal choice for certain high-performance, multi-user applications. This Paper addresses the storage overhead of MVCC with optimistic concurrency control.

Main-memory multicore transactional systems have achieved excellent performance using single-version optimistic concurrency control (OCC), especially on uncontended workloads. Nevertheless, systems based on other concurrency control protocols, such as hybrid OCC/ locking and variations on multiversion concurrency control (MVCC), are reported to outperform the best OCC systems, especially with increasing contention. This paper shows that implementation choices unrelated to concurrency control can explain some of these performance differences. Our evaluation shows the strengths and weaknesses of OCC, MVCC, and TicToc concurrency control under varying workloads and contention levels, and the importance of several implementation choices called basis factors. Given sensible basis factor choices, OCC performance does not collapse on high-contention TPC-C. We also present two optimization techniques, deferred updates and timestamp splitting, that can dramatically improve the high-contention performance of both OCC and MVCC. These techniques are known, but we apply them in a new context and highlight their potency: when combined, they lead to performance gains of \(4.74\times \) for MVCC and \(5.01\times \) for OCC in a TPC-C workload.

Optimistic concurrency control, or OCC, can achieve excellent performance on uncontended workloads for main-memory transactional databases. Contention causes OCC's performance to degrade, however, and recent concurrency control designs, such as hybrid OCC/locking systems and variations on multiversion concurrency control (MVCC), have claimed to outperform the best OCC systems. We evaluate several concurrency control designs under varying contention and varying workloads, including TPCC, and find that implementation choices unrelated to concurrency control may explain much of OCC's previously-reported degradation. When these implementation choices are made sensibly, OCC performance does not collapse on high-contention TPC-C. We also present two optimization techniques, commit-time updates and timestamp splitting , that can dramatically improve the high-contention performance of both OCC and MVCC. Though these techniques are known, we apply them in a new context and highlight their potency: when combined, they lead to performance gains of 3.4X for MVCC and 3.6X for OCC in a TPC-C workload.

A serializable concurrency control mechanism ensures consistency for OLTP systems at the expense of a reduced transaction throughput. A DBMS, therefore usually offers the possibility to allocate lower isolation levels for some transactions when it is safe to do so. However, such trading of consistency for efficiency does not come with any safety guarantees. In this article, we study the mixed robustness problem which asks whether, for a given set of transactions and a given allocation of isolation levels, every possible interleaved execution of those transactions that is allowed under the provided allocation is always serializable. That is, whether the given allocation is indeed safe. While robustness has already been studied in the literature for the homogeneous setting where all transactions are allocated the same isolation level, the heterogeneous setting that we consider in this article, despite its practical relevance, has largely been ignored. We focus on multiversion concurrency control and consider the isolation levels that are available in PostgreSQL and Oracle: read committed (RC), snapshot isolation (SI), and serializable snapshot isolation (SSI). We show that the mixed robustness problem can be decided in polynomial time. In addition, we provide a polynomial time algorithm for computing the optimal robust allocation for a given set of transactions, prioritizing lower over higher isolation levels. The present results therefore establish the groundwork to automate isolation level allocation within existing databases supporting multiversion concurrency control.

Concurrency control allows multiple tasks that share data objects to be concurrently executed in a serializable order, thus significantly improving computation progress. However, to accumulate forward progress on energy-harvesting intermittent systems while achieving data consistency across power cycles, existing approaches based on the checkpointing paradigm typically require system suspension at runtime. The runtime overheads incurred by suspension will be more manifest when more tasks are suspended and resumed during checkpointing, offsetting the computation progress improved by concurrent task execution. This paper presents a multiversion concurrency control design, which enables concurrent task execution without system suspension during checkpointing, while maintaining the serializability of task execution and ensuring data consistency after system recovery. We integrated our design into FreeRTOS running on a Texas Instruments device. Experimental results show that, at the very best, our design can double computation progress by reducing the runtime overheads incurred by system checkpointing, especially when tasks are executed with high concurrency.

The availability of high speed networks and improved microprocessor performance have made it possible to build inexpensive cluster of workstations as an appealing platform for parallel and distributed computing. In this paper, we study the performance of a distributed database system synchronized by virtual time (VT) mechanism by experimenting on a LAN-connected collection of 12 Sun-SPARCS workstations. Our experimental results demonstrate that the VT synchronization protocol is a viable concurrency control method, and it yields about 25-30% reduction in the response time, when compared with a widely used, multiversion (MV) concurrency control scheme based on timestamps order. The reason for comparing with the MV approach is that both virtual time and multiversion protocols are based upon the concept of timestamps, and attain high performance by using multiple version of data objects.

Materialized views have become a standard technique for performance improvement in decision support databases and for a variety of monitoring purposes. In order to avoid inconsistencies and thus unpredictable query results, materialized views and their indexes should be maintained immediately within user transaction just like indexes on ordinary tables. Unfortunately, the smaller a materialized view is, the higher the concurrency contention between queries and updates as well as among concurrent updates. Therefore, we have investigated methods that reduce contention without forcing users to sacrifice serializability and thus predictable application semantics. These methods extend escrow locking with multi-granularity (hierarchical) locking, snapshot transactions, multi-version concurrency control, key range locking, and system transactions, i.e., multiple proven database implementation techniques. The complete design eliminates all contention between pure read transactions and pure update transactions as well as contention among pure update transactions as well as contention among pure update transactions; it enables maximal concurrency of mixed read-write transactions with other transactions; it supports bulk operations such as data import and online index creation; and it provides recovery for transaction, media, and system failures.

Log-structured merge-trees (LSM-trees) are widely used in key-value stores because of its excellent write performance. To reduce LSM-tree's read amplification due to overlapping sorted runs, each file (i.e., SSTable) in an LSM-tree is typically associated with a point or range filter to reduce unnecessary I/Os to the runs that do not contain the target key (range). However, as modern SSDs get faster, probing multiple in-memory filters per query often makes the system CPU bottlenecked, thus compromising the system's throughput. In this paper, we developed the Global Range Filter (GRF) for RocksDB that reduces the number of filter probes per query to one. We follow the pioneering Chucky's approach by storing the sorted run IDs within the filter. However, we identify two practical challenges in building a global range filter: correctness in multi-version concurrency control and efficiency in frequent updates. We solve both challenges by the novel Shape Encoding algorithm. With further optimizations, GRF achieves a dominating performance over the state-of-the-art filters under different workloads when integrated into RocksDB.

The MVCC (Multi-Version Concurrency Control) is so far proposed to increase the concurrency of multiple conflicting transactions and the scalability of a distributed system. However, the larger number of transactions are concurrently performed, the larger amount of electric energy is consumed by servers in a system. In our previous studies, the EEMVTO (Energy-Efficient Multi-Version Timestamp Ordering) algorithm is proposed to not only reduce the total electric energy consumption of servers but also increase the throughput of a system by not performing meaningless write methods on each object. In this paper, the IEEMVTO (Improved EEMVTO) algorithm is newly proposed to furthermore reduce the total electric energy consumption of servers by not performing meaningless read methods in addition to meaningless write methods. The evaluation results show the total electric energy consumption of servers can be more reduced in the IEEMVTO algorithm than the EEMVTO algorithm.KeywordsMulti-version concurrency controlEnergy-Efficient Multi-Version Timestamp Ordering (EEMVTO)Improved EEMVTO (IEEMVTO) algorithmObject-based systemTransaction

Multiversion Concurrency Control

Database Management Systems (DBMS) need to handle large updatable datasets in on-line transaction processing (OLTP) workloads. Most modern DBMS provide snapshots of data in multi-version concurrency control (MVCC) transaction management scheme. Each transaction operates on a snapshot of the database, which is calculated from a set of tuple versions. High parallelism and resource-efficient append-only data placement on secondary storage is enabled. One major issue in indexing tuple versions on modern hardware technologies is the high write amplification for tree-indexes.

Blockchains yield to new workloads in database management systems and K/V-Stores. Distributed Ledger Technology (DLT) is a technique for managing transactions in 'trustless' distributed systems. Yet, clients of nodes in blockchain networks are backed by 'trustworthy' K/V-Stores, like LevelDB or RocksDB in Ethereum, which are based on Log-Structured Merge Trees (LSM-Trees). However, LSM-Trees do not fully match the properties of blockchains and enterprise workloads.

Array database systems offer a declarative language for array-based access on multidimensional data. This study explains the integration of ArrayQL inside a relational database system, either addressable through a separate query interface or integrated into SQL as user-defined functions. With a relational database system as the target, we inherit the benefits such as query optimisation and multi-version concurrency control by design. Apart from SQL, having another query language allows processing the data without extraction or transformation out of its relational form. This is possible as we work on a relational array representation, for which we translate each ArrayQL operator into relational algebra. In our evaluation, ArrayQL within Umbra computes matrix operations faster than state of the art database extensions.

With the rapid development of internet, the distributed file system is gradually facing problem of supporting concurrent 10K and 100K servers operations, so it now becomes an important issue that how to improve performance of the metadata server in high concurrent reading /writing environments. This paper designs and implements the distributed file system named Raccoon FS, researches and solves the problem of low response speed of namespace management brought by the lock competition in distributed file system, and it proposes a new metadata namespace management method that realized the technology of Copy-On-Write and Multi-Version Concurrency Control in B+ tree. Through the evaluation, the namespace management that combined COW and MVCC in B+ tree greatly improved the read and write performance.

A Service Level Agreement (SLA) establishes the trustworthiness of service providers and consumers in several domains; including the Internet of Things (IoT). Given the proliferation of Blockchain technology, we find it compelling to reconsider the assumption of trust and centralised governance typically practised in SLA management including monitoring, compliance assessment, and penalty enforcement. Therefore, we argue that, such critical tasks should be operated by blockchain-based smart contracts in a non-repudiable manner beyond the influence of any SLA party. This paper envisions an IoT scenario wherein a firefighting station outsources end-to-end IoT operations to a specialised service provider. The contractual relationship between them is governed by an SLA which stipulates a set of quality requirements and violation consequences. The main contribution of this paper lies in designing, deploying and empirically experimenting a novel blockchain-based SLA monitoring and compliance assessment framework in the context of IoT. This is done by utilising Hyperledger Fabric (HLF), an enterprise-grade blockchain technology. Our work highlights a set of considerations and best practice at two sides, the IoT application monitoring-side and the blockchain-side. Moreover, it experimentally validates the reliability of the proposed monitoring approach, which collects relevant metrics from each IoT component and examines them against the quality requirements stated in the SLA. Finally, we propose a novel design for smart contracts at the blockchain-side, analyse and benchmark the performance, and demonstrate that the new design proves to successfully handle Multiversion Concurrency Control (MVCC) conflicts typically encountered in blockchain applications, while maintaining sound throughput and latency.