Concurrency Control Algorithm Research Articles

A Survey on Efficient Concurrency Control Algorithm in Distributed Database Systems

Transaction commit protocols help in reaching an agreement among the participating nodes when a transaction has to be committed or aborted. To initiate an agreement each participating node is asked to vote its decision on the operations on its transactional fragment. The participating nodes can decide to either commit or abort an ongoing transaction. In case of a node failure, the active participants take essential steps such as running the termination protocol to preserve database correctness. This paper sought to investigate the current distributed databases commit protocols such as 2PC and 3PC in order to pin-point their shortcomings. For instance, 2PC suffers from blocking of participant site in case of coordinator failure and increased latency due to forced writes of logs. On its part, 3PC suffers more communication overhead due to extra pre-commit phase. Based on these setbacks, an efficient protocol is suggested towards the end of this paper that it believed to address some of the challenges such as blocking and extra message exchange between communicating nodes.

Energy-Efficient Multiple Producer-Consumer

Hardware energy efficiency has been one of the prominent objectives of system design in the last two decades. However, with the recent explosion in mobile computing and the increasing demand for green data centers, software energy efficiency has also risen to be an equally important factor. The majority of classic concurrency control algorithms were designed in an era when energy efficiency was not an important dimension in algorithm design. Concurrency control algorithms are applied to solve a wide range of problems from kernel-level primitives in operating systems to networking devices and web services. These primitives and services are constantly and heavily invoked in any computing system and by a larger scale in networking devices and data centers. Thus, even a small change in their energy spectrum can make a huge impact on overall energy consumption for long periods of time. This paper focuses on the classic producer-consumer problem. First, we study the energy profile of a set of existing producer-consumer algorithms. In particular, we present evidence that although these algorithms share the same functional goals, their behavior with respect to energy consumption are drastically different. Then, we present a dynamic algorithm for the multiple producer-consumer problem, where consumers in a multicore system use learning mechanisms to predict the rate of production, and effectively utilize this prediction to attempt to latch onto previously scheduled CPU wake-ups. Such group latching increases the idle time between consumer activations resulting in more CPU idle time and, hence, lower average CPU frequency. This in turn reduces energy consumption. We enable consumers to dynamically reserve more pre-allocated memory in cases where the production rate is too high. Consumers may compete for the extra space and dynamically release it when it is no longer needed. Our experiments show that our algorithm provides a 38 percent decrease in energy consumption compared to a mainstream semaphore-based producer-consumer implementation when running 10 parallel consumers. We validate the effectiveness of our algorithm with a set of thorough experiments on varying parameters of scalability. Finally, we present our recommendations on when our algorithm is most beneficial.

An improved algorithm for database concurrency control

Concurrency is an effective solution for some of the database problems. As, in database systems, transactions’ conflict is a negative factor that effects on the system performance. Concurrency can be considered a positive solution for this problem, if it is applied under some constraints. This paper proposes an enhancement algorithm of two-phase locking to reduce the transactions’ conflict and achieve deadlock free locking namely deadlock-free cell lock algorithm. Our proposal is based on the reduction of locking level of the data to the smallest restricted point. Also, it is proposed to eliminate deadlock problem of the locking algorithms via forcing the waiting transaction to pass into the rollback or the commit phase. Our proposed algorithm improves the performance of the database and the transactions.

Power‐aware pipelining with automatic concurrency control

SummaryContinuous streaming computations are usually composed of different modules, exchanging data through shared message queues. The selection of the algorithm used to access such queues (ie, the concurrency control) is a critical aspect both for performance and power consumption. In this paper, we describe the design of automatic concurrency control algorithm for implementing power‐efficient communications on shared‐memory multicores. The algorithm automatically switches between nonblocking and blocking concurrency protocols, getting the best from the two worlds, ie, obtaining the same throughput offered by the nonblocking implementation and the same power efficiency of the blocking concurrency protocol. We demonstrate the effectiveness of our approach using two micro‐benchmarks and two real streaming applications.

Concurrency control algorithms for deduplicated cloud storage

Deduplication of data is essential to effectively use cloud storage. As the metadata in deduplicated cloud storage are shared across multiple users, concurrent updates may result in inconsistencies. A coarse-grained locking strategy that has been proposed earlier to overcome this difficulty is not suited for inline deduplication owing to poor performance. In the present work, a fine-grained locking strategy that overcomes this shortcoming is proposed. A metadata structure along with a set of concurrent control mechanisms to accomplish this is presented. This strategy is shown to improve the throughput by as much as 60% with only marginal lock overhead.

