Showing papers on "Multiversion concurrency control published in 2002"

Concurrency classes for shared file systems

Abstract: A method, apparatus and computer product wherein means and mechanisms are provided whereby, in a distributed or clustered shared file system, (1) concurrency classes may be defined specifying granularity of locking, whether locks are cached, and whether modified data is written-through at the completion of updates, (2) certain files, file types, or files and/or file types as used by given applications or classes of applications, may be associated with concurrency classes, and (3) for each usage of a file by an application, the associated concurrency class determines a policy for choosing specific concurrency and coherency control mechanisms to be used for accessing the given file.

Exploiting versions for on-line data warehouse maintenance in MOLAP servers

Abstract: A data warehouse is an integrated database whose data is collected from several data sources, and supports on-line analytical processing (OLAP). Typically, a query to the data warehouse tends to be complex and involves a large volume of data. To keep the data at the warehouse consistent with the source data, changes to the data sources should be propagated to the data warehouse periodically. Because the propagation of the changes (maintenance) is batch processing, it takes long time. Since both query transactions and maintenance transactions are long and involve large volumes of data, traditional concurrency control mechanisms such as two-phase locking are not adequate for a data warehouse environment. We propose a multi-version concurrency control mechanism suited for data warehouses which use multi-dimensional OLAP (MOLAP) servers. We call the mechanism multiversion concurrency control for data warehouses (MVCCDW). To our knowledge, our work is the first attempt to exploit versions for online data warehouse maintenance in a MOLAP environment. MVCC-DW guarantees the serializability of concurrent transactions. Transactions running under the mechanism do not block each other and do not need to place locks.

A Transactional Model for Data Warehouse Maintenance

Abstract: A Data Warehouse Management System (DWMS) incrementally maintains materialized views by issuing maintenance queries to the data sources To address erroneous query results caused by concurrent source updates, state-of-the-art maintenance strategies typically apply compensations to resolve the conflicts For this, they assume however that the source schema are not updated and remain stable over time However, if schema changes occur in any of the sources, then an anomaly may arise, namely, the maintenance or the compensation queries may be broken We now tackle this open problem by modeling the complete maintenance process as a special transaction, called a DWMS_Transaction The anomaly problem can now be rephrased as the serializability of DWMS_Transactions This allows us to apply well-established transaction theory to address this new anomaly problem To achieve such serializability, we propose a multiversion concurrency control technique appropriate for loosely-coupled environments with autonomous sources TxnWrap is complementary to maintenance algorithms from the literature by removing concurrency issues from their consideration The experimental results confirm that TxnWrap achieves predictable steady performance even under a varying rate of concurrency

Specification, verification, and synthesis of concurrency control components

Abstract: Run-time errors in concurrent programs are generally due to the wrong usage of synchronization primitives such as monitors. Conventional validation techniques such as testing become ineffective for concurrent programs since the state space increases exponentially with the number of concurrent processes. In this paper, we propose an approach in which 1) the concurrency control component of a concurrent program is formally specified, 2) it is verified automatically using model checking, and 3) the code for concurrency control component is automatically generated. We use monitors as the synchronization primitive to control access to a shared resource by multipleconcurrent processes. Since our approach decouples the concurrency control component from the rest of the implementation it is scalable. We demonstrate the usefulness of our approach by applying it to a case study on Airport Ground Traffic Control.We use the Action Language to specify the concurrency control component of a system. Action Language is a specification language for reactive software systems. It is supported by an infinite-state model checker that can verify systems with boolean, enumerated and udbounded integer variables. Our code generation tool automatically translates the verified Action Language specification into a Java monitor. Our translation algorithm employs symbolic manipulation techniques and the specific notification pattern to generate an optimized monitor class by eliminating the context switch overhead introduced as a result of unnecessary thread notification. Using counting abstraction, we show that we can automatically verify the monitor specifications for arbitrary number of threads.

Self-adapting concurrency: the DMonA architecture

