1 Martin Vechev IBM T.J. Watson Research Center Joint work with: Hagit Attiya, Rachid Guerraoui, Danny Hendler, Petr Kuznetsov, Maged Michael

Concurrency 2 …is about synchronization

Synchronization 3 but how much ?

Synchronization 4 we don’t know

Synchronization 5 manual empirical process

Synchronization 6 time consuming

Synchronization 7 too much is inefficient

Synchronization 8 too little is incorrect

Example: Set ADT 9 bool add(int key) { ??? } bool remove(int key) { ??? } bool contains(int key) { ??? }

Our Result 10 Concurrent abstract data types (stacks, queues, sets, hash tables, counters …) and mutual exclusion algorithms must use expensive synchronization

Implications 11 concurrent programming: guidance on when avoiding expensive synchronization is futile

12 “…although I hope that these shortcomings will be addressed, I hasten to add that they are insignificant compared to the huge step forward that this paper represents….” -- Linux Weekly News, Jan 26, Implications

13 hardware design: motivation to lower cost of specific synchronization

Implications 14 API design: API specification affects synchronization

Implications 15 program verification: - declare incorrect when synchronization is missing - simplify verification under weak memory models

What expensive synchronization? 16 order: read-after-write

17... write X read Y... read Y write X modern architectures/languages Read-after write reordering... write X fence read Y Fence: enforce order Example: Read-after-Write

What expensive synchronization? 18 atomicity: atomic write-after-read

Atomic Write-after-Read... read X write Y... read X write X... Examples: compare-and-swap fetch-and-add read-modify-write

Which abstract data types ? 20 Atomicity Determinism Commutativity

Example: Set ADT 21 bool add(v) add v bool remove(v) remove v bool contains(v) check if v is in the set

22 Example: Set ADT Example Histories: add(5): true; remove(5): true; … add(5): true; add(5): false; … add(5): true; contains(5): true; …

23 specification of Set is deterministic Example: Set ADT

24 commutativity: a way to select methods

25 select non-commutative methods

26 method A is non-commutative if there exists another method B where: A influences B and B influences A

27 bool add(v) is non-commutative: Example: Set ADT add(v) influences add(v)

28 Example: Set ADT {} add(5): true; add(5): false; (add influences add)

29 bool remove (v) is non-commutative: Example: Set ADT remove (v) influences remove(v)

30 bool contains(v) is commutative: Example: Set ADT contains(v) does not influence add(v), remove(v) or contains(v)

31 How about void add(v) ? void add(v) is commutative Example: Set ADT nobody can influence void add(v)

32 Atomicity Determinism Commutativity Which abstract data types ?

33 Linearizability Determinism Commutativity Which abstract data types ?

34 Linearizability: when a concurrent implementation is equivalent to a sequential specification [Herlihy&Wing – TOPLAS’90] [Filipovic et. al – ESOP 2009]

Theorem 35 given: deterministic sequential specification, non-commutative method M then: any linearizable implementation of spec contains sequential executions of M that use RAW or AWAR

36 bool add(int key) { ??? } bool remove(int key) { ??? } bool contains(int key) { ??? } Example: Set ADT

37 Set specification is deterministic bool remove(v) is non-commutative Any linearizable implementation of remove (v) must have sequential executions with RAW or AWAR Example: Set ADT

38 bool add(int key) { ??? } bool remove(int key) { RAW or AWAR } bool contains(int key) { ??? } Example: Set ADT

39 Set specification is deterministic bool contains(v) is commutative cannot say anything about contains(v) Example: Set ADT

40 bool add(int key) { ??? } bool remove(int key) { RAW or AWAR } bool contains(int key) { ??? } Example: Set ADT

41 Set specification is deterministic bool add(v) is non-commutative Any linearizable implementation of add(v) must have sequential executions with RAW or AWAR Example: Set ADT

42 bool add(int key) { RAW or AWAR } bool remove(int key) { RAW or AWAR } bool contains(int key) { ??? } Example: Set ADT

43 Proof Intuition: Writing show a method must write otherwise, it cannot influence anyone hence, method would be commutative

44 {} Proof Intuition: Writing add(5)true {} no shared write add(5)true add(5) did not influence add(5)

45 Proof Intuition: Reading show a method must read otherwise, it cannot be influenced by anyone hence, method would be commutative

46 Proof Intuition: RAW {} add(5) true add(5) true W no RAW add(5)true add(5) Linearization {}

47 Summary Atomicity (Linearizability) Determinism Commutativity RAW AWAR

48 Future Directions Even when laws have been written down, they ought not always to remain unaltered -- Aristotle

49 Future Directions Algorithm Specialization: Relax dimensions to obtain new algorithms

50 Future Directions Can the dimensions be weakened? (while keeping lower bound) Sequential Consistency ? Weaker Commutativity ? Abstract Determinism ?

51 Future Directions Can the result by strengthened ? write-write read-read sequences of reads and writes composite operations more (all) executions

The End 52