Lock Conflicts Research Articles

Consistency Validation Method for Java Fine-Grained Lock Refactoring

Many existing refactoring tools reduce the possibility of lock conflicts and improve the concurrency of the system by reducing lock granularity and narrowing the scope of locked objects. However, such refactorings can lead to changes in concurrent program behavior, introduce concurrency errors, and often even produce code that does not compile or can be compiled but has changed semantics. To address the problem of changes in concurrent program behavior caused by transferring from coarse-grained locking to fine-grained lock refactoring, a refactoring consistency validation method for fine-grained locking is proposed. Firstly, the types of behavioral changes caused by the existing refactoring engine are analyzed in terms of thread interactions. Secondly, the relevant consistency checking rules are summarized according to the types. Finally, with the help of various program analysis techniques such as call graph analysis, alias analysis and side-effect analysis, the corresponding checking algorithms are designed according to the consistency checking rules to check the consistency of the program before and after refactoring. We implement an automatic validation tool as an Eclipse plug-in. Our approach is verified by ten open-source projects including HSQLDB, Xalan and Cassandra, etc. A total of 1,483 refactoring methods were tested, and 60 inconsistent synchronization behaviors were found, which improved the robustness of refactoring in terms of data dependence and execution order.

Design and Evaluation of MPI File Domain Partitioning Methods under Extent-Based File Locking Protocol

MPI collective I/O has been an effective method for parallel shared-file access and maintaining the canonical orders of structured data in files. Its implementation commonly uses a two-phase I/O strategy that partitions a file into disjoint file domains, assigns each domain to a unique process, redistributes the I/O data based on their locations in the domains, and has each process perform I/O for the assigned domain. The partitioning quality determines the maximal performance achievable by the underlying file system, as the shared-file I/O has long been impeded by the cost of file system's data consistency control, particularly due to the conflicted locks. This paper proposes a few file domain partitioning methods designed to reduce lock conflicts under the extent-based file locking protocol. Experiments from four I/O benchmarks on the IBM GPFS and Lustre parallel file systems show that the partitioning method producing minimum lock conflicts wins the highest performance. The benefit of removing conflicted locks can be so significant that more than thirty times of write bandwidth differences are observed between the best and worst methods.

Branch-and-Bound interval global optimization on shared memory multiprocessors

The focus of this paper is on the analysis and evaluation of a type of parallel strategies applied to the algorithm Advanced Multidimensional Interval analysis Global Optimization (AMIGO). We investigate two parallel versions of AMIGO, called Parallel AMIGO (PAMIGO) algorithm, Global-PAMIGO and Local-PAMIGO. The idea behind our study is that in order to exploit the potential parallelism of algorithms, researchers need to adapt them to the target computer architectures. Our PAMIGO algorithms have been designed for shared memory architectures and are based on a threaded programming model, which is suitable to be run on current personal computers with multicore processors. Our first experimental results show a promising speed-up up to four process units. We analyse the loss of efficiency when the number of process units is greater than four by obtaining a profile of the algorithm executions. Secondly we experiment with the use of a local memory allocator per thread. This increases the efficiency by reducing the number of lock conflicts given by the standard system memory allocator. Our experimental results for both PAMIGO versions, using up to 15 process units, obtain a good performance for hard to solve problems on unicore and multicore processors. It is noteworthy that both versions of PAMIGO obtain a similar performance. Our experiments may be useful for researchers who use parallel B&B algorithms.

Concurrency control in mobile distributed real-time database systems

With the rapid advances in mobile computing technology, there is an increasing demand for processing real-time transactions in a mobile environment. This paper studies concurrency control problem in mobile distributed real-time database systems (MDRTDBS). Based on the High Priority Two Phase Locking (HP-2PL) scheme, we propose a distributed real-time locking protocol, called Distributed High Priority Two Phase Locking (DHP-2PL), for MDRTDBS. In the protocol, the characteristics of a mobile computing system are considered in resolving lock conflicts. Two strategies are proposed to further improve the system performance and to reduce the impact of mobile network on the performance of the DHP-2PL: (1) A transaction shipping approach is proposed to process transactions in a mobile environment by exploring the well-defined behavior of real-time transactions. (2) We explore the application semantics of real-time database applications by adopting the notion of similarity in concurrency control to further reduce the number of transaction restarts due to priority inversion, which could be very costly in a mobile network. A detailed simulation model of a MDRTDBS has been developed, and a series of simulation experiments have been conducted to evaluate the performance of the proposed approaches and the effectiveness of using similarity for concurrency control in MDRTDBS.

Concurrency Control for Time-constrained Transactions in Distributed Databases Systems

