W.E. Weihl, Local atomicity properties: modular concurrency control for abstract data types, ACM Trans. Programming Languages Systems 11(2) (1989) 249 282.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....methods, and not as separate concerns. Furthermore, even if the systems underlying those languages provide default mechanisms for handling concurrency and failures, most work on how to obtain effective mechanisms advocate the tight integration of the mechanisms within the actual methods or objects [21, 31, 32]. The difficulty of providing local concurrency control mechanisms and the strong integration with recovery management is pointed out in [25] On the other hand, object oriented programming is about modeling real world phenomenon with objects. Each object is supposed to encapsulate the state ....

Weihl, W. E.: "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types". ACM Transactions on Programming Languages and Systems 11(2), pp. 249 -- 283, April 1989.

....objects, the order in which access requests are processed at each object may differ from object to object. In order to preserve consistency, the concept of transactions was incorporated into objects. In this research, which includes work on Transaction Management Object (TMO) 3] Local Atomicity[8], and Cooperative Atomicity[6] concurrency inside an object was excluded. The concurrency inside objects, therefore, become too complex to detect the dependencies among operations, from which dependencies among transactions arise, and synchronization code had to be included in the object ....

....be a group of a user jobs, and it may be rolled back, aborted and redone to resolve any undesirable effects and preserve consistency among multiple objects. The Transaction Management Object(TMO) was introduced to deal with this consistency requirement among multiple objects[3] Local Atomicity [8]and Cooperative Atomicity [6] have also been proposed for preserving consistency among multiple objects in distributed systems. In these research, the concurrency within an object was not dealt with, so Linearizability was one approach to resolving concurrency within an object. However, it ....

William E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Language System, 11(2):249--283, Apr. 1989.

....system, then the nodes Scheduler and RecoveryManager must be adapted accordingly. In addition to interaction compatibility requirements, there may be restrictions on the composability of components. For example, the nodes Scheduler and RecoveryManager are in some cases dependent on each other [Weihl 89] Therefore, not every node of the knowledge domain Scheduler can be combined with all nodes of the knowledge domain RecoveryManager. Finally, the different serialization protocols adopted by scheduler nodes may be incompatible with each other [Guerraoui 94] Image Processing Framework There ....

W.E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types, ACM Transactions on Programming Languages and Systems, Vol. 11, No. 2, April 1989, pp. 249-282.

....define, for a given object, the optimal concurrency control or recovery protocol. For instance, commutativity of operations enables the interleaving (without blocking) of transactions on a given object. Unfortunately, the gain in modularity and specialization may lead to incompatibility problems [60]. Broadly speaking, if objects use different transaction serialization protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local conditions, ....

....protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local conditions, to be verified by objects, in order to ensure their compatibility [60, 30]. Replication of Objects and Communications. The communication protocols which have been designed for fault tolerant distributed computing (see Sect. 4.5) consider a standard client server model. The straightforward transposition of such protocols to the object model leads to the problem of ....

W. Weihl, Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types, ACM Transactions on Programming Languages and Systems, Vol. 11, n o 2, 1989.

....define, for a given object, the optimal concurrency control or recovery protocol. For instance, commutativity of operations enables the interleaving (without blocking) of transactions on a given object. Unfortunately, the gain in modularity and specialization may lead to incompatibility problems [Wei 89] Broadly speaking, if objects use different transaction serialization protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local conditions, ....

....protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local conditions, to be verified by objects, in order to ensure their compatibility [Wei 89, Gue 95b] 4.6.3 Replication of Objects and Communications. The communication protocols which have been designed for fault tolerant distributed computing (see Sect. 4.5.3) consider a standard client server model. The straightforward transposition of such protocols to the object model leads to ....

W. Weihl, "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types," ACM Transactions on Programming Languages and Systems, Vol. 11, n o 2, 1989.

....for such applications. In particular, databases or the hot spots of databases are modeled by collections of abstract data objects and semantics of objects are used to improve concurrency. Various concurrency control protocols which adopt different serializability criteria have been proposed [10, 13, 14, 6, 9, 3, 15, 16]. However, relatively not much work has been done on the recovery issues in such models. Actually, serializability and recoverability are two closely related concepts which cannot be considered separately. There are two issues that deserve more investigation. Firstly, we have to study whether the ....

.... T 1 : increases counter X by 10 Transaction T 2 : writes 10 to counter X Transaction T 3 : reads counter X and get 10 Transaction T 3 : reads counter Y and get 0 Transaction T 2 : writes 5 to counter Y Transaction T 2 : commits Transaction T 3 : commits If semantics serializability [14] is adopted, the above history is serializable in the order of T 1 T 3 T 2 , since the final states of the counter objects and the response to each operation is the same as that of the serial history executed in the order of T 1 T 3 T 2 . The above execution is also recoverable, if the traditional ....

