Lock Granularity 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.

Concurrency control by Multiple Granularity of Locks in Multiusers Database Environment

International Journal of Computer Sciences and Engineering (A UGC Approved and indexed with DOI, ICI and Approved, DPI Digital Library) is one of the leading and growing open access, peer-reviewed, monthly, and scientific research journal for scientists, engineers, research scholars, and academicians, which gains a foothold in Asia and opens to the world, aims to publish original, theoretical and practical advances in Computer Science,Information Technology, Engineering (Software, Mechanical, Civil, Electronics & Electrical), and all interdisciplinary streams of Computing Sciences. It intends to disseminate original, scientific, theoretical or applied research in the field of Computer Sciences and allied fields. It provides a platform for publishing results and research with a strong empirical component. It aims to bridge the significant gap between research and practice by promoting the publication of original, novel, industry-relevant research.

Tenant Oriented Lock Granularity Adjustment Strategy in the Shared Storage Multi-tenant Database

SaaS is a perfect technology to achieve scale economy. It uses multi-tenant to allow database to share storage but with irregular load, untraceable transaction characteristics and so on. TOL mechanism provides one granularity between the upper coarse-grained granularity and the lower finegrained granularity for each tenant. But the granularity may not be the most suitable. We define the cluster method and the diffusion method to support the granularity adjustment for a single tenant. Cluster is to make the granularity adjust towards coarser while diffusion gains opposite effect. Because TOL takes advantage of data distribution in multi-tenant database, we combine several aspects when the adjustment strategy is established, including basic table plus extension table and transactions feature. It focuses on locating a more suitable granularity size for one tenant between coarse-grained and fine-grained. In addition, we give experiments indicating that the lock granularity adjustment method is feasible and the adjustment strategy is effective.

Extending WebDAV With Multiple-Granularity Locking

In distributed Web authoring, shared documents can be accessed concurrently by multiple authors who must be coordinated to avoid conflicts. The current Web standard for distributed authoring and versioning uses a two-phase locking to coordinate concurrent access. As the degree to which authors work concurrently may vary though among cooperative sessions, it is necessary to extend the aforementioned standard so as to support a multitude of lock granularity levels. In this paper, we first examine related protocols from the database literature, and then, we comment on their suitability for distributed authoring in the World Wide Web. Our main contribution is a multiple-granularity locking protocol, in which the locks are optional and they convey the meanings of access mode, locking scope, and locking effect. This protocol allows synchronous collaboration by guaranteeing a conflict-free environment and avoiding update loss while it also supports version control. Specifically, by identifying and timestamping object versions, the protocol preserves author intention and operation causality, which were possible so far with operational transformation only. The protocol's efficiency, finally, is demonstrated by a real test with human users and evaluated with simulation experiments, which reveal significant advantages over other protocols of this kind.

Inferring locks for atomic sections

Atomic sections are a recent and popular idiom to support the development of concurrent programs. Updates performed within an atomic section should not be visible to other threads until the atomic section has been executed entirely. Traditionally, atomic sections are supported through the use of optimistic concurrency, either using a transactional memory hardware, or an equivalent software emulation (STM). This paper explores automatically supporting atomic sections using pessimistic concurrency. We present a system that combines compiler and runtime techniques to automatically transform programs written with atomic sections into programs that only use locking primitives. To minimize contention in the transformed programs, our compiler chooses from several lock granularities, using fine-grain locks whenever it is possible. This paper formally presents our framework, shows that our compiler is sound (i.e., it protects all shared locations accessed within atomic sections), and reports experimental results.

Energy-aware disk scheduling for soft real-time I/O requests