Analysing Snapshot Isolation

Snapshot isolation (SI) is a widely used consistency model for transaction processing, implemented by most major databases and some of transactional memory systems. Unfortunately, its classical definition is given in a low-level operational way, by an idealised concurrency-control algorithm, and this complicates reasoning about the behaviour of applications running under SI. We give an alternative specification to SI that characterises it in terms of transactional dependency graphs of Adya et al., generalising serialisation graphs. Unlike previous work, our characterisation does not require adding additional information to dependency graphs about start and commit points of transactions. We then exploit our specification to obtain two kinds of static analyses. The first one checks when a set of transactions running under SI can be chopped into smaller pieces without introducing new behaviours, to improve performance. The other analysis checks whether a set of transactions running under a weakening of SI behaves the same as when running under SI.

Efficiently making (almost) any concurrency control mechanism serializable

Concurrency control (CC) algorithms must trade off strictness for performance. Serializable CC schemes generally pay higher cost to prevent anomalies, both in runtime overhead and in efforts wasted by aborting transactions. We propose the serial safety net (SSN), a serializability-enforcing certifier which can be applied with minimal overhead on top of various CC schemes that offer higher performance but admit anomalies, such as snapshot isolation and read committed. The underlying CC retains control of scheduling and transactional accesses, while SSN tracks the resulting dependencies. At commit time, SSN performs an efficient validation test by examining only direct dependencies of the committing transaction to determine whether it can commit safely or must abort to avoid a potential dependency cycle. SSN performs robustly for various workloads. It maintains the characteristics of the underlying CC without biasing toward certain types of transactions, though the underlying CC might. Besides traditional OLTP workloads, SSN also allows efficient handling of heterogeneous workloads with long, read-mostly transactions. SSN can avoid tracking the majority of reads (thus reducing the overhead of serializability certification) and still produce serializable executions with little overhead. The dependency tracking and validation tests can be done efficiently, fully parallel and latch-free, for multi-version systems on modern hardware with substantial core count and large main memory. We demonstrate the efficiency, accuracy and robustness of SSN using extensive simulations and an implementation that overlays snapshot isolation in ERMIA, a memory-optimized OLTP engine that is capable of running different CC schemes. Evaluation results confirm that SSN is a promising approach to serializability with robust performance and low overhead for various workloads.

Multi Attribute D-S Evidence Theory Based OCC for Shared-State Scheduling in Large Scale Cluster

With the growth of big data problems, nowadays the size of cloud-scale computing clusters is growing rapidly to run complicated parallel processing jobs. To full utilize cluster resources, the cluster management system is being challenged by the scaling cloud size and the often more complicated application requirements. Omega scheduling software provides a flexible and scalable shared-state scheduling architecture for large scale cluster scheduling. One of its key ideas is using an optimistic concurrency control (OCC) algorithm to let parallel schedulers concurrently make decisions. However, there are few studies exploring to extend OCC for a shared-state scheduling architecture. Furthermore, most of the traditional’ shared-state scheduling architectures also use the same OCCs as Omega does. In this paper, we present a multi attributeDempster–Shafer (D-S) evidence theory based OCC for shared-state scheduling. This OCC adaptsthe multi attribute D-S evidence theory to help making conflict decisions for some scheduling transactions. Experiments’ results show that our method can obtain in some respects more optimized scheduling results compared to coarse-grained conflict detection of Omega.

Design, Implementation and Performance Analysis of Concurrency Control Algorithm with Architecture for Temporal Database

Design, Implementation and Performance Analysis of Concurrency Control Algorithm with Architecture for Temporal Database

High-throughput state-machine replication using software transactional memory.

State-machine replication is a common way of constructing general purpose fault tolerance systems. To ensure replica consistency, requests must be executed sequentially according to some total order at all non-faulty replicas. Unfortunately, this could severely limit the system throughput. This issue has been partially addressed by identifying non-conflicting requests based on application semantics and executing these requests concurrently. However, identifying and tracking non-conflicting requests require intimate knowledge of application design and implementation, and a custom fault tolerance solution developed for one application cannot be easily adopted by other applications. Software transactional memory offers a new way of constructing concurrent programs. In this article, we present the mechanisms needed to retrofit existing concurrency control algorithms designed for software transactional memory for state-machine replication. The main benefit for using software transactional memory in state-machine replication is that general purpose concurrency control mechanisms can be designed without deep knowledge of application semantics. As such, new fault tolerance systems based on state-machine replications with excellent throughput can be easily designed and maintained. In this article, we introduce three different concurrency control mechanisms for state-machine replication using software transactional memory, namely, ordered strong strict two-phase locking, conventional timestamp-based multiversion concurrency control, and speculative timestamp-based multiversion concurrency control. Our experiments show that speculative timestamp-based multiversion concurrency control mechanism has the best performance in all types of workload, the conventional timestamp-based multiversion concurrency control offers the worst performance due to high abort rate in the presence of even moderate contention between transactions. The ordered strong strict two-phase locking mechanism offers the simplest solution with excellent performance in low contention workload, and fairly good performance in high contention workload.