[Article contains additional citation context not shown here]

W. E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--283, April 1989.

....object. Thus the Congenial Talking Philosophers problem is more general than the two classical problems. Note that resolving con icts between READ WRITE and WRITE WRITE operations while facilitating concurrency among READ operations is the central topic of database concurrency control (see, e.g. [11, 21, 19, 18, 5, 26, 2]) Despite the similar objective, the Congenial Talking Philosophers problem targets the construction of a low level mechanism to support operation execution. In contrast, database concurrency control typically uses such mechanisms (e.g. locking) to ensure serializability at the transaction ....

William E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems, 11(2):249-283, April 1989. 45

.... exploit the semantics of operations (e.g. perform operation logging) and employ recovery algorithms proposed in [WHBM90, Lom92, MHL 92] 2 Previous Work A number of concurrency control schemes that exploit the semantics of operations have been proposed in the literature [Kor83, SS84, Wei88, Wei89, Her90, BR92] However, most of them do not ensure that resulting histories are strict. Concurrency control schemes proposed in [Kor83, SS84, Wei88, Wei89] define the notion of conflict between arbitrary operations in terms of commutativity (operations conflict if and only if they do not ....

....A number of concurrency control schemes that exploit the semantics of operations have been proposed in the literature [Kor83, SS84, Wei88, Wei89, Her90, BR92] However, most of them do not ensure that resulting histories are strict. Concurrency control schemes proposed in [Kor83, SS84, Wei88, Wei89] define the notion of conflict between arbitrary operations in terms of commutativity (operations conflict if and only if they do not commute) Furthermore, an operation belonging to a transaction is permitted to execute if every other transaction that has executed a conflicting operation has ....

[Article contains additional citation context not shown here]

W. E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems, 11(2):249--282, April 1989.

.... of distributed concurrency control has received much attention and many protocols have appeared in the literature [3, 6, 11] More recently, research effort focuses on ways to increase concurrency, beyond the level that the conventional protocols permit, by utilising the semantics of applications [9, 10, 12, 13, 14, 16, 18, 19, 23, 25, 26, 27]. One approach in this direction suggests the use of typed data or objects [12, 13, 18, 23, 25, 26, 27] These are instances of abstract data types on which high level operations, rich in semantic information, can be defined. By choosing the types that are most natural for an application it is ....

.... More recently, research effort focuses on ways to increase concurrency, beyond the level that the conventional protocols permit, by utilising the semantics of applications [9, 10, 12, 13, 14, 16, 18, 19, 23, 25, 26, 27] One approach in this direction suggests the use of typed data or objects [12, 13, 18, 23, 25, 26, 27]. These are instances of abstract data types on which high level operations, rich in semantic information, can be defined. By choosing the types that are most natural for an application it is possible to achieve greater concurrency than can be obtained when applications are restricted to using ....

[Article contains additional citation context not shown here]

W. E. Weihl, "Local atomicity properties: modular concurrency control for abstract data types", ACM Trans. Program. Lang. Syst., 11:2, pp.249-282, Apr. 1989

....e , the object scheduler for object e, in Figure 3.3) Since each object has its own logical scheduler various concurrency control and recovery algorithms are supported. This allows different objects to use distinct schedulers, provided the schedulers implement the same type of correctness [Wei89b] Object schedulers coordinate the execution of the method s operations at the objects. Information binding the object to its scheduler is stored in the object dictionary. Since the object id uniquely identifies the object, the appropriate object scheduler, Reliable and Recoverable Transactions ....

W. E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems, pages 249--283, April 1989.

....one message it decides nondeterministically, considering their priorities, in which order they will be processed. Here we will describe the first step towards our goal by incorporating concurrency control to enforce serializability. We will show that the work on synchronizing abstract data types [17,19,6,15] can be adopted for the autonomous object model. This way synchronization can be implemented locally within the autonomous objects, thereby reducing the need for global control. Additionally the semantics of object types interface operations is taken into account, thus gaining parallelism. This ....

....data types has been examined by Schwarz and Spector [17] They presented a formalism for specifying concurrency properties of shared abstract data types, exploiting the semantics of the type s operations in order to increase concurrency. Our approach is mainly based on this formalism. In [7] and [19] a hybrid concurrency control protocol for abstract data types is developed, again taking the operation s specific semantics into account. Two optimistic concurrency control protocols for abstract data types considering type specific operations are introduced in [6] Locking mechanisms can ensure ....

W. E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Trans. Programming Languages and Systems, 11(2):249--282, April 1989.