In this work, we develop energy-aware disk scheduling algorithm for soft real-time I/O. Energy consumption is one of the major factors which bar the adoption of hard disk in mobile environment. Heat dissipation of large scale storage system also calls for an energy-aware scheduling technique to further increase the storage density. The basic idea in this work is to properly determine the I/O burst size so that device can be in standby mode between consecutive I/O bursts and that it can satisfy the soft real-time requirement. We develop an elaborate model which incorporates the energy consumption characteristics, overhead of mode transition in determining the appropriate I/O burst size and the respective disk operating schedule. Efficacy of energy-aware disk scheduling algorithm greatly relies on not only disk scheduling algorithm itself but also various operating system and device firmware related concerns. It is crucial that the various operating system level and device level features need to be properly addressed within disk scheduling framework. Our energy-aware disk scheduling algorithm successfully addresses a number of outstanding issues. First, we examine the effect of OS and hard disk firmware level prefetch policy and incorporate its effect in our disk scheduling framework. Second, our energy aware scheduling framework can allocate a certain fraction of disk bandwidth to handle sporadically arriving non real-time I/O's. Third, we examine the relationship between lock granularity of the buffer management and energy consumption. We develop a prototype software with energy-aware scheduling algorithm. In our experiment, proposed algorithm can reduce the energy consumption to one fourth if we use energy-aware disk scheduling algorithm. However, energy-aware disk scheduling algorithm increases buffer requirement significantly, e.g., from 4 to 140 KByte. We carefully argue that the buffer overhead is still justifiable given the cost of DRAM chip and importance of energy management in modern mobile devices. The result of our work not only provides the energy efficient scheduling algorithm but also provides an important guideline in capacity planning of future energy efficient mobile devices.

An Efficient Database Management Scheme for Portable Information Devices

Recently, a flash memory has become a major data storage in building portable information devices because of its nonvolatile, shock-resistant, power-economic nature, and fast access time for read operations. The flash memory, however, needs to be erased before write operations which are very slow as compared to standard main memory. Therefore, traditional data control mechanisms are not easy to apply directly to a flash memory database, and so we propose a new scheme called flash aware transaction management (FATM) scheme for efficient transaction processing in a flash memory database environment. We also exploit segment-dependent variable lock granularity and segment-based lock management. FATM achieves high transaction performance by using a W-Cache and a double queue to overcome the effect of slow write and erase operations in transaction scheduling processes. We also propose a simulation model to show the performance of FATM. Simulation results show FATM outperforms the traditional schemes on flash memory.

Hierarchical, adaptive cache consistency in a page server OODBMS

Due to its simplicity and communication efficiency, many client-server object-oriented database systems are based on the basic page server architecture-pages serve as their smallest unit of data transfer, client caching, and concurrency control. In an earlier paper, we showed how to extend this architecture to permit object-level callback locking, and we showed through simulations that significant performance gains can be expected. In the current paper, we report on our experiences from implementing this approach in the context of the SHORE system. Since SHORE supports multiple lock granularities (volume, file, page, object), we explain how our callback algorithm can be extended to support multigranularity locking. We also discuss some of the stickier issues that arose as we moved our algorithm out of the simulator and into SHORE, which supports a generalized peer-servers architecture. Finally, we present performance measurements that explore the tradeoffs between page-level and object-level concurrency control. Our measurements were obtained by running SHORE on an IBM SP2 shared-nothing parallel machine.

Lock Coarsening: Eliminating Lock Overhead in Automatically Parallelized Object-Based Programs

Atomic operations are a key primitive in parallel computing systems. The standard implementation mechanism for atomic operations uses mutual exclusion locks. In an object-based programming system, the natural granularity is to give each object its own lock. Each operation can then make its execution atomic by acquiring and releasing the lock for the object that it accesses. But this fine lock granularity may have high synchronization overhead because it maximizes the number of executed acquire and release constructs. To achieve good performance it may be necessary to reduce the overhead by coarsening the granularity at which the computation locks objects.In this article we describe a static analysis technique—lock coarsening—designed to automatically increase the lock granularity in object-based programs with atomic operations. We have implemented this technique in the context of a parallelizing compiler for irregular, object-based programs and used it to improve the generated parallel code. Experiments with two automatically parallelized applications show these algorithms to be effective in reducing the lock overhead to negligible levels. The results also show, however, that an overly aggressive lock coarsening algorithm may harm the overall parallel performance by serializing sections of the parallel computation. A successful compiler must therefore negotiate a trade-off between reducing lock overhead and increasing the serialization.

