Automatic Fine-Grained Synchronization via Domination Locking

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