....data and operations for manipulating the data. Transactions manipulate the objects distributed on the network. A transaction T in a client issues operations to the objects. Each operation invoked by T may invoke operations on the other objects. That is, transactions are nested. Nested transactions [1, 11, 12, 13, 16, 17] are structured as ordered trees whose nodes represent operations as transactions and parent child branches denote caller callee relations among the operations. Since the CAD transactions require more objects and take longer time than the conventional ones, there is higher possibility that ....

Weihl, W. E., "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types," ACM Trans. on Programming Language and Systems, Vol.11, No.2, 1989, pp.249-283.

....a detailed path h ho 1 i, ho n i i where every o j is a component of o. v is a sequence of subtransactions v 1 , v n , where each v j is concerned with movement on ho j i. v j is further composed of a sequence of subtransactions on the components of o j . Thus, v on o is nested [16, 17, 21, 22]. When v j commits, i.e. v j leaves o j , v j releases o j . Such a nested transaction is open [20] The following locking scheme is adopted. 1. v locks o. o decides a path h ho 1 i, ho n i i, and issues subtransaction v j on ho j i (for j = 1, n) 2. The subtransactions v 1 , ....

Weihl, W. E., "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types," ACM Trans. on Programming Language and Systems, Vol.11, No.2, 1989, pp.249-283.

....Serializer and RecoveryManager must be adapted accordingly. In addition to interaction compatibility requirements, there may be restrictions on the composability of components. For example, we found out that the components Scheduler and Recovery are in some cases dependent on each other [Weihl 89] Therefore, it is not always possible to combine every concept from the knowledge domain Scheduler with any concept from the knowledge domain RecoveryManager. In addition, we identified that the different serialization protocols adopted by the scheduler components may be incompatible with each ....

W.E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types, ACM Transactions on Programming Languages and Systems, Vol. 11, No. 2, April 1989, pp. 249-282.

....procedure and is also the basis for allowing commitment of versions from different base versions. The conditions under which out of order serialization may be done are straightforward, but the change in serialization order affects the serialization properties of the algorithm. No local atomicity [20] property is met so interobject serializability must be explicitly ensured. The separation of intra and inter object serializability was suggested by Hadzilacos and Hadzilacos [9] and a model was proposed by Zapp and Barker [24, 23] Efficiently ensuring interobject serializability is another ....

W.E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions of Programming Languages and Systems, 11(2):249 -- 282, 1989.

....control should be considered at two levels: local and global. Local concurrency control defines access serialization to objects while the latter is responsible for globally serialize a set of accesses. The integration of both perspectives has some problems which are identified and handled in [Weihl 89, Guerraoui 94] Weihl groups local atomicity in three categories of global serialization protocols: static, when the global order is defined at transaction creation; dynamic, when the global order is defined during transaction execution; and hybrid, when global order is defined when a transaction ....

....policies define the local execution order based on the global serialization order. Two different policies are possible: pessimistic and optimistic. They should be integrated with the global serialization policies. This integration raises the incompatibility problem previously referred to [Weihl 89, Guerraoui 94] The pattern supports both kinds of policies: dependent and orthogonal. The former expects a particular global serialization policy while the latter are independent from the global serialization policy being used. These policies are coded in subclasses of Controller. ffl Dependent ....

William Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--282, April 1989.

....to determine how it behaves in different TAs. This later case, however, does not imply that a data object can be concurrently involved in TAs of arbitrary types, since some TA types may enforce conflicting rules. Basically, all objects in an application must have the same local atomicity property [13]. Furthermore, when an objects is in TAs of different types, there should be no conflicting operation scheduling orders within the object. More on correctness issues can be found in [15] Therefore different transaction models may coexist in the global and local environments. A transaction may ....

W. E. Weihl. Local Atomicity Properties: Modular Concurrency Control Abstract Data Types. ACM Trans. Prog. Lang. Systems. 11(2):249-282, April, 1989.

....transparency is a global concurrency control mechanism that treats all objects in an equal manner. The most common approach is concurrency control based on serialisability [3] Conceptually one serial scheduler is responsible to schedule messages related to interleaving communications. Weihl [33] allows some differentiation among objects by introducing (object) local atomicity properties which allow objects to base their synchronization of concurrent communications solely on local information. This allows for a decentralized concurrency control but still leaves objects with only a minor ....

W. E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Trans. Programming Languages and Systems, 11(2):249--282, Apr 1989.

.... need for more general and powerful transaction models has been recognized for some time and significant work has been done in extending the original transaction concept (e.g. Beeri et al. 1989; Elmagarmid et al. 1990; Herlihy, 1990; Garcia Molina and Salem, 1987; Moss, 1985; Pu et al. 1988; Weihl, 1989]) Many of the notions encompassed in these extensions are useful in defining the DOM transaction model, but, at the same time, they have resulted in a wealth of new concepts, some of which overlap, leave gaps, or hide incompatibilities that arise from incomparable criteria. Hence, the combination ....