Opportunistic Concurrency: A MAC Protocol for Wireless Sensor Networks

How to shorten the time for channel waiting is critical to avoid network contention. Traditional MAC protocols with CSMA often assume that a transmission must be deferred if the channel is busy, so they focus more on the optimization of serial transmission performance. Recent advances in physical layer, however, allows a receiver to reengage onto a stronger incoming signal from an ongoing transmission or interference, and thus shows the potential of parallel transmissions. Indeed, even if the channel is busy, a node has opportunities to carry out a successful transmission. In this study, we propose opportunistic concurrency (OPC), a new MAC layer scheme, which enables sensor nodes to capture the opportunistic concurrency and carry out parallel transmissions instead of always waiting for a clear channel. Based on local concurrency map, which encodes the interactions among different links, OPC utilizes concurrency control algorithm to make transmission decision distributedly. Our experiments on a testbed consisting of 60 TelosB sensor motes identify the transmission opportunities in WSNs with OPC. Evaluation results show that OPC achieves a 17 percent reduction in packet latency, a 9.4 percent addition in throughput and a 10 percent reduction in power consumption compared with existing approaches.

Atomic RMI: A Distributed Transactional Memory Framework

This paper presents Atomic RMI, a distributed transactional memory framework that supports the control flow model of execution. Atomic RMI extends Java RMI with distributed transactions that can run on many Java virtual machines located on different network nodes. Our system employs SVA, a fully-pessimistic concurrency control algorithm that provides exclusive access to shared objects and supports rollback and fault tolerance. SVA is capable of achieving a relatively high level of parallelism by interweaving transactions that access the same objects and by making transactions that do not share objects independent of one another. It also allows any operations within transactions, including irrevocable ones, like system calls, and provides an unobtrusive API. Our evaluation shows that in most cases Atomic RMI performs better than fine grained mutual-exclusion and read/write locking mechanisms. Atomic RMI also performs better than an optimistic transactional memory in environments with high contention and a high ratio of write operations, while being competitive otherwise.

Staring into the abyss

Computer architectures are moving towards an era dominated by many-core machines with dozens or even hundreds of cores on a single chip. This unprecedented level of on-chip parallelism introduces a new dimension to scalability that current database management systems (DBMSs) were not designed for. In particular, as the number of cores increases, the problem of concurrency control becomes extremely challenging. With hundreds of threads running in parallel, the complexity of coordinating competing accesses to data will likely diminish the gains from increased core counts. To better understand just how unprepared current DBMSs are for future CPU architectures, we performed an evaluation of concurrency control for on-line transaction processing (OLTP) workloads on many-core chips. We implemented seven concurrency control algorithms on a main-memory DBMS and using computer simulations scaled our system to 1024 cores. Our analysis shows that all algorithms fail to scale to this magnitude but for different reasons. In each case, we identify fundamental bottlenecks that are independent of the particular database implementation and argue that even state-of-the-art DBMSs suffer from these limitations. We conclude that rather than pursuing incremental solutions, many-core chips may require a completely redesigned DBMS architecture that is built from ground up and is tightly coupled with the hardware.

A Distributed Index Tree and its Concurrency Control Algorithm

This paper presents a new distributed index tree named RDB+-Tree and a concurrency control algorithm named VTC-RDB+. In RDB+-Tree, the leaf node is organized for a hash list. The principle of VTC-RDB+ algorithm can be established by utilizing multiple elements which are in favor of concurrency control and by combining with version and time control method. Theoretical analysis and experimental results show that the RDB+-Tree index tree and VTC-RDB+ algorithm can effectively enhance the query and updating performance of the massive data in the distributed circumstance.

An Adaptive Decision Concurrency Control Algorithm

