Real-time Database Systems Research Articles

Scheduling transactions with stringent real-time constraints

Many real-time database systems (RTDBS) are used to support mission-critical applications such as avionics control systems and defense systems, in which transactions have stringent real-time constraints. In these hard real-time systems, a transaction missing its deadline could lead to catastrophic consequences. The difficulties of providing a guarantee of meeting transaction deadlines in hard RTDBS lie in the problems of priority inversion and deadlocks. The transaction blocking delay due to priority inversion can be unbounded, which is unacceptable in most hard RTDBS. Several priority ceiling protocols have been proposed to solve these two problems. However, they are too conservative in scheduling transactions for the single-blocking and deadlock-free properties, leading to many unnecessary transaction blockings. The main reason for their conservatism is their implicit assumption that if a transaction's operation conflicts with that of another executing transaction, it is presumably unable to preempt the conflicting transaction. In this paper, we propose a new priority ceiling protocol that allows a higher priority transaction to preempt a lower priority transaction on data conflicts by using the notion of dynamic adjustment of serialization order. We devise a worst-case schedulability analysis for the new protocol which provides a better schedulability condition compared to other protocols. The simulation results show that the new priority ceiling protocol outperforms other protocols.

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.

Incorporating load factor into the scheduling of soft real-time transactions for main memory databases

Many real-time applications have very tight time constraints which couldn't be met by disk resident databases. For those applications, main memory database where entire database is stored in main memory is the proper choice. It has been shown that coarse-granule locking is better than fine-granule locking for main-memory databases. Coarse-granule locking makes it easy to extract data access patterns correctly from canned transactions of main memory real-time database systems. In this paper, we propose two real-time transaction scheduling algorithms — CCA-ALF (Cost Conscious Approach with Average Load Factor) and EDF-CR-ALF (Earliest Deadline First-Conditional Restart with ALF) — which use both static (e.g., deadline) and dynamic information (e.g., system load) for main memory databases by utilizing data access patterns of transactions. We compare the performance of those algorithms with CCA and EDF-HP which do not use system load information at all. Our simulations on main memory databases indicate that: i) CCA-ALF is better than EDF-HP, CCA, and EDF-CR-ALF in terms of miss percent and mean lateness, and ii) CCA-ALF adapts well to the changes in the system load.

Is a bird in the hand worth more than two in the bush? Limitations of priority cognizance in conflict resolution for firm real-time database systems

After a "boom" period from the late 80s to the early 90s, there appears to have been a reduction in the amount of work published on Concurrency Control (CC) in real-time database systems (RTDBS) in general and firm RTDBS in particular. This may be because existing paradigms (e.g., Optimistic CC) have been pushed to their limits and it is difficult to extract additional meaningful performance. One of the last unresolved bastions of real-time CC is the successful incorporation of priority cognizance. Researchers have speculated that priority cognizant optimistic concurrency control (OCC) algorithms, if designed well, could outperform priority insensitive ones in real-time database systems. So far, however, there is a distinct lack of conclusive proof available on this topic and the priority cognizant OCC algorithms that have appeared so far in the literature cannot claim unilateral superiority over their priority insensitive relatives. We thus surmise that successful incorporation of priority cognizance may lead to an increase in the performance of OCC protocols in firm RTDBSs. Based on this premise, we analyze the issue of priority cognizance and identify a critical condition that must hold for priority cognizant conflict resolution to work. The condition is that, on the average, the conflict sets of validating transactions should have a "large" number of transactions: We call this a bird in hand more than two in the bush phenomenon. Subsequently, we design a smart priority cognizant OCC variant, which we call OCC-APR, and analyze its performance, as well as that of several other concurrency control algorithms across a wide range of resource contention and system loading parameters. Surprisingly, it turns out that it is very difficult for priority cognizance to work as the above mentioned condition does not, usually,hold. We explain why this occurs and conclude that priority cognizance does not appear to be a promising technique to increase real-time CC performance. The contribution of this paper, thus, is to have laid to rest the "priority cognizance" issue with regard to real-time CCMs.

Priority and deadline assignment to triggered transactions in distributed real-time active databases