....is said to be conflict serializable if it is conflict equivalent to a serial history. There are a number of serializability based correctness criteria that basically differ in how they define a conflict . We concentrate on three criteria discussed in the literature: commutativity [Weihl, 1988; Weihl, 1989; Fekete et al. 1989] invalidation [Herlihy, 1990] and recoverability 1 [Badrinath and Ramamritham, 1987] Commutativity states that two operations conflict if the results of the serial executions of these operations are not equivalent. Consider the simple operations Read and Write. If ....

[Article contains additional citation context not shown here]

Weihl. W. Local atomicity properties: Modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems 11(2): 249--281, April 1989.

....of data objects. In particular, an abstract data type model is used. The concurrency control mechanisms derived from this model have been shown, theoretically, to provide more concurrency as the underlying data types and operations offer a much richer semantics than that of the read write model [22, 21, 24, 12, 6, 23]. However, these algorithms are not being widely used in industrial applications. One of the possible reasons is that the practical performance characteristics of these algorithms have not been studied extensively. Therefore, we are motivated to build a testbed to study several semantics based ....

....are not being widely used in industrial applications. One of the possible reasons is that the practical performance characteristics of these algorithms have not been studied extensively. Therefore, we are motivated to build a testbed to study several semantics based concurrency control protocols [22, 24, 25]. In this paper, we have investigated the overhead and the performance of these protocols in an attempt to understand the practical characteristics of these protocols and to define concurrency from a practical point of view. Contents 1 Introduction 1 2 Background 2 2.1 Read Write Model : ....

[Article contains additional citation context not shown here]

W. E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--283, April 1989.

....that a procedure will execute to completion, thus avoiding the cost of rollback. The work on the reordering of executions based on commutativity can be traced to Lipton[12] or even to Church and Rosser[5] There have been several extensions and variations by Lamport and Schneider [11] Weihl [21], Steele [20] and Misra [17] See Lynch et al. 14] for a thorough study of the two most important notions of commutativity, forward and backward commutativity. The compatibilty definition used in this paper seems similar to backward commutativity. However, compatibility introduces asymmetry ....

W.E.Weihl. Local atomicity properties: modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems, 11(2):249--282, April 1989. Department of Computer Sciences, University of Texas, Austin 78712 E-mail address: misra@cs.utexas.edu

.... , Mario Tokoro y Department of Computer Science Keio University 3 14 1 Hiyoshi, Yokohama 223 JAPAN Tel: 81(44)63 1926 November 24, 1993 1 Introduction Atomic objects, which combine an object model and an atomic action, were developed to achieve reliable and modular distributed computing[1] 2] 3][4]. Atomic objects have the following merits over non object based atomic actions. ffl If all objects satisfy the same local atomicity property[4] all actions are atomic. ffl Semantic information can be independently extracted from each object. The two merits are closely connected with each ....

....Atomic objects, which combine an object model and an atomic action, were developed to achieve reliable and modular distributed computing[1] 2] 3] 4] Atomic objects have the following merits over non object based atomic actions. ffl If all objects satisfy the same local atomicity property[4], all actions are atomic. ffl Semantic information can be independently extracted from each object. The two merits are closely connected with each other. Using non object based atomic actions, it is difficult to extract semantic information from applications because it is required that the ....

W. Weihl, Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types, ACM Transaction on Programming Languages and Systems, Vol.11, No.4

....to such a language and to a demonstration of its utility. Chief among the language constructs has been the concept of a behavioral map. So far we have carried out only first, non conclusive studies concerning synchronization of activities in our model. Based on the works by Liskov and Weihl [22, 21], Herlihy [8] and Schwartz and Spector [19] it is relatively straightforward to incorporate transactions into our model by making the autonomous object types atomic, that is, equip the types participating in transactions with their own localized concurrency control schemes. However, the ....

W. E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Trans. Programming Languages and Systems, 11(2):249--282, Apr 1989.

....two different approaches to address this problem. Instead of modeling the database as a collection of objects that can only be read or written by transactions, a number of researchers have considered placing more structure on data objects to exploit type specific semantics [Kor83, SS84, Her86, Wei89, BR92] This approach increases concurrency in the system while remaining within the confines of serializability. The other approach relaxes the absolute atomicity of transactions and uses the explicit semantics of transactions to allow executions in which a transaction may provide different ....

W. E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--283, April 1989.