For the lack of adaptability about the existing concurrency control algorithms, adaptive decision concurrency control algorithm is proposed. ADCC algorithm divides concurrency control process into two phases in: execution authorizing phase and strategy selecting phase. In execution authorizing phase, algorithm compares statistics and effectiveness of transactions to determine the execution order of conflict transactions. In strategy selecting phase, according to transactions’ read/write status and current conflict rate, algorithm selects optimistic/pessimistic conflict resolution strategy adaptively. Such selection mechanism makes ADCC algorithm have high efficiency no matter database system is busy or idle. Simulation experiment proves that ADCC algorithm this paper proposed is superior to classical strict two phases locking algorithm and hybrid concurrency control. So ADCC algorithm performs well in the period of concurrency control.

Research on concurrency control algorithm for real-time collaborative editing systems

Real-time collaborative editing systems are important groupware tools in the computer supported cooperative work (CSCW) field. They support geographically dispersed users to edit shared files, graphics, etc. simultaneously. Currently popular real-time collaborative editing systems mostly use plain text data for edit and synchronization, and the corresponding operations are deleting, adding or modifying characters. The data acquisition system's metadata in this article is the module, such as deleting, adding or modifying a certain question. On the basis of differential synchronization algorithms and generic operation transformation (GOT) algorithm, this paper proposes a new concurrency control algorithm differential synchronization and generic operation transformation control algorithm (DSGOT).

Provide a New Mapping for Deadlock Detection and Resolution Modeling of Distributed Database to Colored Petri Net

of the most important applications of distributed systems is enabling resource sharing between systems. In such environments, if a sequence of procedures to control resource allocation is not possible to create a deadlock exists. Deadlock problem for a distributed database system that uses locking as a concurrency control algorithm, as there are inherent. The following new rule for the modeling of the proposed method using colored Petri nets is presented. In the model proposed the new rules for mapping TWFG with colored Petri nets for modeling the deadlocks detection and resolve. Colored Petri net is considered one of the most widely used formal methods capable of modeling a wide variety of distributed systems are concurrent. A lot of work being done to define the concurrency execution of transactions in Petri nets is that none of these methods of communication with how mapping TWFG with colored Petri nets for modeling the deadlocks detection and resolve. General Terms Databases, distributed, deadlocks, detection, colored Petri net, mapping.

Cooperative NURBS surface modelling framework using partial control algorithm and concurrent protocol

While many computer–aided design (CAD) and product lifecycle management (PLM) software support collaborative modelling, their main limitation is that it is difficult to control the same surface with other collaborative designs simultaneously. As the state–of–the–art product designs require concurrent interactions and fast modelling time, a new and efficient concurrent protocol is needed without distorting design intents of other modellers. This research focuses on how it is achieved using the partial concurrent control algorithm. In order to consider more general modelling, non–uniform rational B–spline (NURBS) is regards as a basis geometric surface representation. Partial concurrent control algorithm generates new control points, basis function and knots for collaborative designers to work on the same surface without any interference to others. The suggested method is embedded in an efficient concurrent optimistic modelling protocol. The usage of the protocol contributes to design a NURBS surface collaboratively as well as to minimise overall modelling time.

Sequential Control Algorithm in the Form of Fuzzy Interpreted Petri Net

Fuzzy Petri nets (PNs) discussed in the literature are usually considered as expert systems involving fuzzy-based reasoning. They are used as decision support or monitoring systems. There were only few ideas of using fuzzy PNs directly as controllers. This paper defines fuzzy interpreted PN, which can be a formal representation of a concurrent control algorithm. Hardware implementation of the net, which uses fuzzy RS flip-flops and fuzzy gates, is proposed. The usefulness of the net for control algorithm description is exemplified by a hot forging process.

面向多租户Web应用的性能隔离方法

Multi-tenancy enables the sharing of resources and costs across a large pool of users, thus allowing for centralization of infrastructure in locations with lower costs. Performance isolation is a key requirement for multi-tenant Web application hosting environments. This paper proposes a performance isolation approach for application-level sharing multi-tenancy Web applications. A fine-grained application-level resource management model based on the transaction-processing chain is first defined, as well as its concurrency control algorithm based on the semaphore mechanism. This model helps to manage resources usage in a transaction-level and phase-targeted way. It reuses one thread within a transaction process, and therefore, avoids the reengineering cost generated by system reconstruction. The end result is an approach that extends the current Web application hosting environments to multi-tenancy aware hosting environments. A detailed set of experiments were performed under different settings for changing workloads in the controlled TPC-W application to evaluate the effectiveness and performance overhead of our approach. Compared to the traditional coarse-grained strategy, experimental results show that the fine-grained strategy based on our approach is more efficient and agile in avoiding performance interference between multiple hosted tenants and CPU overload. Our results also show that the performance overhead of our approach is small.