Distributed real time database systems: background and literature review

Distrib Parallel Databases (2008) 23: 127–149DOI 10.1007/s10619-008-7024-5

Distributed real time database systems: backgroundand literature review

Udai Shanker · Manoj Misra · Anil K. Sarje

Published online: 26 January 2008© Springer Science+Business Media, LLC 2008

Abstract Today’s real-time systems (RTS) are characterized by managing large vol-umes of dispersed data making real-time distributed data processing a reality. Largebusiness houses need to do distributed processing for many reasons, and they oftenmust do it in order to stay competitive. So, efficient database management algorithmsand protocols for accessing and manipulating data are required to satisfy timing con-straints of supported applications. Therefore, new research in distributed real-timedatabase systems (DRTDBS) is needed to investigate possible ways of applying data-base systems technology to real-time systems. This paper first discusses the perfor-mance issues that are important to DRTDBS, and then surveys the research that hasbeen done so far on the issues like priority assignment policy, commit protocols andoptimizing the use of memory in non-replicated/replicated environment pertaining todistributed real time transaction processing. In fact, this study provides a foundationfor addressing performance issues important for the management of very large realtime data and pointer to other publications in journals and conference proceedingsfor further investigation of unanswered research questions.

Keywords Distributed real time commit protocol · Distributed transactionprocessing · Priority assignment policy · Memory optimization · Replication

U. Shanker (�) · M. Misra · A.K. SarjeDepartment of Electronics and Computer Engineering, Indian Institute of Technology,Roorkee 247667, Indiae-mail: [email protected]

M. Misrae-mail: [email protected]

A.K. Sarjee-mail: [email protected]

Present address:U. ShankerDepartment of Computer Science and Engineering, M.M.M. Engineering College,Gorakhpur 273 010, India

128 Distrib Parallel Databases (2008) 23: 127–149

1 Introduction

Databases and database systems have become an essential component of everydaylife in modern society. In the course of a day, most of us encounter several activi-ties that involve some interaction with databases [32, 50]. Nowadays, because of theinformation technology revolution, fast access to information and its efficient man-agement are key to the success of any activity such as business and other similarones [52, 63, 103]. Today’s business applications are not the old-styled batch appli-cations; rather they do their data processing activities on-line [127]. Modern elec-tronic services and electronic commerce applications, characterized by high volumeof transactions, cannot survive without an on-line support of computer systems anddatabase technology [7]. Therefore, database systems (DBS) play an important role inmanaging the voluminous data and their processing for the fast growing current busi-nesses environment. Existing and emerging applications require new functionalities.The performance need of emerging applications require not only the management oflarge data sets, but also new processing strategies.

DBS can be viewed as a collection of the data items which are shared by manyusers [34, 113, 150]. Database systems can be broadly classified as centralized ordistributed. A centralized DBS runs on a single computer system, whereas a distrib-uted database system (DDBS) consists of a collection of sites, connected together viasome communication network, in which each site is a database system site in its ownright but the sites have agreed to work together, so that a user at any site can accessdata from anywhere in the network, exactly as if the data are all stored at the user’sown site [36].

Real Time Systems (RTS) are those systems for which correctness depends notonly on the logical properties of the produced results, but also on the temporal prop-erties of these results [7, 122, 132, 159]. Typically, RTS are associated with criticalapplications in which human lives or expensive machineries may be at stake [83, 91].Hence, in such systems, an action performed too late (or too early) or a computationwhich uses temporally invalid data may be useless and sometimes harmful even ifsuch an action or computation is functionally correct. As RTS continue to evolve,their applications become more and more complex, and often require timely accessand predictable processing of massive amounts of real time data [154]. The data-base systems especially designed for efficient processing of these types of real timedata are referred as DRTDBS. Thus, DRTDBS are collection of multiple, logicallyinterrelated databases distributed over a computer network where transactions haveexplicit timing constraints, usually in the form of deadlines [13, 25, 94, 95]. In suchsystems, data items shared among transactions are spread over remote locations. Ac-cessing these shared data items must be controlled in order to maintain database’slogical consistency. Satisfying the timing constraints of various real time activities indistributed systems may be difficult due to the distributed nature of the transactionsand database consistency requirements.

There are a number of survey and other papers available in the literature [17,18, 20, 22, 26, 36, 37, 40, 43, 52, 72, 92, 100, 101, 111, 118, 134, 144, 158, 161].However, they mainly focus on concurrency control and other issues related to dis-tributed database systems and distributed real time database systems. To the best of

Distrib Parallel Databases (2008) 23: 127–149 129

our knowledge, none of these consider priority assignment policies, commit proto-cols, and memory optimization for data processing in real time replicated or non-replicated environment. This paper explores the basic issues and research challengesthat are important in the performance of DRTDBS. This is followed by a review of theliterature dealing with the performance issues that are important in the design of data-base systems. Major contributions to the study of database systems are summarizedand future research directions are listed.

2 Distributed real time transaction

When users programs interact with database, partially ordered sets of read and writeoperations are generated [38]. This sequence of operations on the database is calleda transaction. A transaction transforms the current consistent state of the databasesystem into a new consistent state. In DRTDBS, there are two types of transactions:global and local. Global transactions are distributed real-time transactions executedat more than one site, whereas the local transactions are executed at the originatingsite (parent site) only. A common model of a distributed transaction is as follows.There is one process called coordinator executed at the site where the transactionis submitted and a set of other processes called cohorts that execute on behalf of thetransaction at other sites accessed by the transaction. The transaction is an atomic unitof work, which is either completed in it’s entirely or not at all. Hence, a distributedcommit protocol is needed to guarantee uniform commitment of distributed transac-tion execution [119]. The commit operation implies that the transaction is successful,and hence all of its updates should be incorporated into the database permanently.An abort operation indicates that the transaction has failed, and hence requires thedatabase management system to cancel or abolish all of its effects in the databasesystem. In short, a transaction is an “all or nothing” unit of execution. In general,real time transactions are classified into three types namely hard, soft and firm. Nohard real time transaction should have its deadline missed, and its deadline must beguaranteed by the system. On the other hand, any deadline violations of the soft realtime transactions may only result in the performance degradation of the system. Themajor performance metric for the soft real time transaction is the number or percent-age of deadline violations or their average or worst case response time. A firm realtime transaction is a special kind of soft real time transaction that will be killed whenits deadline expires. The performance metric is the number or percentage of deadlineviolations. The completion of a real time transaction might contribute a value to thesystem. The relationship between the value imparted by a real time transaction and itscompletion time can be considered as a value function of time. After a soft real timetransaction misses its deadline, its value might decrease with time. A firm real timetransaction loses its value after its deadline expires. When a hard real time transac-tion misses its deadline, its value becomes negative. It means that a catastrophe mightoccur.

There are basically two types of distributed transaction execution models; viz., se-quential and parallel [4, 99]. In sequential execution model, there can be at most onecohort of a transaction at each execution site, and only one cohort can be active at


a time. After successful completion of one operation, next operation in the sequenceis executed by the appropriate cohort. At the end of execution of the last operation,the transaction can be committed. In parallel execution model, the coordinator of thetransaction spawns all cohorts together and sends them for execution at respectivesites [15]. All cohorts then execute in parallel. The assumption here is that the opera-tions performed by one cohort during its execution at one site are independent of theresults of the operations performed by some other cohort at some other site. In otherwords, the sibling cohorts do not share any information among themselves [154].

One of the fundamental properties of a transaction is isolation. When several trans-actions execute concurrently in the database, the isolation property must be preserved.To ensure this, the system must control the interaction among the concurrent transac-tions; this control is achieved through concurrency control schemes [113, 150]. Someof the main concurrency control techniques, such as two phase locking (2PL), arebased on the concept of locking of data items. Locks are used to ensure noninterfer-ence property of concurrently executing transactions and to guarantee serializabilityof the schedules. A transaction is said to follow the two-phase locking protocol, if alllocking operations precede the first unlock operation in the transaction. Such a trans-action can be divided into two phases: an expanding or growing (first) phase, duringwhich new locks on data items can be acquired but none can be released; and a shrink-ing (second) phase, during which existing locks can be released but no new locks canbe acquired [99]. It ensures serializability, but not by deadlock freedom. Two phaselocking can be static or dynamic. The working principle of static two phase locking(S2PL) is similar to dynamic two phase locking (D2PL) except for the procedure ofsetting locks [77]. In D2PL, transactions acquire locks to access data items on demandand release locks upon termination or commit [137]. In S2PL, the required locks ofa transaction are assumed to be known before its execution [140]. Prior knowledgeof the required data items by a transaction is easy to address in DRTDBS as it isgenerally agreed that the behavior and the data items to be accessed by real-timetransactions, especially hard real-time transactions, are much more well-defined andpredictable. So, as a result of better defined nature of real time transactions, it is notuncommon to assume that the locking information of a transaction is known beforeits execution. For example, in priority ceiling protocol (PCP), the locks required bythe transactions must be known before their arrivals with predefined priorities [123].A transaction has to obtain all its required locks before the start of its execution. If anyone of its locks is being used by another transaction, it releases all seized locks and isblocked (kept in wait state). The locks to be accessed by a transaction at each site canbe packed into a single message for transmission. Hence, the number of messagesand the time delay for setting the remote locks is generally smaller for distributedS2PL than for D2PL. There is no local deadlock and a distributed deadlock is mucheasier to resolve with S2PL than with D2PL. S2PL protocol is deadlock free [125]because blocked transactions cannot hold locks. In the last two decades, a lot of workhas been done to compare D2PL with S2PL [90]. Though most researchers agree thatD2PL is a better choice for conventional non-real-time database systems than S2PLbecause of the followings reasons [68, 120].

