DECdta - Digital's Distributed Transaction Processing Architecture. Digital VAX 6000, VAX TPC Benchmark A, VAX DECtp, VAX DECdta, VAX ACMS, VAX Server, VAX ft, VAX 9000, VAX cluster, VAX KODA
Below you will find brief information for transaction processing system VAX ACMS, transaction processing system VAX DECintact, transaction processing system VAX DECdtm, transaction processing system VAX Rdb/VMS. Digital's transaction processing systems are integrated hardware and software products that operate in a distributed environment to support commercial applications, such as bank cash withdrawals, credit card transactions, and global trading.
Advertisement
Advertisement
DECdta
-
Transaction Processing
Architecture
Philip
A.
Bernstein
William
3:
Emberton
Vijay
Trehan
(DECtp)
prodilcts
The
arcigitecture allows ens}) distributiotz of
LIECtp
products. rnanagernent is the inain fci~zction that ties DECdta modules together It ensures that application programs, database systems, and other resotrrce rnaitclgers inler- operate reliablj~ a distributed system.
Transaction processing
(Tr)
is the activity of execut- ing requests to access shared resources, typically databases. A computer system that is configi~retl execute TP applications is called a
TP system.
A transaction is an execution of a set of opera- tions on shared resources that has the following properties:
Atomicity. Either all of the transaction's opera- tions execute, or the transaction has no effect at all.
Serializability. The set of all operations that exe- cute on behalf of the transaction appears to execute serially with respect to the set of opera- tions executed
by
every other transaction.
Durability, The effects of the tranbaction's oper- ations ;ire resistant to fa~lurcs
A transaction terminates by executing the com-
nit or abort operation. <:oniniit tells the system to install the effect of the transaction's operations permanently. Abort tells the system to undo the effects of the transaction's operations.
For enhanced reliability ant1 availability, a
TP application uses transactions to execute requests.
(from a display, computer, or other device), exe- ciltes one or more transactions t o process the request, and possibly sends a reply to the origina- tor of the request or to some other party specified by the originator.
1'P applications are essential to the operation of many intlustries, such as finance, retail, health care, transportation, government, communications, and manufacturing. Given the broatl range of appli- cations of
TP,
Digital offers
;I
witle variety of protl- ucts with which to build I'l'systenls.
TP products. The goal of 1)ECtp is to offer an inte- grated set of hiirdware and softwarc products that supports the tlevelopment, execution, and management of
TP applications for enterprises of all sizes.
DECtp systems inclutle software components that are specializetl for
TP, notably TI' monitors such as the
ACMS
and DECintact TP monitors, and transaction managers sucl.1 as the l)E<;cltm trans- action manager." DECtp systems ;11so require the integration of general-purpose hardware products
(processors, storage, communications, and termi- nals) and software products (operating systems, database systems, ant1 communication gatcw;lys).
These products ;ire typically intcgratecl as sliown in Figure
1.
TP MONITOR
DATABASE SYSTEMS FORMS MANAGER
COMMUNICATION SYSTEM OPERATING SYSTEM
I
PROCESSORS
1
MASS STORAGE
I
NETWORK
I
~~~~T~~
I
Figure
I
TP APPLICATION
Lnyeritzg
rf
Prodt~uls a
TP
Applic~ition
Sc~/>/>ort
DECrlta
-
Applications on I>E<:tp systems can be designed using a client/server paradigm. This p;~radigm is especially usefill for separating the work of prepar- ing a request from t1i;it of running transactions.
Request prep;ir;ltion can bc done by a front-end system, that is, one that is close to the user, in which processor cycles are inexpensive and inter- active feedback is e:isy to obtain. 7'r;ins;iction execution c;in be done by a larger back-end sys- tem, that is, one th;~t manages 1;irge cl;~t;tbases
;und may be far from the user. Back-end systems may then~selves be distributed. Each back-end system manages
3
portion of the enterprise that make heaw use of the database on that back end. DECtp products ;Ire modul;irized to ;lllow e:isy distribution across front ends and back ends, which enables them to support client/server style al>plications. I)E<:tp systems thereby simplify pro- gramming and reconfiguration in a distributed system.
Digital's Distributed Transaction l'rocessing
Architectilre (I)E<;dt;i) defines the modularization and distribution structure that is common to DICtp products. Distributetl transaction management is the main function that ties this structure together.
This paper describes the DECdta structure and explains how l)E<:tlta components are integrated by distributed transaction management.
Current versions o f
DECtp products implement most, but not all, modules and interfaces in the ture and products will be filled over time. DECtp products that currently implement DECdta compo- nents are referenced throughout the paper.
TP
Application Structure
By analyzing
T'P npplic;~tions, need arises for separate DECdta components.
A
typical
TP application is structured as follows:
Step
1 :
The client application interacts with a user (a person or m;ichine) to gather input, e.g., using a forms manager.
Step
2: l'he client maps the user's input into a request, that is,
a
message that asks the system to perform some work. The client sends the request to a server application to process the request.
A request may be direct or queued. If direct, the client expects a server to process the request right away. If queued, the client deposits the request in a queue from which a server can declueue the request later.
Step
3:
A server processes the request by executing one or more transactions. Each trans action may a. Access multiple resources b.
Cal I programs, some of which may be remote c. Generate requests to execute other transactions d. Interact with
;I user e. Return
;I reply when the transaction finishes
Step 4: If the transaction produces a reply, then the client interacts with the user to display that reply, e.g., using a forms manager.
Each of the above steps involves the interaction of two or more programs. In many cases, it is desir- able that these programs be distributed.
To
dis- tribute them conveniently, it is important that the programs be in separate components. For exam- ple, consider the following:
The presentation service that operates the dis- play and the application that controls which form to display may be distributed.
One may want to off-load presentation services and related functions to front ends, while allow- ing programs on back ends to control which forms ;ire tlisplayed to users. This capability is useful in
Steps 1, 3d, and 4 above to gather input and display output. To ensure that thc presenta- tion service ant1 application can be distributed, the presentation service should correspond to a separate I)E<:dta component.
The clicnt application that sends a request and the server application that processes the request may be distributed. The applications may com- municate throilgh a network or
;I queue.
In Step 2, front-end applications may want to send requests directly to back-end applications or to place requests in queues that are managed on back ends. Similarly, in Step 3c, a trans- action,
T,
transaction, where the queue resides on a dif- ferent system than
T.
To maximize the flexibil- ity of distributing request management, request management should correspontl to a separate
DECdta component.
Two transaction managers that want to run a commit protocol may be distributecl.
For a transaction to be distributed across different systems, as in Step 3b, the transaction management
D i g i t a l TecI~nical
Vol.
.T
!\b. 1 Wiriier 1991
Transaction Processing, Databases, and Fault-tolerant Systems
services must be distribl~ted 'l'o ensure that each transaction is ;ttomic, the tr;ins;iction m;inagers o n these sjrstems must control tr;ins;tction commit- ment using
;I common coninlit protocol.
R) plic;ite m;itters, tlierc is more tll:in o n e widely ~lsetl protocol h)r transaction co~tirnitment. To t h e extent possible,
;i system shoulcl ;illow interopera- tion of these protocols.
To ensure that transaction ni;in;igers can be dis- tributed, t h e tr:lns:lction m:in;lgcr s h o l ~ l d be a c o m p o n e n t of I>E<:dt;i.
Ti) ensure th;it they can interoperate, their tr;ins;tction protocol s h o ~ ~ l c l also be in DE<:tlta. To ensure t1i;it tlifferent c o m m i t protocols c;in be supportetl, the Ixirt of tr;tnsnction management t1i;it defines the protocol for inter- action with remote tr;ins;iction ni:in;tgers should be separated from t h e p;irt that coordinates trans- action execution ;icross local resources. In t h e
DECdta architecture, the former is c;ll let1 a cornmu- nication man;igcr, ant1 the 1;ttter is calletl a trans- action maniiger.
Interoperation of transaction m;in;igers and processes. Altern;itiveljf, several l)~(:dt;t conipo- nents m;ty be implementetl as
;I single soft\v;tre coniponent. For ex;uiiple, an opcr;lting system o r
TP monitor typic;tlly offers the lacilitics of more than o n c l>E<:dta component.
An ;ipplication program is :in). progr:im that uses services of
I)E<:tlt;i components
A resource manager rn:in:tges resources thxt sup- port tr;lnsaction semantics.
A termination (i.e., coniniit :inti ;il>ort).
A communication m:in;tger supports
;I trims- action coliimuriic:ttioli protocol between
'1'1' systems.
A penclent interactions with
;I prcscnt;ttion clcvicc. requests t o execute tr:lns;lctions. affects the modularization of 1)M:tlta components.
A
tr;insaction ni;~y involve tlit'f?rent types of may update data that is managed by different tlatabase systems.
To control transaction conimitnient, tlic. (ransac- tion manager must intcr;ict with clifferent resource managers, possibly supplied h y different vendors.
This requires that resource m;tn;tgcr.; be separate components of I)t.:(:tlta.
The DECdta Architecture
Having seen w h e r e the need for I>E<:clt:i compo- nents arises, w e are now reatly to describe t h e tions o f ;tnd interfaces to e;icli coniponent.
most
I)E<:t!ta intertaces ;ire plrblic. Some of the clartls bodies and industry consortia; i.e., they are
" o p e n " interfaces. Others :ire controlled solely by
Digital. I)E<:dta intcrfacrs :lncl protocols will be published and ;iligned with inclustry stanclartls, as appropriate.
I>E<:dta c o m p o n e n t s ;Ire :ibstr;ict entities, They d o not necessarily map one-to-one to hardware components, softw;ire c o m p o n e n t s (e.g., pro- grams o r proclucts), o r execution environments
(e.g.,
;I
single-threatletl process, a multithreaded process, o r an operating system service). R;itIier, a
DECdta component may be implemented as multi- and distributed s).stem pl;ttforni, ;tntl ;Ire not speci- fic to TI', 2s sho\vn in
Figure
2.
P ~ " o ~ ~ G I T ~ z
We use the term application progr:tm t o nic;ln
:I program that uses the scrviccs provitlctl by other
I>E<:dta c o m p o n e n t s . An :tpplic:ition lxogr;ini could be a customer-written progr;trn, a 1a)reretl product, o r a UT.(:tlta component. tiators and transaction servers. A request initi~ttor is
;I
DECdta c o m p o n e n t that prcp;ircs ancl s ~ r b l n i t s a request for t h e execution of a transaction.
'Ti)
acts with a presentation man;iger t1i;it provides :in interkice t o
;I device, such 21s
;I terniin:il,
n
work- station, a digital private br;lncli exchange, o r an automated teller ni;~cliine.
A transstction server c;tn clcni;irc;itc
;I trans- action, inter;ict with o n e o r more resource ni;in- agers t o access recover:tble resources o n behalf of t h e transaction, invokc o t h e r tr:lnsaction servers, ant1 respontl t o calls from reclucst initiz~tol-s.
For a simple recluest,
21 tr;tns;tction server receives t h e request, processes it, ;lncl optionally returns a reply t o the request initi:itor. A conver- sation;il request is likc
;I simple request, except that while processing t h e request, t h e trans;lction
DECdta
-
APPLICATION PROGRAMS
I
TRANSACTION SERVER
I
TP SERVICES
REQUEST
PRESENTATION
MANAGER
REQUEST COMMUNICATION
MANAGER
. . . . . . . . . . . . . . . . . . . . . . . . .
OPERATING SYSTEM AND DISTRIBUTED SYSTEM SERVICES
DISTRIBUTED DISTRIBUTED
~~~1~~
NAME SERVICE TIME SERVICE
AUTHENTICATION
COMMUNICATION
MANAGERS server exchanges o n e o r m o r e messages with t h e
In principle, a request initiator could ;tlso execute tr;~nsactions
2).
That is, the dis- servers is for clarity only, and does not restrict an application from performing request initiation func- tions in a transaction. Architecturally, this amounts t o can exe- cute in a transaction server
Resource
Manager
A resource manager performs operations on shared resources. We arc especially interested in recover- able resource managers, those that obey trans;tction semantics. In particular,
a
recoverable resource manager undoes a transaction's 11pd;ltes to t h e resources if t h e transaction aborts. O t h e r recover- able resource manager activities in support of trans- actions are described in the next section. In the rest o f this paper, w e use "resource manager" t o mean
"recoverable resource manager."
In a
TP system, t h e most c o m m o n kind of resource manager is a database system. Some pre- may also be resource managers.
A
resource man- ager may b e written by a customer, a third party, o r Digital.
Each resource manager type offers a resource- manager-specific interface that is used by applica- resources managed by the resource manager.
A
des- cription of these resource manager interfaces is outside the scope of DECdta. However, many of these resource manager interfaces have architec- tures defined by industry standards, such as
SQL
(e.g., the
VAX
RdbrVMS product),
CODASYL
data man- ipulation language (e.g., the
VAX DBMS
product), and
COBOL
file operations (e.g.,
RMS
in the
VMS
system).
One type
of
resource manager that plays a spe- cial role in
TI-' systems is a queue resource manager.
It manages recoverable queues, which are often used t o store requests.' It allows application pro- grams t o place elements into queues and retrieve them, s o that application programs can communi- cate even though they execute independently and asynchronously. For example, an application pro- gram that sends elements can communicate with o n e that receives elements even if t h e two applica- tion programs are not operational simultaneously.
This communication arrangement improves avail- ability and facilitates batch input of elements.
Transaction Processing, Databases, and Fault-tolerant Systems
A queue resource manager interface supports such operations as open-queue, close-queue, enqueue, dequeue, and read-element. The
ACMS and DECintact
TP monitors both have queue resource managers as components.
Transaction Manager
A
transaction manager supports the transaction abstraction.
It is responsible for ensuring the atom- icity of each transaction by telling each resource manager in a transaction when to commit. It uses a two-phase commit protocol to ensure that either all resource managers accessed by a transaction commit the transaction or they all abort the trans- action.' To support transaction atomicity, a trans- action manager provides the following functions:
Transaction demarcation operations allow appli- cation programs or resource managers to start and commit or abort a transaction. (Resource managers sometimes start a transaction to exe- cute a resource operation if the caller is not executing a transaction. The
SQL standard requires this.)
Transaction execution operations allow resource managers and communication man- agers to declare themselves part of an existing transaction.
Two-phase commit operations allow resource managers and communication managers to change a transaction's state (to "prepared," "com- mitted," or "aborted").
The serializability of transactions is primarily the responsibility of the resource managers.
Usually, a resource manager ensures serializability by setting locks on resources accessed by each transaction, and by releasing the locks after the transaction manager tells the resource manager to commit. (The latter activity makes serializabil- ity partly the responsibility of the transaction manager.) If transactions become deadlocked, a resource manager may detect the deadlock and abort one of the deadlocked transactions.
The durability of transactions is a responsibility of transaction managers and resource managers.
The transaction manager is responsible for the durability of the commit or abort decision. A resource manager is responsible for the durability of operations of committed transactions. Usually, it ensures durability by storing a description of each transaction's resource operations and state changes in a stable (e.g., disk-resident) log. It can later use the log to reconstruct transactions' states while recovering from a failure.
A
detailed description of the DECdta transaction manager component appears in the Transaction
Manager Architecture section.
A
communication manager provides services for communication between named objects in a TP systcm, such as application programs and trans- action managers. Some communication managers participate in coordinating the termination of a transaction by propagating the transaction man- ager's two-phase commit operations as messages to remote communication managers. Other com- munication managers propagate application data and transaction context, such as a transaction iden- tifier, from one node to another. Some do both.
A
TP system can support multiple communica- tion managers. These communication managers can interact with other nodes using different com- mit protocols or message-passing protocols, and may be part of different name spaces, security domains, systcrn management clomains, etc.
Examples are an
IBM
SNA
~ t ~ 6 . 2 manager or an
ISO-TP communication manager.
By supporting multiple communication man- agers, the DECdta architecture enhances the inter- operability of
TP systems. Different
TP systems can interoperate by executing a transaction using dif- ferent commit protocols.
A
communication manager offers an interface for application programs to communicate with other application programs. Different communica- tion managers may offer different communication paradigms, such as remote procedure call or peer- to-peer message passing.
A
communication manager also has an interface to its local transaction manager.
It uses this inter- face to tell the transaction manager when a trans- action bas spread to a new node and to obtain information about transaction commitment, which it exchanges with communication managers on remote nodes.
Presentation Manager
A
presentation manager provides an application program with a record-oriented interface to a pre- sentation device. Its services are used by applica- tion programs, usually request initiators. By using presentation manager services, instead of directly accessing a presentation device, application pro- grams become device independent.
Vol.
3
No.
1 Winter
1991
Digital Technical Journal
DECrlta
-
Processing Architecture
A forms manager is o n e type of presentation manager. Just as a database system supports opera- tions t o define, o p e n , close, and access databases, a forms manager s u p p o r t s operations t o define, enable, disable, and access forms. A form includes t h e definition of t h e fields (with different attributes) that make irp t h e form. It ;ilso includes services t o map t h e fielcls into device-independent application records, t o perform data validation, and to perform data conversion t o map fields o n t o device-specific frames.
O n e presentation manager is Digital's I)E<:forms forms management product. The IlE<:forms prod- uct is the first implementation of the ANSI/ISO
Forms Interface (Management Systems standard
(CODASM.
FIMS).'
Request Manager
A request manager provides services t o authenti- cate t h e source of requests (a user and/or a presen- tation device), t o submit requests, ant1 t o receive replies from t h e execution of requests. It s u p p o r t s such operations as send-request and receive-reply.
Send-request must provide t h e identity of t h e source device, t h e identity of the user who entered gram t o be invoked, and t h e input data t o t h e program.
A
request manager can either pass t h e request directly t o an application program, o r it can store requests in a queue. In t h e latter case, another request manager can subsequently schedule t h e request by dequeuing t h e request and invoking an application program. The
ACMS
System Interface is
;In example of an existing request manager inter- face for direct requests. The
ACMS
Queued Trans- action Initiator is an example of a request manager that schedules queued requests.'
Transaction Manager Architecture
DE<:dta c o m p o n e n t s are tied together by t h e trans- action abstraction. Transactions allow application programs, resource managers, request managers
(indirectly through queue resource managers), and communication managers t o interoperate reliably.
Since transactions play an especially important role in t h e DECdta architecture, w e describe t h e transaction management functions in m o r e detail.
The DECdta architecture includes interfaces between transaction managers and application programs, resource managers, and communication managers, as s h o w n in Figure
3.
It also includes a
I
APPLICATION
PROGRAM
6
1
OTHER
COMMUNICATION
MANAGERS
Figure Trcinsclctior? il.1~1nclgc.r
transaction manager protocol, whose messages are propagated by commilnication managers. This p r u tocol is used by Digital's I>E<:dtm distributed trans- action manager.'
From a transaction manager's viewpoint, a trans- action consists o f trans;tction demarcation opera- tions, transaction execution operations, two-phase commit operations, and recovery operations.
T h e transaction demarcation operations a r e issued by an application program t o a transac- tion manager and inclutle operations to stArt and either end o r abort a transaction.
Transaction execution operations are issued by resource managers ant1 communication man- agers t o a tr;ins;~ction manager. They include operat ions
-
For a resource manager o r communication manager to join an existing transaction
- action manager t o start a n e w branch of a transaction that already exists at another node
Two-phase c o m m i t operations are issued by a transaction manager to resource managers, communic;ition managers, and through com- munication managers t o other transaction man- agers, and vice-versa. They include operations
-
For a transaction manager t o ask a resource manager o r commilnication manager t o pre- pare, commit, o r abort a transaction
- For a resource manager o r cornmunica- tlon manager t o tell a transaction manager w h e t h e r it has p r e p a r e d , c o m m i t t e d , o r aborted a transaction
I 5
Digital 'li~cbnicul
I4)I
.i
I I r ' i ~ ~ r o .
Transaction Processing, Databases, and Fault-tolerant Systems
-
For a communication manager to ask a trans- action manager to prepare, commit, o r ;tbort
;I transaction
-
For a transaction manager to tell a commu- nication manager whether it has prepared, committecl, o r aborted a transaction
Recovery operations are issued by a resource manager t o its transaction manager to deter- m i n e t h e state of a transaction (i.e., committed o r aborted).
In response t o a start operation invoked by an application program, the transaction manager clis- penses a unique transaction identifier for t h e trans- action. The transaction manager that processes the start operation is that transaction's h o m e trans- action manager.
When an application program invokes an opera- tion supported by a resource manager, the resource manager must find out tlie transaction identifier of the application program's transaction.
This can happen in different ways. For example, the application program may tag the operation with the transaction identifier, o r the resource manager may look u p the transaction identifier in the appli- cation program's context. When a resource man- ager receives its first operation on behalf of a transaction,
T, it mustjoin
T, meaning that it must tell a transaction manager that it is a su6orcZinnte for
T.
Alternatively, t h e DECdta architecture sup- ports a model in which a resource manager may ask t o be joined automatically to all transactions man- aged by its transaction manager, rather than asking t o join each transaction separately.
A
transaction,
T, spreads from o n e node, Node
1, t o another node, Node 2, by sending a message
(through a communication manager) from an appli- cation program that is executing
T
at Node
1 t o an application program at Node 2. When
T
a message from Node 1 t o Node
2 for t h e first time, t h e communication managers at Node
1 and
Node
2 must perform br;inch registration. This function may be performed automatically by the communication managers. Or, i t may be done man- ually by the application program, which tells the communication managers at Node 1 and Node 2 that the transaction has spread to Node 2. In either case, the resiilt is as follows: the communication manager at Node 1 becomes the suborclinate of the transaction manager at Node 1 for
T and the supe- rior of t h e communication manager at Node
2 for
T; and the communication manager at Node 2 becomes t h e superior of t h e transaction manager at Node
2 for
T.
This arrangement allows the com- mit protocol between transaction managers to be propagated properly by communication managers.
After the transaction is done with its application work, t h e application program that started transac- tion
T may invoke an "end" operation ;it the home transaction manager to cornnzit
T.
'I'his causes the h o m e transaction managcr to ask its subordinate resource managers and communication managers t o try t o commit
T.
The transaction manager does this by using a two-phase commit protocol. The protocol ensures that e i t h e r all subordinate resource managers commit the transaction o r they all abort the transaction.
In phase
1, the home transaction manager asks its subordinates for
T toprepctre
T.
A
subordinate p e p a r c s
T by doing what is ncccssary t o guarantee that it can either commit I ' o r abort'rifasked t o d o s o by its superior; this guarantee is valid even i f it fails immediately after becoming prepared. To prepare
T,
Each subortlinate for 'I' recursjvely propagates the prepare request to its subordinates for
T
Each resource manager subordinate writes all of
'T's upclatcs to stable storage
Each resource manager and transaction manager subordinate writes a prepare-record t o stable storage
A
subordinate for
T replies with a "yes" vote if and w h e n i t has completetl its stable writes and all of its subordinates for
T have voted "yes"; other- wise, it votes "no." If any subordinate for
T does not acknowledge t h e request t o prepare within t h e timeout period, then t h e h o m e transaction man- ager aborts
T; t h e effect is t h e same as issuing an abort operation.
In phase
2, when the h o m e tr;lnsactjon manager has received "yes" votes from all of its subortlinates for
T, it decicles to commit
T.
It writes a commit record for
T to st;tble storage ;ind tclls its subordi- nates for
T to c o m m i t
T.
Each subordinate for
T writes a commit recortl for
,r to stable storage ancl recursively propagates the commit request to its subordinztes for T. subordinate for T replies with an acknowletlgment i f and when it has c o m n ~ i t t e d the transaction (in the case of a resource manager suborclinate) ancl has received ack~lowledgrnents from all subordinates for
T.
When the home trans- action manager receives acknowledgments from all of its subordinates for
T, t h e transaction commit- ment is complete.
k 1 .
.3
I W i ~ r t e r Digital Techrrical Journal
LlEC~/tcr- Digitul's Distributed Transaction Processing Arcbitecture
To recover fro111 :I f ; ~ i l i ~ r c , that participatecl in
;I tr;lnsaction must examine their logs o n st;ible storage t o tletcrmine wliat to clo. If thc log contains
;I comnlit o r abort record for
T, then
7'
completecl. No action is required. If t h e log contains n o prepare, commit, o r xbort record for
1', then
1'
was active.
'I'
must be ;~bortecl. log c o n t a i n s a p r e p a r e record for
T, b u t n o c o m - mit o r abort record for
7'.
T was between phases
1 and
2.
The resource manager must ask its superior transaction rn;lnager w h e t h e r t o c o m m i t o r abort t h e transaction.
An inherent problem i n all two-phase c o m m i t protocols is that a resource managcr is blocked between phases
1 and 2, that is, after voting "yes" and before receiving t h e commit o r abort tlecision.
It cannot c o m m i t o r abort t h e transaction 1111til t h e transaction manager tells it which t o do. If its trans- action ni;in;lger fails, t h e resource manager may be blocked indefinitely, until e i t h e r t h e transaction manager recovers o r a n extern;~l system manzrger, steps in t o tell the resource nian- ager whether to commit or ; ~ b o r t .
A
system e r r o r s at any time during its execution. Or, work) o r a resource manager (prior t o voting "yes") may tell its trllnsaction manager t o abort
1'.
111 e i t h e r case, t h e transaction niariager t h e n tells a11 of its subordin;ites for
'I' t o u n d o t h e effects of 7''s resoilrce m;tn;lger oper;~tions. Subordinate resource m;in;Igcrs ;lbort
T, and subordinate com- munication managers recursively propagate t h e abort request t o their subordinates for
T.
The two-phase c o m m i t protocol is optimized for those cases in which t h e number of messages exchanged can b e reduced below that of the gen- eral case (c.g.. if there is only o n e subordinate resource manager. if a rcsoiIrce manager did n o t rnoclify resources, o r if t h e prcsumecl-abort proto- t o
S ; I V ~
Summary
We have presented an overview o f t h e I>ECdta architecture. As part of this overview, w e intro- of e;~cli interface. We also described tlie DECtlta transaction management architecture in s o m e detail. Over time, many interfaces of t h e I>Ec:dta
Acknowledgments
This architecture grew from discussions with many colleagues. We thank thern all for their liclp, espe- cially Dieter Gawlick, Bill Laing, Dave Lomet, Bruce
Mann, Barry Rubinson, Diogenes Torres, and t h e
TP architecture group, inclutling Etlwarcl Bri~ginsky,
Tony DellaFera, George Gajnak, Per (;yllstrom, and
Yoav Raz.
References
1. T. Speer and
M.
Storm, "Digital's Transaction
Processing Monitors;'
Digital Technical Journal,
vol.
3,
no. I (Winter 1991, this issue):
18-32.
2. W. Lqing, J. Johnson, and R. Landau, "Transaction
Management Support in t h e
\!MS
Operating
System Kernel,"
Digital T e c h n i c a l J o ~ r u l ,
3,
no. I (Winter 1991, this issue):
33-44.
3.
F?
Bernstein, V. H;lclzilacos, and
N.
Goodman,
Conc~lrrency and Reco~wry D~ttabuse
Systems
(lieatling,
MA:
Addison-Wesley, 1987).
4
I?
Bernstein, M. Hsu, and B. Mann, "lrnplement- ing Recoverable Recluests l l s ~ n g Queues,"
Proceeclitzgs
1990
AGW
SIGIWOD
Conference on
Mcrizngettzent of Dcrtcr (May 1990)
5.
FIMS
Jo~lrttal
o,$
Dei)elopmerrt
(Norfolk,
VA:
CODASYL FlMS
Committee, July 1990).
6.
C. Mohan, 0 . Linclsay, and R . Oberm;~rck,
"Transactjon Management in tlie R* Ilistributed
Ilatabase
management
System,"
A C M
Truns- actions
0 1 2
Dotabase Systems,
vol 11, no.
4
(December 1986).
Digital TechtticaI J o u r t ~ ~ I
I
W17tttcv 1991
17
Download
Advertisement
Key features
Distributed transaction processing
Database access
System fault tolerance
Client/server computing model
Open interfaces
Industry standards support
High availability
High performance
Data integrity
Frequently asked questions
DECdta is Digital's Distributed Transaction Processing Architecture. It describes the modules and interfaces that are common to Digital's transaction processing (DECtp) products.
DECdta allows easy distribution of DECtp products, supports client/server style applications, and ensures reliable interoperation of application programs, database systems, and other resource managers in a distributed system.
DECdta components include presentation services, request management, transaction management, communication managers, and resource managers.
DECdta uses a distributed transaction manager to coordinate transaction commit across multiple systems, ensuring atomicity, serializability, and durability of transactions.
DECdta supports standards such as X/Open Transaction Processing Working Group, IEEE POSIX, and International Standards Organization's Open System Interconnection activities.