Cooperative Concurrency for a Multicore World

Transcription

1 Cooperative Concurrency for a Multicore World Stephen Freund Williams College Cormac Flanagan, Tim Disney, Caitlin Sadowski, Jaeheon Yi, UC Santa Cruz

2 Controlling Thread Interference: #1 Manually x = 0; while (x < len) { tmp = a[x]; b[x] = tmp; x++; x = 0; while (x < len) { interference tmp = a[x]; interference b[x] = tmp; x++; + Works some of the time Easy to make mistakes

3 Controlling Thread Interference: #2 Enforce Race Freedom Race: concurrent conflicting accesses Thread A t1 = bal; bal = t1 + 10; Thread B t2 = bal; bal = t2 10; Thread A t1 = bal bal = t Thread B t2 = bal bal = t2-10

4 Controlling Thread Interference: #2 Enforce Race Freedom Race: concurrent conflicting accesses Thread A t1 = bal; bal = t1 + 10; Thread B t2 = bal; bal = t2 10; Thread A t1 = bal bal = t Thread B t2 = bal bal = t2-10

5 Controlling Thread Interference: #2 Enforce Race Freedom + Races are correlated to defects + Race-freedom ensures sequentially-consistent behavior But not sufficient Thread A t1 = bal; bal = t1 + 10; Thread B t2 = bal; bal = t2 10; Thread A t1 = bal bal = t Thread B t2 = bal bal = t2-10

6 Controlling Thread Interference: #2 Enforce Race Freedom Thread A ; t1 = bal; ; ; bal = t1 + 10; ; Thread B ; bal = 0 ; Thread A t1 = bal bal = t Thread B bal = 0

7 Controlling Thread Interference: #3 Enforce Atomicity Atomic method must behave as if it executes serially, without interleaved operations of other thread void copy() { x = 0; while (x < len) { tmp = a[x]; b[x] = tmp; x++;

8 Controlling Thread Interference: #3 Enforce Atomicity Atomic method must behave as if it executes serially, without interleaved operations of other threads atomic void copy() { x = 0; while (x < len) { tmp = a[x]; b[x] = tmp; x++; + Can use sequential reasoning in atomic methods + 90% of methods are atomic

9 Controlling Thread Interference: #3 Enforce Atomicity Atomic method must behave as if it executes serially, without interleaved operations of other threads 10% of methods aren't No information about thread interference Local atomic blocks awkward void busy_wait() { ; while (!test()) { ; ; x++;

10 Controlling Thread Interference: #3 Enforce Atomicity Atomic method must behave as if it executes serially, without interleaved operations of other threads atomic void copy() { x = 0; while (x < len) { tmp = a[x]; b[x] = tmp; x++; Bimodal Semantics atomic vs. read-modify-write void busy_wait() { ; while (!test()) { ; ; x++;

11 Controlling Thread Interference: #4 Cooperative Multitasking Cooperative scheduler performs context switches only at statements + Clean semantics Sequential reasoning valid by default except where s highlight thread interference Uses only a single processor

12 Cooperative Concurrency Cooperative Scheduler Sequential Reasoning Except at s x = 0 barrier x = 2 x = 0 s mark all interference points Preemptive Scheduler Full performance No overhead x = 0 barrier x = 2 Cooperative Coop/preemptive Equivalence Preemptive

13 Cooperative Concurrency Cooperative Scheduler Sequential Reasoning Except at s x = 0 barrier x = 2 x = 0 s mark all interference points Coop/preemptive Equivalence Preemptive Scheduler Full performance No overhead x = 0 barrier x = 2 Cooperative Preemptive

