Concurrency Control Algorithm Research Articles

Managing concurrent execution of transactions in mobile ad-hoc network database systems: an energy-efficient approach

A Mobile Ad-hoc Network (MANET) is a collection of mobile, wireless and battery-powered nodes without any fixed infrastructure. Therefore, it fits well in mission-critical applications such as disaster rescue and military operations. However, when a node runs out of energy, communication may fail and transactions may be aborted if they are time-critical and miss their deadlines. In order to provide timely and correct results for multiple concurrent transactions, energy-efficient database concurrency control (CC) techniques become critical for database systems built for MANET. Due to the characteristics of MANET databases, existing CC algorithms cannot work effectively. In this paper, an energy-efficient CC algorithm is developed for mission-critical MANET databases in a clustered network architecture where nodes are divided into clusters, each of which has a cluster head, responsible for the processing of all nodes in the cluster. The cluster structure is constructed using a novel weighted clustering algorithm, which uses node mobility, remaining energy and workload to group nodes into clusters and select cluster heads. In our CC algorithm, we elect cluster heads to work as coordinating servers to conserve energy and balance energy consumption among servers, and propose an optimistic CC algorithm to offer high concurrency and avoid wasting limited system resources. Besides correctness proof and theoretical analysis, comprehensive simulation experiments were conducted, and simulation results show the superiority of our CC algorithm over existing techniques in terms of transaction abort rate, total energy consumption by all servers, and degree of balancing energy consumption among servers.

An intelligent hybrid optimistic/pessimistic concurrency control algorithm for centralized database systems using modified GSA-optimized ART neural model

Concurrency control is the activity of synchronizing operations issued by concurrent executing transactions on a shared database. The aim of this control is to provide an execution that has the same effect as a serial (non-interleaved) one. The optimistic concurrency control technique allows the transactions to execute without synchronization, relying on commit-time validation to ensure serializability. Effectiveness of the optimistic techniques depends on the conflict rate of transactions. Since different systems have various patterns of conflict and the patterns may also change over time, so applying the optimistic scheme to the entire system results in degradation of performance. In this paper, a novel algorithm is proposed that dynamically selects the optimistic or pessimistic approach based on the value of conflict rate. The proposed algorithm uses an adaptive resonance theory–based neural network in making decision for granting a lock or detection of the winner transaction. In addition, the parameters of this neural network are optimized by a modified gravitational search algorithm. On the other hand, in the real operational environments we know the writeset (WS) and readset (RS) only for a fraction of transactions set before execution. So, the proposed algorithm is designed based on optional knowledge about WS and RS of transactions. Experimental results show that the proposed hybrid concurrency control algorithm results in more than 35 % reduction in the number of aborts in high-transaction rates as compared to strict two-phase locking algorithm that is used in many commercial database systems. This improvement is 13 % as compared to pure-pessimistic approach and is more than 31 % as compared to pure-optimistic approach.

Relaxed Concurrency Control in Software Transactional Memory

Some of today's TM systems implement the two-phase-locking (2PL) algorithm which aborts transactions every time a conflict occurs. 2PL is a simple algorithm that provides fast transactional operations. However, it limits concurrency in benchmarks with high contention because it increases the rate of aborts. We propose the use of a more relaxed concurrency control algorithm to provide better concurrency. This algorithm is based on the conflict-serializability (CS) model. Unlike 2PL, it allows some transactions to commit successfully even when they make conflicting accesses. We implement this algorithm in a STM system and evaluate its performance on 16 cores using standard benchmarks. Our evaluation shows that the algorithm improves the performance of applications with long transactions and high abort rates. Throughput is improved by up to 2.99 times despite the overheads of testing for CS at runtime. These improvements come with little additional implementation complexity and require no changes to the transactional programming model. We also propose an adaptive approach that switches between 2PL and CS to mitigate the overhead in applications that have low abort rates.

Flexible Concurrency Control for Legacy CAD to Construct Collaborative CAD Environment