Abstract: A major problem in todays Internet servers is that they suffer from extreme peak loads. Traditional (operating) systems are designed to perform extremely well under heavy load conditions. However, it is not feasible to over-provision resources only to support peak loads. A key factor to deal with such peak loads is internal concurrency control. We have developed a component based architecture (DMonA), which allows to adapt internal concurrency according to measured throughput. Performance tests show that DMonA outperforms traditional approaches, while it is still very manageable thanks to the underlying DiPS component architecture.

Automated Concurrency Re-Assignment in High Level System Models for Efficient System-Level Simulation

Abstract: Simple and powerful modeling of concurrency and reactivity along with their efficient implementation in the simulation kernel are crucial to the overall usefulness of system level models using the C++-based modeling frameworks. However the concurrency alignment in most modeling frameworks is naturally expressed along hardware units, being supported by the various language constructs, and the system designers express concurrency in their system models by providing threads for some modules/units of the model. Our experimental analysis shows that this concurrency model leads to inefficient simulation performance, and a concurrency alignment along dataflow gives much better simulation performance, but changes the conceptual model of hardware structures. As a result, we propose an algorithmic transformation of designs written in these C++-based environments with concurrency alignment along units/modules. This transformation, provided as a compiler front-end, will re-assign the concurrency along the dataflow, as opposed to threading along concurrent hardware/software modules, keeping the functionality of the model unchanged. Such a front-end transformation strategy will relieve hardware system designers from concerns about software engineering issues such as, threading architecture, and simulation performance, while allowing them to design in the most natural manner whereas, the simulation performance can be enhanced up to almost two times as shown in our experiments.

Concurrency and Hardware Design

Abstract: We introduce a simple formal framework for specifying and implementing concurrent systems. The framework enables the specification of safety and progress properties and is based on Enhanced Characteristic Functions. The use of Enhanced Characteristic Functions leads to simple definitions of operations such as hiding and various process compositions. We discuss two compositions: the network composition for building networks of processes and the specification composition for building specifications of processes. A central notion in our framework is the notion of a snippet. A snippet represents a part behavior of a process satisfying one specific constraint. A specification of a concurrent process satisfying all constraints is expressed by means of a specification composition of snippets. We present various properties of the specification and network compositions that can be helpful in the specification and implementation of concurrent systems. We illustrate our design approach with the design of some asynchronous circuits.

Multiversion locking protocol with freezing for secure real-time database systems

Abstract: 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. Recently, security has become another important issue in many real-time applications. In many systems, sensitive information is shared by multiple users with different levels of security clearance. As more advanced database systems are being used in applications that need to support timeliness while managing sensitive information, there is an urgent need to develop protocols for concurrency control in transaction management that satisfy both timing and security requirements. In this paper, we propose a new multiversion concurrency control protocol that ensures that both security and real-time requirements are met. The proposed protocol is primarily based on locking. However, in order to satisfy timing constraints and security requirements, a new method, called the freezing method, is proposed. In order to show that our protocol provides a higher degree of concurrency than existing multiversion protocols, we define a new serializability for multiversion concurrency control, called FR-serializability, which is more general than traditional serializability. We present several examples to illustrate the behavior of our protocol, along with performance comparisons with other protocols. The simulation results show significant performance improvement of the new protocol.

Advanced concurrency control in Java

Abstract: 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.

Real-time concurrency control in a multiprocessor environment

Abstract: Although many high-performance computer systems are now multiprocessor-based, little work has been done in real-time concurrency control of transaction executions in a multiprocessor environment. Real-time concurrency control protocols designed for uniprocessor or distributed environments may not fit the needs of multiprocessor-based real-time database systems because of a lower concurrency degree of transaction executions and a larger number of priority inversions. This paper proposes the concept of a priority cap to bound the maximum number of priority inversions in multiprocessor-based real-time database systems to meet transaction deadlines. We also explore the concept of two-version data to increase the system concurrency level and to explore the abundant computing resources of multiprocessor computer systems. The capability of the proposed methodology is evaluated in a multiprocessor real-time database system under different workloads, database sizes and processor configurations. It is shown that the benefits of the priority cap in reducing the blocking time of urgent transactions are far greater than the losses involved in committing less urgent transactions. The idea of two-version data also greatly improves the system performance because of a much higher concurrency degree in the system.