....concurrency control in conventional database systems. Efforts in this area may be divided into those which correspond to slight modifications to, or extensions of, existing techniques (e.g. BG83, Moh90] and those which introduce drastically different concurrency control algorithms (e.g. Wei89b, DK90] This section summarizes the results which may be applicable to improving concurrency control in objectbases. Optimism Some applications [MT86, BS91] benefit greatly from the use of optimistic algorithms for concurrency control. Whenever it can be determined a priori that the ....

...., UT j is serialized before UT i . Any correct concurrency control algorithm must ensure that the serialization orders at O 3 and O 6 are consistent. Consistent serialization orderings across objects can be achieved using either static or dynamic local atomicity properties as described by Weihl [Wei89b] Algorithms employing static techniques offer the advantage of pre determined ordering of conflicting CHAPTER 3. THE OBJECT BASE CONCURRENCY CONTROL PROBLEM 81 i O UT 1 UT 2 m i1 m j1 m s1 m s2 m t1 m t2 O s O j O t s s s s i1 2 i1 j1 j1 1 1 2 Figure 3.6: Inter Transaction ....

W.E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions of Programming Languages and Systems, 11(2):249 -- 282, 1989.

....a language and to a demonstration of its utility. Chief among the language constructs has been the concept of a behavioral map. So far we have carried out only first, non conclusive studies concerning synchronization of activities in our model. Based on the works by Liskov and Weihl (1985) and Weihl (1989), Herlihy (1990) and Schwarz and Spector (1984) it is relatively straightforward to incorporate transactions into our model by making the autonomous object types atomic, that is, equip the types participating in transactions with their own localized concurrency control schemes. However, the ....

Weihl, W. E. (1989). Local atomicity properties: Modular concurrency control for abstract data types. ACM Trans. Programming Languages and Systems, 11(2), 249--282.

....distinguished by their synchronization primitives: locking or timestamping. ffl Weihl defines concurrency control in the context of atomic objects [Weihl 84] An atomic object encapsulates concurrency control and recovery control. Global serializability is achieved using local object properties [Weihl 89] Three local properties are explored: dynamic protocols, in which the serialization order of transactions is determined from the order in which they access the objects; static protocols, in which the serialization order of transactions is defined at transaction creation time; and hybrid ....

....order of transactions is defined at transaction creation time; and hybrid protocols, which define the serialization order when a transaction finishes. All atomic objects accessed by a transaction must use the same local atomicity properties, otherwise global serializability cannot be achieved [Weihl 89] ffl Concurrency control is supported by several systems which implement atomic objects and local atomicity, for instance Argus [Liskov 88] Avalon [Eppinger 91] Arjuna [Shrivastava 91] and Hermes ST [Fazzolare 93] These systems use nested transactions and two phase locking as their default ....

[Article contains additional citation context not shown here]

William Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--282, April 1989.

....is too generic in its treatment of operations. More specific definitions of conflicts can be used in object specific conflict tables. Three notions of conflicts that consider the semantics of the operations (and possibly their return values) have been proposed in the literature: commutativity [32, 33], invalidation [24] and recoverability [6] As an example of conflict definition that takes into account operation semantics, consider using commutativity to define the conflict table of a set object. Commutativity states that two operations conflict (do not commute) if executing them in any ....

W. Weihl, Local atomicity properties: Modular Concurrency Control for Abstract Data Types, ACM Trans. on Programming Languages and Systems, 11(2), 1989.

....the transactions in which A can dequeue y and B can dequeue x, and thus, the history is not serializable. However, if each object has access to some global information, such as the transaction tree, its synchronization condition can ensure locally a more restrictive form of serializability. Weihl [Weihl 89] describes three such local atomicity properties (e.g. hybrid atomicity) if each object ensures the same local property, then the system will be serializable, although some serializable histories may not be allowed. 3 example taken from [Herlihy Wing 88] R.Lerner Specifying Objects of ....

....possibly start nested transactions, and terminate either by committing or aborting. In this environment, transactions 11 have the following properties: A transaction waits for one operation to complete before invoking the next operation or starting nested transactions. 11 Adapted from [Weihl 89] R.Lerner Specifying Objects of Concurrent Systems Chapter 3 Specifications of Serializable Objects 52 . When a transaction starts one or more nested transactions, it waits until they all terminate before invoking further operations or committing. A transaction cannot commit while ....

[Article contains additional citation context not shown here]

William E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems 11(2):249-283, April, 1989. R.Lerner -- Specifying Objects of Concurrent Systems 199

....such applications. In particular, databases, or the hot spots of databases, are modeled by the collection of abstract data objects and the semantics of objects are used to improve concurrency. Various concurrency control protocols which adopt different serializability criteria have been proposed [10, 13, 14, 6, 9, 3, 17, 16, 15]. However, relatively, there has not been much work done on the recovery issues in such models. In fact, serializability and recoverability are two closely related concepts which cannot be considered separately. In the following, we will use two examples to illustrate that the traditional recovery ....

