Transaction specification in multidatabase systems based on parallel ...

Transaction Specification in Multidatabase Systems Based on Parallel Logic Programming* Eva Kuehn and Franz Puntigam University of Technology Vienna Institute for Computer Languages E-mail: { eva,franz}@vip.uucp

Abstract The integration of multiple autonomous and heterogeneous database systems into one multidatabase system requires a powerful language which serves both for specifying queries and transactions. In our previous work we proposed a Prolog-based language for specifying queries in multidatabase systems. In this paper, we have introduced a parallel Prologbased query language which serves well as a concurrent specification language for the representation of a recently proposed transaction model called “Flex Transactions’’. We have described the extended language by using examples and have shown its advantages in comparison to existing parallel logic languages. A prototype implementation of this language (VPL Vienna Parallel Logic Language) has been developed a t the University of Technology Vienna and is currently under investigation in the Interbase Project a t Purdue University.

1 Introduction A multidatabase system (MDBS) is a federation of pre-existing database systems (called local database systems, or LDBSs). A MDBS is different, from traditional homogeneous distributed database systems ‘The work is supported by the F W F (Fonds zur Foerderung der Wissenschaftlichen Forschung) project nuniber P7773-PHY; main part of this work has been done while eva Kuehn was on leave at the Department of Computer Sciences a t Purdue University, supported by a grant from the Austrian Government (Kurt-Goedel-Stipendium) and also supported by the Indiana Corporation for Science and Technology (CST), a PYI Award from NSF under grant IRI-8857952, grants from the AT&T Foundation, Tektronix, SERC, Mobil Oil and Bell Northern Research.

TH0372-3/91/0000/0110$01.OO 0 1991 IEEE

Ahmed K. Elmagarmid Indiana Center for Database Systems Department of Computer Sciences Purdue University W. Lafayette, IN 47907 [email protected]

in that LDBSs are autonomous. Local autonomy reflects the fact that LDBSs were designed and developed independently. Autonomy of LDBSs guarantees that local applications previously developed continue to be executable without modification, and ensures the security of LDBSs. The autonomy requirements of LDBSs have profound effects on the execution of global transactions [l].For example, global transactions in MDBSs could be long lived because of delay of subtransactions. In [2], a new transaction model (called “Flex Transactions”) was proposed to cope with the autonomy problems of transaction processing in multidatabase systems. The concept of Flex Transactions is a generalization of traditional transactions. More specifically, it relaxes the atomicity requirement of transactions by allowing multiple commit sets. It also controls granularity of isolation by using compensating transactions and allows flexible execution by associating value functions with global transactions and subtransactions. In this paper, we will discuss the specification of RfDUS transactions. More specifically, we will propose a parallel Prolog language as the specification language for Flex Transactions. We will show how the language could be used as an integration tool for heterogeneous da t,abases. In section 2 we will summarize the concept of Flex Transactions. In section 3 we will give an introduction to parallel logic programming in general and point out why existing languages are not sufficient for our purpose. We will introduce our proposal for a parallel Prolog-based transaction language (VPL Vienna Parallel Logic Language). In section 4 we will demonstrate how VPL may serve for MDBS transaction specification. In section 5 we will describe our

110

MDBS architecture.

Integrated Prolog Multidatabase System [4], [5]), a sequential Prolog system was used as a tool for integrating heterogeneous database systems. It has been 2 Flex Transactions shown that Prolog, extended with a naming concept, may provide all features of a dynamic multidatabase Features of Flex Transactions [2] are reviewed using language like MSQL [6]. So far, in the VIP-MDBS the following example. language only the idea of logic integration dealing Example 2.1 (Travel Agency) Consider a multi- with differences concerning names, structure, scaling, database s y s t e m of a travelservice company. T h e sys- and semantics of data has been shown. To also supt e m consists of local airline, car, and hotel databases. port concurrent execution of transactions, sequential T h e multidatabase s y s t e m allows users t o plan a trip Prolog is not sufficient. In this paper, we will give an introduction of how sequential Prolog can be exby making reservations f o r flights, cars and rooms. tended by parallelisms and explain our proposal for Flex Transactions have the following three fea- a parallel Prolog language for MDBS transactions. tures.

Function replication: In many multidatabase applications, a specific function could be accomplished by more than one local system. For example, the user may leave to the system the choice t o rent a car from Hertz or Avis. This property is called function replication and is incorporated in Flex Transactions to allow flexible composition of global transactions.

