1. Concurrency Control II
More on Two Phase Locking
Time Stamp Ordering
Validation Scheme

2. Database Implementation – Concurrency Control Yan Huang
Learning Objectives
Variations of two phase locking
Dealing with Deadlock and Starvation
Time Stamp Ordering Technique
Validation
Database Implementation – Concurrency Control Yan Huang

3. Database Implementation – Concurrency Control Yan Huang
Schedules
Interleaved (or non-interleaved) actions from several transactions
A schedule is good if it can be transformed into one of the serial schedules by switching two consecutive non-conflict actions
We’ve learned 2PL to achieve serializability
It is a pessimistic scheme
Database Implementation – Concurrency Control Yan Huang

4. Database Implementation – Concurrency Control Yan Huang
Recall
2PL (two phase locking)
Locks of Ti
growing
shrinking
time
Each transaction has to follow, no locking anymore after the first unlocking
Database Implementation – Concurrency Control Yan Huang

5. Why 2PL serializability?
Acyclic precedence graph = serializability
Basic idea:
No cycle in precedence graph
Because
if there is a arc from Ti to Tj in precedence graph, the first unlocking of Ti precede the first unlocking of Tj (proof details in ccI notes)
If there is circle, you will have Ti < Ti
Database Implementation – Concurrency Control Yan Huang

6. Who will follow 2PL in practice?
Looks like it is DB application developers’ job.
But, they can not be trusted  and too much work
Checking conformity of every transaction is costly
In practice, CC subsystems of DBMS take over the responsibility
Database Implementation – Concurrency Control Yan Huang

7. Database Implementation – Concurrency Control Yan Huang
Variations of 2PL
Basic 2PL
Conservative 2PL
Strict 2PL
Rigorous 2PL
Database Implementation – Concurrency Control Yan Huang

8. Database Implementation – Concurrency Control Yan Huang
Basic 2PL
2PL with binary locks
Covered in last class
Database Implementation – Concurrency Control Yan Huang

9. Database Implementation – Concurrency Control Yan Huang
Shared locks
So far:
S = ...l1(A) r1(A) u1(A) … l2(A) r2(A) u2(A) …
Do not conflict
Instead:
S=... ls1(A) r1(A) ls2(A) r2(A) …. us1(A) us2(A)
Database Implementation – Concurrency Control Yan Huang

10. Database Implementation – Concurrency Control Yan Huang
Lock actions
l-ti(A): lock A in t mode (t is S or X)
u-ti(A): unlock t mode (t is S or X)
Shorthand:
ui(A): unlock whatever modes
Ti has locked A
Database Implementation – Concurrency Control Yan Huang

11. Well formed transactions
Ti =... l-S1(A) … r1(A) … u1 (A) …
Ti =... l-X1(A) … w1(A) … u1 (A) …
Database Implementation – Concurrency Control Yan Huang

12. Database Implementation – Concurrency Control Yan Huang
What about transactions that read and write same object?
Option 1: Request exclusive lock
Ti = ...l-X1(A) … r1(A) ... w1(A) ... u1(A) …
Database Implementation – Concurrency Control Yan Huang

13. Database Implementation – Concurrency Control Yan Huang
What about transactions that read and
write same object?
Option 2: Upgrade
(E.g., need to read, but don’t know if will write…)
Ti=... l-S1(A) … r1(A) ... l-X1(A) …w1(A) ...u1(A)…
Think of
- Get 2nd lock on A, or
- Drop S, get X lock
Database Implementation – Concurrency Control Yan Huang

14. Database Implementation – Concurrency Control Yan Huang
Compatibility matrix
Comp S X
S true false
X false false
Database Implementation – Concurrency Control Yan Huang

15. Database Implementation – Concurrency Control Yan Huang
Schedule
T T2
l-s1(A);Read(A)
A A+100;Write(A)
l-x1(B); u1(A)
l-s2(A);Read(A)
A Ax2;Write(A); l-x2(B)
Read(B);B B+100
Write(B); u1(B)
l-x2(B); u2(A);Read(B)
B Bx2;Write(B);u2(B);
delayed
Database Implementation – Concurrency Control Yan Huang

16. Database Implementation – Concurrency Control Yan Huang
Conservative 2PL
Lock all items it needs then transaction starts execution
If any locks can not be obtained, then do not lock anything
Difficult but deadlock free
first action starts
growing
locks
shrinking
time
Database Implementation – Concurrency Control Yan Huang

17. Database Implementation – Concurrency Control Yan Huang
Strict 2PL
T does not release any write locks until it commits or aborts
Good for recoverability
Since reads or writes on what T writes
Deadlock free?
growing
locks
shrinking
time
First write unlock
Database Implementation – Concurrency Control Yan Huang
T commits or aborts

18. Database Implementation – Concurrency Control Yan Huang
Rigorous 2PL
T does not release any locks until it commits or aborts
Easy to implement
Deadlock free?
T commits or aborts
growing
locks
shrinking
time
Database Implementation – Concurrency Control Yan Huang

19. Database Implementation – Concurrency Control Yan Huang
Does basic 2PL guarantee serializability?
Does conservative 2PL guarantee serializability?
Does strict 2PL guarantee serializability?
Does rigorous 2PL guarantee serializability?
Database Implementation – Concurrency Control Yan Huang

20. Compare variations of 2PL
Deadlock
Only conservative 2PLis deadlock free
Q: give a schedule of two transactions following 2PL but result in deadlock.
Database Implementation – Concurrency Control Yan Huang

21. Database Implementation – Concurrency Control Yan Huang
Exercises:
S1: r1(y)r1(x)w1(x)w2(x)w2(y)
S2: r1(y)r3(x)w1(x)w3(x)w2(y)w2(x)
S3: r3(y)w1(x)w3(x)r1(z)w2(y)w2(x)
Assuming binary lock right before read or write; and rigorous 2PL (release all locks right after last operation), are S1, S2,and S3 possible?
Database Implementation – Concurrency Control Yan Huang

22. Database Implementation – Concurrency Control Yan Huang
Deadlocks
Detection
Wait-for graph
Prevention
Resource ordering
Timeout
Wait-die
Wound-wait
Database Implementation – Concurrency Control Yan Huang

23. Database Implementation – Concurrency Control Yan Huang
Deadlock Detection
Build Wait-For graph
Use lock table structures
Build incrementally or periodically
When cycle found, rollback victim T5 T2 T1 T7 T4 T6 T3
Database Implementation – Concurrency Control Yan Huang

24. Database Implementation – Concurrency Control Yan Huang
Resource Ordering
Order all elements A1, A2, …, An
A transaction T can lock Ai after Aj only if i > j
Problem : Ordered lock requests not realistic in most cases
Database Implementation – Concurrency Control Yan Huang

25. Database Implementation – Concurrency Control Yan Huang
Timeout
If transaction waits more than L sec., roll it back!
Simple scheme
Hard to select L
Database Implementation – Concurrency Control Yan Huang

26. Database Implementation – Concurrency Control Yan Huang
Wait-die
Transactions are given a timestamp when they arrive …. ts(Ti)
Ti can only wait for Tj if ts(Ti)< ts(Tj) else die
Database Implementation – Concurrency Control Yan Huang

27. Database Implementation – Concurrency Control Yan Huang
Example: T1
(ts =10) T2
(ts =20) T3
(ts =25)
wait
wait?
wait
Very high level: only older ones have the privilege to wait, younger ones die if they attempt to wait for older ones
Database Implementation – Concurrency Control Yan Huang

28. Database Implementation – Concurrency Control Yan Huang
Wound-wait
Transactions are given a timestamp when they arrive … ts(Ti)
Ti wounds Tj if ts(Ti)< ts(Tj)
else Ti waits
“Wound”: Tj rolls back and gives lock to Ti
Database Implementation – Concurrency Control Yan Huang

29. Database Implementation – Concurrency Control Yan Huang
Example: T1
(ts =25) T2
(ts =20) T3
(ts =10)
wait
wait
wait
Very high level: younger ones wait; older ones kill (wound) younger ones who hold needed locks
Database Implementation – Concurrency Control Yan Huang

30. Database Implementation – Concurrency Control Yan Huang
Who die?
Looks like it is always the younger ones
either die automatically
or killed
What is the reason?
Will the younger ones starve?
Suggestions?
Database Implementation – Concurrency Control Yan Huang

31. Database Implementation – Concurrency Control Yan Huang
Timestamp Ordering
Key idea:
Transactions access variables according to an order decided by their time stamps when they enter the system
No cycles are possible in the precedence graph
Database Implementation – Concurrency Control Yan Huang

32. Database Implementation – Concurrency Control Yan Huang
Timestamp
System time when transactions starts
An increasing unique number given to each stransaction
Denoted by ts(Ti)
Database Implementation – Concurrency Control Yan Huang

33. Database Implementation – Concurrency Control Yan Huang
The way it works
Two time stamps associated with each variable x
RS(x): the largest time stamp of the transactions read it
WS(x): the largest time stamp of the transactions write it
Protocol:
ri(x) is allowed if ts(Ti) >= WS(x)
wi(x) is allowed if ts(Ti) >=WS(x) and ts(Ti) >=RS(x)
Disallowed ri(x) or wi(x) will kill Ti, Ti will restart
Database Implementation – Concurrency Control Yan Huang

34. Database Implementation – Concurrency Control Yan Huang
x y z
RS= RS= RS=-1
WS=-1 WS= WS=-1
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
W(y);
R (y);
W(z);
R(y);
W(x);
Database Implementation – Concurrency Control Yan Huang

35. Database Implementation – Concurrency Control Yan Huang
x y z
RS= RS= RS=-1
WS= WS= WS=-1
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
Database Implementation – Concurrency Control Yan Huang

36. Database Implementation – Concurrency Control Yan Huang
x y z
RS=100 RS= RS=-1
WS=-1 WS= WS=-1
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
W(y);
Database Implementation – Concurrency Control Yan Huang

37. Database Implementation – Concurrency Control Yan Huang
x y z
RS=100 RS= RS=-1
WS=-1 WS= WS=-1
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
W(y);
R (y);
Database Implementation – Concurrency Control Yan Huang

38. Database Implementation – Concurrency Control Yan Huang
x y z
RS=100 RS= RS=-1
WS=-1 WS= WS=300
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
W(y);
R (y);
W(z);
Database Implementation – Concurrency Control Yan Huang

39. Database Implementation – Concurrency Control Yan Huang
x y z
RS=200 RS= RS=-1
WS=-1 WS= WS=300
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
W(y);
R (y);
W(z);
Database Implementation – Concurrency Control Yan Huang

40. Database Implementation – Concurrency Control Yan Huang
x y z
RS=200 RS= RS=-1
WS=-1 WS=100 WS=300
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
W(y);
R (y);
W(z);
T1 is rolled back
Database Implementation – Concurrency Control Yan Huang

41. Database Implementation – Concurrency Control Yan Huang
x y z
RS=200 RS= RS=-1
WS=-1 WS=100 WS=300
Example
Assuming: ts(T1) = 100, ts(T2) = 200, ts(T3) = 300
T T T3
R(x);
W(y);
R (y);
W(z);
What happen to RS and WS?
T1 is rolled back
Database Implementation – Concurrency Control Yan Huang

42. Net result of TO scheduling
Conflict pairs of actions are taken in the order of their home transactions
But the basic TO does not guarantee recoverability
later
Database Implementation – Concurrency Control Yan Huang

43. Database Implementation – Concurrency Control Yan Huang
Validation
An optimistic scheme
Transactions have 3 phases:
(1) Read
all DB values read
writes to temporary storage
no locking
(2) Validate
check if schedule so far is serializable
(3) Write
if validate ok, write to DB
Database Implementation – Concurrency Control Yan Huang

44. Database Implementation – Concurrency Control Yan Huang
Key idea
Make validation atomic
If T1, T2, T3, … is validation order, then resulting schedule will be conflict equivalent to Ss = T1 T2 T3...
Database Implementation – Concurrency Control Yan Huang

45. Database Implementation – Concurrency Control Yan Huang
To implement validation, system keeps two sets:
FIN = transactions that have finished phase 3 (and are all done)
VAL = transactions that have successfully finished phase 2 (validation)
Database Implementation – Concurrency Control Yan Huang

46. Example of what validation must prevent:
RS(T2)={B} RS(T3)={A,B}
WS(T2)={B,D} WS(T3)={C} 
=  T2
start T2
validated T3
validated T3
start
time
Database Implementation – Concurrency Control Yan Huang

47. Example of what validation must prevent:
allow
Example of what validation must prevent:
RS(T2)={B} RS(T3)={A,B}
WS(T2)={B,D} WS(T3)={C} 
=  T2
start T2
validated T3
validated T3
start T2
finish
phase 3 T3
start
time
Database Implementation – Concurrency Control Yan Huang

48. Another thing validation must prevent:
RS(T2)={A} RS(T3)={A,B}
WS(T2)={D,E} WS(T3)={C,D} T2
validated T3
validated
BAD: w3(D) w2(D)
finish T2
time
Database Implementation – Concurrency Control Yan Huang

49. Another thing validation must prevent:
allow
Another thing validation must prevent:
RS(T2)={A} RS(T3)={A,B}
WS(T2)={D,E} WS(T3)={C,D} T2
validated T3
validated
finish T2
finish T2
time
Database Implementation – Concurrency Control Yan Huang

50. Database Implementation – Concurrency Control Yan Huang
Validation Rule
When start validating T
Check RS(T)  WS(U) is empty for U that started but did not finish validation before T started
Check WS(T)  WS(U) is empty for any U that started but did not finish validation T start validation
Database Implementation – Concurrency Control Yan Huang

51. Database Implementation – Concurrency Control Yan Huang
start
validate
finish
Exercise:
U: RS(U)={B}
WS(U)={D}
W: RS(W)={A,D}
WS(W)={A,C}
T: RS(T)={A,B}
WS(T)={A,C}
V: RS(V)={B}
WS(V)={D,E}
Database Implementation – Concurrency Control Yan Huang