(1) Smaller probability of lock conflicts due to the shorter average lock holding timein D2PL; and


(2) Difficulty in determining the required locks before execution of the transaction

However, the meaning of “better” performance in DRTDBS is quite different fromthat in conventional non real time database systems. In conventional database sys-tems, the main performance measures are mean system throughput and mean systemresponse time. On the contrary, minimizing the number of missed deadlines is themain concern in DRTDBS.

In non real time S2PL, a transaction is blocked if any of its required locks is seizedin a conflicting mode by another transaction. While it is being blocked, some of itsrequired locks which may be free initially can be seized by other transactions. Thus,even when the original conflicting locks are released, the transaction may be blockedby other transactions which arrive after it. So, the blocking time of higher prioritytransaction can be arbitrarily long due to prolonged blocking as a result of waitingfor multiple locks [33]. An alternative for concurrency control in DRTDBS is to usereal time S2PL (RT-S2PL).

In RT-S2PL, each lock in the database is defined with a priority equal to the pri-ority of the highest priority transaction waiting for that lock. All the locks of thedata items to be accessed by a transaction have to be set in appropriate modes beforeprocessing of the transaction. If any of the required locks is in a conflicting mode orhas a priority higher than that of the requesting transaction; none of the required lockswill be set and the transaction will be blocked instead. However, for the locks withlower priorities, their priorities will be updated to that of the requesting transaction.These features of RT-S2PL make it attractive for DRTDBS [77, 79, 136]. In RT-S2PLprotocols, the problem of locking-induced thrashing can be prevented because lockrequesting transactions can be blocked due to a lock conflict [141–143].

3 Issues in distributed real time database system

The time expressed in the form of a deadline is a critical factor to be consideredin distributed real time transactions [106]. Completion of transactions on or beforeits deadline is one of the most important performance objectives of DRTDBS [133,138]. There are several important factors that contribute to the difficulty in meetingthe deadlines of a distributed transaction [40]. One of the most significant factors isthe data conflict among transactions [28]. The data conflict that occurs among exe-cuting transactions is referred to as execute-execute conflict. The conflict involvingexecuting-committing transactions is termed as execute-commit conflict. A numberof real time concurrency control protocols have been proposed in the past to resolveexecute-execute conflicts [21, 23, 39, 55–57, 67, 96, 116, 130, 139, 151, 153, 156].A commit protocol has to work with concurrency control protocol to handle execute-commit conflict and to ensure the transaction atomicity. The traditional commit proto-cols block the lock requesting transactions until the lock holding transaction releasesthe lock. The blocked transactions may seriously affect the performance of DRTDBS,especially when failures occur during the commitment phase.

Predictability and consistency are fundamental to real time transaction processing,but sometimes require conflicting actions [74, 88, 105, 128]. To ensure consistency,we may have to block certain transactions. Blocking of these transactions, however,


may cause unpredictable transaction execution and may lead to the violation of timingconstraints. There are a number of other sources of unpredictability such as commu-nication delays, site failures [24], and transaction’s interaction with the underlyingoperating system and I/O subsystems [17].

Other design issues of DRTDBS are data access mechanism and invariance, repli-cation of data items at various sites, new metrics for database correctness and per-formance, maintaining global system information, security, fault tolerance, failurerecovery, optimizing the use of memory, deadline assignment strategies [80, 81],possibility of distributed deadlocks [18] etc. Also, there is no adequately designedtechnique for scheduling the CPU as the primary resource in DRTDBS [6].

Among the above mentioned issues, priority assignment policy for scheduling oftransactions, commit protocol, memory optimization in non-replicated/replicated en-vironment are considered in this study. We agree that our coverage of issues is in-complete; we are trying to point out some research areas that in our opinion, havepotential but received very little attention to survey the work carried out. In the fol-lowing sections, we will review the literature which has addressed these issues.

3.1 Priority assignment policy

Usually a real time database system is a part of a large and complex real time system.The tasks in RTS and transactions in DRTDBS are similar in the sense that both areunits of work as well as units of scheduling [64, 74, 75]. However, tasks and trans-actions are different computational concepts and their differences affect how theyshould be scheduled and processed. Unlike transactions, tasks in real time systemsdo not consider consistency of the data items used.

Liu and Layland [97] have developed a rate monotonic static assignment schemeto determine the schedulability of a set of periodic tasks for centralized RTS. The pro-posed priority assignment techniques can be broadly classified into three categories:static, dynamic and hybrid. A scheduling algorithm is said to be static if priorities areassigned to tasks once and for all. A scheduling algorithm is said to be dynamic if thepriority of a task changes from request to request. One of the most used algorithmsbelonging to this class is Earliest Deadline First (EDF), according to which prioritiesassigned to tasks are inversely proportional to the absolute deadlines of active jobswhere deadline of a job depends on the arrival time of its next occurrence. A schedul-ing algorithm is said to be hybrid if the priorities of some of the tasks are fixed andpriorities of the remaining tasks vary from request to request. Though many real timetask scheduling techniques are still used for scheduling real time transactions, thetransaction scheduling in real time database systems needs a different approach thanthat used in scheduling tasks in real time systems.

Most concurrency controllers block or restart transactions when data conflicts aredetected. The victim selection policy is based on the rules of the specific concurrencycontroller. The traditional no priority based concurrency control algorithm penalizesthe transaction that requests the lock last [152]. The transaction remains blocked untilthe conflicting lock is released. The real time priority of the transaction is not consid-ered in processing the lock request. Recent studies show that the system performancecan be significantly improved by using priority based scheduling. The random pri-ority assignment policy assigns priority to each transaction on a random basis and


the priority assigned to transaction is independent of transaction deadline. In the LSFpolicy, the transaction with less slack time will have higher priority. The slack timecan be defined as the amount of time the cohort can afford to wait in order to completebefore its deadline [155].

The transaction with closest deadline is assigned highest priority. It is called EDF,initially designed for real time tasks scheduling. It is a biased approach. If two cohortshave same deadline, one with earlier arrival time is assigned a higher priority on thebasis of first come first serve (FCFS).

The performance of different scheduling policies for soft deadline based transac-tions was first addressed by Abbot R. and Garcia-Monila H. [2]. They studied theperformance of three priority assignment techniques; FCFS, EDF and LSF, with dif-ferent concurrency control methods namely serial execution (SE), high priority (HP),and conditional restart (CR) through simulation. The pioneering work in RTDBSperformance evaluation of various scheduling options for a real time database systemwith disk and shared locks is reported again by Abbot R. and Garcia-Monila H. [1].The scheduling algorithms used for this study are FCFS, EDF and LSF along withthe concurrency control algorithms such as wait, wait-promote, high priority & con-ditional restart.

Pang et al. investigated the problem of “bias” against longer transactions under“earliest-deadline-based” scheduling policies in a centralized RTDBS [108, 109].Their approach to solve the problem of bias assigns virtual deadlines to all trans-actions. A transaction with an earlier virtual deadline is served before one with alater virtual deadline. The virtual deadline of a transaction is adjusted dynamically asthe transaction progresses and is computed as a function of the size of the transaction.

In a real-time database system, an application may assign a value to a transactionto reflect the return it expects to receive if the transaction commits before its deadline[53, 54]. Haritsa et al. [58] addressed the problem of establishing a priority order-ing among transactions characterized by both values and deadlines that results inmaximizing the realized value. They proposed the Adaptive Earliest Deadline (AED)protocol for priority assignment as well as for load control of the transactions. AEDwas later improved to Adaptive Earliest Virtual Deadline (AEVD) policy using vir-tual deadline based on both arrival time and deadline. Datta et al. addressed someof the weaknesses in AEVD, and proposed the Adaptive Access Parameter (AAP)method for explicit admission control [27].

Dogdu Erdogan and Ozsoyoglu Gultekin proposed new priority assignment andload control policies for repeating real-time transactions [33]. Based on the executionhistories of the transactions, they showed that a widely used priority assignment tech-nique EDF is biased towards scheduling short transactions favorably and proposedprotocols that attempt to eliminate the discriminatory behavior of EDF by adjustingthe priorities using the execution history information of transactions. They introducedthe notion of “fair scheduling” of transactions in which the goal was to have “similar”success ratios for all transaction classes (short to long in size).

The processing of transactions in DRTDBS is much more complex than in central-ized real time database systems. In DRTDBS, a transaction is generally divided intoseveral sub transactions (cohorts). These cohorts execute on different sites. The sys-tem performance is heavily dependent on the local scheduling of the cohorts at differ-ent sites. It has been shown by Kao B. and Garcia-Monila H. that the distributed real


time system performance, in terms of meeting task deadlines, can be improved by as-signing appropriate priorities to the sub-tasks of a task [70]. They suggested four dif-ferent heuristics, i.e., Ultimate Deadline (UD), Effective Deadline (ED), Equal Slack(EQS) and Equal Flexibility (EQF) for assigning deadlines to sub-tasks [70]. Theseheuristics consider only real time constraints and may not be suitable for DRTDBSas they do not consider their impact on data contention which can seriously affect thesystem performance. Lee Victor et al. examined the performance of these four heuris-tics and suggested three other alternatives that take into consideration the impact ofdata conflicts [89]. These alternative priority assignment strategies are Number ofLocks held (NL), Static EQS (SEQS) and Mixed Method (MM). The NL strategyassigns the priority to cohorts on the basis of the number of locks being held by itsparent transaction while other two heuristics are improved versions of the heuristicsdiscussed by Kao B. and Garcia-Monila [70]. However, both of the above studiesconsider only sequential executions of tasks/cohorts. These heuristics, except UD,are not suitable for cohorts executing in parallel. Moreover the authors in [89] havenot studied the fairness property of these schemes.