3.1

In this subsection we give an overview about parallelism in logic programming languages. In the literature we find two approaches to incorporate parallelism into Prolog:

1. Implicit Parallelism: In the first approach Prolog’s performance is improved by keeping its sequential semantics and trying to prove goals in parallel (for example [7]). The user writes Prolog programs in the usual way and need not be aware of the parallelism.

Mixed transaction: Another observation is that some actions can be semantically undone, even after they are finished. For example, a subtransaction reserving a seat on a flight could be compensated by another subtransaction which cancels the reservation. The fact is taken advantage of by allowing subtransactions to commit before the corresponding global transaction has committed. Global transactions consisting of both compensatable and non-compensatable subtransactions are called mixed transactions.

2. Explicit Parallelism: In the other approach, the user uses explicit language constructs to express concurrency and synchronization. The semantics of such languages differ from the semantics of sequential Prolog and are based on Dijkstra’s Guarded Commands [8]. These languages may be characterized by the concepts of guard, commitment operator, and shared variable data synchronization. A program consists of a finite set of guarded clauses of the form: Head :- Guard I Body. Clauses with same Head form a procedure. These languages support committed-choice OR-parallelism and stream AND-parallelism. All clauses of a procedure try to prove their Guard in parallel (ORparallel). The first clause that succeeds to prove its Guard (i.e. this clause “commits’’1) is selected - all other OR-parallel running clauses of the same procedure are killed; even if this

Value function: In Flex Transactions, a value function may be associated with each global and subtransaction. The typical value function is completion time of the transaction. For example, the reservation of a seat for a flight must be made before the trip. To specify Flex Transactions, a language should be able to represent the above three features. In addition, mechanisms are needed to synchronize execution of subtransactions. For example, a car should not be rented until the flight ticket has been booked.

3

A Parallel Prolog Language

