The document describes the functions and operations of a Transaction Manager (TM). The TM receives calls to begin, save, prepare, commit, rollback transactions and read transaction contexts. It maintains data structures for transactions, resource managers, and sessions. It implements transaction functions like begin, commit through logging savepoints and coordinating with resource managers. On restart, it replays the log through REDO and UNDO operations to recover state and ensure transactions are recovered to a consistent state.

1. Transaction Manager
Software is like entropy.
It is difficult to grasp,
weighs nothing,
and obeys the Second Law of Thermodynamics;
i.e., it always increases.
Norman Augstine
9:00
11:00
1:30
3:30
7:00
Overview
Faults
Tolerance
T Models
Party
TP mons
Lock Theory
Lock Techniq
Queues
Workflow
Log+RM
TM
CICS & Inet
Adv TM
Cyberbrick
Files &Buffers
COM+
Corba
Replication
Party
B-tree
Access Paths
Groupware
Benchmark
Mon Tue Wed Thur Fri

2. When Everything Works
Normally, no resorce manager fails, and the
system is up.The TM receives the following
calls:
Begin_Work(),
Save_Work(),
Prepare_Work(),
Commit_Work(),
Rollback_Work(),
Read_ Context().

3. Other “Normal” Calls
Normally, no resorce manager fails, and the
system is up.The TM receives the following
calls:
Leave_Transaction(),
Resume_Transaction(),
Status_Transaction(),
Identify(),
Join_Work().

4. The TM And Context
With each type of savepoint, the TM can
record context information for the transaction.
Context is provided by a resource manager and
can be reestablished when the transaction
returns to that savepoint.
For the TM, context is only a string of bytes.
The “meaning” of context is only understood
by the subsystem that created it. The context
established by a database system is different
from the one provided by a transactional GUI.

5. Transaction Identifiers
TRIDs must be created at high rates at each
node in a distributed system. TRIDs must be
unique in time and space.
This is the structure of a TRID:
typedef struct {TIMESTAMP BirhtdayOf TM;
RMID IDofTM;
long LocalSqncNo;
char FutureUse[2];
} TRID;

6. name
TMid
next_transid
birthday
RM_list
tran_list
Transaction Manager Anchor
name
rmid
up?
low_water_lsn
checkpoint_lsn
transid
status
next_savepoint
savepoint
save point lsn
rm_list
max_lsn
min_lsn
lock_list
session_list
rmid
savepoint lsn
vote
Maintained by Log Manager
Maintained by Lock Manager
session name
polarity
remote_TM_name
birthday
stuff
Locks
Log Records
Resource Manager Entries
Resource Managers
Joined to This Transaction
Transaction Descriptors
TM_anchor
RMCB
TransCB
SECB
RMTranCB
The TM´s
Data
Structures

7. What the TM Knows About RMs
typedef struct
{ RMCB * NextRMCB;
char RMName[BIG];
RMID IDofRM;
Boolean RMisUP;
LSN OldestLogRecForREDO;
LSN CheckpointLSN;
} RMCB;

8. What the TM Knows About Transactions
typedef struct
{ TransCB * NextTranCBt;
TRID TRIDofTran;
tran_status StatusOfTran;
long NextSaveptNo;
long CurrentSaveptNo;
LSN LSNofCurrentSavept;
LSN MostRecentLSNofTran;
LSN FirstLSNofTran;
to be continued ...

9. RMTranCB * RMsAttachedToTran;
SECB * SessionsAttachedToTran;
pointer LocksHeldByTran;
pointer LockTranWaitsFor;
long TimeoutForLockWaits;
TransCB * ForDeadlockDetector;
} TransCB;
. . . Knows About Transactions

10. Some Simple Addressing Functions
TRID MyTrid(void);
Returns transaction identifier of caller’s process.
TransCB MyTrans(void);
Returns a copy of caller’s transaction CB.
TransCB * MyTransP(void);
Returns pointer to caller’s transaction CB.

11. Implementation of MyTrid
TRID MyTrid(void)
/*return curr. TRID of calling process*/
{ TransCB * mytranp = MyTransP();
/*pointer to caller’s TA CB */
if ( mytranp != NULL )
return mytranp->trid;
/*return his trid if he has one*/
else return NULLTrid;}
/*no trid if caller has no control blk*/

12. Savepoints
There are seven basic types of savepoints:
Begin
Save
Prepare
Rollback
Commit
Abort
Complete

13. The TM Savepoint Log Record
typedef struct
{ SAVE_PT_TYPE RecordType;
long SaveptNum;
tran_status Status;
Boolean SoftOrPersistent;
long NumRMs;
RMTransCB RM[NumRMs];
long NumSess;
SECB Session[NumSess];
context ContextData;
} TM_savepoint;

