Starvation-free secure multiversion concurrency control

Many real-time database applications arise in safety-critical installations and military systems where enforcing security is crucial to the success of the enterprise. A secure real-time database system has to simultaneously satisfy who requirements guarantee data security and minimize the number of missed transaction deadlines. We investigate here the performance implications, in terms of missed deadlines, of guaranteeing security in a real-time database system. In particular, we focus on the concurrency control aspects of this issue. Our main contributions are the following: First, we identify which among the previously proposed real-time concurrency control protocols are capable of providing protection against both direct and indirect (covert channels) means of unauthorized access to data. Second, using a detailed simulation model of a firm-deadline real-time database system, we profile the real-time performance of a representative set of these secure concurrency control protocols. Our experiments show that a prioritized optimistic concurrency control protocol. OPT-WAIT, provides the best overall performance. Third, we propose and evaluate a novel dual approach to secure transaction concurrency control that allows the real-time database system to simultaneously use different concurrency control mechanisms for guaranteeing security and for improving real-time performance. By appropriately choosing these different mechanisms, we have been able to design hybrid concurrency control algorithms that provide even better performance than OPT-WAIT.

A concurrency control mechanism (or a scheduler) is the component of a database system that safeguards the consistency of the database in the presence of interleaved accesses and update requests. We formally show that the performance of a scheduler, i.e., the amount of parallelism that it supports, depends explicitly upon the amount of information that is available to the scheduler. We point out that most previous work on concurrency control is simply concerned with specific points of this basic trade-off between performance and information. In fact, several of these approaches are shown to be optimal for the amount of information that they use.

A new secure 2PL real-time concurrency control algorithm (ES2PL)

For next generation information systems, concurrency control mechanisms are required to handle high level abstract operations and to meet high throughput demands. The currently available single level concurrency control mechanisms for reads and writes are inadequate for future complex information systems. In this paper, we will present a new multilevel concurrency protocol that uses a semantics-based notion of conflict, which is weaker than commutativity, called recoverability . Further, operations are scheduled according to relative conflict , a conflict notion based on the structure of operations. Performance evaluation via extensive simulation studies show that with our multilevel concurrency control protocol, the performance improvement is significant when compared to that of a single level two-phase locking based concurrency control scheme or to that of a multilevel concurrency control scheme based on commutativity alone. Further, simulation studies show that our new multilevel concurrency control protocol performs better even with resource contention.

Control of concurrency is a critical aspect of both performance and correctness of real-time systems. Use of formal policies and mechanisms for concurrency control, in the style of transaction processing systems, would make it easier to reason about the logical correctness of concurrently executing processes in real-time systems. Adaptation of transaction processing techniques to real-time environments is a goal of our research. In this paper we describe a simulator used to study the interactions among scheduling policy, overload management, and concurrency control policy and the effects on the performance of real-time applications. The structure and capabilities of the simulator are described and its use in the evaluation of some concurrency control options for a real-time application is demonstrated. Through this example, we show how the simulation is customized for different processing models, scheduling options, and concurrency control policies.

Since 1990, transaction processing in multilevel secure database management systems (DBMSs) has been receiving a great deal of attention from the database research community. Transaction processing in these systems requires modification of conventional scheduling algorithms and commit protocols. These modifications are necessary because preserving the usual transaction properties when transactions are executing at different security levels often conflicts with the enforcement of the security policy. Considerable effort has been devoted to the development of efficient, secure algorithms for the major types of secure DBMS architectures: kernelized, replicated, and distributed. An additional problem that arises uniquely in multilevel secure DBMSs is that of secure, correct execution when data at multiple security levels must be written within one transaction. Significant progress has been made in a number of these areas, and a few of the techniques have been incorporated into commercial trusted DBMS products. However, there are many open problems remain to be explored. This paper reviews the achievements to date in transaction processing for multilevel secure DBMSs. The paper provides an overview of transaction processing needs and solutions in conventional DBMSs as background, explains the constraints introduced by multilevel security, and then describes the results of research in multilevel secure transaction processing. Research results and limitations in concurrency control, multilevel transaction management, and secure commit protocols are summarized. Finally, important new areas are identified for secure transaction processing research.

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.

