Basic Timestamp Research Articles

Formal Development of Basic Timestamp Concurrency Control Mechanism using Event-B

Formal methods are mathematical techniques that are used to develop model of complex systems. They provide mathematical proofs for ensuring correctness of model. Through formal methods, it may possible to identify and remove errors at prior stage of development. Event-B is a formal method that is used to develop those systems that can be modeled as discrete transition systems. It rigorously describes the problem and verifies the correctness of model by discharging proof obligations. It performs the consistency checking by preserving invariants of model. In this paper, we have done formal verification of basic time stamp mechanism using Event-B. Basic time stamp is concurrency control mechanism to control concurrent execution of transactions. The main objective of timestamp is to execute transactions such that their execution is equivalent to serial execution in time stamp order.

Prescheduling policy for real-time concurrency control: A performance evaluation

A new priority management policy, aprescheduling policy, is proposed. This policy can be applied on any conventional concurrency control protocol to schedule a real-time transaction. Costly preemption is avoided by the prescheduling policy, and parsing dataset of a transaction is not needed. Three widely used conventional concurrency control protocols (dynamic two-phase locking, basic timestamp ordering, and optimistic) are incorporated with the prescheduling policy to form three real-time concurrency control protocols. Performance of the three protocols is evaluated from three different viewpoints: database management systems, protocols, and transaction. From a database management system viewpoint, we show the prescheduling policy can improve the performance of protocols by raising thevalid ratio and reducingrestart counts. In general, two-phase locking with the prescheduling policy performs the best in most cases and yields the best choice for concurrency control in a real-time application. Deciding factors that affect performance of each protocol are identified from protocol viewpoint. Some suggestions are given for writing a timely transaction from the aspect of transaction viewpoint.

Analysis of the probability of transaction abort and throughput of two timestamp ordering algorithms for database systems

The author analyzes and compares the performance of two timestamp ordering concurrency control algorithms, namely, the basic and multiversion, for database systems. The multiversion algorithm improves the performance of the basic timestamp ordering algorithm by keeping multiple versions of data objects. The author discusses the performance enhancement in the multiversion algorithm over the basic algorithm. The author also discusses the storage overhead due to multiple versions of data objects in the multiversion algorithm. The exact performance model of these algorithms is so complex that it is impossible to find a closed-form solution. The author reduces the complexity of the analysis by analyzing a single transaction in isolation and reflects the presence of other transactions on the isolated transaction by the probability of conflict/abort. The analysis provides useful insight into the performance of these algorithms.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Performance analysis of the basic timestamp ordering algorithm via Markov modeling

Locking and timestamping are two popular approaches to concurrency control in database systems. Although more than a dozen analytic performance studies of locking techniques have recently appeared in the literature, analytic performance study of times tamp-based concurrency control algorithms largely remains and unexplored area. Since a large class of concurrency control algorithms used timestamps, there is a strong need of analytic performance study of these algorithms. In this paper, we analyze the performance of the basic timestamp ordering concurrency algorithm for database systems. Due to the complex nature of concurrency control algorithms, it is very difficult to accurately analyze their perfomance mathematically. We show that even after making some assumptions, an exact performance model of the basic timestamp ordering concurrency control algorithm is so complicated that it is pratically impossible to find its closed-form solution. We circumvent this problem in the following way: We analyze a single transaction in isolation rather than analyzing the whole system. (This reduces the complexity of the analysis substantially.) We reflect the presence of other trasactions on the transaction under consideration by the probability that a conflicting access to a data object has been made. We assume that a transaction sees the average state of the system and all the transactions exhibit the average steady-state behavior, which permits us to work with averages rather than with probability distributions. Therefore, the technique used in the analysis is approximate. We illustrate the technique with numerical examples. We plot a set of performance measures for several values of the model parameters. The results of analysis are validated against a simulation study. We also extend the analysis to open database systems where transactions arrive from an external source.

Performance comparison of database concurrency control mechanisms based on two-phase locking, timestamping and mixed approach

Many techniques have been proposed for managing concurrent execution of transactions in database systems. There are two well-known categories: one uses locks and the other uses timestamps. The performance of seven different concurrency control algorithms belonging to these two categories have been investigated with the help of detailed and realistic simulation models so that a comparative evaluation of their performance can be done. These include the performance of four different locking techniques, the basic timestamp technique and wound-wait and wait-die systems. We have evaluated the effect of deadlocks, read : write ratio, cascade rollback, degree of concurrency, transaction-size mixes, transaction wait time and transaction blockings on the overall performance of these algorithms. We show that cascade rollbacks, contrary to our expectation, do not affect throughput significantly, since these rollbacks do not occur very frequently and their average degree is always small. Deadlocks occur rarely and the degree of cycles is never very high. The effect of read : write ratios does not extend to higher transaction arrival rates and the effect of transaction waittime on the throughput is not so severe. We also give some guidelines for selecting the most suitable concurrency control mechanism for a particular type of workload.

Parallelism and concurrency control performance in distributed database machines

While several distributed (or 'shared nothing') database machines exist in the form of prototypes or commercial products, and a number of distributed concurrency control algorithms are available, the effect of parallelism on concurrency control performance has received little attention. This paper examines the interplay between parallelism and transaction performance in a distributed database machine context. Four alternative concurrency control algorithms are considered, including two-phase locking, wound-wait, basic timestamp ordering, and optimistic concurrency control. Issues addressed include how performance scales as a function of machine size and the degree to which partitioning the database for intra-transaction parallelism improves performance for the different algorithms. We examine performance from several perspectives, including response time, throughput, and speedup, and we do so over a fairly wide range of system loads. We also examine the performance impact of certain important overhead factors (e.g., communication and process initiation costs) on the four alternative concurrency control algorithms.

Concurrency control in distributed databases through time intervals and short-term locks

A method for concurrency control in distributed database management systems that increases the level of concurrent execution of transactions, called ordering by serialization numbers (OSN), is proposed. The OSN method works in the certifier model and uses time-interval techniques in conjunction with short-term locks to provide serializability and prevent deadlocks. The scheduler is distributed, and the standard transaction execution policy is assumed, that is, the read and write operations are issued continuously during transaction execution. However, the write operations are copied into the database only when the transaction commits. The amount of concurrency provided by the OSN method is demonstrated by log classification. It is shown that the OSN method provides more concurrency than basic timestamp ordering and two-phase locking methods and handles successfully some logs which cannot be handled by any of the past methods. The complexity analysis of the algorithm indicates that the method works in a reasonable amount of time.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A method for concurrency control in distributed DBMSs

In this paper, a method for concurrency control in distributed DBMSs, called Permission Test Method is proposed. The PT method satisfies the basic requirements for concurrency control, that is, it executes the transactions in a serializable order, deadlocks do not appear and indefinite postponment is prevented by the method. In PT method, transactions, which are permitted to run, are not aborted unless a related site failure occurs. Furthermore, the complexity analysis indicates that the algorithm will work in a reasonable amount of time. The PT method provides more concurrency than the Basic Timestamp Ordering and Two-Phase Locking techniques.

An abstract model of database concurrency control algorithms

An abstract model of concurrency control algorithms is presented. The model facilitates implementation-independent descriptions of various algorithms, allowing them to be specified in terms of the information that they require, the conditions under which blocking or restarts are called for, and the manner in which requests are processed. The model also facilitates comparisons of the relative storage and CPU overheads of various algorithms based on their descriptions. Results are given for single-site versions of two-phase locking, basic timestamp ordering, and serial validation. Extensions which will allow comparisons of multiple version and distributed algorithms are discussed as well.