Collaborative CAD (Co-CAD) systems can be constructed based on either 3D kernel or legacy stand-alone CAD systems, which are typically commercial CAD systems such as CATIA, Pro/E and so on. Most of synchronous Co-CAD systems, especially these based on legacy stand-alone CAD systems, adopt the lock mechanism or the floor control as concurrency controls which are very restrictive and stagnant. A flexible concurrency control method is proposed to support the flexible concurrency control in Co-CAD systems based on legacy stand-alone CAD systems. At first, a model of operation relationship is proposed with special consideration for the concurrency control of these kinds of Co-CAD system. Then two types of data structure, the Collaborative Feature Dependent Graph (Co-FDG) and the Collaborative Feature Operational List (Co-FOL), are presented as the cornerstone of flexible concurrency control. Next a Flexible Concurrency Control Algorithm (FCCA) is proposed. Finally a Selective Undo/Redo Algorithm is proposed which can improve the flexibility of Co-CAD furthermore.

A Concurrency Control Method Based on Commitment Ordering in Mobile Databases

Disconnection of mobile clients from server, in an unclear time and for an unknown duration, due to mobility of mobile clients, is the most important challenges for concurrency control in mobile database with client-server model. Applying pessimistic common classic methods of concurrency control (like 2pl) in mobile database leads to long duration blocking and increasing waiting time of transactions. Because of high rate of aborting transactions, optimistic methods aren`t appropriate in mobile database. In this article, OPCOT concurrency control algorithm is introduced based on optimistic concurrency control method. Reducing communications between mobile client and server, decreasing blocking rate and deadlock of transactions, and increasing concurrency degree are the most important motivation of using optimistic method as the basis method of OPCOT algorithm. To reduce abortion rate of transactions, in execution time of transactions` operators a timestamp is assigned to them. In other to checking commitment ordering property of scheduler, the assigned timestamp is used in server on time of commitment. In this article, serializability of OPCOT algorithm scheduler has been proved by using serializability graph. Results of evaluating simulation show that OPCOT algorithm decreases abortion rate and waiting time of transactions in compare to 2pl and optimistic algorithms.

Optimistic concurrency control by melding trees

This paper describes a new optimistic concurrency control algorithm for tree-structured data called meld. Each transaction executes on a snapshot of a multiversion database and logs a record with its intended updates. Meld processes log records in log order on a cached partial-copy of the last committed state to determine whether each transaction commits. If so, it merges the transaction's updates into that state. Meld is used in the Hyder transaction system and enables Hyder to scale out without partitioning. Since meld is on the critical path of transaction execution, it must be very fast. The paper describes the meld algorithm in detail and reports on an evaluation of an implementation. It can perform over 400K update transactions per second for transactions with two operations, and 130K for transactions with eight operations.

A neural-based concurrency control algorithm for database systems

Concurrency control (CC) algorithms guarantee the correctness and consistency criteria for concurrent execution of a set of transactions in a database. A precondition that is seen in many CC algorithms is that the writeset (WS) and readset (RS) of transactions should be known before the transaction execution. However, in real operational environments, we know the WS and RS only for a fraction of transaction set before execution. However, optional knowledge about WS and RS of transactions is one of the advantages of the proposed CC algorithm in this paper. If the WS and RS are known before the transaction execution, the proposed algorithm will use them to improve the concurrency and performance. On the other hand, the concurrency control algorithms often use a specific static or dynamic equation in making decision about granting a lock or detection of the winner transaction. The proposed algorithm in this paper uses an adaptive resonance theory (ART)-based neural network for such a decision making. In this way, a parameter called health factor (HF) is defined for transactions that is used for comparing the transactions and detecting the winner one in accessing the database objects. HF is calculated using ART2 neural network. Experimental results show that the proposed neural-based CC (NCC) algorithm increases the level of concurrency by decreasing the number of aborts. The performance of proposed algorithm is compared with strict two-phase locking (S2PL) algorithm, which has been used in most commercial database systems. Simulation results show that the performance of proposed NCC algorithm, in terms of number of aborts, is better than S2PL algorithm in different transaction rates.

On the analytical modeling of concurrency control algorithms for Software Transactional Memories: The case of Commit-Time-Locking

We present an analytical performance modeling approach for concurrency control algorithms in the context of Software Transactional Memories (STMs). We consider a realistic execution pattern where each thread alternates the execution of transactional and non-transactional code portions. Our model captures dynamics related to the execution of both (i) transactional read/write memory accesses and (ii) non-transactional operations, even when they occur within transactional contexts. We rely on a detailed approach explicitly capturing key parameters, such as the execution cost of transactional and non-transactional operations, as well as the cost of begin, commit and abort operations. The proposed modeling methodology is general and extensible, lending itself to be easily specialized to capture the behavior of different STM concurrency control algorithms. In this work we specialize it to model the performance of Commit-Time-Locking algorithms, which are currently used by several STM systems. The presented analytical model has been validated against simulation results based on workload profiles derived by tracing applications proper of the STAMP benchmark suite, running on top of the TL2 transactional memory layer.