A distributed real-time active database system (DRTADBS) reacts to the critical events that occurred in the external environment by triggering of transactions. In this paper, the priority and deadline assignment to triggered transactions under two coupling modes, the deferred and immediate, in a DRTADBS is discussed. Two new approaches, the data state dependent (DSD) and the transaction-data deadline (TDD), are proposed to assign criticality and deadlines to the triggered transactions, respectively. In the DSD approach, the criticality of a triggered transaction is defined according to the state of the temporal data object which is responsible for its triggering. The objective of the DSD approach is to increase the number of commit achieved by the triggered transactions especially the more critical ones. The performance of these two approaches under the two coupling modes has been investigated. The results show that the DSD approach is more effective under the immediate coupling mode than under the deferred coupling mode due to the late creation of the triggered transactions under the deferred coupling mode. The TDD approach can improve the system performance under both deferred and immediate coupling mode.

A new measure of temporal consistency for derived objects in real-time database systems

A real-time database system (RTDBS) must satisfy the timing constraints of its transactions as well as the temporal consistency constraints of its temporal data. The data is considered to be temporally consistent if it is absolutely and relatively consistent. A data object is absolutely consistent if its age is younger than an absolute threshold, and a set of data objects is considered to be relatively consistent if the dispersion of ages is smaller than a relative threshold. It is often difficult to select appropriate values for the thresholds that satisfy both absolute and relative consistency, especially in the case of objects whose values are derived (derived objects). In this paper we propose a new measure of temporal consistency for derived objects that is based on a new definition for the age of the derived object. Our proposed age provides additional insight into the temporal consistency of derived data objects and is useful for real-time database design and management.

Secure buffering in firm real-time database systems

Many real-time database applications arise in electronic financial services, safety-critical installations and military systems where enforcing is crucial to the success of the enterprise. We investigate here the performance implications, in terms of killed transactions, of guaranteeing multi-level secrecy in a real-time database system supporting applications with firm deadlines. In particular, we focus on the buffer management aspects of this issue.Our main contributions are the following. First, we identify the importance and difficulties of providing secure buffer management in the real-time database environment. Second, we present , a novel buffer management algorithm that provides covert-channel-free security. SABRE employs a fully dynamic one-copy allocation policy for efficient usage of buffer resources. It also incorporates several optimizations for reducing the overall number of killed transactions and for decreasing the unfairness in the distribution of killed transactions across security levels. Third, using a detailed simulation model, the real-time performance of SABRE is evaluated against unsecure conventional and real-time buffer management policies for a variety of security-classified transaction workloads and system configurations. Our experiments show that SABRE provides security with only a modest drop in real-time performance. Finally, we evaluate SABRE's performance when augmented with the GUARD adaptive admission control policy. Our experiments show that this combination provides close to ideal fairness for real-time applications that can tolerate covert-channel bandwidths of up to one bit per second (a limit specified in military standards).

Triggered Updates for Temporal Consistency in Real-TimeDatabases

A real-time database system has temporal consistency constraints in addition to timing constraints. The timing constraints require a transaction to be completed by a specified deadline, and the temporal consistency constraints require that temporal data read by a transaction be up-to-date. If a transaction reads out-of-date data, it will become temporally inconsistent. A real-time database system consists of different types of temporal data objects, including derived objects. The value of a derived object is computed from a set of other objects, known as the read-set of the derived object. The derived object may not always reflect the current state of its read-set; a derived object can become out-of-date even if its read-set is up-to-date. Any subsequent transaction reading the derived object will then become temporally inconsistent. In this case, in order to read up-to-date objects, a transaction will have to wait until some other transaction updates the out-of-date object. However, in doing so, the waiting transaction may miss its deadline, particularly if the update is not periodic but instead arrives randomly. We propose to update the outdated objects so that not only is the temporal consistency improved, but also the number of missed deadlines does not increase significantly, and as a result there is an overall improvement in the performance of the system. We propose, implement and study a novel approach, to be known as triggered updates, to improve temporal consistency in firm real-time database systems when updates are not periodic. We identify properties of triggered updates and explain how they work by giving both an intuitive and a probabilistic analysis. We present strategies for generating triggered updates, discuss their suitability in various contexts and perform a detailed simulation study to evaluate their performance. Results show that it is possible to improve temporal consistency without degrading the timeliness of real- time database systems to a great deal.