The design of concurrency control protocols for time-constrained transactions is complicated due to the requirements to maintain the database consistency and to satisfy the timing constraints of the transactions. In the past few years, various real-time locking protocols have been proposed for different real-time database systems (RTDBS). However, the use of these protocols for distributed real-time database systems (DRTDBS) has received much less attention, even though many RTDBS are distributed in nature. In this paper, two efficient real-time locking protocols are proposed for DRTDBS. The first one, based on dynamic locking, is called Distributed Hybrid Two Phase Locking (DHb2PL). Its performance has been compared in detail with three other distributed real-time locking protocols. The performance results indicate that DHb2PL is much better than the other protocols as a result of a better approach to resolving lock conflicts and its deadlock free property. The second one, called DRT-S2PL, is based on static locking where the locks required by a transaction are assumed to be known before its execution. Its relative performance as compared with DHb2PL is dependent on the proportion of remote locks required by a transaction. DRT-S2PL is more suitable for systems with transactions which have to set a large proportion of remote locks.

Improved extendible hashing with high concurrency

AbstractWe propose an improved extendible hashing scheme and a bucket multi‐versioning scheme that achieve a higher concurrency. In our improved extendible hashing, the global depth and directory entries are asynchronously modified to reduce lock conflicts on the directory. Furthermore, bucket multi‐versioning enables read‐only access to a bucket which is being split. Simulation studies show that these two methods provide an increase in speed in proportion to the number of processors and that they enable concurrent insertions and retrievals to be performed without either affecting the other.

Hybrid concurrency control for abstract data types

Databases and other transaction-processing systems use concurrency control and recovery algorithms to ensure that transactions are atomic (i.e., serializable and recoverable). We present a new algorithm based on locking that permits more concurrency than existing commutativity-based algorithms. The algorithm exploits type-specific properties of objects; necessary and sufficient constraints on lock conflicts are derived directly from a data type specification. In addition, the algorithm permits operations to be both partial and non-deterministic, and it permits the lock mode for an operation to be determined by its results as well as its name and arguments. We give a complete formal description of the algorithm, encompassing both concurrency control and recovery, and prove that the algorithm satisfies hybrid atomicity, a local atomicity property that combines aspects of static and dynamic atomic algorithms. We also show that the algorithm is optimal in the sense that no hybrid atomic locking scheme can permit more concurrency.

Performance analysis of two-phase locking

A straightforward analytic solution method is developed which takes into account the variability of transaction size (the number of lock requests). The authors first obtain analytic expressions for the probability of lock conflict, probability of deadlock, and the waiting time per lock conflict. They then develop a family of noniterative analytic solutions to evaluate the overall system performance by considering the expansion in transaction response time due to transaction blocking. The accuracy of these solutions is verified by validation against simulation results. Also introduced is a new measure for the degree of lock contention, which is a product of the mean number of lock conflicts per transaction and the mean waiting time per lock conflict (when blocked by an active transaction). It is shown that the variability in transaction size results in an increase in both measures as compared to fixed-size transactions of comparable size. The authors also provide a solution method for the case when the processing times of transaction steps are different.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Analysis of database performance with dynamic locking

A detailed model of a transaction processing system with dynamic locking is developed and analyzed. Transaction classes are distinguished on the basis of the number of data items accessed and the access mode (read-only/update). The performance of the system is affected by transaction blocking and restarts, due to lock conflicts that do not or do cause deadlocks, respectively. The probability of these events is determined by the characteristics of transactions and the database access pattern. Hardware resource contention due to concurrent transaction processing is taken into account by specifying the throughput characteristic of the computer system for processing transactions when there is no data contention. A solution method based on decomposition is developed to analyze the system, and also used as the basis of an iterative scheme with reduced computational cost. The analysis to estimate the probability of lock conflicts and deadlocks is based on the mean number of locks held by transactions. These probabilities are used to derive the state transition probabilities for the Markov chain specifying the transitions among the system states. The decomposition solution method and the associated iterative scheme are shown to be more accurate than previously defined methods for dynamic locking through validation against simulation results. Several important conclusions regarding the behavior of dynamic locking systems are derived from parametric studies.

Database Applications of the FETCH-AND-ADD Instruction

The FETCH-AND-ADD instruction provides for synchronization of multiple processes in a parallel manner. This paper explores the use of FETCH-AND-ADD in the context of database systems. We show how to enqueue locks, detect lock conflicts, and release locks without resorting to critical program sections that require mutual exclusion during execution. The scheme is compatible with a variant of lock management proposed by Rosenkrantz and Stearns. A second approach to parallel lock management is based on a reservation scheme by Milenkovic. This methodology uses FETCH-AND-ADD implementation of a priority queue. An implementation of such a queue originally reported by Gottlieb and Kruskal is used for this purpose, although the storage requirements for queue management may be unacceptably large in specific cases. Both approaches described in the paper suggest that FETCH-AND-ADD is potentially effective for eliminating serial bottlenecks caused by lock conflicts in multiprocessor systems.