A concurrency control method based on document marking

Abstract: High reactivity cannot be achieved without each object being replicated on every site, when assuming a nonnegligible network latency in a CSCW system. It is an austerity challenge for concurrency control, and can cause some new problems, such as intention violation. A new algorithm about concurrency control, based on document marking, uses state vector. It not only accords with the integrity consistency model, but also is easy to understand and more efficient.

Concurrency control with Java and relational databases

Abstract: As Web-based information systems usually run in concurrent environment, the complexity for implementing and testing those systems is significantly high. Therefore it is useful to have guidelines to introduce concurrency control, avoiding ad hoc control strategies, which may have a negative impact in efficiency and may not guarantee system safety. This paper defines guidelines for concurrency control in Web-based information systems implemented in Java with relational databases. In particular we show where Java and relational database concurrency control mechanisms should be used in order to implement our concurrency control strategy. Additionally, we analyze the performance of different concurrency controls approaches. The main point of the guidelines is to guarantee system correctness without redundant concurrency control, both increasing performance and guaranteeing safely.

Concurrent object-oriented programs: From specification to code

Abstract: In this paper we put forward a concurrent object-oriented programming language in which concurrency is tightly integrated with objects. Concurrency is expressed by extending classes with actions and allowing methods to be guarded. Concurrency in an object may be hidden to the outside, thus allowing concurrency to be introduced in subclasses of a class hierarchy. A disciplined form of intra-object concurrency is supported. The language is formally defined by translation to action systems. Inheritance and subtyping is also considered. A theory of class refinement is presented, allowing concurrent programs to be developed from sequential specifications. Our goal is to have direct rules for verification and refinement on one hand and a practical implementation on the other hand. We briefly sketch our implementation. While the implementation relies on threads, the management of threads is hidden to the programmer.

Network-aided concurrency control in distributed databases

Abstract: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ii Table of

Design and implementation of the concurrency control manager in the main-memory DBMS Tachyon

Abstract: In this paper we discuss the design and implementation of a concurrency control manager for Tachyon, a main-memory DBMS. Since a main-memory DBMS, unlike a disk-resident DBMS, performs all data updates or data retrievals by accessing main-memory only the portion of the cost for the concurrency control manager in the total cost for a data update or a data retrieval is fairly high. Thus, the development of an efficient concurrency control manager greatly accelerates the performance of the entire main-memory DBMS. Our concurrency control manager employs the two-phase locking protocol, and has the following characteristics. First, it adapts the partition as a locking granule, and thus effectively adjusts the trade-off between system concurrency and locking cost. Second, it enjoys low locking costs by maintaining lock information directly in the partition itself. Third, it provides the latch as a mechanism for physical consistency of system data. Our latch supports both shared and exclusive modes. and maximizes CPU utilization by combining the Bakery algorithm and the Unix semaphore facility. Fourth, for solving the deadlock problem, it periodically examines whether a system is in a deadlock state based on lock waiting information. In addition, we discuss various issues arising in development such as mutual exclusion of a transaction table, mutual exclusion of indexes and system catalogs, and phantom problem handling.

Concurrency Control in Transactional Drago

Abstract: The granularity of concurrency control has a big impact on the performance of transactional systems. Concurrency control granularity and data granularity (data size) are usually the same. The effect of this coupling is that if a coarse granularity is used, the overhead of data access (number of disk accesses) is reduced, but also the degree of concurrency. On the other hand, if a fine granularity is chosen to achieve a higher degree of concurrency (there are less conflicts), the cost of data access is increased (each data item is accessed independently, which increases the number of disk accesses). There have been some proposals where data can be dynamically clustered/unclustered to increase either concurrency or data access depending on the application usage of data. However, concurrency control and data granularity remain tightly coupled. In Transactional Drago, a programming language for building distributed transactional applications, concurrency control has been uncoupled from data granularity, thus allowing to increase the degree of concurrency without degrading data access. This paper describes this approach and its implementation in Ada 95.