....2 . Therefore, the above history could be considered recoverable, if a more advanced recovery mechanism based on abstract data objects is used. Consider Sample history II in Figure 1 on counter objects X and Y . Assume that the initial values of the counters are zero. If semantics serializability [14] is adopted, the above history is serializable in the order of T 1 T 3 T 2 , since the final states of the counter objects and the response to each operation is the same as that of the serial history executed in the order of T 1 T 3 T 2 . The above execution is also recoverable because T 3 reads ....

[Article contains additional citation context not shown here]

W. E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--283, April 1989.

....object model and atomic actions, were developed to achieve reliable and modular distributed computing. Atomic objects have the following two advantages over non object based atomic actions. The first advantage is that all actions are atomic if all objects satisfy the same local atomicity property[18]. The second one is that semantic information can be independently extracted from each object to enhance the degree of concurrency[1, 7, 14, 17] The two advantages are closely connected with each other. It is difficult to extract semantic information from applications when using non object based ....

....degree of concurrency, but it is difficult to introduce the relation through specifications. 2.2 Interaction between Concurrency Control and Recovery While many theories have been developed for concurrency control, these have been weak in the theoretical analysis of recovery algorithms. Weihl [18, 19] studied two commutativity based concurrency control algorithms: one is a forward commutativity and another is a backward commutativity. In his paper, he discussed the impact of recovery algorithms on concur3 rency control algorithms. For example, a correct recovery algorithm such as the undo ....

W. Weihl, Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types, ACM Transaction on Programming Languages and Systems, Vol.11, No.4

....perspectives [21] pessimistic [22] when the application is expected to have high contention, and optimistic, when the level of contention is supposed to be low. Moreover, policies are distinguished by their synchronization primitives: locking [23] and timestamping [24] Policies are classified [25] as dynamic, in which the serialization order is determined from the order in which objects are accessed, and static, in which the serialization order is based on a predefined total order. The combination of this three aspects generates well known policies as, for instance, two phase locking ....

William Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--282, April 1989.

....due to its strong constraint[4] Atomic objects, which combine object model and atomicity, were developed to achieve reliable and modular distributed computing. Atomic objects have the following merits over non object based atomic actions. ffl If all objects satisfy a same local atomicity property[21], all actions are atomic. ffl Semantic information can be independently extracted from each object to enhance the degree of concurrency[1, 8, 17, 20] The two merits are closely connected with each other. Using non object based atomic actions, it is difficult to extract semantic information from ....

....behavior of computation. Modularity is important in distributed environment because we cannot assume to know all applications in systems in advance. In object model, serializability should ensure that entire computation is correct if each object is correct. The properties was first proposed in [21]. He proposed three properties to satisfy serializability in object model. When each object uses the concurrency control and recovery algorithm which satisfy a same local atomicity property, entire computation becomes serializable. In other words, each object can use the different algorithm which ....

W. Weihl, Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types, ACM Transaction on Programming Languages and Systems, Vol.11, No.4,

....from having to rely on system types so that more convenient data types can be used to increase performance. However, implementing user defined atomic types is difficult. Argus has had an influence on other systems (e.g. Avalon) and provided a basis for important work on atomic objects (e.g. [29, 28]) The disadvantage of Argus is its monolithic construction which does not allow for either flexibility in the transaction model or for different languages to be used. 2.3 Camelot and Avalon Camelot [30, 31] is a distributed transaction facility developed at Carnegie Mellon University and ....

William E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems, 11(2):249--283, April 1989.

....opportunities for concurrent execution. More specific definitions of conflicts can be used in object specific conflict tables. Various notions of conflicts that consider the semantics of the operations (and possibly their return values) have been proposed in the literature, including commutativity [Wei88,Wei89], invalidation [Her90] and recoverability [BR87] Conflict tables provided by object designers may use these or any other conflict notion that considers operation semantics to allow more concurrency than the default read write conflicts. Conflict definition by temporal correctness criteria: ....

W. Weihl, "Local atomicity properties: Modular Concurrency Control for Abstract Data Types", ACM Trans. on Programming Languages and Systems, 11(2), 1989.

....define, for a given object, the optimal concurrency control or recovery protocol. For instance, commutativity of operations enables the interleaving (without blocking) of transactions on a given object. Unfortunately, the gain in modularity and specialization may lead to incompatibility problems [Wei 89] Broadly speaking, if objects use different transaction serialization protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local conditions, ....

....protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local conditions, to be verified by objects, in order to ensure their compatibility [Wei 89, Gue 95b] 4.6.3 Replication of Objects and Communications. The communication protocols which have been designed for fault tolerant distributed computing (see Sect. 4.5.3) consider a standard client server model. The straightforward transposition of such protocols to the object model leads to ....