Complex distributed tasks often involve parallel execution of the subtasks at dif-ferent nodes. To meet the deadline of a global task, all of its parallel subtasks haveto finish in time. In comparison to a local task (which involves execution at only onenode), a global task may find it much harder to meet its deadline because it is fairlylikely that at least one of its subtasks run into an overloaded node. Another problemwith complex distributed tasks occurs when a global task consists of parallel and ser-ial subtasks. If one parallel subtask is late, then the whole task is late. The problem ofassigning deadlines to the parallel and the serial subtasks of the complex distributedtasks is addressed by Kao B. and Garcia-Monila H. [71]. They studied the problemof automatically translating the deadline of a real time activity to deadlines for all itssequential and parallel sub tasks constituting the activity. Each sub task deadline isassigned just before the sub task is submitted for execution. The structure of com-plex tasks is assumed to be known in advance. To meet the deadline of a global task,the scheduler must estimate the execution times of the subtasks and assign them toprocessors in such a way that all will finish before the deadline of the global task.A number of strategies for assigning a deadline to each parallel subtask have beenproposed. Strategies have also been proposed for assigning deadlines to sequentialsubtasks. The problem of assigning deadlines to parallel and serial subtasks of com-plex distributed tasks in a real time system has been studied through simulation. Theempirical results are provided for assigning virtual deadlines to parallel subcompo-nents of a task in order to meet the global task deadline.

Lam et al. investigated the effects of different priority assignment heuristics usingoptimistic concurrency control protocol and high priority two phase locking [81, 90].The results of their performance experiments show that optimistic concurrency con-trol protocols are more affected by the priority assignment policies compared to lock-ing based protocols. It was also shown that considering both transaction deadline andcurrent data contention in assigning transaction priorities provides best performanceamong a variety of priority assignment techniques.

Traditional real time schedulers do not consider the impact of communication de-lay for transferring the remote data and results. To reduce the miss percentage of


transactions and the wastage of time for remote transaction due to communicationdelay, a new real time scheduler called Flexible High Reward (FHR) is proposed byChen Hong-Ren et al. [24]. FHR tries to reduce the miss percentage by giving slightlyhigh priority to remote transactions.

Most of the previous work on priority assignment focuses either on centralizeddatabase or on distributed databases where subtasks (cohorts) of transaction are ex-ecuted sequentially. Very few researches have considered the scheduling problem ofdistributed cohorts executing in parallel [61].

In the paper [147], the authors have considered parallel execution of cohorts andproposed a heuristic to determine their priorities. The proposed heuristic improvesthe system performance by favoring cohorts demanding lesser number of locks. Thisminimizes the number of blocked/aborted cohorts. Further, the authors have dis-cussed the notion of fairness in transaction scheduling, and in their scheme a co-hort’s temporary priority is calculated every time a data contention occurs to favornear completion cohorts. This reduces a large amount of wasted work and ensuresfairness and freedom from starvation in transaction scheduling with a goal to havesimilar success ratio for all transactions (short to long in size). They compared theproposed scheme with EDF priority assignment policy. Simulation results show thatthe proposed scheme combined with intermediate (temporary) priority assignmentpolicy gives better performance than EDF based scheme. Fairness is also achievedwith the intermediate (temporary) priority assignment policy.

3.2 Real time commit protocols

In distributed environment, a transaction may decide to commit at some sites whileat some other sites it could decide to abort resulting in a violation of transactionatomicity [104, 113]. To overcome this problem, distributed database systems use adistributed commit protocol to ensure that all the participating sites agree on the finaloutcome (commit/abort) of the transaction [8, 87].

The two phase commit protocol (2PC) referred to as the Presumed Nothing2PC protocol (PrN) is the most commonly used protocol in the study of DDBS[14, 41, 42]. It ensures that sufficient information is force-written on the stable stor-age to reach a consistent global decision about the transaction [9, 102, 131]. A numberof 2PC variants [84, 98, 121] have been proposed and can be classified into followingfour groups [86].

(1) Presumed Abort/Presumed Commit Protocols [10, 11].(2) One Phase Commit Protocols [3, 9, 51].(3) Group Commit Protocols [110].(4) Pre Commit/Optimistic Commit Protocols.

Due to a series of synchronous messages and logging cost, commit processing canresult in a significant increase in the transaction execution time. In a real-time envi-ronment, this is clearly undesirable. It may also result in priority inversion, because,once a cohort reaches the prepared state, it has to retain all its data locks until it re-ceives the global decision from the coordinator. This retention is fundamentally nec-essary to maintain atomicity. Therefore, if a high priority transaction requests access


to a data item that is locked by a “prepared cohort” of lower priority, it is not possibleto forcibly obtain access by preempting/aborting the low priority cohort. In this sense,the commit phase in DRTDBS is inherently susceptible to priority inversion. Moreimportantly, the priority inversion interval is not bounded since the time duration thata cohort is in the prepared state, can be arbitrarily long (e.g. due to blocking or net-work delays). This is especially more problematic in distributed context. Therefore,in order to meet the transaction deadlines, the choice of a better commit protocol isvery important for DRTDBS. For designing the commit protocols for DRTDBS, weneed to address two questions.

(1) How do we adapt the standard commit protocol into the real-time domain?(2) How can we decrease the number of missed transactions in the system?

Researchers have proposed some real-time commit protocols in the literature toaddress this issue. Soparkar et al. have proposed a protocol that allows individual sitesto unilaterally commit [129]. If later on it is found that the decision is not consistentglobally then compensation transactions are executed to rectify errors. The problemwith this approach is that many actions are irreversible in nature. The scheme pro-posed by Yongik et al. is also based on the theme of allowing individual sites to unilat-erally commit the idea being that unilateral commitment results in greater timelinessof actions [160]. If later on it is found that the decision is not consistent globally,“compensation” transactions are used to rectify the errors. While the compensation-based approach certainly appears to have the potential to improve timeliness, yet thereare quite a few practical difficulties described below.

(1) The standard notion of transaction atomicity is not supported—instead, a “re-laxed” notion of atomicity is provided.

(2) The design of a compensating transaction is an application specific task since itis based on the application semantics.

(3) The compensation transactions need to be designed in advance so that they canbe executed as soon as error is detected. This means that the transaction workloadmust be fully characterized a priori.

(4) Some real actions such as firing a weapon or dispensing cash may not be com-pensated at all.

From the performance viewpoint also, there are some difficulties.

(1) The execution of compensation transactions is itself an additional burden on thesystem.

(2) It is not clear as to how the database system should schedule the compensationtransactions relative to the normal transactions.

A centralized timed 2PC protocol guarantees that the fate of a transaction (commitor abort) is known to all the cohorts before the expiry of the deadline when there areno processor, communication or clock faults [29, 30]. In case of faults, however,it is not possible to provide such guarantees and an exception state is allowed whichindicates the violation of the deadline. Further, the protocol assumes that it is possiblefor DRTDBS to guarantee allocation of resources for a duration of time within a giventime interval. Finally, the protocol is predicated upon the knowledge of worst-casecommunication delays.


Ramesh Gupta et al. did a detailed study of the relative performance of differentcommit protocols [44–49, 59]. Using a detailed simulation model for firm-deadlineDRTDBS, the authors have evaluated the deadline miss performance of a variety ofstandard commit protocols including 2PC, PA, PC and 3PC. Then they have pro-posed and evaluated the performance of a new commit protocol called OPT designedspecifically for the real-time environment [5, 47, 48]. It is a 2PC variant that attemptsto alleviate priority inversion in 2PC and includes features such as controlled opti-mistic access to uncommitted data, active abort and silent kill. This protocol allowsa high priority transaction to borrow (i.e., access) data items held by low prioritytransaction that is waiting for the commit message under the assumption that the lowpriority transaction will most probably commit. This creates dependencies amongtransactions. If a transaction depends on other transactions, it is not allowed to startcommit processing and is blocked until the transactions, on which it depends, havecommitted. The blocked committing transaction may include a chain of dependen-cies as other executing transactions may have data conflicts with it. They have alsosuggested two variant of OPT, namely Shadow-Opt and Healthy-Opt protocols [46].In Healthy-Opt, a health factor is associated with each transaction and the transactionis allowed to lend its data only if its health factor is greater than a minimum value.However, it does not consider the type of dependencies between two transactions. Theabort of a lending transaction aborts all transaction that has borrowed the data fromit. The performance of the system is dependent on a chosen threshold value of healthfactor (HF), which is defined as the ratio of TimeLeft to MinTime, where TimeLeftis the time left until the transaction’s deadline and MinTime is the minimum time re-quired for commit processing. In Shadow-Opt, a cohort creates a replica of the cohortcalled a shadow, whenever, it borrows a data page. The original cohort continues itsexecution and the shadow is blocked at the point of borrowing. If the lending cohortcommits, the borrowing cohort continues and the shadow is discarded, otherwise ifthe lender aborts, the borrowing cohort is aborted.