Transaction Scheduling in Distributed Real-Time Systems

In this paper, we study the performance of using optimistic approach to concurrency control in distributed real-time database systems (RTDBS). The traditional optimistic approach suffers from the problem of unnecessary restarts. Transaction restarts can significantly increase the system workload and intensify resource and data contention. In distributed environments, the complexity of the system and the high communication overhead exacerbate the problem. Therefore, the number of unnecessary restarts is the determinant factor that affects the performance of optimistic approach in distributed RTDBS. When optimistic approach is extended to distributed environments, a number of issues resulting from the increased complexity and communication overhead have to be resolved. In this paper, a new real-time distributed optimistic concurrency control (DOCC) protocol with dynamic adjustment of serialization order (DASO), called DOCC-DA is proposed. This protocol can avoid unnecessary transaction restarts by dynamically adjusting the serialization order of the conflicting transactions. Therefore, resources can be saved and more transactions can meet their deadlines. In the DOCC-DA protocol, a new distributed circular validation scheme is included to facilitate transaction validation in distributed environments. The performance of the DOCC-DA protocol has been examined in detail by simulation. The results showed that the performance of the DOCC-DA protocol is consistently better than that of other protocols.

Real-time index concurrency control

Real time database systems are expected to rely heavily on indexes to speed up data access and thereby help more transactions meet their deadlines. Accordingly, high performance index concurrency control (ICC) protocols are required to prevent contention for the index from becoming a bottleneck. We develop real time variants of a representative set of classical B-tree ICC protocols and, using a detailed simulation model, compare their performance for real time transactions with firm deadlines. We also present and evaluate a real time ICC protocol called GUARD-link that augments the classical B-link protocol with a feedback based admission control mechanism. Both point and range queries, as well as the undos of the index action transactions are included in the study. The performance metrics used in evaluating the ICC protocols are the percentage of transactions that miss their deadlines and the fairness with respect to transaction type and size. Experimental results show that the performance characteristics of the real time version of an ICC protocol could be significantly different from the performance of the same protocol in a conventional (nonreal time) database system. In particular, B-link protocols, which are reputed to provide the best overall performance in conventional database systems, perform poorly under heavy real time loads. The new GUARD-link protocol, however, although based on the B-link approach, delivers the best performance (with respect to all performance metrics) for a variety of real time transaction workloads, by virtue of its admission control mechanism. GUARD-link provides close to ideal fairness in most environments.

Improving Predictability of Transaction Execution Timesin Real-time Databases

We present a design for multi-version concurrency control and recovery in a main memory database, and describe logical and physical versioning schemes that allow read-only transactions to execute without obtaining data item locks or system latches. Our schemes enable a system to provide the guarantee that updaters will never interfere with read-only transactions, and read-only transactions will not be delayed due to data contention. Consequently, transaction executions become more predictable—this partially alleviates a major problem in real-time database system (RTDBS) scheduling, namely, significant unpredictability in transaction execution times. As a result, in addition to a transaction's deadline, a more accurate estimate of its execution time can also be taken into account, thus facilitating better scheduling decisions. Our contributions include several space saving techniques for the main-memory implementation, including improved methods for logical aging of data items and the introduction of physical aging for low-level structures. Some of these schemes have been implemented on a widely-used software platform within Lucent, and the full scheme is implemented in the Dali main-memory storage manager.

Integrating security and real-time requirements using covert channel capacity

Database systems for real-time applications must satisfy timing constraints associated with transactions in addition to maintaining data consistency. In addition to real-time requirements, security is usually required in many applications. Multi-level security requirements introduce a new dimension to transaction processing in real-time database systems. In this paper, we argue that, due to the conflicting goals of each requirement, tradeoffs need to be made between security and timeliness. We first define mutual information, a measure of the degree to which security is being satisfied by a system. A secure two-phase locking protocol is then described and a scheme is proposed to allow partial violations of security for improved timeliness. Analytical expressions for the mutual information of the resultant covert channel are derived, and a feedback control scheme is proposed that does not allow the mutual information to exceed a specified upper bound. Results showing the efficacy of the scheme obtained through simulation experiments are also discussed.