W. Weihl, Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types, ACM Transactions on Programming Languages and Systems, Vol. 11, n o 2, 1989.

....dependency between a and b is assumed. Hence, serializability does not take into account any application specific information. Semantic transaction models have been proposed to take into account the semantics of the operations in defining and resolving value dependencies [GM83, Sch84, Wei88, Wei89, FO89, KS88a, KS88b, Her90] These models assume that transactions can issue operations semantically richer than reads and writes. Conflicts are usually defined by providing an operation compatibility table which specifies all possible value dependencies between transactions. One of the basic ....

W. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems, 11(2), 1989.

....define, for a given object, the optimal concurrency control or recovery protocol. For instance, commutativity of operations enables the interleaving (without blocking) of transactions on a given object. Unfortunately, the gain in modularity and specialisation may lead to incompatibility problems [Weihl 1989]. Broadly speaking, if objects use different transaction serialisation protocols (i.e. serialise the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serialisable. A proposed approach to handle that problem is in defining local conditions, ....

....protocols (i.e. serialise the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serialisable. A proposed approach to handle that problem is in defining local conditions, to be verified by objects, in order to ensure their compatibility [Weihl 1989, Guerraoui 1995] 3.6.3 Replication of objects and communications The communication protocols which have been designed for fault tolerant distributed computing (see Sect. 3.5.4) consider a standard client server model. The straightforward transposition of such protocols to the object model ....

Weihl, W., 1989. Local atomicity properties: modular concurrency control for abstract data types. ACM Trans. on Programming Languages and Systems 11(2).

....define, for a given object, the optimal concurrency control or recovery protocol. For instance, commutativity of operations enables the interleaving (without blocking) of transactions on a given object. Unfortunately, the gain in modularity and specialization may lead to incompatibility problems [Wei 89] Broadly speaking, if objects use different transaction serialization protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local ....

....protocols (i.e. serialize the transactions along different orders) global executions of transactions may become inconsistent, i.e, non serializable. A proposed approach to handle that problem is in defining local conditions, to be verified by objects, in order to ensure their compatibility [Wei 89, Gue 95b] 3.6.3 Replication of Objects and Communications. The communication protocols which have been designed for fault tolerant distributed computing (see Sect. 3.5.3) consider a standard client server model. The straightforward transposition of such protocols to the object model leads to ....

W. Weihl, "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types," ACM Transactions on Programming Languages and Systems, Vol. 11, n o 2, 1989.

....execute an operation on an object, a transaction must acquire a lock on the object in a mode appropriate for the operation. The algorithms ensure a local atomicity property called dynamic atomicity 4 , which means that if every object in a system is dynamic atomic, transactions will be atomic [89]. The algorithms are based on a simple intuition: two operations conflict if they do not commute. For reads and writes, two operations conflict if one of them is a write. For abstract data types, the commutativity definitions are somewhat more subtle. Weihl defined a notion of commutativity ....

....BA: withdraw(j) ok] BA: withdraw(j) no] BA: balance,j] BA: deposit(j) ok] x x BA: withdraw(j) ok] x x BA: withdraw(j) no] x BA: balance,j] x x x indicates that the operations for the given row and column do not commute forward. Figure 6. 1: Conflict relation for the bank account BA Proof: in [89]. 2 The idea of our semantic primitive is to allow different schedules of operations as long as they are equivalent to an agreed linear sequence of operations. Equivalence is specified with respect to the forward commutativity relation. Definition 18 Let M i , 1 i m be the same automata M ....

[Article contains additional citation context not shown here]

W. E. Weihl. Local atomicity properties: Modular concurrency control for abstract data types. ACM Transactions on Programming Languages and Systems, 11(2):249--282, April 1989.

....perspectives [28] pessimistic [19] when the application is expected to have high contention, and optimistic, when the level of contention is supposed to be low. Moreover, policies are distinguished by their synchronization primitives: locking [15] and timestamping [41] Policies are divided [43] in dynamic, in which serialization order is determined from the order in which they access the objects, and static, in which serialization order is based on a predefined total order. The combination of this three aspects generates well know policies as, for instance, two phase locking, which is ....

William Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--282, April 1989.

.... Data Operation Approach In the data operation approach, the specification of isolation guarantees is based on a conflict relation between pairs of semantically rich data access operations that can be invoked by the interactions, where data objects are viewed as instances of abstract data types [SS84, We89, LMWF93]. Allowing such semantically rich operations to invoke further operations on the same or other objects leads to the model of open nested transactions [Gr81, GR93, BSW88,BBG89,Wei91, WS92] which can be traced back to the seminal work on spheres of control by Bjork and Davies [Da78] Typically, ....