Concurrency control and recovery mechanisms are essential for ensuring reliability and consistency in distributed database systems (DDBS). This systematic review examines recent advances between 2020 and 2025, focusing on trends, techniques, and performance models. Following the PRISMA protocol, studies were sourced from the Association for Computing Machinery (ACM) Digital Library, the Institute of Electrical and Electronics Engineers (IEEE) Xplore, SpringerLink, and ScienceDirect using targeted keywords and strict inclusion criteria. Concurrency control approaches are grouped into pessimistic methods, such as Two-Phase Locking (2PL) with high latency under contention, optimistic methods offering higher throughput but increased abort rates, multiversion systems providing read scalability, and adaptive machine learning hybrids that reduce latency in conflict conditions. Recovery mechanisms include Write Ahead Logging (WAL) with minimal performance loss, checkpointing and shadow paging with moderate degradation, and distributed commit protocols like the Paxos consensus protocol that maintain high availability. Performance modelling through queuing theory and Markov chains shows that Optimistic Concurrency Control (OCC) has higher rollback probabilities under heavy load, while Two Phase Locking (2PL) reaches throughput limits at high transaction rates. The review offers a decision framework linking workload characteristics to suitable mechanisms and highlights gaps such as inconsistent benchmarking and limited industrial validation. Future research should focus on unified benchmarking, intelligent adaptive models, and resilient recovery methods for distributed environments.

High-frequency trading (HFT) has always been welcomed because it benefits not only personal benefits but also the whole social welfare. While the recent advance of portfolio selection in HFT market enables to bring about more profit, it yields much contended OLTP workloads. Featuring exploiting the abundant parallelism, transaction pipeline, the state-of-the-art concurrency control (CC) mechanism, however, suffers from limited concurrency confronted with HFT workloads. Its variants that enable more parallel execution by leveraging fine-grained contention information also take little effect. To solve this problem, we for the first time observe and formulate the source of restricted concurrency as harmful ordering of transaction statements. To resolve harmful ordering, we propose PARE, a pipeline-aware reordered execution, to improve application performance by rearranging statements in order of their degrees of contention. In concrete, two mechanisms are devised to ensure the correctness of statement rearrangement and identify the degrees of contention of statements, respectively. We also study the off-line reordering problem. We prove that this problem is NP-hard and present an off-line reordering approach to approximate the optimal reordering strategy. Experiment results show that PARE can improve transaction throughput and reduce transaction latency on HFT applications by up to an order of magnitude than the state-of-the-art CC mechanism.

Performance comparison of database concurrency control mechanisms based on two-phase locking, timestamping and mixed approach

Parallel file systems employ data declustering to increase I/O throughput. As a result, a single read or write operation can generate concurrent data accesses on multiple storage devices. Unless a concurrency control mechanism is employed, familiar file access semantics are likely to be violated. This paper details the transaction-based concurrency control mechanism implemented in the PIOUS parallel file system. Performance results are presented demonstrating that sequential consistency semantics can be provided without loss of system scalability.

Snapshot Isolation (SI) is a concurrency control mechanism that has been implemented by several commercial and open resources platforms. However, under SI, a set of program may experience a non-serializable execution, in which database integrity constraints can be violated. An elegant approach from Fekete (2005) shows how to guarantee serializable execution on platforms that offer both SI and traditional two-phase locking (2PL) concurrency control, by running some transactions (pivots) with 2PL and the rest at SI. While Fekete's Pivot 2PL technique performs better than running all transactions at 2PL, it often loses much performance compared to SI for all transactions. In this paper we identify causes that harm performance of Pivot 2PL, and we propose an improved approach, called Pivot Ordered2PL, in which a few transactions are rewritten (without changing their functionality). We evaluate Pivot Ordered2PL and find it ensures serializable execution with performance close to that of SI.

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.

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.

Developing concurrent applications is not a trivial task. As programs grow larger and become more complex, advanced concurrency control mechanisms are needed to ensure that application consistency is not compromised. Managing mutual exclusion on a per‐object basis is not sufficient to guarantee isolation of sets of semantically‐related actions. In this paper, we consider ‘atomic blocks’, a simple and lightweight concurrency control paradigm that enables arbitrary blocks of code to access multiple shared objects in isolation. We evaluate various strategies for implementing atomic blocks in Java, in such a way that concurrency control is transparent to the programmer, isolation is preserved, and concurrency is maximized. We discuss these concurrency control strategies and evaluate them in terms of complexity and performance. Copyright © 2002 John Wiley & Sons, Ltd.