1 / 20

ICS 214B: Transaction Processing and Distributed Data Management

ICS 214B: Transaction Processing and Distributed Data Management. Lecture 5: Tree-based Concurrency Control and Validation Currency Control Professor Chen Li. T 1 lock. T 1 lock. T 1 lock. all objects accessed through root, following pointers. Tree-based Concurrency Control. A.

israel
Download Presentation

ICS 214B: Transaction Processing and Distributed Data Management

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. ICS 214B: Transaction Processing and Distributed Data Management Lecture 5: Tree-based Concurrency Control and Validation Currency Control Professor Chen Li

  2. T1 lock T1 lock T1 lock • all objects accessed • through root, • following pointers Tree-based Concurrency Control A B C D E F  can we release A lock if we no longer need A?? Notes 05

  3. T1 lock T1 lock T1 lock T1 lock Idea: traverse like “Monkey Bars” A B C D E F Notes 05

  4. Why does this work? • Assume all Ti start at root; exclusive lock • Ti Tj  Ti locks root beforeTj • Ti always locks an element before Tj • Actually works if we don’t always start at root Root Q Ti  Tj Notes 05

  5. Rules: tree protocol (exclusive locks) (1) First lock by Ti may be on any item (2) After that, item Q can be locked by Ti only if parent(Q) locked by Ti (3) Items may be unlocked at any time (4) After Ti unlocks Q, it cannot relock Q Notes 05

  6. Tree-like protocols are used typically for B-tree concurrency control E.g.,during insert, do not release parent lock, until you are certain child does not have to split Root Notes 05

  7. Validation Concurrency Control Another type of optimistic concurrency control No locks are needed 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 Notes 05

  8. Key idea • Make validation atomic • If T1, T2, T3, … is validation order, then resulting schedule will be conflict equivalent to Ss = T1 T2 T3... Notes 05

  9. 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) Notes 05

  10. =   BAD: R3(B) W2(B) Example of what validation must prevent: RS(T2)={B} RS(T3)={A,B} WS(T2)={B,D} WS(T3)={C} T3 Validated? T2 start T2 validated T3 start T2 finish time “T3 validated” failed, since T3 starts before T2 finished, and T3 could have read B before T2 wrote B, violating T2T3 Notes 05

  11. =   allow Example of what validation must prevent: RS(T2)={B} RS(T3)={A,B} WS(T2)={B,D} WS(T3)={C} T3 Validated T2 start T2 validated T2 finish T3 start time Notes 05

  12. 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 “T3 validated” failed, since W3(D) could be before w2(D), violating T2T3 Notes 05

  13. 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 Notes 05

  14. Validation rules for Tj: Globally: VAL = {}; (1) When Tj starts phase 1: ignore(Tj)  FIN (2) at Tj Validation: if check (Tj) then [ VAL  VAL U {Tj}; do write phase; FIN FIN U {Tj} ] Notes 05

  15. Check (Tj): For Ti  VAL - IGNORE (Tj) DO IF [ WS(Ti)  RS(Tj)   OR Ti  FIN ] THEN RETURN false; RETURN true; Is this check too restrictive ? Notes 05

  16. Improving Check(Tj) For Ti  VAL - IGNORE (Tj) DO IF [ WS(Ti)  RS(Tj)   OR (Ti  FIN AND WS(Ti)  WS(Tj) )] THEN RETURN false; RETURN true; Notes 05

  17. 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} Notes 05

  18. U: no condition • T: OK • Condition 1: RS(T)  WS(U) = {AB}  {D} =  • Condition 2: WS(T)  WS(U) = {AC}  {D} =  • V: OK • Condition 1: RS(V)  WS(U) = {AD}  {E} =  OK • Condition 2: WS(V)  WS(T) = {DE}  {AC} =  OK • W: Not OK • Condition 1: RS(W)  WS(T) = {AD}  {AC} =  Not OK Notes 05

  19. Validation (also called optimistic concurrency control) is useful in some cases: - Conflicts rare - System resources plentiful - Have real-time constraints Notes 05

  20. Summary Have studied C.C. mechanisms used in practice - 2 PL - Multiple granularity - Tree (index) protocols - Validation Notes 05

More Related