Prolog (Programming in Logic) [3] can be used as a powerful query language. In VIP-MDBS (Vienna

Introduction: Parallelism in Prolog

I I n the rest of the paper we will use “commit” in the sense of “language-comniitnwnt”and explicitly indicate a commitment in V P L and in an LDAS.

111

“&&” (parallel AND operator). The declarachoice does not produce a solution, backtracktive reading of a clause is: “Head is proven, if ing is not possible. Stream AND-parallelism its B o d y can be proven”. means that two or more AND-parallel goals may work on the same solution and may share so-called stream variables by which communica- Transaction and Commitment: A procedure can be defined as a transaction. In particular, it tion and synchronization is possible. The most can be defined as a compensatable or as a nonwell-known languages that belong to this class compensatable transaction. In case of comare GHC (Guarded Horn Clauses), Parlog, and pensatable transactions, this definition implicC P (Concurrent Prolog) [9], [lo]. itly assumes ‘1’ (commitment) at the end of each clause of this procedure. The granular3.2 VPL Vienna Parallel Logic Lanity of committed code can be chosen arbitrarily. ‘‘I” commits to a clause by aborting’ all wage other OR-parallel running clauses of the same For the purpose of transaction specification in MDBS, procedure. Commitment is an atomic action only languages with explicit language constructs for where all side-effects (i.e. bindings to commuconcurrency and synchronization are of importance. nication variables or database updates) become But there are several reasons why existing languages visible and locks on LDBS are released. Comof this class are not sufficient for our purpose. The pensatable transactions can thus be committed main disadvantages of these languages are: earlier - the effects of a committed transaction can be compensated later on. The advantages For a query only one search path is possible are that LDBS are blocked as short as possidue to lack of backtracking. Thus a potentially ble, leading to a higher degree of parallelism existing solution may not be found and without in the MDBS environment. Transactions may extra language extensions there are no means to also be nested. In case of non-compensatable produce several solutions t o a problem. transactions, commitment is propagated t o the Compensation of committed code is not poscalling clause (delayed). Note that necessarily sible. T h e granularity of commitment is exa t the end of each top-level transaction a comactly one clause, it cannot be chosen arbitrarily. mitment has to be assumed. Therefore, no delayed commitment as required for non-compensatable transactions is possible. Back tracking: Within non-commit ted procedures , backtracking is allowed. This is an extended Committed OR-parallelism, as supported by form of backtracking which is able to undo nonthese languages, allows only for parallel execucommitted side-effects. Therefore it is possition of small pieces of code. Especially for the ble to try several solutions - a feature which concept of function replication in Flex Transis essential for DBS. A committed transaction actions a high degree of OR-parallelism would cannot be re-entered by normal backtracking be desirable. but only semantically undone (as specified by the user): in case a goal is to be backtracked, The language we propose differs from existing lanwhich is an already committed transaction, the guages of the second class by the following improvecompensating action for this transaction is acments (for a full language description see [ll]): tivated. Clause Search and Conjunction: VPL is a real Communication and Synchronization: In consuperset of sequential Prolog, this means supcurrent branches, communication and synchroport of language constructs for sequential as nization is supported via so-called “commuwell as parallel execution. In general, a VPL nication variables”. A communication variprogram consists of a finite set of sequential able is designated by cc#”3 and has a “sinand parallel procedures. A sequential procegle assignment” property, i.e. it can be writdure consists of clauses of the form: Head :ten only once. The binding of a communicaB o d y . A parallel (OR-parallelism) procedure 2Aborting - in contrast to killing - undoes side-effects. consists of clauses of the form: Head ::-B o d y . 3 ~clarity ~ rwe will write “s” at any place a communication B o d y consists of goals (viz. subqueries) convariable appears in the program, although this is not necessary. nected by “&” (sequential AND operator) or ~~

112

I

tion variable becomes globally visible after com- MDBS transactions to demonstrate the use of commitment. In contrast t o normal Prolog vari- munication variables. Note, that specifications in the ables, after commitment, this assignment can- parallel language are executable. not be undone on backtracking. VPL supports delayed as well as immediate commitment on Example 4.1 (A simple Flex Transaction withthese variables. For simplification, in this paper out Concurrency) C o n s i d e r a multidatabase syswe only introduce two immediately committing t e m of a travel service company. T h e s y s t e m consists system defined predicates for writing (“”) communication variables. at site s is denoted by s : :db): E.g. #X Y waits until #X has been instantiated to a non-variable term in sit e l ::united another AND- or OR-parallel branch and then /* United A i r l i n e s database at site 1 */ reads the value of #x into a normal Prolog variflights(From,To,FlightNR,Price). able Y. seats(FlightNR,ClientName,Date). Interface to LDBS: A “remote-call” primitive is sit e2::panam provided as the interface between VPL and /* P a n a m Airlines database at site 2 */ a remote (database) system. In fact, this ftab(From,To,FlightNR). remote call is implemented as a specialized prices(FlightNR,Price). control-metacall, but for simplification we only seats(FlightNR,ClientName,Date). describe the interface by means of a remote call. The general format of this primitive Car rental databases: Similarly, car rental databases contain data about car reseris: remote-call(sitename: :systemname, vations. query), where query is passed to the multidatabase interface (MDI) of the LDBS (see figsitel::hert z ure 1). We assume that the MDI is able t o pro/ * H e r t z car rental database at site 1 */ cess or translate Prolog syntax, the query may cars(CarType,CarNr,Price). be given in Prolog and results are passed back book-car(CarNr,ClientName,Date). by Prolog variables. We assume that, for noncancel(CarNr,ClientName,Date). compensatable transactions, all LDBSs provide two phase commit protocol. Therefore each site2: :avis remote call has to be confirmed by sending a /* Avas car rental database at site 2 */ database commit to the LDBS. This is done cars(CarType,CarNr,Price). when either a compensatable transaction or the carient(CarNr,ClientWame,Date). top level transaction finishes (i.e. reaches its cancel(CarNr,ClientName,Date). commitment point). The LDBS remains locked Hotel databases: Hotel databases contain data between remote call and commit. about room reservations.

4

VPL

as the Specification Language for MDBS Transactions

In this section we show by examples how features of Flex Transactions could be specified in the above described parallel Prolog language. We give examples of Flex Transactions that can be defined by partial orderings, precedence predicates and acceptable slates. We show how such a specification can be represented in VPL. Finally we show an example for dependent

site1::hilton /* Hilton hotel database nt szte 1 rooms(Room,RoomPrice).

reserve(Room,Date,ClientName).

site3::sheraton /* S h e r a t o n hotel database at site 3 */ rooms(Room,RoomPrice). bookioom(Room,ClientName,Date). T h e multidatabase s y s t e m allows users t o plan a trip by making reservations f o r flights, cars and rooms. Suppose that a u s e r w a n t s t o reserve a seat