14. Implementation of Begin_Work
TRID Begin_Work(context * it, Boolean soft)
{TransCB * trans; /*the transaction’s descriptor */
TRID him; /*the newTRID */
TM_savepoint save; /*the savept record*/
if (MyTrid() != NULLTrid) return(NULLTrid);
him = TM_anchor.next_trid; /*give nextTRID */
TM_anchor.next_trid.sequence++;
(MyProcessP())->trid = him;
trans = malloc(sizeof(TransCB));
trans->next = TM_anchor.tran_list;
TM_anchor.tran_list = trans;
trans->trid = him

15. Implementation of Begin_Work
trans->status = ACTIVE;
trans->save_pt = 1; trans->next_save_pt = 2;
trans->RM_list = trans->lock_list =
trans->ses_list = NULL;
save.record_type = begin;
save.save_pt_num= 1; save.soft = soft;
save.num_RM = save.sessions = 0;
copy(save.it, it, it.length);
trans->save_pt_lsn = log_insert( save, sizeof(save));
if (!soft) log_flush(trans->max_lsn,FALSE);
return(him);
};

16. Implementation of Commit_Work
Boolean Commit_Work(context * it, Boolean lazy)
{ TransCB * trans = MyTransP();
TM_savepoint save;
long save_num
Boolean vote;
RMTransCB * rm;
SECB * session;
if (MyTrid() == NULLTrid) return(0);
for each rm in trans->RM_list
{rm->prepared =rmid.Prepare(&rm->save_pt_lsn))
if (!rm->prepared)
{ Abort_Work();
return FALSE;};}

17. Implementation of Commit_Work
for each outgoing session in trans->ses_list
{vote = TM.Prepare(void);
if (! vote or timeout)
{ Abort_Work();
return FALSE;};};
trans->status = PREPARED;
save_num = trans->save_pt ++;
save.record_type = commit;
save.soft = FALSE;
save.save_pt_num = save_num;
copy(save, trans->RM_list);
copy(save, trans->ses_list);
copy(save.it, it);

18. Implementation of Commit_Work
trans->save_pt_lsn = log_insert( save, sizeof(save));
log_flush(trans->max_lsn, lazy);
trans->status = COMMITTING;
for each rm in trans->RM_list
{ if ( rmid.Commit( ))
{ deallocate rmid from transaction;};
else {rm_commit(&rm);};};
for each outgoing session in trans->ses_list
{ TM.Commit();
if (! timeout) { free session; }
else {session_failure(&session);};};

19. Implementation of Commit_Work
if ( trans->RM_list == NULL &&
trans->ses_list == NULL)
{ trans->status = COMMITTED;
save.record_type = commit_complete;
log_insert( save, sizeof(header)+sizeof(record_type));
dequeue and free trans structure;}
(MyProcessP())->trid = NULLTrid;
return TRUE;
};

20. Data Flow at Commit
Savepoint
Rollback
Prepare
Commit /
Abort
From Application or
Remote Transaction
Manager
Local
Transaction
Manager
Joined
Resource
Managers
Outgoing Sessions
Remote
Transaction
Managers
and Servers

21. Handling a Session Failure
void session_failure(SECB * session)
{ TransCB * trans = MyTransP();
Boolean timeout = TRUE;
TM_savepoint save;
RMID TM= session->him;
while( timeout) { TM.Commit( );};
free session;
if ( trans->RM_list == NULL &&
trans->ses_list == NULL)
{ trans->status = COMMITTED;
save.record_type = commit_complete;
log_insert( save, sizeof(save));
dequeue and free trans structure;};
exit(); };

22. Distributed Commit
Ø1
Ø2
Ø1
Ø2
Ø1
Ø2
Ø1
Ø2
root
participant participant
participant
participant
Communications
Manager
TM.Prepare()
TM. Commit()
Ø1
Ø2
participant
Local TM
callbacks
Ø1
Ø2

23. Coordinator Failure
void coordinator_failure(SECB * session)
tran_status outcome = prepared;
RMID TM= session->him;
while( outcome not in {committing, aborting})
{ outcome=TM.Status_Transaction(MyTrid());};
switch (outcome)
{ aborting: Abort(); break;
committing:Commit( ); break;
}
exit();
};

24. Savepoint Logic
RM 1
Save Point
Log Record
RM 2
Save Point
Log Record
Transaction
Manager's
Save Point
Log Record
Transaction's Log
Records Increassing LSNs
In the TM´s savepoint record, the LSNs of the
participating resource managers are recored, so
they can be reestablished later on.

25. Savepoint Implementation
int Save_Work(context * it, Boolean soft)
{TransCB * trans = MyTransP();
TM_savepoint save;
long save_num;
RMTransCB * rm;
SECB * session;
Boolean vote;
if (MyTrid() == NULLTrid) return(0);
save_num = trans->next_save_pt + +;
for each rm in trans->RM_list
if( ! vote = rmid.Savepoint(&rm->save_pt_lsn )))
{ Abort_Work(); return 0;};

