1 / 30

Automatic Fine-Grained Synchronization via Domination Locking

Automatic Fine-Grained Synchronization via Domination Locking. Guy Golan-Gueta Tel-Aviv University Nathan Bronson Stanford University Alex Aiken Stanford University G. Ramalingam Microsoft Research Mooly Sagiv Tel-Aviv University Eran Yahav Technion.

brett-nolan
Download Presentation

Automatic Fine-Grained Synchronization via Domination Locking

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. Automatic Fine-Grained Synchronizationvia Domination Locking Guy Golan-Gueta Tel-Aviv University Nathan Bronson Stanford University Alex Aiken Stanford University G. Ramalingam Microsoft Research Mooly Sagiv Tel-Aviv University Eran Yahav Technion

  2. Creating Highly Concurrent Data-Structures • Given a sequential implementation of a data-structure • Automatically create a correct highly concurrent version of this data-structure

  3. Creating Highly Concurrent Data-Structures via Fine-Grained Locking • Automatically add locks to guarantee: • Correctness • Atomicity • Deadlock freedom • High level of parallelism • Fine-grained locks, lock for each object • A lock is only held while necessary

  4. Creating Highly Concurrent Data-Structures via Fine-Grained Locking • Automatically add locks to guarantee: • Correctness • Atomicity • Deadlock freedom • High level of parallelism • Fine-grained locks, lock for each object • A lock is only held while necessary list n2 n1 n3 n4 early release

  5. Example: remove from a balanced search-tree (Treap) When should I acquire and release each lock? Under what conditions?

  6. Locking Protocol • Enforce a locking protocol in the given code • What locking protocol do we need to enforce? • How to enforce this protocol in the given code?

  7. What locking protocol? • Two Phase Locking • Does not allow early release • Tree/DAG locking • Assume that the objects graph is static • Dynamic versions of Tree/DAG locking

  8. Our Approach: The Domination Locking Protocol • Works for any shape • Allows early release

  9. Two types of objects • Distinguishes between exposed and hidden objects • Exposed objects • “roots” of data structures • may be pointed by transaction arguments • Hidden objects • may not be pointed by transaction arguments • may be reachable via exposed objects List ... void insert(List l, int k) {…} hidden hidden hidden exposed

  10. Restricted Semantics • Leverages the restricted semantics of software modules • thread can access n3 only after n1 & n2 List n2 n1 n3 n4 exposed hidden hidden hidden

  11. Domination Locking transaction t can access object only when holding its lock an hidden object u can be acquired by t only if every path between an exposed object to u includes an object which is locked by t DS a1 a2 a4 a3 a7 a5 a6

  12. assume ≤ be a total order of objects • t can acquire an exposed object u, only if • t has never acquired an exposed object v ≤ u • t has never released a lock DSA a1 ... DSB b1 ...

  13. Concurrent Correctness from Sequential Conditions If every sequential execution satisfies DL and is able to terminate • concurrent operations are conflict-serializable and deadlock-free (Intuition similar to Rinetzky et. al POPL’10)

  14. Automatic Locking • A method to enforce DL when shape== forest • add locking by relying on the restricted shape • without understanding the details of the given code

  15. Example: remove from a balanced search-tree (Treap)

  16. Forest-Based Data-Structure • In every sequential execution, shape is a forest at the beginning and end of transactions

  17. Forest-Based Data-Structure • In every sequential execution, shape is a forest at the beginning and end of transactions • Example: ListA forest violation a1 a2 a3 a4 move a3 from ListA to ListB ListB b1 b2 b3 b4

  18. Forest-Based Data Structure • Consistent objects • exposed object has no predecessors • hidden object has 0 or 1 predecessors (unshared) • A data-structure is forest-based if • In every sequential execution, all object are consistent at the beginning and end of transactions

  19. Reference counters We add to two reference counters to objects • Stack reference counter • counts number of incoming pointers from private memory (stack variables) • Heap reference counter • counts number of incoming pointers from heap objects

  20. Reference counters s=1 h=0 s=0 h=1 s=0 h=0 s=0 h=2 s=1 h=1 y x

  21. Locking • Acquire object u when • stack counter of u becomes positive • Release object u when • stack counter of u becomes 0 • u is consistent

  22. s=1 h=0 s=0 h=1 s=0 h=0 s=1 h=1 s=0 h=1 x y

  23. s=1 h=0 s=0 h=1 s=0 h=0 s=1 h=2 s=0 h=1 x y

  24. s=1 h=0 s=0 h=1 s=0 h=0 s=0 h=2 s=1 h=1 y x

  25. Locking Arguments void Move(List x, List y) { … void Move(List x, List y) { { if( address(x) <= address(y) ) { acquire(x); acquire(y); } else { acquire(y); acquire(x); } … • Acquire *x and *y without leading to a deadlock • Define a unique identifier for each object • e.g. use memory addresses • Acquire according the order of identifiers

  26. RB tree (top-down implementation)

  27. Treap

  28. Apriori

  29. Summary • New Locking Protocol – Domination Locking • Applies to any shape • Allows early release • Automatic realization for forest-based data-structures • Preliminary Evaluation • Automatic fine-grained locking for red-black tree and others • Scales similarly to hand crafted locking

  30. Thank You

More Related