An improved 2PL-HP based concurrency control algorithm in real time database

In the real time database management systems the mechanism of concurrency control 2PL-high priority, by applying a sacrificing approach of the low-priority transaction during the competition with high priority transaction, not only waste the resources of the system but also decrease the system efficiency due to the increase of the transaction failure because of miss deadline. The survey is focusing on the weak points of this mechanism and presenting a new approach that by omitting the unnecessary restarts greatly improve the efficiency of the system. We also present a new approach for determining the transaction's priority to provide the possibility of more successful transaction. This approach will be more prominent especially when there is more competition among the transactions for locking the resources of the system. By modeling the behavior system in Markov model, this increase in efficiency of the system comparing to the 2PL-HP mechanism has been improved. Key words: Real time databases, concurrency control, transaction priority, performance evaluation.

Secure concurrency control protocol with timeliness guarantees in real-time database systems

Real-time database systems (RTDBSs) are usually applied in the time-critical applications with security constraints. For these applications, RTDBSs must simultaneously satisfy two requirements in guaranteeing data security and minimizing the deadline miss ratio for admitted transactions. Multilevel secure database systems based on mandatory access control can prevent direct unlawful information flows between transactions. However, they cannot be free from illegal information transfers between transactions by means of the concurrency control mechanism, so the novel concurrency control algorithms supporting security and real-time requirements are needed for RTDBSs. In this paper, we present a novel secure real-time concurrency control algorithm (SRCC) for RTDBSs. The SRCC makes an effective tradeoff between security constraints and timing constraints by introducing secure control factor and real-time influence factor. Further, in order to obtain the better real-time performance, an enhanced SRCC called ESRCC is proposed by introducing the concept of similarity. The experimental results show that the ESRCC can ensure excellent real-time performance while guaranteeing data security.

Analysis of Real-Time Multiversion Concurrency Control Algorithms using Serialisability Graphs

This paper analyses the correctness of Multiversion Concurrency Control(MVCC) algorithms that are commonly deployed in Realtime Databases. Database systems for real-time applications must satisfy timing constraints associated with transactions. Typically, a timing constraint is expressed in the form of a deadline and is represented as a priority to be used by schedulers. MVCC Algorithms used here makes use of a specialized version of Serialisation Graph, Called MultiVersion Serialisation Graph(MVSG) to resolve data conflicts to maintain the serialization order among conflicting transactions. Using MVSG,MVCC algorithms can determine which lower priority transactions should be aborted to avoid deadlocks.

Serializable isolation for snapshot databases

Many popular database management systems implement a multiversion concurrency control algorithm called snapshot isolation rather than providing full serializability based on locking. There are well-known anomalies permitted by snapshot isolation that can lead to violations of data consistency by interleaving transactions that would maintain consistency if run serially. Until now, the only way to prevent these anomalies was to modify the applications by introducing explicit locking or artificial update conflicts, following careful analysis of conflicts between all pairs of transactions. This article describes a modification to the concurrency control algorithm of a database management system that automatically detects and prevents snapshot isolation anomalies at runtime for arbitrary applications, thus providing serializable isolation. The new algorithm preserves the properties that make snapshot isolation attractive, including that readers do not block writers and vice versa. An implementation of the algorithm in a relational DBMS is described, along with a benchmark and performance study, showing that the throughput approaches that of snapshot isolation in most cases.

근해 조사용 무인잠수정의 개발

This paper is mainly concerned with the development of a remotely operated vehicle for investigation of the coastal sea. For this, we have designed and constructed a vehicle entitled KMU-ROV(Korea Maritime University Remotely Operated Vehicle), for purpose of investigation mission under 50(m) of the sea surface. We have designed six independent waterproof actuators and the housing of the controller for underwater operation. For six degree-of-freedom motion, we have analyzed the dynamics of the KMU-ROV and have designed a new composition of six actuators including the driving system. For motion control, we have composed a concurrent velocity control algorithm for controlling the speed of all the actuating motors. The control system for the KMU-ROV is composed of a master DSP controller, DSP controller for the motor control and various sensors. We composed the PID control algorithm and a network system for controlling motors using the CAN communication. The performance of the KMU-ROV was presented by testing the developed control algorithm and control system under the water.