Harista et al. proposed a new protocol Permits Reading of Modified Prepared-Datafor Timeliness (PROMPT) that is also designed specifically for the real-time environ-ment and includes features such as controlled optimistic access to uncommitted data,active abort, silent kill and healthy lending [60, 61, 76]. The performance results ofPROMPT show that it provides significant improvement over the classical commitprotocols, and makes extremely efficient use of the lending premise. The authorshave also evaluated the priority inheritance approach to address the priority inversionproblem associated with prepared data, but found it to be inherently unsuitable for thedistributed environment. Due to sharing of data items, it creates commit or abort de-pendencies between the conflicting transactions. The dependencies limit the commitorder of the transactions and thus may cause a transaction to miss its deadline whileit is waiting for its dependent transaction to commit. The impact of buffer space andadmission control is not studied since it is assumed that buffer space is sufficientlylarge to allow the retention of data updates until commit time. In case of sequentialtransaction execution model, the borrower is blocked for sending the WORKDONEmessage and the next cohort can not be activated at other site for its execution. It willbe held up till the lender completes. If its sibling is activated at another site anyway,the cohort at this new site will not get the result of previous site because previous co-hort has been blocked for sending of WORKDONE message due to being borrower.


In shadow PROMPT, a cohort forks off a replica of the transaction, called a shadow,without considering the type of dependency whenever it borrows a data page [149].

Lam et al. proposed deadline-driven conflict resolution (DDCR) protocol whichintegrates concurrency control and transaction commitment protocol for firm realtime transactions [78, 82]. DDCR resolves different transaction conflicts by main-taining three copies of each modified data item (before, after and further) accordingto the dependency relationship between the lock-requester and the lock holder. Thisnot only creates additional workload on the systems but also has priority inversionproblems. The serializability of the schedule is ensured by checking the before setand the after sets when a transaction wants to enter the decision phase. The protocolaims to reduce the impact of a committing transaction on the executing transactionwhich depends on it. The conflict resolution in DDCR is divided into two parts (a) re-solving conflicts at the conflict time; and (b) reversing the commit dependency whena transaction, which depends on a committing transaction, wants to enter the decisionphase and its deadline is approaching.

If data conflict occurs between the executing and committing transactions, sys-tem’s performance will be affected. Pang Chung-leung and Lam K. Y. proposed anenhancement in DDCR called the DDCR with similarity (DDCR-S) to resolve theexecuting-committing conflicts in DRTDBS with mixed requirements of criticalityand consistency in transactions [107]. In DDCR-S, conflicts involving transactionswith looser consistency requirement and the notion of similarity are adopted so thata higher degree of concurrency can be achieved and at the same time the consis-tency requirements of the transactions can still be met. The simulation results showthat the use of DDCR-S can significantly improve the overall system performance ascompared with the original DDCR approach.

Based on PROMPT and DDCR protocols, B. Qin and Y. Liu proposed doublespace commit (2SC) protocol [112]. They analyzed and categorized all kind of de-pendencies that may occur due to data access conflicts between the transactions intotwo types commit dependency and abort dependency. The 2SC protocol allows a non-healthy transaction to lend its held data to the transactions in its commit dependencyset. When the prepared transaction aborts, only the transactions in its abort depen-dency set are aborted and the transactions in its commit dependency set execute asnormal. These two properties of the 2SC reduce the data inaccessibility and the prior-ity inversion that is inherent in distributed real-time commit processing. 2SC protocoluses blind write model. Extensive simulation experiments have been performed tocompare the performance of 2SC with that of other protocols such as PROMPT andDDCR. The simulation results show that 2SC has the best performance. Furthermore,it is easy to incorporate it in any current concurrency control protocol.

Ramamritham et al. [115] have given three common types of constraints for the ex-ecution history of concurrent transactions. The paper [19] extends the constraints andgives a fourth type of constraint. Then the weak commit dependency and abort depen-dency between transactions, because of data access conflicts, are analyzed. Based onthe analysis, an optimistic commit protocol Two-Level Commit (2LC) is proposed,which is specially designed for the distributed real time domain. It allows transac-tions to optimistically access the locked data in a controlled manner, which reducesthe data inaccessibility and priority inversion inherent and undesirable in DRTDBS.


Furthermore, if the prepared transaction is aborted, the transactions in its weak com-mit dependency set will execute as normal according to 2LC. Extensive simulationexperiments have been performed to compare the performance of 2LC with that ofthe base protocols PROMPT and DDCR. The simulation results show that 2LC iseffective in reducing the number of missed transaction deadlines. Furthermore, it iseasy to be incorporated with the existing concurrency control protocols.

The management of transactions is among the main issues to tackle in manycurrent data intensive applications such as multimedia applications or video-conferencing. These applications are often distributed over several sites, manipulatelarge volumes of data and their actions have temporal constraints and are causallyrelated. Therefore, DRTDBS are the systems that manage them efficiently, notablyif the transaction concurrency control and commit processes take into account theprecedence relationships which might exist between transactions or cohorts. The pa-per [12] proposes Causal-Prompt protocol to manage the commit process of suchtransactions. The authors have shown that Causal-Prompt protocol respects certaintransactions properties and enhances the real-time transaction success ratio (numberof transactions that meet their deadlines/total number of transactions).

With the appearance of main memory based database system, the databaseprocessing time has been reduced an order of magnitude, since the database accessdoes not incur any disk access at all. However, when it comes to distributed mainmemory database systems, the distributed commit process is still very slow since thedisk logging at several sites has to precede the transaction commit. Insoen et al. [69]have reevaluated various distributed commit protocols and came up with the causalcommit protocol suitable for distributed main memory real time database systems.The simulation study has also been performed which confirms that the new protocolgreatly reduces the time to commit the distributed transaction without any consistencyproblem.

In paper [62], the authors proposed an approach based on the (m, k)-firm notionto manage distributed transactions. This notion is used to relax hard real-time con-straints by allowing some invocations of periodic tasks to be lost. In this case, eachtask is divided into a mandatory part and an optional part. Mandatory jobs must becompleted whereas optional jobs may be discarded from the system in overload con-ditions. A distributed transaction is divided into sub transactions according to thelocation of the data they have to access. Furthermore, these sub transactions may bemandatory or optional according to their criticality (according to their weights, forexample). The contribution of this article is twofold: (i) the authors study the useof the m and k parameters to manage the mandatory and the optional parts of dis-tributed transactions and then present the ( m

k)-firm transaction model and (ii) they

propose new concurrency control and commit methods for these transactions. Sim-ulation results show that this scheme is suited to DRTDBS compared to some otherclassical transaction models.

Many existing commit protocols try to improve system performance by allow-ing a committing cohort to lend its data to an executing cohort, thus reducing datainaccessibility. These protocols block the borrower when it tries to send WORK-DONE/PREPARED message [61, 112] thus increasing the transactions commit time.The paper [145] first analyzes all kind of dependencies that may arise due to data


access conflicts among executing-committing transactions when a committing cohortis allowed to lend its data to an executing cohort. It then proposes a static two-phaselocking and high priority based, write-update type, ideal for fast and timeliness com-mit protocol i.e. SWIFT. In SWIFT, the execution phase of a cohort is divided intotwo parts, locking phase and processing phase and then, in place of WORKDONEmessage, WORKSTARTED message is sent just before the start of processing phaseof the cohort. Further, the borrower is allowed to send WORKSTARTED message, ifit is only commit dependent on other cohorts instead of being blocked as opposed to[61, 112]. This reduces the time needed for commit processing and is free from cas-caded aborts. To ensure non-violation of ACID properties, checking of completionof processing and the removal of dependency of cohort are required before sendingthe YES-VOTE message. Simulation based on [35, 65, 66, 85, 93, 124, 135] hasbeen done for main memory resident [31] as well as disk resident databases. Simu-lation results show that SWIFT improves the system performance in comparison toearlier protocol. The performance of SWIFT is also analyzed for partial read-only op-timization, which minimizes intersite message traffic, execute-commit conflicts andlog writes resulting in a better response time. The impact of permitting the cohorts ofthe same transaction to communicate with each other [78, 82] has also been analyzed.

4 Memory optimization

The important database system resources are the data items that can be viewed as logi-cal resource, and CPU, disks and the main memory which are physical resources [37].Though the cost of the main memory is dropping rapidly and its size is increasing,the size of database is also increasing very rapidly. In real time applications, wherethe databases are of limited size or are growing at a slower rate than the memory ca-pacities are growing, they can be kept in the main memory. However, there are manyreal time applications that handle large amount of data and require support of an in-tensive transaction processing [114]. The amount of data they store is too large (andtoo expensive) to be stored in the non volatile main memory. Examples include tele-phone switching, satellite image data, radar tracking, media servers, computer aidedmanufacturing etc. In these cases, the database can not be accommodated in the mainmemory easily. Hence, many of these types of database systems are disk resident. Thebuffer space in the main memory is used to store the execution code, copies of files& data pages, and any temporary objects produced. With the new functionalities andfeatures of the light weight devices, there is a need of new policies/protocols so thatthe memory utilization can be improved [117]. Ramamritham K. and Sen R. utilizeda novel storage model, ID based storage, which reduces storage costs considerably.They present an exact algorithm for allocating memory among the database opera-tors. Because of its high complexity, a heuristic solution based on the benefit of anoperator per unit memory allocation has also been proposed.

Memory efficient fast distributed real time commit protocol (MEFCP) presentsan optimized distributed real time commit protocol based on new locking schemeand write operation divided into update and blind write [146, 148]. This protocoloptimizes the memory required for maintaining the transient information of lender &


borrower [61]. It also sends the WORKDONE message if borrower has locked thedata in mode 2 only. Mode 2 can be defined as if a cohort T2 wants to write/updatea data item read by another cohort T1 in its committed phase, it changes the flag ofthe data item from Mode 1 to Mode 2. T2 is now not allowed to commit until T1commits. However, if T1 aborts, T2 does not abort. MEFCP has been compared withPROMPT and 2SC commit protocols through simulation.

5 Replicated environment

In replicated database systems, copies of the data items can be stored at multiplesites. The potential of data replication for high data availability and improved readperformance is crucial to RTDBS. On the other hand, data replication introduces itsown problems. Access to a data item is no longer controlled exclusively by a singlesite; instead, the access control is distributed across the sites each storing a copy ofthe data item. It is necessary to ensure that mutual consistency of the replicated datais provided, in other words, replicated copies must behave like a single copy. This ispossible by preventing conflicting accesses on the different copies of the same dataitem, and by making sure that all data sites eventually receive all updates. Multiplecopy updates lead to a considerable overhead due to the communication requiredamong the data sites holding the copies [157]. Therefore, major issue is the develop-ment of replication protocol/policy. Some sporadic efforts [157, 164, 165] have beenmade for the development of different types of protocols/policies. However, almostall the research works related to the issues considered in this paper have reportedrelative performances of the protocols/policies in non replicated environment onlyexcept two-phase commit protocol. Also, providing quality of service guarantees fordata services in a distributed environment is a challenging task [162] In this directionvery little work has been reported so far [163].

6 Scope for research in future

Although, a vast amount of work have been done on various issues concerning DRT-DBS as presented in the earlier sections, there still remain many challenging andunresolved issues that warrant further investigation. Following are some suggesteddirections for further work in distributed real time database systems.

(1) Integration and performance evaluation of various protocols and heuristics withreference to DRTDBS.

(2) Although tremendous research efforts have been reported in hard real time sys-tems in dealing with hard real time constraints, very little work has been reportedin hard real time database systems. The performance of the reported work for softor firm real time database systems can be evaluated for hard real time constrainedtransactions [16, 126, 144].

(3) The work such as commit protocols etc. reported for real time database systemscan be extended for Mobile DRTDBS [73], where memory space, power andcommunication bandwidth are bottleneck. There is a need to design various pro-tocols for different purposes that may suit to the specific need of hand held de-vices.


(4) Fault tolerance and reliability are highly desirable features in many real time ap-plications because, in these applications, continued operation under catastrophicfailure and quick recovery from failure is very crucial. These aspects may also bedealt.

(5) More work is needed to explore the impact of establishing the communication inbetween cohorts (siblings) of the same transaction on the overall system perfor-mance.

(6) Now-a-days grid database and grid computing are challenging areas for computerresearchers. Existing techniques/protocols can be extended or new protocols canbe developed for grid database systems.

(7) Biomedical Informatics is quickly evolving into a research field that encompassesthe use of all kinds of biomedical information, from genetic and proteomic datato image data associated with particular patients in clinical settings. Biomed-ical Informatics comprises the fields of Bioinformatics (e.g., genomics and pro-teomics) and Medical Informatics (e.g., medical image analysis), and deals withissues related to the access to information in medicine, the analysis of genomicsdata, security, interoperability and integration of data-intensive biomedical appli-cations. Main issues in this field is provision of large computing power such thatresearchers have access to high performance distributed computational resourcesfor computationally demanding data analysis, e.g., medical image processing andsimulation of medical treatment or surgery and large storage capacity and distrib-uted databases for efficient retrieval, annotation and archiving of biomedical data.What is missing today is full integration of methods and technologies to enhanceall phases of biomedical informatics and health care, including research, diag-nosis, prognosis, etc. and dissemination of such methods in the clinical practice,whenever they are developed, deployed and maintained. Hence it is another topicof research interest.

7 Conclusion

This paper described basic concepts and definitions of the real time database sys-tem and reviewed the work carried out in the areas of priority assignment policiesfor the scheduling of transactions, commit processing and memory optimization innon-replicated/replicated environment. The priority assignment policies for transac-tion scheduling both for centralized and distributed RTDBS are discussed. Most ofthe priority assignment policies are suitable only when the cohorts of a transactionexecute sequentially. The traditional commit processing protocol 2PC and its variantshave also been described. Different real time commit protocols proposed in the liter-ature are explained and compared. Most of these protocols try to improve the perfor-mance by allowing a transaction to use a data item locked by some other transaction.There is complete lack of policies/protocols which can be well suited to efficient useof memory by creating lesser number of temporary objects.

Some of the highlighting factors about the work reported in this study are re-evaluation of the static two phase locking mechanism, priority assignment policy,and commit protocols suitable for handling huge volume of data and large number oftransactions.


References

1. Abbott, R., Garcia-Molina, H.: Scheduling real-time transactions with disk resident data. In: Pro-ceedings of the 15th International Conference on Very Large Databases, Amsterdam, The Nether-lands, pp. 385–395 (1989)

2. Abbott, R., Garcia-Monila, H.: Scheduling real-time transaction: a performance evaluation. In: Pro-ceedings of the 14th International Conference on Very Large Databases, pp. 1–12, August 1988

3. Abdallah, M., Guerraoui, R., Pucheral, P.: One-phase commit: does it make sense. In: Proceedingsof the International Conference on Parallel and Distributed Systems (ICPADS’98), Tainan, Taiwan,14–16 December 1998

4. Agrawal, D., Abbadi El, A., Jeffers, R.: Using delayed commitment in locking protocols for real-time databases. In: Proceedings of the ACM International Conference on Management of Data (SIG-MOD), San Diego, CA, 2–5 June 1992, pp. 104–113 (1992)

5. Agrawal, D., Abbadi El, A., Jeffers, R., Lin, L.: Ordered shared locks for real-time databases. Int.J. Very Large Data Bases 4(1), 87–126 (1995)

6. Aldarmi, S.A., Burns, A.: Dynamic CPU scheduling with imprecise knowledge of computation time.Technical Report YCS-314, Department of Computer Science, University of York, UK (1999)

7. Aldarmi, S.A.: Real-time database systems: concepts and design. Department of Computer Science,University of York, April 1998

8. Al-Houmaily, Y.J., Chrysanthis, P.K.: Atomicity with incompatible presumptions. In: Proceedingsof the 18th ACM Symposium on Principles of Database Systems (PODS), Philadelphia, June 1999

9. Al-Houmaily, Y.J., Chrysanthis, P.K.: In search for an efficient real-time atomic commit protocol.http://www.cs.bu.edu/techreports/pdf/1996-027-ieee-rtss9.pdf/13.ps

10. Al-Houmaily, Y.J., Chrysanthis, P.K., Levitan, S.P.: Enhancing the performance of presumed commitprotocol. In: Proceedings of the ACM Symposium on Applied Computing, San Jose, CA, USA,28 February–1 March 1997

11. Al-Houmaily, Y.J., Chrysanthis, P.K., Levitan, S.P.: An argument in favor of the presumed commitprotocol. In: Proceedings of the IEEE International Conference on Data Engineering, Birmingham,April 1997

12. Amanton, L., Sadeg, B., Berred, A.: Towards the commit process of causal-ordered distributed real-time transactions. In: Proceedings of the 3rd IEEE International Symposium on Signal Processingand Information Technology (ISSPIT), 14–17 December 2003, pp. 588–592 (2003)

13. Arahna, R.F.M., Ganti, V., Narayanan, S., Muthukrishnan, C.R., Prasad, S.T.S., Ramamritham, K.:Implementation of a real-time database system. Inf. Syst. 21(1), 55–74 (1996)

14. Attaluri, G.K., Salem, K.: The presumed-either two-phase commit protocol. IEEE Trans. Knowl.Data Eng. 14(5), 1190–1196 (2002)

15. Audsley, N.C., Burns, A., Richardson, M.F., Wellings, A.J.: Data consistency in hard real-time sys-tems. YCS 203, Department of Computer Science, University of York, June 1993

16. Audsley, N.C., Burns, A., Richardson, M.F., Wellings, A.J.: Absolute and relative temporal con-straints in hard real time databases. In: Proceedings of the 4th Euromicro Workshop on Real-TimeSystems, pp. 148–153. IEEE Computer Society Press, Athens (1992)

17. Bestavros, A.: Advances in real-time database systems research. ACM SIGMOD Rec. 24(1), 3–8(1996)

18. Bestavros, A., Lin, K.J., Son, S.H.: Real-Time Database Systems: Issues and Applications. KluwerAcademic, Dordrecht (1997)

19. Biao, Q., Yunsheng, L., Jin, C.Y.: A commit strategy for distributed real-time transaction. J. Comput.Sci. Tech. 18(5), 626–631 (2003)

20. Bowers, D.S.: Directions in Databases. Lecture Notes in Computer Science, vol. 826, pp. 23–54.Springer, Berlin (1994)

21. Burger, A., Kumar, V., Hines, M.L.: Performance of multiversion and distributed two-phase lockingconcurrency control mechanisms in distributed databases. Int. J. Inf. Sci. 1–2, 129–152 (1997)

22. Carey, M.J., Jauhari, R., Livny, M.: Priority in DBMS resource scheduling. In: Proceedings of the of15th VLDB Conference, August 1989

23. Chakravarthy, S., Hong, D., Johnson, T.: Real time transaction scheduling: a framework for synthe-sizing static and dynamic factors. TR-008, CISE Dept., University of Florida (1994)

24. Chen, H.-R., Chin, Y.H., Tseng, S.-M.: Scheduling value-based transactions in distributed real-timedatabase systems. In: Proceedings of the 15th International Parallel and Distributed Processing Sym-posium, 23–27 April 2001, pp. 978–984 (2001)


25. Chen, Y.-W., Gruenwald, L.: Effects of deadline propagation on scheduling nested transactions indistributed real-time database systems. J. Inf. Syst. 21(1), 103–124 (1996)

26. Chrysanthis, P.K., Samarasm, G., Al-Houmaily, Y.J.: Recovery and performance of atomic commitprocessing in distributed database systems. In: Kumar, V., Hsu, M. (eds.) Performance of DatabaseRecovery Mechanism, pp. 370–416. Prentice Hall, New York (1998)

27. Datta, A., Mukhejee, S., Konana, F., Yiguler, I.R., Bajaj, A.: Multiclass transaction scheduling andoverload management in firm real-time database systems. Inf. Syst. 21(1), 29–54 (1996)

28. Datta, A., Son, S.H., Kumar, V.: Is a bird in the hand worth more than two in the bush? Limitations ofpriority cognizance in conflict resolution for firm real-time database systems. IEEE Trans. Comput.49(5), 482–502 (2000)

29. Davidson, S.B., Lee, I., Wolfe, V.: A protocol for timed atomic commitment. In: Proceedings of theIEEE 9th International Conference on Distributed Computing Systems, 5–9 June 1989, pp. 199–206(1989)

30. Davidson, S.B., Lee, I., Wolfe, V.: Timed atomic commitment. IEEE Trans. Comput. 40(5), 573–583(1991)

31. DeWitt, D.J., Katz, R.H., Olken, F., Shapiro, L.D., Stonebraker, M.R., Wood, D.: Implementationtechniques for main memory database systems. In: Proceedings of the ACM International Confer-ence on Management of Data (SIGMOD), Boston, MA, pp. 1–8 (1984)

32. DiPippo, L.C., Wolfe, V.F.: Real-time databases. Database Systems Handbook. Multiscience, NewYork (1997)

33. Dogdu, E., Ozsoyoglu, G.: Real-time transactions with execution histories: priority assignment andload control. In: Proceedings of the 6th International Conference on Information and KnowledgeManagement, Las Vegas, NV, pp. 301–308

34. Elmasri, R., Navathe, S.B.: Fundamentals of Database Systems. Addison-Wesley, Reading (2000)35. Fortier, P.J., Turner, P.: A simulation program for analysis of distributed database processing con-

cepts. In: Proceedings of the 19th Annual Symposium on Simulation, Tampa, FL, pp. 105–126(1986)

36. Garcia-Molina, H., Lindsay, B.: Research directions for distributed databases. ACM SIGMOD Rec.19(4), 68–103 (1990)

37. Garcia-Molina, H., Salem, K.: Main memory database systems: an overview. IEEE Trans. Knowl.Data Eng. 4(6), 509–516 (1992)

38. Gehani, N., Ramamritham, K., Shanmugasundaram, J., Shmueli, O.: Accessing extra database infor-mation: concurrency control and correctness. Inf. Syst. 23(7), 439–462 (1996)

39. George, B.: A secure real-time transaction processing. PhD thesis, Supercomputer Education andResearch Centre, I.I. Sc. Bangalore, India, December 1998

40. Ginis, R., Wolfe, V.F.: Issues in designing open distributed real-time databases. In: Proceedings ofthe 4th IEEE International Workshop on Parallel and Distributed Real-Time Systems, Honolulu, HI,15–16 April 1996, pp. 106–109 (1996)

41. Gray, J., Reuter, A.: Transaction Processing: Concepts and Technique. Morgan Kaufman, San Mateo(1993)

42. Gray, J.: Notes on Database Operating Systems. Operating Systems: an Advanced Course. LectureNotes in Computer Science, vol. 60, pp. 397–405. Springer, Berlin (1978)

43. Gray, J.: The transaction concept, virtues and limitations. In: Proceedings of the 7th VLDB Confer-ence, Cannes, France, pp. 144–154 (1981)

44. Gupta, R., Haritsa, J.R.: Commit processing in distributed real-time database systems. In: Proceed-ings of the National Conference on Software for Real-Time Systems, Cochin, India, pp. 195–204,January 1996

45. Gupta, R.: Commit processing in distributed on-line and real-time transaction processing systems.MSc thesis, Supercomputer Education and Research Centre, I.I. Sc. Bangalore, India (2000)

46. Gupta, R., Haritsa, J.R., Ramamritham, K.: More optimism about real-time distributed commitprocessing. Technical Report TR-97-04, Database System Lab, Supercomputer Education and Re-search Centre, I.I. Sc. Bangalore, India (1997)

47. Gupta, R., Haritsa, J.R., Ramamritham, K.: Revisiting commit processing in distributed databasesystems. In: Proceedings of the ACM International Conference on Management of Data (SIGMOD),Tucson, May 1997

48. Gupta, R., Haritsa, J.R., Ramamritham, K., Seshadri, S.: Commit processing in distributed real-timedatabase systems. In: Proceedings of Real-time Systems Symposium, Washington DC, December1996. IEEE Computer Society, San Francisco (1996)


49. Gupta, R., Haritsa, J.R., Ramamritham, K., Seshadri, S.: Commit processing in distributed real-timedatabase systems. Technical Report TR-96-01, Database System Lab, Supercomputer Education andResearch Centre, I.I. Sc. Bangalore, India (1996)

50. Hansen, G.W., Hansen, J.V.: Database Management and Design. Prentice-Hall, India (2000)51. Haritsa, J.R., Ramamritham, K.: Adding PEP to real-time distributed commit processing. In: Pro-

ceedings of the 21st IEEE Real-time Systems Symposiums, Orlando, USA, 27–30 November 2000,pp. 37–46 (2000)

52. Haritsa, J.R., Ramamritham, K.: Real-time database systems in the new millennium. J. Real-TimeSyst. 19(3), 1–5 (2000)

53. Haritsa, J.R., Carey, M.J., Livny, M.: Data access scheduling in firm real-time database systems.J. Real-Time Syst. 4(3), 203–242 (1992)

54. Haritsa, J.R., Carey, M.J., Livny, M.: Value-based scheduling in real-time database systems. Techni-cal Report TR-1204, CS Department, University of Wisconsin, Madison (1991)

55. Haritsa, J.R., Carey, M.J., Linvy, M.: Dynamic real-time optimistic concurrency control. In: Pro-ceedings of the 11th Real-Time Systems Symposium, December 1990

56. Haritsa, J.R., Carey, M.J., Linvy, M.: On being optimistic about real-time constraints. In: Proceedingsof the ACM PODS Symposium, April 1990

57. Haritsa, J.R., George, B.: Secure real-time transaction processing. In: Kuo, T.-W., Lam, K.-Y. (eds.)Real-time Database Systems: Architecture and Techniques. Kluwer International Series in Engineer-ing and Computer Science, vol. 593, pp. 141–157. Kluwer Academic, Dordrecht (2001)

58. Haritsa, J.R., Livny, M., Carey, M.J.: Earliest deadline scheduling for real-time database systems.In: Proceedings of 12th IEEE Real-Time Systems Symposium (RTSS), San Antonio, TX, December1991, pp. 232–242 (1991)

59. Haritsa, J.R., Ramamritham, K., Gupta, R.: Characterization and optimization of commit processingperformance in distributed database systems. Technical Report, University of Massachusetts, March1998

60. Haritsa, J.R., Ramamritham, K., Gupta, R.: Real-time commit processing. In: Kuo, T.-W., Lam, K.-Y. (eds.) Real-time Database Systems: Architecture and Techniques. Kluwer International Series inEngineering and Computer Science, vol. 593, pp. 227–243. Kluwer Academic, Dordrecht (2001)

61. Haritsa, J.R., Ramamritham, K., Gupta, R.: The PROMPT real-time commit protocol. IEEE Trans.Parallel Distrib. Syst. 11(2), 160–181 (2000)

62. Haubert, J.A., Mammeri, L.Z., Sadeg, B.: Management of imprecise transactions in distributed real-time database systems. In: Proceedings of the 7th ISPS, Algiers, May 2005, pp. 15–26 (2005)

63. Hong, D.-K.: Real time transaction scheduling: a cost-conscious approach. MSc thesis, GraduateSchool of University of Florida (1992)

64. Hong, D.-K., Johnson, T., Chakravarthy, S.: Real-time transaction scheduling: a cost conscious ap-proach. In: Proceedings of the SIGMOD Conference, pp. 197–206 (1993)

65. Huang, J., Stankovic, J.A.: Real-time buffer management. COINS TR 90-65, August 199066. Huang, J.: Real time transaction processing: design, implementation and performance evaluation.

PhD thesis, University of Massachusetts, May 199167. Huang, J., Stankovic, J.A., Ramamritham, K., Towsley, D.: On using priority inheritance in real-

time databases. In: Proceedings of the 12th Real-Time Systems Symposium, 4–6 December 1991,pp. 210–221 (1991)

68. Hung, S.-L., Lam, K.W., Lam, K.Y.: Efficient technique for performance analysis of locking pro-tocols. In: Proceedings of the 2nd IEEE International Workshop on Modeling, Analysis, and Sim-ulation of Computer and Telecommunication Systems, Durham, NC, USA, 31 January–2 February1994, pp. 276–283 (1994)

69. Inseon, L., Heon, Y.Y., Taesoon, P.: A new approach for distributed main memory database system:a causal commit protocol. IEICE Trans. Inf. Syst. E87-D(1), 196–204 (2004)

70. Kao, B., Garcia-Molina, H.: Deadline assignment in a distributed soft real-time system. In: Proceed-ings of the 13th International Conference on Distributed Computing Systems, pp. 428–437 (1993)

71. Kao, B., Garcia-Molina, H.: Subtask deadline assignment for complex distributed soft real-timetasks. Technical Report 93-149, Stanford University (1993)

72. Kao, B., Garcia-Monila, H.: An overview of real-time database systems. In: Advances in Real-TimeSystems, pp. 463–486 (1995)

73. Kayan, E., Ulusoy, O.: An evaluation of real time transaction management issues in mobile databasesystems. Comput. J. 42(6) (1999)

74. Kim, Y.-K., Son, S.H.: Predictability and consistency in real-time database systems. In: Son, S.H.(ed.) Advances in Real-Time Systems, pp. 509–531. Prentice Hall, New York (1995)


75. Kim, Y.-K.: Predictability and consistency in real time transaction processing. PhD thesis, Universityof Virginia, May 1995

76. Lam, K.-Y., Kuo, T.-W.: Real-Time Database Systems: Architecture and Techniques. Kluwer Acad-emic, Dordrecht (2001)

77. Lam, K.-Y.: Concurrency control in distributed real-time database systems. PhD thesis, City Univer-sity of Hong Kong, Hong Kong, October 1994

78. Lam, K.-Y., Cao, J., Pang, C.-L., Son, S.H.: Resolving conflicts with committing transactions indistributed real-time databases. In: Proceedings of the Third IEEE International Conference on En-gineering of Complex Computer Systems, Como, Italy, 8–12 September 1997, pp. 49–58 (1997)

79. Lam, K.-Y., Hung, S.L., Son, S.H.: On using real-time static locking protocols for distributed real-time databases. Real-Time Syst. 13, 141–166 (1997)

80. Lam, K.-Y., Law, G.C.K., Lee, V.C.S.: Priority and deadline assignment to triggered transactions indistributed real-time active databases. J. Syst. Softw. 51(1), 49–60 (2000)

81. Lam, K.-Y., Lee, V.C.S., Kao, B., Hung, S.L.: Priority assignment in distributed real-time databasesusing optimistic concurrency control. IEE Proc. Comput. Digit. Tech. 144(5), 324–330 (1997)

82. Lam, K.-Y., Pang, C., Son, S.H., Cao, J.: Resolving executing-committing conflicts in distributedreal-time database systems. J. Comput. 42(8), 674–692 (1999)

83. Lam, K.-W., Lee, V.C.S., Hung, S.L.: Transaction scheduling in distributed real-time systems. Int.J. Time-Crit. Comput. Syst. 19, 169–193 (2000)

84. Lampson, B., Lomet, D.: A new presumed commit optimization for two phase commit. In: Proceed-ings of the 19th International Conference on Very Large Data Bases, Dublin, Ireland (1993)

85. Lee, I., Yeom, H.Y.: A fast commit protocol for distributed main memory database systems. In:Proceedings of the 16th International Conference on Information Networking (ICOIN-16), Cheju,Korea, January 2002

86. Lee, I., Yeom, H.Y.: A single phase distributed commit protocol for main memory database systems.In: 16th International Parallel & Distributed Processing Symposium (IPDPS 2002), Ft. Lauderdale,FL, 15–19 April 2002

87. Lee, I., Heon, Y., Park, T.: A new approach for distributed main memory database systems: a causalcommit protocol. IEICE Trans. Inf. Syst. E87-D(1), 196–204 (2004)

88. Lee, J.: Concurrency control algorithms for real-time database systems. PhD thesis, Department ofComputer Science, University of Virginia (1994)

89. Lee, V.C.S., Lam, K.Y., Kao, B.C.M., Lam, K.W., Hung, S.L.: Priority assignment for sub-transaction in distributed real-time databases. In: 1st International Workshop on Real-Time DatabaseSystems (1996)

90. Lee, V.C.S., Lam, K.-Y., Kao, B.: Priority scheduling of transactions in distributed real-time data-bases. Int. J. Time-Crit. Comput. Syst. 16, 31–62 (1999)

91. Lee, V.C.S., Lam, K.-W., Hung, S.L.: Concurrency control for mixed transactions in real-time data-bases. IEEE Trans. Comput. 51(7), 821–834 (2002)

92. Lin, K.-J., Son, S.H.: Real-time databases: characteristics and issues. In: Proceedings of the 1st IEEEWorkshop on Object-Oriented Real-Time Dependable Systems, Dana Point, CA, October 1994,pp. 113–116 (1994)

93. Lindsay, B.G., Haas, L.M., Mohan, C., Wilms, P.F., Yost, R.A.: Computation and communication inR∗: a distributed database manager. ACM Trans. Comput. Syst. 2(1), 24–38 (1984)

94. Lindström, J., Raatikainen, K.: Using importance of transactions and optimistic concurrency con-trol in firm real-time databases. In: Proceedings of the 7th International Conference on Real-TimeComputing Systems and Applications (RTCSA’2000), Cheju Island, South Korea, 12–14 December2000

95. Lindstrom, J.: Optimistic concurrency control method for distributed real time database systems.PhD thesis, Report A-2003-I, Helsinki University, January 2003

96. Lindström, J.: Using priorities in concurrency control for RTDBS. In: Seminar on Real-Time andEmbedded Systems, Department of Computer Science, University of Helsinki, Autumn 1999

97. Liu, C.L., Layland, J.W.: Scheduling algorithms for multiprogramming in a hard real-time environ-ment. J. ACM 20(1), 46–61 (1973)

98. Misikangas, P.: 2PL and its variants. In: Seminar on Real-Time Systems, Department of ComputerScience, University of Helsinki (1997)

99. Mittal, A., Dandamudi, S.P.: Dynamic versus static locking in real-time parallel database systems. In:Proceedings of the 18th International Parallel and Distributed Processing Symposium (IPDPS’04),Santa Fe, NM, 26–30 April 2004


100. Mohan, C., Dievendorff, D.: Recent work on distributed commit protocols, and recoverable messag-ing and queuing. Data Eng. Bull. 17(1) 1994

101. Mohan, C.: An overview of recent database research. J. Database 10(2), 3–24 (1978)102. Mohan, C., Lindsay, B., Obermarck, R.: Transaction management in the R∗ distributed database

management systems. ACM Trans. Database Syst. 11(4), 378–396 (1986)103. Mohania, M.K., Kambayashi, Y., Tjoa, A.M., Wagner, R., Bellatreche, L.: Trends in database re-

search. In: DEXA, pp. 984–988 (2001)104. Ng, P.: A commit protocol for checkpointing transactions. In: Proceedings of the 7th Symposium on

Reliable Distributed Systems, Columbus, OH, USA, 10–12 October 1998, pp. 22–31 (1998)105. O’Neil, P., Ramamritham, K., Pu, C.: Towards predictable transaction executions in real-time data-

base systems. Technical Report 92–35, University of Massachusetts, August 1992106. Ozsoyoglu, G., Snodgrass, R.T.: Temporal and real-time databases: a survey. IEEE Trans. Knowl.

Data Eng. 7(4), 513–532 (1995)107. Pang, C.-L., Lam, K.Y.: On using similarity for resolving conflicts at commit in mixed distributed

real-time databases. In: Proceedings of the 5th International Conference on Real-Time ComputingSystems and Applications, 27–29 October 1998

108. Pang, H.H.: Query processing in firm real-time database systems. PhD thesis, University of Wiscon-sin, Madison (1994)

109. Pang, H.H., Carey, M.J., Livny, M.: Multiclass query scheduling in real-time database systems. IEEETrans. Knowl. Data Eng. 7(4), 533–551 (1995)

110. Park, T., Yoem, H.Y.: A Distributed Group Commit Protocol for Distributed Database Systems. SeoulNational University, Korea

111. Purimetla, B., Rajendran, M., Sivasankaran, K., Ramamritham, K., Stankovic, J.A.: Real Time Data-bases: Issues and Applications. Advances in Real Time Systems, Prentice Hall, New York (1996)

112. Qin, B., Liu, Y.: High performance distributed real-time commit protocol. J. Syst. Softw. 68(2),145–152 (2003)

113. Ramakrishnan, R., Gehrke, J.: Database Management System. McGraw Hill, New York (2003)114. Ramakrishnan, R., Ullaman, J.D.: A survey of research on deductive database systems. www-db.

stanford.edu/~ullman/dscb/ch1.pdf115. Ramamritham, K., Chrysanthis, P.K.: A taxonomy of correctness criteria in database applications.

J. Very Large Data Bases 5, 85–97 (1996)116. Ramamritham, K., Chrysanthis, P.K.: In search for the acceptability criteria: database consistency

requirements and transaction correctness properties. In: Proceedings of the International Workshopon Distributed Object Management, Canada, August 1992, pp. 211–229 (1992)

117. Ramamritham, K., Sen, R.: DELite: database support for embedded lightweight devices. In: EM-SOFT, Pisa, Italy, 27–29 September 2004, pp. 3–4 (2004)

118. Ramamritham, K.: Real-time databases. Distrib. Parallel Databases 1(2), 199–226 (1993), specialissue: Research Topics in Distributed and Parallel Databases

119. Ramsay, S., Nummenmaa, J., Thanisch, P., Pooley, R.J., Gilmore, S.T.: Interactive simulation ofdistributed transaction processing commit protocols. In: Luker, P. (ed.) Proceedings of Third Con-ference of the United Kingdom Simulation Society (UKSIM’97), Department of Computer Science,University of Edinburgh, pp. 112–127 (1997)

120. Ryu, I.K., Thomasian, A.: Analysis of database performance with dynamic locking. J. ACM 37(3),491–523 (1990)

121. Samaras, G., Britton, K., Citron, A., Mohan, C.: Two-phase commit optimizations and tradeoffs inthe commercial environment. In: Proceedings of the 9th International Conference on Data Engineer-ing, 19–23 April 1993, pp. 520–529 (1993)

122. Seshadri, T.S., Haritsa, J.R.: Integrating standard transactions in real-time database systems. Inf.Syst. 21(1), 3–28 (1996)

123. Sha, L., Rajkumar, R., Son, S.H., Chang, C.H.: A real-time locking protocol. IEEE Trans. Comput.40(7), 793–800 (1991)

124. Shih, S., Kim, Y.-K., Son, S.H.: Performance evaluation of a firm real time database system. In:Proceedings of the 2nd International Workshop on Real-Time Computing Systems and Applications,25–27 October 1995, pp. 116–124 (1995)

125. Shiow, C., Li, V.O.K.: Performance analysis of static locking in distributed database systems. IEEETrans. Comput. 39(6), 741–751 (1990)

126. Shu, L.C., Young, M., Rajkumar, R.: An abort ceiling protocol for controlling priority inversion.Software Engineering Institute, Carnegie Mellon University (1994)


127. Silberschatz, A., Stonebraker, M., Ullman, J.: Database research: achievements and opportunitiesinto the 21st century. ACM SIGMOD Rec. 25(1), 52–63 (1996)

128. Son, S.H.: Real-time database systems: present and future. In: Proceedings of the Second Interna-tional Workshop on Real-Time Computing Systems and Applications, Tokyo, Japan, 25–27 October1995, pp. 50–52 (1995)

129. Soparkar, N., Levy, E., Korth, H.F., Silberschatz, A.: Adaptive commitment for real-time distributedtransaction. Technical Report TR-92-15, 1992, Dept. of Computer Science, University of Texas,Austin and also in the Proceedings of the 3rd International Conference on Information and Knowl-edge Management, Gaithersburg, MD, USA, pp. 187–194 (1994)

130. Srinivasa, R.: Network-aided concurrency control in distributed databases. PhD thesis, University ofVirginia, January 2002

131. Stamos, J.W., Cristian, F.: A low-cost atomic commit protocol. In: Proceedings of the 9th IEEESymposium on Reliable Distributed Systems, Huntsville, AL, USA, 9–12 October 1990, pp. 66–75(1990)

132. Stankovic, J.A.: Misconception about real-time computing. IEEE Comput. 21(10), 10–19 (1988)133. Stankovic, J.A., Ramamritham, K., Towsley, D.: Scheduling in real-time transaction systems. In:

van Tilborg, A., Koob, G. (eds.) Foundations of Real-Time Computing: Scheduling and ResourceManagement, pp. 157–184. Kluwer Academic, Dordrecht (1991)

134. Stankovic, J.A., Son, S.H., Hansson, J.: Misconception about real-time database. IEEE Comput.32(6), 29–36 (1999)

135. Taina, J., Son, S.H.: Towards a general real-time database simulator software library. In: Proceedingsof Active and Real-Time Database Systems (1999)

136. Takkar, S., Dandamudi, S.P.: An adaptive scheduling policy for real-time parallel database system.www.mpcs.org/MPCS98/Final_Papers/Paper.48.pdf

137. Tay, Y.C., Suri, R.: Choice and performance in locking for databases. In: Proceedings of the 10thInternational Conference on Very Large Databases, August 1984

138. Tay, Y.C.: Some performance issues for transactions with firm deadlines. In: Proceedings of Real-Time Systems Symposium, Pisa, Italy, December 1995, pp. 322–331 (1995)

139. Tay, Y.C., Goodman, N., Suri, R.: Locking performance in centralized database. ACM Trans. Data-base Syst. 10(4), 415–462 (1985)

140. Tay, Y.C., Suri, R., Goodman, N.: A mean value performance model for locking in databases: theno-waiting case. J. ACM 32(3), 618–651 (1985)

141. Thomasian, A., Ryu, I.K.: Performance analysis of two-phase locking. IEEE Trans. Softw. Eng.17(5), 386–402 (1991)

142. Thomasian, A.: Concurrency control: methods, performance, and analysis. ACM Comput. Surv.30(1), 70–119 (1998)

143. Thomasian, A.: Two-phase locking performance and its thrashing behavior. ACM Trans. DatabaseSyst. 18(4), 579–625 (1993)

144. Udai, S., Manoj, M., Sarje, A.K.: Hard real-time distributed database systems: future directions.In: Proceedings of All India Seminar on Recent Trends In Computer Communication Networks,Department of Electronics & Computer Engineering, Indian Institute of Technology Roorkee, India,7–8 November 2001, pp. 172–177 (2001)

145. Udai, S., Manoj, M., Sarje, A.K.: SWIFT—a new real time commit protocol. Int. J. Distrib. ParallelDatabases 20(1), 29–56 (2006)

146. Udai, S., Manoj, M., Sarje, A.K.: A memory efficient fast distributed real time commit protocol.In: Proceedings of the 7th International Workshop on Distributed Computing (IWDC 2005), IndianInstitute of Technology Kharagpur, India, 27–30 December 2005

147. Udai, S., Manoj, M., Sarje, A.K.: Priority assignment heuristic and issue of fairness to cohorts exe-cuting in parallel. WSEAS Int. Trans. Comput. 4(7), 758–768 (2005)

148. Udai, S., Manoj, M., Sarje, A.K.: The MEWS distributed real time commit protocol. WSEAS Int.Trans. Comput. 4(7), 777–786 (2005)

149. Udai, S., Manoj, M., Sarje, A.K., Rahul, S.: Dependency sensitive shadow SWIFT. In: Proceedingsof the 10th International Database Applications and Engineering Symposium (IDEAS 06), Delhi,India, 11–14 December 2006

150. Ullman, J.D.: Principle of Database Systems. Galgotia, New Delhi (1992)151. Ulusoy, O., Belford, G.: Real-time transaction scheduling in database systems. Inf. Syst. 18(8), 559–

580 (1993)152. Ulusoy, O., Belford, G.G.: A simulation model for distributed real-time database systems. In: Pro-

ceedings of the 25th Annual Symposium on Simulation, Orlando, FL, USA, pp. 232–240 (1992)


153. Ulusoy, O., Buchmann, A.: A real-time concurrency control protocol for main-memory databasesystems. Inf. Syst. 23(2), 109–125 (1998)

154. Ulusoy, O.: A study of two transaction processing architectures for distributed real-time databasesystems. J. Syst. Softw. 31(2), 97–108 (1995)

155. Ulusoy, O.: Analysis of concurrency control protocols for real time database systems. Inf. Sci.111(1–4) (1998)

156. Ulusoy, O.: Concurrency control in real-time database systems. PhD thesis, Department of ComputerScience, University of Illinois, Urbana-Champaign (1992)

157. Ulusoy, O.: Processing real-time transactions in a replicated database system. Distrib. Parallel Data-bases 2(4), 405–436 (1994)

158. Ulusoy, O.: Research issues in real-time database systems. Inf. Sci. 87(1–3), 123–151 (1995)159. Vrbsky, S.V., Tomic, S.: Satisfying timing constraints of real time databases. J. Syst. Softw. 41,

63–73 (1998). www.mpcs.org/MPCS98/Final_Papers/Paper.48.pdf160. Yoon, Y., Han, M., Cho, J.: Real-time commit protocol for distributed real-time database systems.

In: Proceedings of the 2nd IEEE International Conference on Engineering of Complex ComputerSystems, 21–25 October 1996, pp. 221–225 (150)

161. Yu, P.S., Wu, K.-L., Lin, K.-J., Son, S.H.: On real-time databases: concurrency control and schedul-ing. Proc. IEEE 82(1), 140–157 (1994)

162. Wei, Y., Son, S.H., Stankovic, J.A.: Maintaining data freshness in distributed real-time databases. In:ECRTS, pp. 251–260 (2004)

163. Wei, Y., Son, S.H., Stankovic, J.A., Kang, K.-D.: QoS management in replicated real time databases.In: RTSS, pp. 86–97 (2003)

164. Xiong, M., Ramamritham, K., Haritsa, J.R., Stankovic, J.A.: MIRROR: a state-conscious concur-rency control protocol for replicated real-time databases. Inf. Syst. 27(4), 277–297 (2002)

165. Zhou, H., Jahanian, F.: Real-time primary-backup (RTPB) replication with temporal consistencyguarantees. In: Proceedings of ICDCS, May 1998

Distributed real time database systems: background and literature review

Documents

Transcript of Distributed real time database systems: background and literature review