Exercises for Chapter 13:
Transactions and Concurrency Control
From Coulouris, Dollimore and Kindberg
Distributed Systems:
Concepts and Design
Edition 4, © Pearson Education 2005
Exercise 13.1
 The TaskBag is a service whose functionality is to provide a repository for ‘task
descriptions’. It enables clients running in several computers to carry out parts of a
computation in parallel. A master process places descriptions of sub-tasks of a
computation in the TaskBag, and worker processes select tasks from the TaskBag
and carry them out, returning descriptions of results to the TaskBag. The master
then collects the results and combines them to produce the final result.
The TaskBag service provides the following operations:
setTask
takeTask
allows clients to add task descriptions to the bag;
allows clients to take task descriptions out of the bag.
A client makes the request takeTask, when a task is not available but may be
available soon. Discuss the advantages and drawbacks of the following
alternatives:
(i) the server can reply immediately, telling the client to try again later;
(ii) make the server operation (and therefore the client) wait until a task becomes available.
(iii)use callbacks.
.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.2
A server manages the objects a1, a2, ... an. The
server provides two operations for its clients:
read (i) returns the value of ai;
write(i, Value) assigns Value to ai.
The transactions T and U are defined as follows:
T: x = read(j); y = read (i); write(j, 44); write(i, 33);
U: x = read(k); write(i, 55); y = read (j); write(k, 66).
Give three serially equivalent interleavings of the
transactions T and U.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.3
Give serially equivalent interleavings of T and U in
Exercise 13.2 with the following properties: (1) that
is strict; (2) that is not strict but could not produce
cascading aborts; (3) that could produce cascading
aborts.
page 479
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.4
 The operation create inserts a new bank account at a branch. The
transactions T and U are defined as follows:
T: aBranch.create("Z");
U: z.deposit(10); z.deposit(20).
Assume that Z does not yet exist. Assume also that the deposit operation
does nothing if the account given as argument does not exist. Consider
the following interleaving of transactions T and U:
T
U
z.deposit(10);
aBranch.create(Z);
z.deposit(20);
State the balance of Z after their execution in this order. Are these
consistent with serially equivalent executions of T and U?
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.5
A newly created object like Z in Exercise 13.4 is
sometimes called a phantom. From the point of view
of transaction U, Z is not there at first and then
appears (like a ghost). Explain, with an example,
how a phantom could occur when an account is
deleted.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.6
 The ‘transfer’ transactions T and U are defined as:
T: a.withdraw(4); b.deposit(4);
U: c.withdraw(3); b.deposit(3);
Suppose that they are structured as pairs of nested
transactions:
T1: a.withdraw(4); T2: b.deposit(4);
U1: c.withdraw(3); U2: b.deposit(3);
Compare the number of serially equivalent interleavings of
T1, T2, U1 and U2 with the number of serially equivalent
interleavings of T and U. Explain why the use of these nested
transactions generally permits a larger number of serially
equivalent interleavings than non-nested ones.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.7
Consider the recovery aspects of the nested
transactions defined in Exercise 13.6. Assume that a
withdraw transaction will abort if the account will be
overdrawn and that in this case the parent
transaction will also abort. Describe serially
equivalent interleavings of T1, T2, U1 and U2 with
the following properties: (i) that is strict; (ii) that is not
strict. To what extent does the criterion of strictness
reduce the potential concurrency gain of nested
transactions?
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.8
 Explain why serial equivalence requires that once a
transaction has released a lock on an object, it is not allowed
to obtain any more locks.
A server manages the objects a1, a2, ... an. The server
provides two operations for its clients:
read(i) returns the value of ai
write(i, Value) assigns Value to ai
The transactions T and U are defined as follows:
T: x = read(i); write(j, 44);
U: write(i, 55); write(j, 66);
Describe an interleaving of the transactions T and U in which
locks are released early with the effect that the interleaving is
not serially equivalent.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.9 (part 1)
 The transactions T and U at the server in Exercise 13.8 are
