MCS lock and its variants provide scalability on many-core architectures, using lists of lock requests to reduce access contention on the mutex data. Most recent variants have adopted a two-stage design, allowing requests to be allocated from stack memory rather than heap. However, this design still produces mutex access contention and limits fairness in the presence of fast paths. This paper proposes the Freezer mechanism and its optimization methods, which extend the list structure operations of MCS lock, to reduce mutex access without using heap memory and enable an independent choice of fairness policies and fast paths. Additionally, we propose four optimization methods for queue-based reader-writer locks. Our evaluation using three benchmarks demonstrated the effectiveness of the proposed fair reader-writer locks. They achieved up to 3.5× higher throughput and improved tail latency by up to 2.7× compared to the baselines.

This paper proposes Oze, a concurrency control protocol that handles heterogeneous workloads, including long-running update transactions. Oze explores a large scheduling space using a multi-version serialization graph to reduce false positives. Oze manages the graph in a decentralized manner to exploit many cores in modern servers. We further propose an OLTP benchmark, BoMB (Bill of Materials Benchmark), based on a use case in an actual manufacturing company. BoMB consists of one long-running update transaction and five short transactions that conflict with each other. Experiments using BoMB show that Oze can handle the long-running update transaction while achieving four orders of magnitude higher throughput than state-of-the-art optimistic and multi-version protocols and up to five times higher throughput than pessimistic protocols. We also show Oze performs comparably with existing techniques even in a typical OLTP workload, TPC-C, thanks to a protocol switching mechanism.

Summary This article proposes EPO‐R, which is an efficient garbage collection scheme designed for multi‐version concurrency control (MVCC) protocols. MVCC generates a version for each update operation, and it can exhaust physical memory for dynamically changing environments such as IoT payments. Eager pruning of obsolete versions (EPO) is a novel garbage collection technique for long‐term transactions. We found room for improvement in EPO, which triggers reclamation invocation. EPO is triggered for each write operation, and it wastes CPU resources. The proposed method EPO‐R is triggered on a read operation to address this issue. The result of experiments with 64 CPU cores and workloads with the combination of short‐term and long‐term transactions demonstrated that EPO‐R exhibited 6.3 times higher throughput than that of EPO. The reason for this can be explained by analyzing the number of unreclaimable versions.

Transaction processing is widely used for many applications, such as credit card payments or social data analysis. To deal with these applications, scalable concurrency control protocols have been proposed. Modern techniques mainly target SEARCH and UPDATE operations. Unfortunately, the issues of improving the performance of SCAN, which is used for large size of data analysis, and avoiding phantom anomalies have not been addressed. In this paper, we propose a novel protocol for the efficient execution of transactional wide-range SCAN. The proposed protocol, node-locking, acquires locks of the leaf nodes in the tree index during SCAN to prevent phantoms. The proposed protocol avoids deadlocks due to locking by applying the WaitDie protocol to index nodes. On a workload containing SCAN transactions reading 10,000 records, Silo with the proposed protocol shows up to 743 times performance improvement over the original Silo protocol.

Bamboo is a state-of-the-art concurrency control protocol based on the 2-phase locking protocol. One problem of Bamboo is that it requires transactions to fetch timestamps from a single centralized atomic counter. To replace the concentrated access to it, each transaction should generate timestamps independently. This paper proposes thread-ID method (TID), which dismisses the process of fetching timestamps entirely by assigning an ID to each thread, and transactions use the thread IDs as their timestamps. In high-contention settings, the performance of TID plummets, but proposed optimization FairTID sustains the performance. The experiments measured an improvement of up to 60% from Bamboo with the proposed method.

This paper presents yet another concurrency control analysis platform, CCBench. CCBench supports seven protocols (Silo, TicToc, MOCC, Cicada, SI, SI with latch-free SSN, 2PL) and seven versatile optimization methods and enables the configuration of seven workload parameters. We analyzed the protocols and optimization methods using various workload parameters and a thread count of 224. Previous studies focused on thread scalability and did not explore the space analyzed here. We classified the optimization methods on the basis of three performance factors: CPU cache, delay on conflict, and version lifetime. Analyses using CCBench and 224 threads, produced six insights. The performance of optimistic concurrency control protocol for a read-only workload rapidly degrades as cardinality increases even without L3 cache misses. (I2) Silo can outperform TicToc for some write-intensive workloads by using invisible reads optimization. (I3) The effectiveness of two approaches to coping with conflict (wait and no-wait) depends on the situation. (I4) OCC reads the same record two or more times if a concurrent transaction interruption occurs, which can improve performance. (I5) Mixing different implementations is inappropriate for deep analysis. (I6) Even a state-of-the-art garbage collection method cannot improve the performance of multi-version protocols if there is a single long transaction mixed into the workload. On the basis of I4, we defined the read phase extension optimization in which an artificial delay is added to the read phase. On the basis of I6, we defined the aggressive garbage collection optimization in which even visible versions are collected. The code for CCBench and all the data in this paper are available online at GitHub.