14 Benefits of Yield over Atomic Atomic methods are those with no s atomic void copy() { x = 0; while (x < len) { tmp = a[x]; b[x] = tmp; x++; void busy_wait() { ; while (!test()) { ; ; ; x++; atomic is a method-level spec. is a code-level spec.

15 Benefits of Yield over Atomic atomic void copy() { x = 0; while (x < len) { tmp = a[x]; b[x] = tmp; x++; x++ is always an atomic increment operation void busy_wait() { ; while (!test()) { ; ; ; x++;

16 Benefits of Yield over Atomic atomic void copy() { x = 0; while (x < len) { tmp = a[x]; b[x] = tmp; x++; void busy_wait() { ; while (!test()) { ; ; ; { t = x; ; x = t + 1; ead

17 Cooperability in the Design Space Policy Enforcement traditional sync + analysis new run-time systems Non-Interference Specification atomic atomicity, serializability transactional memory cooperability automatic mutual exclusion Transactional Memory, Larus & Rajwar, 2007 Automatic mutual exclusion, Isard & Birrell, HOTOS 07

18 Cooperative Concurrency Cooperative Scheduler Sequential Reasoning Except at s x = 0 barrier x = 2 x = 0 Coop/preemptive Equivalence Preemptive Scheduler Full performance No overhead x = 0 barrier x = 2 Cooperative Preemptive

19 Cooperative Concurrency Cooperative Scheduler Sequential Reasoning Except at s x = 0 barrier x = 2 x = 0 JCC Preemptive Scheduler Full performance No overhead x = 0 barrier x = 2 Cooperative Input: Java source + s + race info Preemptive

20 volatile int x; Version 1 void update_x() { x = slow_f(x); No between accesses to xaaa Cooperative Coop/preemptive Equivalence Preemptive

21 void update_x() { synchronized(m) { x = slow_f(x); Version 2 But Bad performance Cooperative Coop/preemptive Equivalence Preemptive

22 void update_x() { int fx = slow_f(x); Version 3 synchronized(m) { x = fx; No between accesses to xaaa Cooperative Coop/preemptive Equivalence Preemptive

23 void update_x() { int fx = slow_f(x); ; synchronized(m) { x = fx; Version 4 Stale value after Cooperative Coop/preemptive Equivalence Preemptive

24 void update_x() { int y = x; for (;;) { ; int fy = slow_f(y); Version 5 (test and retry) if (x == y) { x = fy; return; y = x; No between accesses to xaaa Cooperative Coop/preemptive Equivalence Preemptive

25 void update_x() { int y = x; for (;;) { ; int fy = slow_f(y); if (x == y) { ; x = fy; return; y = x; Stale value after Version 6 Cooperative Coop/preemptive Equivalence Preemptive

26 void update_x() { int y = x; for (;;) { ; int fy = slow_f(y); synchronized(m) { if (x == y) { x = fy; return; y = x; Version 7 Cooperative Coop/preemptive Equivalence Preemptive

27 Identifying Cooperable Code Commuting Classifications [Lipton 76] M Both-mover N Non-mover R Right-mover L Left-mover Y Yielding Race-Free Access Racy Access Acquire Release Serializable blocks have pattern: R* [N] L* Cooperable blocks have the pattern: ((R* [N] L*) Y)* [R* [N] L*]

28 ((R* [N] L*) Y)* [R* [N] L*] void deposit(int n) { synchronized(m) { t1 = bal; bal = t1 + n; acquire(m) t1 = bal bal = t1 + n release(m) acquire(m) t1 = bal bal = t1 + n release(m) R M M L

29 ((R* [N] L*) Y)* [R* [N] L*] void deposit(int n) { synchronized(m) { t1 = bal; bal = t1 + n; acquire(m) t1 = bal bal = t1 + n release(m) acquire(m) t1 = bal bal = t1 + n release(m) void deposit(int n) { synchronized(m) { t1 = bal; synchronized(m) { bal = t1 + n; acquire(m) R t1 = bal release(m) acquire(m) bal = t1 + n release(m) M L R M L R M L R M L

30 ((R* [N] L*) Y)* [R* [N] L*] void deposit(int n) { synchronized(m) { t1 = bal; ; synchronized(m) { bal = t1 + n; R M L Y R M L acquire(m) t1 = bal release(m) acquire(m) bal = t1 + n release(m) R M L Y R M L

31 Cooperative Trace acquire(m) t1 = bal release(m) acquire(m) bal = t1 + n release(m) acquire(m) t1 = bal release(m) acquire(m) bal = t1 + n release(m)

32 N Effect Language Commuting Effects Lattice if (test) s1 else s2 L M R Atomicity Effects: Y Atomic or Compound Method specs to enable modular checking: atomic mover void m1() atomic non-mover void m2() compound non-mover void m3()

33 Effect Language Conditional Effects class Vector { int count; this? atomic mover : atomic non-mover public synchronized int length() { return count;

34 class TSP { Object lock; volatile int shortestpathlength; // lock held on writes non-mover void searchfrom(path path) { if (path.length() >=..shortestpathlength) return; if (path.iscomplete()) {..synchronized(lock) { if (path.length() < shortestpathlength) shortestpathlength = path.length(); else { for (Path c : path.extendtoadj()) {..searchfrom(c);

35 Program Number of Interference Points No Spec Race Atomic Atomic Race Yield Unintended Yields java.util.zip.inflater java.util.zip.deflater Interference 49 13at: Interference at: Interference at: java.lang.stringbuffer java.lang.string field racy field accesses accesses all racy 6 field field 2accesses 1 0 java.io.printwriter all lock acquires all lock acquires java.util.vector atomic method calls java.util.zip.zipfile in non-atomic methods points sparse tsp elevator Fewer Interference Points: Easier to Reason about Code raytracer-fixed sor-fixed moldyn-fixed Total 3,928 1,291 1, Total per KLOC ~35 Annotations/KLOC

36 Cooperability Thread interference is notoriously problematic awkward semantics hard to reason about correctness destructive interference syntactically hidden, often ignored Document interference with s (10-20/KLOC) Tools verify cooperative-preemptive equivalence Cooperative scheduling for reasoning Preemptive scheduling for performance Next steps: user studies, hybrid checkers, inference