Concurrency in Dependable Real-Time Objects

Abstract: Producing complex real-time distributed computing systems with design-time guarantees of timely service capabilities is still considered by a predominant part of the research community to be a distant goal. Yet the recognition of the importance of facilitating such system engineering is steadily growing in the current century. This is because timeliness guaranteeing is a fundamental way of achieving a high degree of dependability. The TMO (Time-triggered Message-triggered Object) programming and specification scheme has been established in recent years to support such timeliness-guaranteed design. It is a high-level high-precision real-time distributed object programming scheme. The TMO scheme accompanies an execution scheme involving disciplined control of resources and services offered by typical commercial operating system platforms. Current versions of these schemes contain design and execution rules that prevent most important potential obstacles on the paths to timeliness-guaranteed design. However, there remain a number of challenging research issues which must be resolved satisfactorily before one can say whether the TMO scheme enables maximum exploitation of concurrency by programmers or not. Issues encountered in pursuing both goals together, i.e., enabling timeliness-guaranteed design and enabling maximum exploitation of concurrency, as well as solution approaches identified are discussed here.

Concurrency control for distributed cooperative engineering applications

Abstract: Distributed cooperative engineering applications require consistent and long-term sharing of large volumes of data, which may cause conflicts due to concurrent read/write operations. Therefore designing concurrency control for underlying middleware systems is a difficult issue.Current transactional solutions, even if based on an optimistic approach, do not solve the problem because such applications access shared data for long periods of time performing a large number of read/write operations. Typically, a large set of modifications has to be discarded and this is unacceptable given the amount of work lost.In this paper, we describe the design and implementation of concurrency control mechanisms aimed at both reducing the amount of such conflicts and supporting the consistent long-term sharing of data. The mechanism of visibility depth allows the programmer to specify the consistency of shared data w.r.t. different sets of sites. We also provide other mechanisms: private-copy that allows data to be read/written without being considered as part of a transaction and reordering transaction history to avoid transaction aborts. We evaluate these techniques on a prototypical middleware system called PerDiS and show that: (i) the concurrency control mechanisms are well adapted to support long-lived data sharing in local or wide-area networks, and (ii) performance is acceptable.

A transactional model for Data Warehouse maintenance

Abstract: A Data Warehouse Management System (DWMS) incrementally maintains materialized views by issuing maintenance queries to the data sources. To address erroneous query results caused by concurrent source updates, state-of-the-art maintenance strategies typically apply compensations to resolve the conflicts. For this, they assume however that the source schema are not updated and remain stable over time. However, if schema changes occur in any of the sources, then an anomaly may arise, namely, the maintenance or the compensation queries may be broken. We now tackle this open problem by modeling the complete maintenance process as a special transaction, called a DWMS―Transaction. The anomaly problem can now be rephrased as the serializability of DWMS―Transactions. This allows us to apply well-established transaction theory to address this new anomaly problem. To achieve such serializability, we propose a multiversion concurrency control technique appropriate for loosely-coupled environments with autonomous sources. TxnWrap is complementary to maintenance algorithms from the literature by removing concurrency issues from their consideration. The experimental results confirm that TxnWrap achieves predictable steady performance even under a varying rate of concurrency.

Concurrency Control and Deadlock Recovery of Active Rules

Abstract: In rule-based active database systems, triggered rules are generally executed in the context of database transactions. Coupling mode, specified in rule definition, determines when a rule transaction will be launched and how these parallel rule transactions are to be serialized. Following an investigation on lock inheritance and lock preemption among these concurrent transactions when accessing shared data objects, this paper proposes an concurrency control algorithm, and based on transaction tree (forest), an effective deadlock detection algorithm and a minimal-price based deadlock recovery algorithm are presented.