26. Savepoint Implementation
for each session in trans->ses_list
{ vote = TM.Savepoint(save_num);
if (timeout || ! vote ) { Abort_Work();
return 0;};};
trans->save_pt = trans->next_save_pt++;
save.record_type = save;
save.save_pt_num = save_num; save.soft = soft;
copy(save, trans->RM_list);
copy(save, trans->ses_list);
copy(save.it, it);
trans->save_pt_lsn = log_insert( save, sizeof(save));
if (!soft) log_flush(trans->max_lsn, soft);
return save_num; };

27. The UNDO of Savepoints
void UNDO(LSN lsn)
{TransCB * trans = MyTransP();
TM_savepoint save;
TRID him =MyTrid();
RMID rmid;
RMTransCB * rm;
SECB * session;
log_record_header header;
Boolean vote=TRUE;
log_read(lsn,&header,save,sizeof(save));
trans->save_pt = save.save_pt_num;

28. The UNDO of Savepoints
for each rm in trans->RM_list
{ if ( rm is in save )
rm->save_pt_lsn = save.RM.save_pt_lsn;
else rm->save_pt_lsn = NULLlsn;.
vote= vote ||
rmid.UNDO_Savepoint(rm->save_pt_lsn);}
for each session in trans->ses_list
vote = vote || TM.UNDO_Savepoint(trans->save_pt);
if ( vote )
{ trans->max_lsn = header.tran_prev_lsn;
trans->save_pt_lsn =
log_insert(save,sizeof(save));}
return;};

29. Rollback Log Records
Begin
Do
Do
Do
Save
Do
Do
Do
UnDo
Rollback
UnDo
UnDo
UnDo
Do
Do
Do
Compensation log records

30. System Restart
R E D O T r a n s a c t io n M a n a g e r
C h e c k p o in t C h e c k p o in t
U N D O
C h e c k p o in t
C o m p e n s a t io n L o g R e c o r d s
G e n e r a t e d B y U n d o S c a n
L o g a t R e s t a r t : R E D O s c a n f o r w a r d f r o m la s t c h e c k p o in t
L o g u n c h a n g e d : U N D O s c a n b a c k f r o m e n d o f lo g a lo n g t r a n p r e v ls n
U N D O s c a n g e n e r a t e d c o m p e n s a t io n r e c o r d s ( u n d o lo g g in g )
A t e n d o f U N D O s c a n , c h e c k p o in t a n d m a r k r e s o u r c e m a n a g e r a s u p
I d e n t if y ( R M I D )
R E D O f r o m t h a t R M I D lo w w a t e r ls n R E D O c a llb a c k s
U N D O c a llb a c k s
R e t u r n f r o m I d e n t if y ( )
N o w T r a n s a c t io n M a n a g e r is " u p "
T M ( c h k p _ ls n )

31. Transaction States at Restart
b e g in
d o
d o
d o
b e g in
d o
c o m m it
c o m p le te
b e g in
d o
d o
r o llb a c k
u n d o
u n d o
a b o r t
c o m p le te
b e g in
d o
d o
c o m m it
b e g in
d o
d o
r o llb a c k
u n d o
u n d o
a b o r t
b e g in
d o
d o
p e r s is te n t s a v e
b e g in
d o
d o
p r e p a r e
C o m p le t e dC o m p le t in g
P e r s is te n t
b e g in
d o
d o
p e r s is te n t s a v e
d o
d o
A c t iv e
F a ilu r e & R e s t a r t R E D O in
p e r s is te n t s to r a g e
R E D O in p e r s is te n t s to r a g e
te ll e a c h r e s o u r c e m a n a g e r
th e n w r ite c o m p le tio n r e c o r d
R E D O in p e r s is te n t s to r a g e
te ll e a c h r e s o u r c e m a n a g e r
to b e p r e p a r e d
R E D O in p e r s is te n t s to r a g e
U N D O to p e r s is te n t s a v e
if n o n e , d o a b o r t lo g ic

32. Resource Manager at Restart
Identify()
TM_Startup()
UNDO()
REDO()
Commit()
Abort()
He'sup!
Transaction
Manager
Resource
Manager
REDOscan
UNDOscan
resolution

33. Using Two Checkpoints For Restart
One scan for ALL RMs
REDO
Checkpoint Checkpoint
UNDO
Checkpoint
CompensationLog
Records
GeneratedBy UndoScan
Logat Restart: REDOscanforwardfrom2ndtolast checkpoint
Logunchanged: UNDOscanbackfromendof logalongtran prevlsn
UNDOscangeneratedcompensationrecords (undologging)
At endof UNDOscan, checkpoint andallownewtransactions tobegin

34. Why Restart Works
A case analysis of the restart state of a transaction’s outcome,
its log record and the state of the page in persistent memory.
Transacti
on
Log
record
Persistent
Page
Why Recovery Works
1 committe
d
volatile old impossible: force-log -
at-commit
2 new impossible:
WAL +force-log-at -
commit
3 durable old REDO makes it new
4 new REDO idempotence
5 aborted volatile old no record at restart
(implicit UNDO).
6 new impossible: WAL
7 durable old REDO then UNDO
8 new REDO idempotence +
UNDO