Secure Concurrency Control in Firm Real-Time Database Systems

Many real-time database applications arise in electronic financial services, safety-critical installations and military systems where enforcing security is crucial to the success of the enterprise. For real-time database systems supporting applications with firm deadlines, we investigate here the performance implications, in terms of killed transactions, of guaranteeing multilevel secrecy. In particular, we focus on the concurrency control (CC) aspects of this issue. Our main contributions are the following: First, we identify which among the previously proposed real-time CC protocols are capable of providing covert-channel-free security. Second, using a detailed simulation model, we profile the real-time performance of a representative set of these secure CC protocols for a variety of security-classified workloads and system configurations. Our experiments show that a prioritized optimistic CC protocol, OPT-WAIT, provides the best overall performance. Third, we propose and evaluate a novel “dual-CC” approach that allows the real-time database system to simultaneously use different CC mechanisms for guaranteeing security and for improving real-time performance. By appropriately choosing these different mechanisms, concurrency control protocols that provide even better performance than OPT-WAIT are designed. Finally, we propose and evaluate GUARD, an adaptive admission-control policy designed to provide fairness with respect to the distribution of killed transactions across security levels. Our experiments show that GUARD efficiently provides close to ideal fairness for real-time applications that can tolerate covert channel bandwidths of upto one bit per second.

The Reduced Ceiling Protocol for Concurrency Control in Real-time Databases with Mixed Transactions

This paper proposes a real-time concurrency control protocol called Reduced Ceiling Protocol (RCP) for real-time database systems (RTDBS) consisting of hard and soft real-time transactions. The schedulability of hard real-time transactions can be improved by bounding the blocking time from soft real-time transactions. Different concurrency control strategies are proposed to resolve data conflicts between different combinations of hard and soft real-time transactions, and the properties of the RCP schedules are shown. In the RCP, methodologies are proposed to reduce the number of aborts for soft real-time transactions due to data conflicts with hard real-time transactions. Simulation experiments have been performed to study the performance of the RCP as compared with the optimistic concurrency control with wait 50 (OCC wait-50) under different workloads of soft real-time transactions, various ratios of read/write operations, and deadline constraints. It has been found that the RCP can not only guarantee the performance of hard real-time transactions but also reduce the number of deadlines missed of the soft real-time transactions under all situations.

MDARTS: a multiprocessor database architecture for hard real-time systems

Complex real time systems need databases to support concurrent data access and provide well defined interfaces between software modules. However, conventional database systems and prior real time database systems do not provide the performance or predictability needed by high speed, hard real time applications. The authors designed, implemented, and evaluated an object oriented database system called MDARTS (Multiprocessor Database Architecture for Real Time Systems). MDARTS avoids the client server overhead of most prior real time database systems and object oriented, real time systems by moving transaction execution into application tasks. By eliminating these sources of overhead and focusing on basic data management services for control systems (data sharing, serializable transactions, and multiprocessor support), the MDARTS prototype provides hard real time transaction times approximately three orders of magnitude faster than prior real time database systems. MDARTS ensures bounded locking delay by disabling preemption when a transaction is waiting for a lock, and hence, allows for the estimation of worst case transaction execution times. Another contribution of MDARTS is that it supports explicit declarations of real time requirements and semantic constraints within application code. The MDARTS library examines these declarations at application initialization time and attempts to construct objects that are compatible with the requirements. Besides local shared memory transactions with hard real time response time guarantees, MDARTS also supports remote transactions that use remote procedure calls for data access with less stringent timing constraints. The MDARTS prototype is implemented in C++ and it runs on VME based multiprocessors and Sun workstations.

Issues and approaches to supporting timeliness and security in real-time database systems

Databases for real-time systems are essential in supporting time-critical applications. However, there has not been much work in supporting security in real-time database systems, although sensitive information must be safeguarded in real-time systems as well. In this paper we address the issues that need to be considered for supporting both requirements of timeliness and security in real-time database systems. We present an adaptive policy to achieve the balance between the two requirements dynamically. We also present the notion of flexible security and the specification language that allows the designer to specify important properties of the database at an appropriate level.

Resolving Executing-Committing Conflicts in Distributed Real-time Database Systems

In a distributed real-time database system (DRTDBS), a commit protocol is required to ensure transaction failure atomicity. If data conflicts occur between executing and committing transactions, the performance of the system may be greatly affected. In this paper, we propose a new protocol, called deadline-driven conflict resolution (DDCR), which integrates concurrency control and transaction commitment management for resolving executing and committing data conflicts amongst firm real-time transactions. With the DDCR, a higher degree of concurrency can be achieved, as many data conflicts of such kind can be alleviated, and executing transactions can access data items which are being held by committing transactions in conflicting modes. Also, the impact of temporary failures which occurred during the commitment of a transaction on other transactions, and the dependencies created due to sharing of data items is much reduced by reversing the dependencies between the transactions. A simulation model has been developed and extensive simulation experiments have been performed to compare the performance of the DDCR with other protocols such as the Opt [1], the Healthy-Opt [2], and the base protocol, which use priority inheritance and blocking to resolve the data conflicts. The simulation results show that the DDCR can significantly improve the system performance under different workload and workload distributions. Its performance is consistently better than the base protocol and the Opt protocols in both main-memory resident and disk-resident DRTDBS.

A secure dynamic copy protocol in real-time secure database systems

Concurrency control for real-time secure database systems must satisfy not only logical data consistency but also timing constraints and security requirements associated with transactions. These conflicting natures between timing constraints and security requirements are often resolved by maintaining several versions (or secondary copies) on the same data items. In this paper, we propose a new lock-based concurrency control protocol, Secure Dynamic Copy Protocol, ensuring both conflicting requirements. Our protocol aims for reducing the storage overhead of maintaining secondary copies and minimizing the processing overhead of update history. The main idea of our protocol is to keep a secondary copy only when it is needed to resolve the conflicting read/write operations in real time secure database systems. For doing this, a secondary copy is dynamically created and removed during a transaction's read/write operations. While comparing the existing real-time security protocol, we have also examined the performance characteristics of our protocol through simulation under different workloads. The results show that our protocol consumed less storage and decreased the deadline missing transactions.

Dynamic CPU Scheduling with Imprecise Knowledge of Computation-Time

The majority of the studies conducted in scheduling real-time transactions mostly concentrate on concurrency control protocols, while overlooking the CPU as being the primary resource. Consequently, there are various techniques for scheduling the CPU in conventional time-critical systems; meanwhile, there does not seem to be any technique that is adequately designed for scheduling such a resource in Real-Time Database (RTDB) systems. In this paper, we construct an efficient CPU scheduling scheme that minimizes the preemption rate in order to reduce the frequency by which synchronization protocols must be invoked, along with their inherited performance degradation. In addition, we also introduce a new timing model upon which the newly introduced scheduler is incorporated in order to utilize the system's imprecise knowledge of computation time estimates.

Efficient detection and resolution of deadlocks in distributed databases

Deadlock detection and resolution is one of the major components of a successful distributed database management system. In this article, we discuss deadlock detection and resolution strategies and present two approaches for detecting and resolving deadlocks in both general distributed database systems and distributed real-time database systems. Our first approach is to collect information on the connectivity of nodes of the overall Transaction Wait-For Graph (TWFG) of the distributed database system and then use these connectivities information to build a local TWFG at each node of the overall TWFG. We then detect the deadlocks by locating the cycles in each local TWFG. To resolve the deadlocks, the nodes involved in those cycles in each local TWFG, are removed until there is no cycle in the local TWFGs. Our second approach continuously checks for the occurrence of a deadlock between different transaction trees. As soon as it detects a deadlock, it resolves it by aborting one of the transaction tree which has been initiated more recently. Some of the advantages of our approaches over the approaches which use Probe messages are: (1) no extra storage required to store different probe messages, (2) no false (Phantom) deadlocks are reported, (3) detects and resolves all deadlocks. In addition, our approaches use less message and time to detect and resolve all deadlocks in existing TWFG of the distributed database system.