113

r

*/

>' >'

,(' > ' F , '), ('> y, yl s,F , s),,(' s,,' s,F>')}. Let us assume that booking a flight and renting a car are compensatable actions. It is possible to commit the booking of several airline tickets for the execution time of reservation2 (on completion tame the {(s,s)}, non-taken tickets have to be returned), whereas the booking of a car may be also tried in parallel but the first booking immediately cancels other parallel running car transactions. In VPL we define the following (nested) transactions:

on the United airline database, and then rent a car at Avis. The Flex Transaction is defined as follows: the order of the actions (i.e. the partial ordering) bs tunited 4 tauis; the precedence predicates are ppunited = true, and ppauis = (xunited = s). The tauis)= set of acceptable states is where S = success, F = failure, N = not been submitted, E = currently executing, and Y = S, F, N or E. The Flex Transaction of this example can be mapped into VPL as follows: transaction reservationl(N,D,F,T,FP,CP) :remote-call(sitei::mited, flights (F,T,Fn,FP) & insert(seats(Fn,N,D))) & remote-call(site2::avis, cars(CT,Cn,CP) & insert(carient(Cn,N,D))).

transaction reservation2(N,D,F,T,P,C) :( bookSlight(N,D,F,T,FP) && rent -car(N ,D,C ,CP ,S) && reserve_hotel(N,D,HP) ) & P is FP + CP + HP.

