1 / 35

Understanding Deadlock and Timestamp Ordering in Concurrency Control Implementation

This guide explores deadlock management and timestamp ordering in concurrency control systems. Key concepts include handling deadlocks and starvation, using timestamp ordering techniques, and the validation schemes within database implementations. We cover methods such as wait-for graphs, resource ordering, timeouts, wait-die, and wound-wait strategies. Additionally, we highlight the optimistic validation scheme, which consists of read, validate, and write phases, ensuring the integrity of transactions in multi-user environments. Gain insights into effective database concurrency control mechanisms.

taariq
Télécharger la présentation

Understanding Deadlock and Timestamp Ordering in Concurrency Control Implementation

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Concurrency Control III Dead Lock Time Stamp Ordering Validation Scheme

  2. Learning Objectives • Dealing with Deadlock and Starvation • Time Stamp Ordering Technique • Validation Database Implementation – Concurrency Control Yan Huang

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

  4. 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

  5. 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

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

  7. 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

  8. wait? Example: T1 (ts =10) T2 (ts =20) T3 (ts =25) 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

  9. 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

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

  11. 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

  12. 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

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

  14. 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

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

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

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

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

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

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

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

  22. 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 Database Implementation – Concurrency Control Yan Huang

  23. 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

  24. Time stamps of a transaction Ti • Start(Ti) • Validation(Ti) • Finish(Ti) Database Implementation – Concurrency Control Yan Huang

  25. 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

  26. Schedule T1 T2 Read(A) A A+100; Read(A) A Ax2; Read(B);B B+100 validate Write(A) Write(B); Read(B) B Bx2; validate Write(A) Write(B); Database Implementation – Concurrency Control Yan Huang

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

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

  29. BAD: w3(D) w2(D) 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 time Database Implementation – Concurrency Control Yan Huang

  30. 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

  31. Validation Rule • When start validating T • Check RS(T)  WS(U) is empty for any 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 before T started validation) Database Implementation – Concurrency Control Yan Huang

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

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

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

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

More Related