B+-트리 기반의 이동객체 색인 기법

이동객체 응용은 빈번하게 변경되는 이동객체의 위치정보를 효과적으로 처리할 수 있는 색인구조를 필요로 한다. 이동객체의 위치를 색인하기 위해 제안된 색인기법들은 대부분 R-트리를 기반으로 하고 있다. R-트리는 변경보다는 검색 연산의 성능에 초점이 맞추어진 색인구조이어서 잦은 변경을 다뤄야 하는 이동객체의 응용에 적합하지 않은 측면이 있다. 일부 연구에서는 R-트리의 변경 연산 성능을 향상시키기 위한 연구를 진행한 바 있다. 하지만, 변경 연산의 성능이 개선되었다 하더라도 R-트리가 기본적으로 내재하고 있는 동시성 제어기법 문제(동시성 제어 기법의 비효율성과 안정성) 때문에 R-트리 기반의 색인기법을 실제 응용에서 쓰는 데는 여전히 문제가 있다. 이 논문에서는 B+-트리와 힐버트 곡선 (Hilbert Curve)를 기반으로 하는 새로운 이동객체 색인 기법을 제안한다. 기존에 제안된 B+-트리 기반의 색인기법과는 다르게 이 논문에서는 힐버트 커브의 해상도(또는 차수, order)를 객체의 분포도와 개수에 따라서 가변적으로 적용하는 방법을 제안한다. 실험을 통해서 제안하는 색인 기법이 응답시간과 처리율 측면에서 기존 색인기법에 비해 우수함을 보인다. Applications involving moving objects require index structures to handle frequent updates of objects' locations efficiently. Several methods to index the current, the past and the future positions of moving objects have been proposed for the applications. Most of them are based on R-tree like index structures. Some researches have made efforts to improve update performance of R-trees that are actually focused on query performance. Even though the update performance is improved by researchers' efforts, the overhead and immaturity of concurrency control algorithms of R-trees makes us hesitate to choose them for moving objects. In this paper, we propose an update efficient indexing method that can be applicable for indexing the past, the current and the future locations. The proposed index is based on B+-Trees and Hilbert curve. We present an advanced Hilbert curve that adjusts automatically the order of Hilbert curve in subregions according to the data distribution and the number of data objects. Through empirical studies, we show that our strategy achieves higher response time and throughput.

Modeling of concurrent web sessions with bounded inconsistency in shared data

Client interactions with web-accessible network services are organized into sessions involving requests that read and write shared application data. When executed concurrently, web sessions may invalidate each other's data. Allowing the session with invalid data to progress might lead to financial penalties for the service provider, while blocking the session's progress will result in user dissatisfaction. A compromise would be to tolerate some bounded data inconsistency, which would allow most of the sessions to progress, while limiting the potential financial loss incurred by the service. This paper develops analytical models of concurrent web sessions with bounded inconsistency in shared data, which enable quantitative reasoning about these tradeoffs. We illustrate our models using the sample buyer scenario from the TPC-W benchmark, and validate them by showing their close correspondence to measured results in both a simulated and a real web server environments. We augment our web server with a profiling and automated decision making infrastructure which is shown to successfully choose the best concurrency control algorithm in real time in response to changing service usage patterns.

Concurrency control based on role concept

A Role-Based Access Control (RBAC) model is used to make a system secure. In addition to keeping systems secure, objects have to be consistent in the presence of multiple transactions. Traditional locking protocols and timestamp ordering schedulers are based on 'first-comer-winner' and 'timestamp order' principles to make multiple conflicting transactions serialisable, respectively. In this paper, we discuss concurrency control algorithms based on the significance of roles. We discuss a Role Ordering (RO) scheduler so that multiple conflicting transactions are serialisable in a significant dominant relation of roles. We evaluate the RO scheduler as compared with the Two-Phase Locking (2PL) protocol.

Making snapshot isolation serializable

Snapshot Isolation (SI) is a multiversion concurrency control algorithm, first described in Berenson et al. [1995]. SI is attractive because it provides an isolation level that avoids many of the common concurrency anomalies, and has been implemented by Oracle and Microsoft SQL Server (with certain minor variations). SI does not guarantee serializability in all cases, but the TPC-C benchmark application [TPC-C], for example, executes under SI without serialization anomalies. All major database system products are delivered with default nonserializable isolation levels, often ones that encounter serialization anomalies more commonly than SI, and we suspect that numerous isolation errors occur each day at many large sites because of this, leading to corrupt data sometimes noted in data warehouse applications. The classical justification for lower isolation levels is that applications can be run under such levels to improve efficiency when they can be shown not to result in serious errors, but little or no guidance has been offered to application programmers and DBAs by vendors as to how to avoid such errors. This article develops a theory that characterizes when nonserializable executions of applications can occur under SI. Near the end of the article, we apply this theory to demonstrate that the TPC-C benchmark application has no serialization anomalies under SI, and then discuss how this demonstration can be generalized to other applications. We also present a discussion on how to modify the program logic of applications that are nonserializable under SI so that serializability will be guaranteed.

Real-time Optimistic Concurrency Control based on Transaction Finish Degree

Concurrency control is one of the main issues in the studies of real-time database systems. Optimistic concurrency control algorithms have the attractive properties of being non-blocking and deadlock-free. However, they have the problems of late conflict detection and transaction restarts. Although the number of transaction restarts is reduced by dynamic adjustment of serialization order in real-time database systems, they are still some unnecessary transaction restarts. In this study, we propose a new method called Transaction Finish Degree (TFD) and a new Multiversion Optimistic Concurrency Control algorithm based on TFD (MVOCC-TFD), which can reduce the number of unnecessary restarts. Theoretical analysis and experimental results demonstrate that the new algorithm can outperform the previous ones

Multiversion-based view maintenance over distributed data sources

Materialized views can be maintained by submitting maintenance queries to the data sources. However, the query results may be erroneous due to concurrent source updates. State-of-the-art maintenance strategies typically apply compensations to resolve such conflicts and assume all source schemata remain stable over time. In a loosely coupled dynamic environment, the sources may autonomously change not only their data but also their schema or semantics. Consequently, either the maintenance or the compensation queries may be broken. Unlike compensation-based approaches found in the literature, we instead model the complete materialized view maintenance process as a view maintenance transaction (VM_Transaction). This way, the anomaly problem can be rephrased as the serializability of VM_Transactions. To achieve VM_Transaction serializability, we propose a multiversion concurrency control algorithm, called TxnWrap , which is shown to be the appropriate design for loosely coupled environments with autonomous data sources. TxnWrap is complementary to the maintenance algorithms proposed in the literature, since it removes concurrency issues from consideration allowing the designer to focus on the maintenance logic. We show several optimizations of TxnWrap, in particular, (1) space optimizations on versioned data materialization and (2) parallel maintenance scheduling. With these optimizations, TxnWrap even outperforms state-of-the-art view maintenance solutions in terms of refresh time. Further, several design choices of TxnWrap are studied each having its respective advantages for certain environmental settings. A correctness proof based on transaction theory for TxnWrap is also provided. Last, we have implemented TxnWrap. The experimental results confirm that TxnWrap achieves predictable performance under a varying rate of concurrency.

A comparative study of some concurrency control algorithms for cluster-based communication networks

This paper presents a comparative study of some concurrency control algorithms for distributed databases of computer clusters which emphasize high availability and high performance requirements. For this purpose, we have analyzed some concurrency control algorithms which are used in commercial DBMSs, such as the pessimistic locking algorithm as it verifies transaction conflicts early in their execution phase, and the optimistic algorithm which investigates the presence of conflicts after the execution phase. A new algorithm is proposed and implemented by a simulation program. The three algorithms were tested using different configurations. Simulation results showed that the locking algorithm performed better than the optimistic method in presence of conflicts between transactions, while the optimistic algorithm provided better results in the absence of conflicts. Furthermore, in a distributed database with a certain probability of conflicts, the locking algorithm can be used to guarantee strong consistency and an acceptable level of performance. However, if this probability is negligible, the system performance can be improved by using the optimistic algorithm. The proposed algorithm offers improved performance in numerous cases. As a result, it can be used in a distributed database to guarantee a satisfactory level of performance in the presence of conflicts.