transaction book-flight(N,D,F,T,P) ::book-united(N,D,F,T,P). Partial ordering is represented by the sequential transaction book-flight(N,D,F,T,P) : : book-panam(N,D,F,T,P). AND operator ("&") between the two remote calls; precedence predicates are implicitly fulfilled by the logical sequence of predicates: there are no precon- transaction book-mited(N,D,F,T,P) :remote-call(site1: :united, ditions for the remote call to the United database, flights(F,T,Fn,P) & whereas the precondition for the remote call to the insert(seats(Fn,N,D))). Avis database is a successful booking in the United compensate book-mited(N,D,F,T,P) :database. A failure of the remote call to the United rem0t exall( s it e I: :m i tad, database would introduce backtracking (in the examflights (F,T,Fn,P) & ple there is no alternative - and therefore cause the delete(seats(Fn,N,D))). failure of the whole transaction) and avoid the remote call to the Avis database. The set of acceptable transaction book-panam(N,D,F,T,P) :states is also represented implicitly by the declarative remote-call(site2::panam, reading of the transaction: reservation1 is proven ftab(F,T,Fn) & (i.e. accepted) if both United and Avis booking are prices (Fn,P) & successful. insert(seats(Fn,N,D))). compensate book-panam(N,D,F,T,P) :Example 4.2 (Mixed Transaction, Function remote_call(site2::panam, Replication) We will use the databases from the ftab(F,T,Fn) & previous example. Suppose that a user wants to delete(seats(Fn,N,D))). travel from New York to Chicago b y plane. In Chicago the user needs a rented car and a room transaction rent-car(N,D,C,P,sitei::hertz) : : reservation - preference Hilton and then Sheraton. remote-call(sitel::hertz, All transactions may run in parallel, except that cars(C,Cn,P) & the booking in Hilton must be tried before the bookinsert(book-car(Cn,N,D))). ing in Sheraton. The partial ordering is defined transaction rent_car(N,D,C,P,site2::avis) : : by t h i l t o n 4 tsheraton; the precedence predicates are remote-call (site2 : :avis, ppunited = true, pppanam = true, Ppauis = true, cars(C,Cn,P) & pphertz = true, pphilton = true, and ppsheraton = insert(carient(Cn,N,D))). (xhilton = F ) . The set of acceptable states compensate rent-car((N,D,C,P,S) :is ( t u n i t e d , t o a n a m , thertt t a u i s thilton, t s h e r a t o n ) = remote-cdl(Site, cars(C,Cn,P) &

114

insert (cancel(Cn,N ,D> )

.

Let US now assume that the transaction at Avis is successful. As rentsax is a compensatable transaction, the Avis transaction can commit (in VPL and the LDBS) and abort the OR-parallel Hertz transaction. If the United transaction succeeds and commits (in VPL and the LDBS), then the book-flight transaction also succeeds. But book-flight is not compensatable and does not abort the OR-parallel book-panam transaction. Therefore it is possible that both the United transaction and the Panam transaction commit (in VPL and the LDBS). If the Hilton transaction also succeeds, then the total price may be computed as the sum of the Panam or United ticket price, the Avis car price and the Hilton room price. Let us assume that the Panam ticket is ~ e l e c t e d .Now ~ reservation2 (which is our top level transaction) reaches its commitment and sends a commit message to the Hilton transaction still executing. When the second clause of book-flight is selected (the Panam flight), the United transaction is automatically compensated. Reservation2 succeeds.

transaction reserve-hotel(N,D,P) :remote-call(sitel::hilton, rooms(R,P) & insert(reserve(R,D,N))). transaction reservehotel(N,D,P) :remote_call(site3::sheraton, rooms(R,P) & insert (bookioom(R,N ,D)) 1.

When reservation2 is activated, 5 database transactions may run in parallel: booking a flight, renting a car and reserving a room in Hilton may run AND-parallel, where both booking a flight and renting a car each consists of two OR-parallel running transactions. If the transaction at Hilton fails, the Sheraton transaction is started. Partial ordering is represented by using a sequential clause search (":-") for the definition of the bookhotel transaction. As there are no partial orderings between other transactions, these may run parallel (parallel clause search (": :-") in the definition of the book-flight and rent-car transactions and parallel AND ("&&") in the definition of reservation2). Precedence predicates are implicitly Example 4.3 (Transaction with Value Funcfulfilled: except for the Sheraton transaction there tions) Let us assume that a user wants to book a are no preconditions. The preference Hilton then Pight either at the united.0~at the panam database. Sheraton is represented as described above. The set But there are different ofice hours for the databases. of acceptable states is represented by the declarative This can easily be expressed in V P L b y means of a reading of the transactions: reservation2 is a suc- time constraint (actualtime(TM) is a system defined cess if one of the United and Panam transactions and primitive which returns the actual time). one of the Avis and Hertz transactions succeeds - intransaction reservation3(NDD,F,T,P) : : dependently of the state of the three others - and actualtime(TM) & if a room is booked either at Sheraton or at Hilton. TM greater 8 am L Sheraton is tried only if Hilton is a failure. TM less 5 pm & Let us discuss some possible executions: remote-call(sitei::united, flights (F ,T,Fn ,P) & 0 If there is no hotel room available at all, insert(seats(Fn,N,D))). all AND-parallel rent-car and book-flight transactions are aborted. If for example Avis transaction reservation3(NDD,F,T,P) ::actualtime(TM) & has already committed (in VPL and the LDBS), TM greater 6 am & then the Avis transaction is compensated by TM less 11 am & means of the corresponding compensating acremote-call(site2::panam, tion. Reservation2 fails. ftab(F,T,Fn) & prices(Fn,P) & 0 If there is no flight available, then the insert (seats(Fn,N,D) ) 1. reservelotel and rent-car transactions are canceled. As room booking is a nonFrom 6 am to 8 am flights may be booked in the compensatable action, neither Hilton nor Sher- panam database. From 8 a m to 11 a m flights may be aton transaction may have yet committed and 4The system selects one of them nondeterministically. The thus may be undone by means of backtracking. transaction could be rewritten so that the user decides which Res ervat ion2 fails. one is taken.

115

booked a t any one of the two databases. From 11 a m to 5 pm only the united database has business hours. From 5 p m t o 6 a m no flights may be booked a t all. The following is an example for dependent transactions:

Example 4.4 (Swap values between two databases) Let u s a s s u m e t w o databases, dbA at site1 and dbB at site2. T h e u s e r w a n t s t o read a value (X) f r o m database dbA and write it t o database dbB and within t h e s a m e transaction read a value (Y) f r o m database dbB and write it into database dbA.

I n teroperabili t y- C omponen t Integration-Directory

t

t

transaction swap :tai(#X,#Y) && ta2(#X,#Y). transaction tai(#X,#Y) :remote-call(site1: :dbA, read(VX) & #X VY & write(VY1). transaction ta2( #x, #Y) :remote-call( site2: :dbB, read(VY) & #Y vx & write(VX1).

Figure 1: System Architecture tem. The resulting system combines features found in both the DOL (Distributed Operation Language) based architecture [12] and VIP-MDBS architecture [5] (see figure 1). In the system, the integration directory contains static information for the integration of heterogeneous systems. The information is used by the interoperability component which implements VPL statements. A query is decomposed, translated and then submitted to an MDI ( a multidatabase interface) of each LDBS, which is in charge of the execution of the subquery and sends the result back to the interoperability component.

Communication is achieved by communication variables #X and #Y. Both transactions tal and ta2 may run in parallel. First they read a value from their corresponding LDBS. Then this value is communicated to the other transaction (#X Vx, in which both wait until the communication variable receives a value). Finally the Conclusions received value is written to the LDBS. When the swap 6 (i.e. the top level) transaction finishes, it commits In this presentation we have shown the use of a paralboth tal and ta2. lel Prolog language that is suited for specification of MDBS transactions. In particular, the representation 5 Proposed Architecture of Flex Transaction specifications as executable VPL (Vienna Parallel Logic Language) queries has been In this section, we briefly describe the proposed ar- demonstrated. This language has been designed as chitecture for a multidatabase system currently be- a transaction language in a heterogeneous environing prototyped a t the University of Technology Vi- ment. Its main advantages are that subtransactions enna. The interface showing both features of a mul- may be committed earlier i f a compensation action for tidatabase language (e.g., MSQL) and support for them exists (i.e. a semantical undo-operation). This powerful transactions (e.g., Flex Transactions) is be- gives way for a higher degree of parallelism in the ing incorporated on top of a new multidatabase sys-

116

MDBS environment, as locks on autonomous LDBS may be released before the completion of the whole global MDBS transaction. Effects of committed actions can be compensated. Therefore, the concept of function replication in Flex Transactions can easily be performed by allowing parallel running transactions that try to acquire the same goal. Abortion and compensation of superfluous work is automatically done by the language. It has already been shown that a Prolog-based query language is a superset of MSQL. It is our belief that having an interface that couples the features of MSQL with Flex Transactions will prove to be a great asset towards building multidatabase systems.

References Dl

Du Weimin, Elmagarmid Ahmed, Leu Yungho & Osterman Shawn, 'Effects of Local Autonomy on Global Concurrency Control in Heterogeneous Distributed Database Systems', Proceedings of the 2nd International Conference on Data and Knowledge Systems for Manufacturing and Engineering (DKSME), October 1989.

PI

Elmagarmid A. K., Leu Y., Litwin W. & Rusinkiewicz M., 'A Multidatabase Transection Model for InterBase', Proceedings of the 16th V L D B Conf., Australia 1990.

[31

Sterling L. & Shapiro E., The A r t of Prolog, MIT Press, 1986.

[41

Kuehn eva & Ludwig Thomas, 'Extending Prolog by Multi Database Features', European Teleinformatics Conference - EUTECO'88 on Research into Networks and Distributed Applications, Vienna, Austria, April 1988.

I51

Kuehn eva & Ludwig Thomas, 'VIP-MDBS: A Logic Multidatabase System', Proceedings of the International Symposium on Databases in Parallel and Distributed Systems, IEEE Computer Society Press, Austin Texas, Dec. 1988.

[GI

Litwin Witold, Abdellatif A., Nicolas B., Vigier Ph. & Zerounal A., 'MSQL: A Multidatabase Manipulation Language', Information Science, A n International Journal, Special Issue on DBS, June 1987.

[7]

Warren David H.D., 'Or-Parallel Execution Models of Prolog', TAPSOFT'87, Proc. of the Int. Conf. on Theory and Practice o f Software Development, Pisa, Italy, Springer-Verlag, March 1987.

I['

Dijkstra E. W., Guarded commands, nondeterminacy, and formal derivation of programs, Comm. A G M 18, 8, August 1975.

[91

Shapiro Ehud, Concurrent Prolog, Collected Papers, Vol. l & 2, The MIT Press, 1987.

[lo]

Shapiro Ehud, The Family of Concurrent Logic Programming Languages, ACM Computing Surveys, Vol. 21, No. 3, September 1989.

[111

Kuehn eva & Puntigam Franz, 'The VPL Vienna Parallel Logic Language', T R - f85-91-1, University of Technology, Vienna, Jan. 1991.

[121

Rusinkiewicz Marek, Osterman Shawn, Elmagarmid A b e d K. & Loa Kanchei, 'The Distributed Operation Language for Specifying Multi-System Applications', Proceedings of the 1st Int. Conference on Systems Integration, 1990.

117