Weihl, W.E., Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types, ACM Transactions on Programming Languages and Systems Vol.11 No.2, 1989

....in general, have taken two different approaches to address this problem. Instead of modeling the database as a collection of objects that can only be read or written by transactions, a number of researchers have considered placing more structure on data objects to exploit type specific properties [16, 25, 14, 2, 27, 15, 6]. This approach increases concurrency in the system while remaining within the confines of serializability. The other approach is to reject serializability as the sole correctness criterion and instead use explicit semantics of transactions and databases to permit interleaved executions of ....

....on bank account objects X and Y with initial amounts 100. Transaction T1 : withdraws 10 from account X Transaction T2 : balance of 90 on account X Transaction T2 : balance of 100 on account Y Transaction T1 : deposits 10 to account Y Even if we consider type specific approach [27], i.e. consider the semantics of withdraw, balance and deposit operations, the above execution is not serializable. In a serial execution, T 2 would either see 100 in both accounts X and Y or 90 in account X and 110 in account Y . Suppose now we permit balance operations to return values with ....

[Article contains additional citation context not shown here]

W. E. Weihl. Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types. ACM Transactions on Programming Languages and Systems, 11(2):249--283, April 1989.

....called atomic data objects, are responsible for providing their own synchronisation and recovery mechanisms. It can be shown that if each object involved in a transaction individually satisfies the same local atomicity property, then the transaction as a whole satisfies a global atomicity property [Weihl 1989]. Thus the task of ensuring that transactions behave atomically and are serialisable can be delegated down to the individual atomic objects. The advantages of this approach are that it allows type specific concurrency rules to be exploited at the object level and simplifies the overall design of ....

W. E. Weihl, "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types", ACM TOPLS, April 1989.

....control in transaction systems today. In recent years much research has focused on extending concurrency control methods to take the semantics of the data into account, thus permitting more concurrency by allowing transactions executing commuting operations to run concurrently (e.g. see [8, 13, 16, 15, 14]) Such logical locking can be important to avoid concurrency bottlenecks that arise at frequently updated data items (or hot spots ) For some applications, however, the requirement that noncommuting operations must conflict can hurt performance by restricting concurrency. Recently, ....

....formulated as instances of hybrid systems, which are composed of transaction automata, hybrid object automata and a hybrM controller. The transaction automata represent user written code; they are just the same as in a 4 Weihl defined several local properties for single level transaction systems [16, 15]: the local property defined here generalizes one of those to nested transaction systems. 154 ,4. Fekete et al. Theoretical Computer Science 149 1995 ) 151 178 serial system. See the appendix for a description of serial systems and the definition of correctness based on them. Each hybrid ....

[Article contains additional citation context not shown here]

W.E. Weihl, Local atomicity properties: modular concurrency control for abstract data types, ACM Trans. Programming Languages Systems 11(2) (1989) 249 282.

....control in transaction systems today. In recent years much research has focused on extending concurrency control methods to take the semantics of the data into account, thus permitting more concurrency by allowing transactions executing commuting operations to run concurrently (e.g. see [9, 14, 17, 16, 15]) Such logical locking can be important to avoid concurrency bottlenecks that arise at frequently updated data items (or hot spots ) For some applications, however, the requirement that Supported in part by the Defense Advanced Research Projects Agency (DARPA) under Contract ....

....automata, hybrid objec automata and a hybrid controller. Throughout, we use a totally ordered set of limestamps. In our development, we will not actually need the set to be totally ordered it will be enough that the 3 Weihl defined several local properties for single level transaction systems [17, 16]; the local property defined here generalizes one of those to nested transaction systems. timestamps assigned to sibling transactions be ordered with respect to each other. However, for simplicity we assume the total ordering. A natural choice for 7 is the set of positive integers, or more ....

W. E. Weihl. Local atomicity properties: modular concurrency control for abstract data types. A CM Transactions on Programrain# Languages and Systems, 11(2):249- 282, April 1989.

No context found.

Weihl, W. E., "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types," ACM Trans. on Programming Language and Systems, Vol.11, No.2, 1989, pp.249-283.

No context found.

William E. Weihl. Local Atomicity Properties: Modular Concurrency Control For Abstraction Data Types. ACM TOPLAS, Vol 11, no 2, April 1989. pp 169- 193.

No context found.

Weihl, W. E., "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types," ACM Trans. on Programming Language and Systems, Vol.11, No.2, 1989, pp.249-283.

No context found.

Weihl, W. E., "Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types," ACM Trans. on Programming Language and Systems, Vol.11, No.2, 1989, pp.249-283.

First 50 documents  Next 50

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC