Object-Based Quorum Scheme for Replicated

Object-Based Quorum Scheme for Replicated Objects Kyouji Hasegawa, Hiroaki Higaki, and Makoto Takizawa Dept. of Computers and Systems Engineering, Tokyo Denki University Email

fkyo,

Abstract

In object-based systems, objects are replicated to increase the performance, reliability, and availability. We discuss a novel object-based locking (OBL) protocol to lock replicas of objects by extending the quorumbased protocol for read and write to abstract methods. Unless two methods con ict, subsets of the replicas locked by the methods do not intersect even if the methods change the replicas. Methods not computed on a replica A but computed on another replica are computed on A when a method con icting with the methods are issued to A in the OBL protocol. We newly propose a version vector to identify what methods are computed on a replica. 1

Introduction

g

hig, taki @takilab.k.dendai.ac.jp

Reliable distributed systems are composed of replicas of objects. The replicas of the object have to be mutually consistent. The two-phase locking (2PL) protocol [1,2] locks one of the replicas for read and all the replicas for write. The 2PL protocol is not ecient for write-dominated applications because all the replicas are locked for write. In the quorum-based protocol [3], some numbers Qr and Qw of the replicas named quorum numbers are locked for read and write, respectively. Here, a constraint \ Qr + Qw > a " for the number a of the replicas has to be satis ed. Distributed applications are modeled to be a collection of multiple objects which are cooperating. Object-based frameworks like CORBA [7] are widely used to develop the distributed applications. An object supports abstract methods like Deposit in a bank object. The object is locked in an abstract mode corresponding to a method. A pair of methods op1 and op2 supported by an object o con ict if the result obtained by applying op1 and op2 to o depends on the computation order of op1 and op2 [1]. In this paper, we propose a novel locking scheme for replicated objects named OBL (object-based locking ) protocol, which is an extension of the quorum-based protocol [3] to the replicas of the abstract objects. Before computing a method opt on an object o, some quorum number Qt of the replicas of o are locked in the abstract mode for opt . Qt depends on how frequently opt is invoked. The more frequently opt is invoked, the smaller Qt gets. Suppose a pair of methods opt and opu are issued to replicas of the object o. If opt and opu are update methods, the quorum-based protocol requires that \ Qt + Qu > a " hold. If opt and opu are com-

puted on a pair of replicas ot and ou, respectively, the states of ot and ou get dierent. Then, if both opt and opu are computed on replicas ot and ou , respectively, ot and ou get the same state if opt and opu are compatible. In the quorum-based protocol, there must be at least one newest replica where all write methods issued are computed. However, there can exist replicas from which the newest version can be constructed even if there is no newest replica. In order to do that, we have to identify what methods are computed on each replica. We newly propose a version vector to identify the methods computed on each replica. In the OBL protocol, fewer number of replicas are locked than the quorum-based protocol and the 2P L protocol. In section 2, we present the system model. In section 3, we extend the quorum concepts to object-based system. In section 4, we discuss the OBL protocol with the version vector. In section 5, we evaluate the OBL protocol compared with the quorum-based protocol in terms of the number of replicas to be locked. 2

Objects

A system is composed of objects o1 ; : : : ; on (n  1) which are cooperating by exchanging messages in a reliable network. Each object oi supports methods opi1 ; : : : ; opili (li  1) for manipulating oi and is encapsulated so that oi can be manipulated only through the methods supported by oi . By using the network, oi can send messages to oj with no message loss in the sending order. The objects are distributed on multiple processors. Objects are stored in server processors. If a transaction in a client processor sends a request message of a method opi to an object oi in a server, oi computes opi. Here, opi may invoke a method opij on another object oij . The methods are nested. oi sends the response of opi back to the transaction. A transaction is an atomic invocation sequence of methods. The transaction an method commit only if all the methods invoked commit. A method which changes the state of the object is an update one. Let op(s) denote a state obtained by applying a method op to a state s of an object oi . A method opij is compatible with another method opik i opij  opik (si ) = opik  opij (si) for every state si of oi . opij conflicts with opik unless opij is compatible with opik . The con icting relation Ci among the methods is not transitive. We assume Ci is symmetric. Ci is assumed to be speci ed on de nition of the object oi. The

interleaved and parallel computation of methods has to be serializable [1]. On receipt of a request of a method opi, an object oi is locked in a lock mode (opi ) in order to make the computation serializable. If op1 is compatible with op2 , the mode (op1) is compatible with (op2 ). Otherwise, the mode (op1 ) con icts with (op2 ). After computing opi, the lock of the mode (opi) on the object oi is released. Let Mi (m) be a set of lock modes with which a lock mode m con icts in oi . 3 3.1

Object Quorums Quorum constraint

Let R(oi ) be a cluster of an object oi , i.e. a set of replicas o1i , : : :, oai i of oi (ai  1). We extend the quorum-based protocol [3] to lock the replicas in the object-based systems. Let Nit be a subset of replicas to be locked by a method opit , named a quorum set of opit (Nit  R(oi )). Let Qit be the quorum number of the replicas in Nit . The quorum numbers have to satisfy the following object-based locking (OBL) constraint.

[OBL constraint]

 If (opit ) con icts with (opiu ), Qit + Qiu > ai . Let '(opit ) be usage frequency of a method opit , i.e. how frequently opit is issued to oi . Here, '(opi1 ) + : : : + '(opili ) = 1. Qi1 , : : :, Qili are obtained so as to minimize the average number '(opi1 )Qi1 + : : : + '(opili )Qili of the replicas locked. This means, the more frequently opit is invoked, the fewer number of the replicas are locked by opit . A transaction T locks the replicas o1i ; : : : ; oai i as follows before manipulating the replicas by opit . First, a quorum set Nit is xed for opit in the cluster R(oi). Every replica in Nit is locked in a mode (opit ). If all the replicas in Nit are locked, the replicas in Nit are manipulated by opit . When T commits, the locks on the replicas in Nit are released. According to the quorum-based protocol, Qit + Qiu > a i if opit and opiu are update methods. Here, ai is the number of the replicas of an object oi . In the OBL protocol, Qit + Qiu > ai only if opit con icts with opiu . In another word, Qit + Qiu > ai can hold even if opit or opiu is an update method. The OBL protocol satis es the following properties. [Properties] For every pair of con icting methods opit and opiu of an object oi : 1 At least Qit + Qiu { ai replicas compute both of the methods opit and opiu . 2 If a pair of replicas ohi and oki compute both opit and opiu , ohi and oki compute opit and opiu in the same order. 2 3.2

Precedency among replicas

[Example 1] Each of replicas B 1, B 2, B 3, and B 4

of the bank object B supports four methods Deposit (D), W ithdraw (W ), Check (C ), and Audit (A). The method D is compatible with the method W . C is compatible with A. D and W con ict with C and A.

D, W , and A are update ones but C is not. Figure 1 indicates a graph showing the con icting relation among the methods. Here, a node shows a method and an edge between the nodes indicates that the nodes con ict. Each replica B i has a version number V i whose initial value is 0. Let the quorum number QD of D be 3 and QW of W be 2. Here, QD + QW > 4. D is issued to three replicas, say B 1 , B 2 , and B 3 and V 1 = V 2 = V 3 = 1. Then, W is issued to B 1 and B 4 . Since V 1 (= 1) > V 4 (= 0), W is computed on B 1 and V 1 = 2. B 4 is updated by taking the state from B 1 . Here, V 1 = V 4 = 2 and V 2 = V 3 = 1. If the quorum number is decided based on the con icting relation, we can reduce the quorum number but cannot decide which replica is the newest by using the version numbers. Here, Qit + Qiu > ai if a pair of methods opit and opiu con ict. For example, QD , QW , QC , and QA can be 2, 2, 3, and 3, respectively. First, suppose D is issued to B1 and B 2 and W is issued to B3 and B 4 since QD = QW = 2. Here, the version numbers of the replicas are changed to 1, i.e. V 1 = V 2 = V 3 = V 4 = 1. Then, C is issued to B 1 , B 2 , and B 3 since QC = 3. Here, B 3 is dierent from B 1 and B 2 although they have the same version number 1. Since D and W are compatible, the instance of D computed on B 1 and B 2 is also computed on B 3 and B 4 and the instance of W computed on B 3 and B 4 is computed on B1 and B 2 . Then, C can be computed on one of the replicas, say B 1 . Thus, the replicas can be the newest by computing methods which are not computed on the replicas but computed on the others if these methods are compatible. Problem is that the states of B 1 and B2 cannot be recognized to be dierent from B 3 and B4 by using the version numbers because the version numbers of B 1 , B 2 , B 3 , and B 4 are 1 after D and W are computed. 2 D

A

W

C

Figure 1: Con icting graph. A replica ohi is considered to be newer than another replica oki if every method instance computed on oki is computed on ohi . [De nition] A replica ohi precedes another replica oki (ohi ! oki ) i every update method computed on oki is computed on ohi . 2 \ ohi ! oki " means that oki is obsolete since some update methods computed on ohi are not computed on oki . ohi is maximal i there is no replica oki such that ohi ! oki in the cluster R(oi ). ohi is maximum i oki ! ohi for every replica oki in R(oi ). The quorumbased protocol requires that every quorum set include at least one maximum replica ohi . That is, if a pair of

update methods opit and opiu are issued, at least one replica ohi computes both opit and opiu . In the OBL protocol, no replica may compute both of opit and opiu if opit and opiu are compatible even if opit and opiu are update ones. Hence, there may be no maximum replica but may exist multiple maximal replicas. R(oi ) is complete i there is a maximum replica in R(oi). R(oi) may be incomplete in the OBL protocol. [De nition] A pair of maximal replicas ohi and oki are unifiable i ohi and oki get the same state if every update method not computed on one of ohi and oki is computed on the other replica. 2 Suppose there are two replicas ohi and oki . Let hoph1 , : : :, ophlh i be a sequence hk of update methods computed on a replica ohi but not on oki . Let hopk1 , : : :, opklk i be a sequence kh of update methods computed on oki but not on ohi . If every pair of methods ophu and opkv are compatible for u = 1, : : :, lh and v = 1, : : :, lk , a state obtained by applying hk to oki is the same as a state obtained by applying kh to ohi . The state obtained here is a least upper bound of ohi and oki ( ohi [ oki ) with respect to \!". For example, suppose B 1 and B 2 compute D and B 3 and B 4 compute W in Example 1. Here, 13 = 23 = hW i and 31 = 41 = hDi. The uni able relation \" is equivalent. Let U (ohi ) be an equivalent set f oki j oki  ohi in R(oi ) g for a maximal replica ohi . A cluster R(oi ) is consistent i U (ohi ) = U (oki ) for some pair of maximal replicas ohi and oki in R(oi ). Here, U (ohi ) is referred to as unifiable set U (oi) of R(oi ). A least upper bound of the replicas in a consistent cluster R(oi ) shows a possible maximum replica to be obtained from the replicas in R(oi). In the quorum-based protocol, there exists a maximum replica. If R(oi ) is inconsistent, the replicas cannot be consistent. Incomplete methods are update ones computed on some replicas but not on every replica in a uni able set U (oi ) of R(oi). Every pair of incomplete methods not computed on a same replica are computed not on every replica. Complete methods are update methods computed on every replica in U (oi ). Let us consider how opit is computed on the replicas. opit can be computed on a replica ohi in the quorum set Nit if every incomplete method which con icts with opit is computed on ohi . However, there might not exist such a replica ohi in R(oi ). Hence, opit is computed as follows. 1 Incomplete methods on each maximal replica are computed on the other maximal replicas in Nit as presented before. Here, every maximal replica is the newest one. 2 Then, opit is computed on the maximal replicas. 3 If opit is an update method, the states of the replicas in Nit have to be changed. The non-maximal replicas in R(oi ) compute every update method computed on the maximal ones but not computed on the replicas. In another way, one of the maxi-

mal replicas sends the state to the other replicas. Here, every replica in Nit is the newest one, i.e. maximum replica in R(oit ). 3.3

Version vector

We newly introduce a version vector to identify what methods are computed on each replica. Each replica ohi manipulates a bitmap vector BMih = hBMih1 , : : :, BMilhi i and a counter vector Uih = hUih1 , : : :, Uilhi i. Each element BMith is in a bitmap form hBMith1 , : : :, BMithai i. The k th bit BMithk is 1 if ohi knows that opit is issued to oki , otherwise 0 (k = 1, : : :, ai ). Each element Uith is a version number of the replica ohi with respect to opit . Uith is incremented by one each time opit is computed on ohi and opit is an update method. For example, BMBi and UBi of a i , BM i , BM i , BM i i and replica B i are hBMBD BW BC BA i i i i i, respectively, hUBD , UBW , UBC , UBA in Example 1 [Figure2]. Here, let Vith denote (Uith )BMith . For exam2 = 3 2 2 ple, VBD 1101 shows BMBD = 1101 and UBD =3. h h h h Vi is a version vector hVi1 , : : :, Vili i. oi manipulates the version vector Vih which includes both information on BMih and Uih . [Example 2] Initially, each replica B j has the version vector VBj = h00000 , 00000 , 00000 , 00000 i for j = 1, : : :, 4 in Example 1. Suppose D is issued to B 1 and B 2 since QD = 2. VB1 = VB2 = h11100 , 00000 , 00000 , 00000 i. Then, W is issued to B 3 and B 4 since QW = 2. VB3 = VB4 = h00000 , 10011 , 00000 , 00000 i. Then, C is issued to B1 , B 2 , and B 3 since QC = 3. VB1 = VB2 6= VB3 . Since 1 2 3 1 = V2 = 1 VBD 1100 and VBW = 10011 , B and B BD 1 2 3 know that D is issued to B and B , and B knows that W is issued to B 3 and B 4 . Here, no replica is maximum because every replica has computed either D or W . One replica, say B 1, is selected. The instance 1 is of W computed on B 3 is computed on B 1 . VBW 1 changed to be 10011 , i.e. VB = h11100 , 10011 , 00000 , 00000 i. Then, C is computed on B 1 . Since C is not 1 is not changed. D is issued to an update one, VBC 3 4 3 B and B . VB = VB4 = h10011 , 10011 , 00000 , 00000 i. Then, the method A is issued to three replicas B 2 , 2 B3 , and B 4 since QA =3. Since VBD = 11100 and 3 2 3 VBD = 10011 , B and B compute dierent instances D1 and D2 of D , respectively. B2 and B 3 exchange 2 = 00000 the instances of D1 and D2 . In addition, VBW 3 and VBW = 10011 . Here, the instances of D and W computed on B 3 have to be computed on B 2 to obtain the least upper bound version of B 2 and B 3 . Since D is compatible with W , D and W can be computed on B2 in any order. Now, the method A is computed on B2 after D and W are computed. Here, B 2 computes a sequence D1 WD2 A and B 2 computes W D2 D1 A. VB2 = h21111 , 10011 , 00000 , 10111 i and A updates B 2 . If the state of B 2 is sent to B 3 and B 4 , B 3 and B 4 are

B1

B2

B3

B4









D1 D1 W D1 D1 W

D1 D1





C



D1 W C

D1





W

W

W

W W D2

D2 D1 W C

D1

W W D2

A







W D2

W D2

D1 W C

D1 W C

D1 W D2

W D2

W D2 D1 A W D2 D1 A D1 W D2 A D1 A D1 A

Figure 2: Version vectors. updated with the state of B 2 . VB2 = VB3 = VB4 . Here, 1 = V2 = V3 4 VBD BD BD = VBD (= 21111 ) is initialized to be 00000 since the same instances of D are surely computed on every replica. In stead of sending the states, B 3 and B 4 can compute A. Then, B 2 can send a sequence of the instances computed on B 2 to the other replicas. 2 Let BMih and BMik be bitmaps for ohi and oki , respectively. BMih is included in BMik (BMih  BMik ) i BMikj =1 if BMihj =1 for j = 1, : : :, ai . BMih [ BMik shows hBM 1 , : : :, BM ai i where BM j = 1 if BMihj = BMikj = 1, otherwise 0 for j = 1, : : :, ai .  Vith  Vitk i Uith  Uitk and BMith  BMitk .  Vih  Vik i Vith  Vitk for every method opit . A pair of version elements Vith and Vitk are not comparable i neither Vith  Vitk nor Vith  Vitk . If BMith \ BMitk 6= , Vith and Vitk are not comparable even if Uith  Uitk or Uitk  Uith . For example, suppose VB1 = h11100 , 00000 , 00000 , 00000 i and VB3 = h21110 , 00000 , 00000, 00000 i. Here, VB1  VB3 . Here, if VB2 = h20011 , 1 and V 2 are not comparable. 00000, 00000 , 00000 i, VBD BD In a subset N  R(oi ), Vih is maximal i there is no replica oki in N where Vik  Vih for ohi in N . We de ne a least upper bound \[" for a pair of version elements Vith and Vitk on opit as follows : 8 V k if V h  V k : > < Vith if Vith  Vitk : it it it  Vith [ Vitk = > Uith + Uitk ; BMith [ BMitk i : hotherwise :

Vih [ Vik = hVih1 [ Vik1 , : : :, Vilhi [ Vilki i. For example, VB2 = h10011 , 00000 , 00000 , 00000 i [ VB3 = h11100 , 10011 , 00000 , 00000 i = h21111 , 10011 , 00000 , 00000 i. [ De nition ] A version vector Vih is equivalent with another one Vik (Vih  Vik ) i Vivh = Vivk for every update method opiv con icting with every pair of compatible methods opit and opiu . 2 For example, D and W are compatible with one another and con ict with A. Hence, VB1 = h11100 , 00000 , 00000 , 20101 i is equivalent with VB2 = h00000 , 10011 , 1 = V2 = 2 h k 00000 , 20101 i since VBA 0101 . If Vi  Vi , BA h k oi and oi can get the same state by computing compatible methods which are not yet computed on the replicas. 

4

Object-based Locking Protocol

We discuss a locking protocol by using the version vector. Suppose a method opit is issued to an object oi . A replica ohi of oi has a method log lhi for storing a sequence of method instances computed on ohi . Let lith be a subsequence of instances of opit in the log lih . Each instance op has a bitmap op:BM showing replicas to which op is issued. That is, op:BM k = 1 if op is issued to oki . The counter Uith gives the number of method instances in lith . [ Locking protocol ] An object os sends a method opit to every replica in the quorum set Nit of opit . 1 All the replicas in Nit are locked in a mode (opit ). Unless succeeded in locking the replicas, opit aborts. Each replica ohi in Nit sends back

a response with the version vector Vih and the method log lih to os . 2 On receipt of the responses from all the replicas in Nit , os obtains Vs = [ f Vik j oki 2 Nit g. Let Ph (opit ) denote a set f opiu j opiu con icts with opit , opiu :BM 6= h1: : :1i, and ohi computes opiu g. os nds a replica ohi in Nit which is maximal with respect to methods con icting with opit . 3 If a replica ohi is found, os requires ohi to compute opit . ohi computes opit . a If opit is not an update method, ohi sends a response to os . b Otherwise, ohi sends the set Ph (opit ) to one replica oki in Nit . oki computes every opiu in Ph (opit ) unless oki had computed opiu . For every opiv in Ph (opit ), opiv :BM := opiv :BM _ opit :BM . oki sends a response back to os . 4 Unless ohi is found, os selects one maximal replica ohi in the quorum set Nit . Let P (opit ) be a set f opiu j opiu con icts with opit and is computed on some replica ohi in Nit g. a If opit is an update, os sends P (opit ) to every replica in Nit . Each replica ohi computes every update opiu computed in Nit which is not computed on ohi and then computes opit . For every opiu in P (opit ), opiu :BM := opiu :BM _ op:BM in ohi . ohi sends a response back to os . b If opit is not an update, os selects one maximal replica ohi in Nit . os sends P (opit ) to ohi . ohi computes every opiu in P (opit ) if ohi had not computed opiu . Then, ohi computes opit . ohi sends a response to os. 2 Methods stored in the method log lhi have to be eventually removed to reduce the log size in ohi . The bitmap opit :BM attached to opit in the log lih shows that ohi knows that opit is computed on oki if BM k =1. If opit :BM = h1: : :1i, ohi knows that opit is computed on every replica. However, ohi cannot remove opit from lih because another replica oki may not yet know that every replica has computed opit . Hence, a following instance opiu in the log lih is removed :  opiu :BM = opiv :BM = h1: : :1i for every method opiv in lih which con icts with opiu and is computed before opiu . The counter Uith and the bitmap BMith are initialized again, i.e. Uith := 0 and BMith := h0: : :0i if BMith gets h1: : :1i. If BMith = h1: : :1i in some replica ohi , opit is computed on every replica oki in the quorum set Nit . Thus, Uith shows how many instances of opit are computed on oti . If BMith \ BMitk =  and ( Uith > 0 or Uitk > 0 ) for an update method opit , a sequence sh

of instances of opit computed on ohi is dierent from sk of oki . sh and sk include Uith and Uitk instances of opit , respectively. In the OBL protocol, sk and sh are required to be computed on ohi and oki , respectively. Then, BMith := BMitk := BMith \ BMitk and Uith := Uitk := Uith + Uitk + 1. [Theorem] For every update method opit , if BMith  BMitk and Uith  Uitk , every instance of opit computed on Bih is also computed on Bik . 2 [Theorem] If Vih  Vik , every pair of con icting instances opit and opiu computed on a replica ohi are computed on another replica oki in the same order. 2 [Theorem] Every pair of maximal replicas ohi and oki are uni able to one unique replica. 2 [Theorem] All the replicas are uni able to one unique replica in the OBL protocol. 2 5

Evaluation

We evaluate the OBL protocol by comparing with the quorum-based protocol in terms of the number of the replicas locked. An object oi supports methods opi1 , : : :, opili (li  1). In the quorum-based protocol, an update opit is considered to be write. Otherwise, opit is read. Quorum sets Nit and Niu for a pair of methods opit and opiu are decided so that Nit \ Nit 6=  if opit or opiu is an update. On the other hand, Ni1 , : : :, Nili are obtained based on the con icting relation. Nit \ Niu 6=  only if opit con icts with opiu . That is, Nit \ Niu =  if opit is compatible with opiu even if opit or opiu is an update one in the OBL protocol. Let '(opit ) denote a usage frequency of opit where '(opi1 ) + : : : + '(opili ) = 1. For various values of the usage frequency ', the minimum quorum numbers QO it and QQ to be locked in the OBL protocol and the quorumit based protocol, respectively, are calculated. In the evaluation, an object is assumed to support two types of methods op1 and op2 . Figure 3 shows con icting graphs for three cases. op

op

case 1 :

op

op

case 2 :

op

op

case 3 :

1

1

1

2

2

2

Figure 3: Con icting relations. Figures 4, 5, and 6 show the quorum number for usage frequency of op1 in case that the number ai of the replicas is 10. In the quorum-based protocol, the quorum number of opi depends on whether or not opi is an update. We assume that opi is an update if opi con icts with itself. We also assume that one of op1 and op2 is an update if op1 con icts with op2 . For example, at least one of op1 and op2 must be an update in case 1 because op1 con icts with op2 . Hence, op1

a i = 10

6.0

6.0

5.0

5.0

Quorum number

Quorum number

a i = 10

OBL protocol quorum-based minimum quorum-based maximum quorum-based average

4.0 3.0

4.0 3.0

2.0

2.0

1.0

1.0

0

0.5

1.0

0

Frequency of op1

1.0

OBL protocol quorum-based minimum quorum-based maximum quorum-based average

Figure 6: Evaluation of OBL protocol (case 3).

3.0

object supports a more abstract level of method than read and write. The version vector has been proposed to maintain the mutual consistency of the replicas. The replicas are not required to compute every update instance which has been computed on the other replicas if the instance is compatible with the instances computed. Through the evaluation, we have shown that fewer number of replicas are locked in the OBL protocol than the quorum-based protocol.

2.0

References

a i = 10 6.0

Quorum number

0.5

Frequency of op1

Figure 4: Evaluation of OBL protocol (case 1).

5.0 4.0

1.0

0

0.5

1.0

Frequency of op1

Figure 5: Evaluation of OBL protocol (case 2). and op2 are considered to be one of write and write, write and read, and read and write. There are three cases depending on whether or not the methods are update ones. Hence, there are three combinations of update and non-update methods in case 1, two in case 2, and four in case 3. We obtain the minimum, maximum, and average quorum numbers for the quorumbased protocol through the computation. The quorum number of the OBL protocol is also calculated so that the OBL constraint are satis ed. Figures 4, 5, and 6 show that the fewer number of replicas are locked in the OBL protocol than the quorum-based protocol. Even if op1 and op2 are update methods, op1 may be compatible with op2 . For example, the method D is compatible with W in Example 1. 6

OBL protocol quorum-based minimum quorum-based maximum quorum-based average

Concluding Remarks

This paper has discussed the object-based locking (OBL) protocol for the replicas of the objects. The

[1] Bernstein, P. A., Hadzilacos, V., and Goodman, N., \Concurrency Control and Recovery in Database Systems," Addison -Wesley , 1987. [2] Carey, J. M. and Livny, M., \Con ict Detection Tradeos for Replicated Data," ACM TODS, Vol.16, No.4, 1991, pp. 703{746. [3] Garcia-Molina, H. and Barbara, D., \How to Assign Votes in a Distributed System," Journal of ACM, Vol 32, No.4, 1985, pp. 841-860. [4] Hasegawa, K. and Takizawa, M., \Optimistic Concurrency Control for Replicated Objects", Proc. of the Int'l Symp. on Communications (ISCOM'97 ), 1997, pp. 149{152. [5] Jing, J., Bukhres, O., and Elmagarmid, A., \Distributed Lock Management for Mobile Transactions," Proc. of IEEE ICDCS -15 , 1995, pp. 118125. [6] Korth, H. F., \Locking Primitives in a Database System," JACM, Vol. 30, No. 1, 1983, pp. 55-79. [7] Silvano, M. and Douglas, C. S., \Constructing Reliable Distributed Communication Systems with CORBA," IEEE Communications Magazine , Vol.35, No.2, 1997, pp.56{60. [8] Yoshida, T. and Takizawa, M., \Model of Mobile Objects," Proc. of the 7th DEXA (Lecture Notes in Computer Science, No 1134, Springer-Verlag), 1996, pp. 623{632.