Multigranularity locking in multiple job classes transaction processing system

The conditions of when to apply fine and coarse granularity to different kinds of transaction are well understood. However, it is not very clear how multiple job classes using different lock granularities affect each other. This study aims at exploring the impact of multigranularity locking on the performance of multiple job classes transaction processing system which is common in multiuser database system. There are two key findings in the study. Firstly, lock granularity adopted by identical job classes should not differ from each other by a factor of more than 20; otherwise, serious data contention may result. Secondly, short job class transactions are generally benefited when its level of granularity is similar to that of the long job class since this will reduce the additional lock overhead and data contention which are induced by multigranularity locking.

Lock-granularity analysis tools in SVR4/MP

The design of the SVR4/MP multiprocessing system with fine-grained locking is discussed. SVR4/MP scales efficiently to eight processors under a database transaction processing workload and typical multiuser benchmarks. In developing SVR4/MP, initial lock placement was deemphasized and rapid, iterative tuning of lock placement was the focus. Sophisticated tools were used to perform iterative overall performance and scalability tuning of the operating system. The tools developed to determine lock granularity quantitatively are described and an example of their use to optimize overall system efficiency is presented.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The distributed deadlock detection algorithm

We propose a distributed deadlock detection algorithm for distributed computer systems. We consider two types of resources, depending on whether the remote resource lock granularity and mode can or cannot be determined without access to the remote resource site. We present the algorithm, its performance analysis, and an informal argument about its correctness. The proposed algorithm has a hierarchical design intended to detect the most frequent deadlocks with maximum efficiency.

On the modeling of shared resources with various lock granularities using queueing networks

This paper presents a practical and noniterative method for evaluating queueing networks in which serialization delays are represented using measurable parameters. Two types of models are introduced to describe synchronization of accesses to shared resources using simulation and numerical methods, respectively. The model parameters are estimated from the values of measurable quantities. For the analytic models, the probabilities that a shared resource is locked, thereby causing other processes to wait for the resource to be accessible, are calculated, under certain assumptions, as functions of the probabilities of access and of the number of active transactions. The service times of lock servers are calculated as functions of the loads on all service centers. Performance measures applicable to the evaluation of computer systems are introduced and evaluated. An impact of various lock granularities on system performance is presented. An example involving a distributed file system and measurement data collected in a small business installation is given to compare performance measures provided by the simulation and analytic models.

Modelling parallel access to shared resources in a distributed file system using queueing networks

This paper presents a practical and noniterative method for evaluating queueing networks in which delays due to locking of files are represented using measurable parameters. A queueing network model of a distributed file system is introduced. The model allows read and write locks and allows multiple classes of users to be represented. The model parameters are estimated from the values of measurable quantities. An approximation of branching probabilities is used to direct transactions to their original sites when they leave a remote host. The service times of lock servers are calculated as functions of the loads on all service centers. The various lock granularities may be represented by this model. Performance measures applicable to the evaluation of computer systems are introduced and evaluated. An example involving a distributed file system and measurement data collected in a small business installation is given to compare performance measures and locking delays provided by the simulation and analytic models for various lock granularities.

A survey of techniques for the modeling of serialization delays in computer systems

The problem of exclusive access to shared resources was solved using critical sections that are accessed by controlling the values of the synchronization primitives (e.g., semaphores) [4]. In [5] it is shown that a queueing network model can be constructed to represent spin lock behavior. That model may be used to predict the performance degradation due to locking. The results of extensive simulations of systems with static and dynamic locking to study the effects of the granularity of locks in a database system are presented in [8,9].