defined as follows:
T: x = read(i); write(j, 44);
U: write(i, 55); write(j, 66);
Initial values of ai and aj are 10 and 20, respectively. Which of
the following interleavings are serially equivalent, and which
could occur with two-phase locking?
a) T
U
b) T
U
x = read (i);
x = read (i);
write(i, 55);
write(j, 44);
write(j, 44);
write(i, 55);
write(j, 66);
write(j, 66);
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.9 continued
(c)
T
x = read (i);
write(j, 44);
U
write(i, 55);
write(j, 66);
(d)
T
U
write(i, 55);
x = read (i);
write(j, 66);
write(j, 44);
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.10
Consider a relaxation of two-phase locks in which
read-only transactions can release read locks early.
Would a read-only transaction have consistent
retrievals? Would the objects become inconsistent?
Illustrate your answer with the following transactions
T and U at the server in Exercise 13.8:
T: x = read (i); y= read(j);
U: write(i, 55); write(j, 66);
in which initial values of ai and aj are 10 and 20.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.11
The executions of transactions are strict if read and
write operations on an object are delayed until all
transactions that previously wrote that object have
either committed or aborted. Explain how the locking
rules in Figure 13.16 ensure strict executions.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.12
Describe how a non-recoverable situation could
arise if write locks are released after the last
operation of a transaction but before its commitment.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.13
Explain why executions are always strict, even if
read locks are released after the last operation of a
transaction but before its commitment. Give an
improved statement of rule 2 in Figure 13.16.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.14 (first part)
 Consider a deadlock detection scheme for a single server.
Describe precisely when edges are added to and removed
from the wait-for-graph.
Illustrate your answer with respect to the following
transactions T, U and V at the server of Exercise 13.8
T
U
write(i, 66);
V
write(i, 55);
write(i, 77);
commit
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.14 continued
When U releases its write lock on ai, both T and V
are waiting to obtain write locks on it. Does your
scheme work correctly if T (first come) is granted the
lock before V? If your answer is ‘No’, then modify
your description.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.15
Consider hierarchic locks as illustrated in Figure
13.26. What locks must be set when an appointment
is assigned to a time slot in week w, day d, at time t?
In what order should these locks be set? Does the
order in which they are released matter?
What locks must be set when the time slots for every
day in week w are viewed? Can this be done when
the locks for assigning an appointment to a time slot
are already set?
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.16
 Consider optimistic concurrency control as applied to the
transactions T and U defined in Exercise 13.9. Suppose that
transactions T and U are active at the same time as one
another. Describe the outcome in each of the following cases:
(i) T's request to commit comes first and backward validation is used;
(ii) U's request to commit comes first and backward validation is used;
(iii) T's request to commit comes first and forward validation is used;
(iv) U's request to commit comes first and forward validation is used.
In each case describe the sequence in which the operations
of T and U are performed, remembering that writes are not
carried out until after validation.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.17
 Consider the following interleaving of transactions T and U:
T
U
openTransaction
openTransaction
y = read(k);
write(i, 55);
write(j, 66);
commit
y = read(i);
write(j, 44);
The outcome of optimistic concurrency control with backward validation is that
T will be aborted because its read operation conflicts with U's write operation
on ai, although the interleavings are serially equivalent. Suggest a modification
to the algorithm that deals with such cases.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.18
Make a comparison of the sequences of operations
of the transactions T and U of Exercise 13.8 that are
possible under two-phase locking (Exercise 13.9)
and under optimistic concurrency control (Exercise
13.16).
T: x = read(i); write(j, 44);
U: write(i, 55); write(j, 66);
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.19
 Consider the use of timestamp ordering with each of the
example interleavings of transactions T and U in Exercise
13.9. Initial values of ai and aj are 10 and 20, respectively,
and initial read and write timestamps are t0. Assume that
each transaction opens and obtains a timestamp just before
its first operation; for example, in (a) T and U get timestamps
t1 and t2 respectively, where t0 < t1 < t2. Describe in order of
increasing time the effects of each operation of T and U. For
each operation, state the following:
(i) whether the operation may proceed according to the write or read rule;
(ii)timestamps assigned to transactions or objects;
(iii) creation of tentative objects and their values.
What are the final values of the objects and their
timestamps?
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.20
Repeat Exercise 13.19 for the following interleavings
of transactions T and U
T
U
openTransaction
T
U
openTransaction
openTransaction
openTransaction
write(i, 55);
write(j, 66);
write(i, 55);
write(j, 66);
commit
x = read (i);
write(j, 44);
x = read (i);
commit
write(j, 44);
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.21
Repeat Exercise 13.20 using multiversion timestamp
ordering.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.22
In multiversion timestamp ordering, read operations
can access tentative versions of objects. Give an
example to show how cascading aborts can happen
if all read operations are allowed to proceed
immediately.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.23
What are the advantages and drawbacks of
multiversion timestamp ordering in comparison with
ordinary timestamp ordering.
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005
Exercise 13.24
Make a comparison of the sequences of operations
of the transactions T and U of Exercise 13.8 that are
possible under two-phase locking (Exercise 13.9)
and under optimistic concurrency control
(Exercise 13.16)
T: x = read(i); write(j, 44);
U: write(i, 55); write(j, 66);
Instructor’s Guide for Coulouris, Dollimore and Kindberg Distributed Systems: Concepts and Design Edn. 4
© Pearson Education 2005