Sec$on 6: Mutual Exclusion Michelle Ku5el [email protected] Toward sharing resources (memory) Have been studying parallel algorithms using fork- join – Lower span via parallel tasks Algorithms all had a very simple structure to avoid race condi$ons – Each thread had memory “only it accessed” • Example: array sub-range – On fork, “loaned” some of its memory to “forkee” and did not access that memory again un$l aer join on the “forkee” slide adapted from: Sophomoric Parallelism & 2 Concurrency, Lecture 4 Toward sharing resources (memory) Strategy won’t work well when: – Memory accessed by threads is overlapping or unpredictable – Threads are doing independent tasks needing access to same resources (rather than implemen$ng the same algorithm) slide adapted from: Sophomoric Parallelism & 3 Concurrency, Lecture 4 Race Condi$ons A race condi*on is a bug in a program where the output and/or result of the process is unexpectedly and cri$cally dependent on the relave sequence or $ming of other events. The idea is that the events race each other to influence the output first. Examples Mul$ple threads: 1. Processing different bank-account operaons – What if 2 threads change the same account at the same $me? 2. Using a shared cache (e.g., hashtable) of recent files – What if 2 threads insert the same file at the same $me? 3. Creang a pipeline (think assembly line) with a queue for handing work to next thread in sequence? – What if enqueuer and dequeuer adjust a circular array queue at the same $me? Sophomoric Parallelism & 5 Concurrency, Lecture 4 Concurrent Programming Concurrency: Correctly and efficiently managing access to shared resources from mul$ple possibly-simultaneous clients Even correct concurrent applicaons are usually highly non-determinisc: how threads are scheduled affects what operaons from other threads they see when – non-repeatability complicates tes$ng and debugging adapted from: Sophomoric 6 Parallelism & Concurrency, Lecture 4 Sharing, again It is common in concurrent programs that: • Different threads might access the same resources in an unpredictable order or even at about the same $me • Program correctness requires that simultaneous access be prevented using synchronizaon • Simultaneous access is rare – Makes tes$ng difficult – Must be much more disciplined when designing / implemen$ng a concurrent program Sophomoric Parallelism & 7 Concurrency, Lecture 4 Tes$ng concurrent programs • in general extremely difficult: – relies on execu$ng the par$cular sequence of events and ac$ons that cause a problem – number of possible execu$on sequences can be astronomical – problem sequences may never occur in the test environment Why use threads? Unlike parallelism, not about implemen$ng algorithms faster But threads s$ll useful for: • Code structure for responsiveness – Example: Respond to GUI events in one thread while another thread is performing an expensive computaon • Processor u1liza1on (mask I/O latency) – If 1 thread “goes to disk,” have something else to do • Failure isola1on – Convenient structure if want to interleave mul$ple tasks and don’t want an excep$on in one to stop the other Sophomoric Parallelism & 9 Concurrency, Lecture 4 Synchronizaon Synchronizaon constraints are requirements pertaining to the order of events. • Serializaon: Event A must happen before Event B. • Mutual exclusion: Events A and B must not happen at the same $me. Mutual exclusion One of the two most important problems in concurrent programming – several processes compete for a resource, but the nature of the resource requires that only one process at a $me actually accesses the resource – synchronizaon to avoid incorrect simultaneous access – abstrac$on of many synchronizaon problems Synchronizaon • In real life we oPen check and enforce synchronizaon constraints using a clock. How do we know if A happened before B? If we know what $me both events occurred, we can just compare the $mes. • In computer systems, we oPen need to sasfy synchronizaon constraints without the benefit of a clock, either because there is no universal clock, or because we don’t know with fine enough resolu$on when events occur. Mutual exclusion Mutual exclusion: Events A and B must not happen at the same *me. a.k.a. crical secon, which technically has other requirements One process must block: not proceed un$l the “winning” process has completed – join is not what we want – block un$l another thread is “done using what we need” not “completely done execu$ng” Example: Parallel Primality Tesng • Challenge – Print primes from 1 to 1010 • Given – Ten-processor mul$processor – One thread per processor • Goal – Get ten-fold speedup (or close) Slide from: Art of Multiprocessor Programming 14 Load Balancing 1 109 2·109 … 1010 P0 P1 … P9 • Split the work evenly • Each thread tests range of 109 Art of Multiprocessor 15 Programming Procedure for Thread i void primePrint { int i = ThreadID.get(); // IDs in {0..9} for (j = i*109+1, j<(i+1)*109; j++) { if (isPrime(j)) print(j); } } Art of Multiprocessor 16 Programming Issues • Higher ranges have fewer primes • Yet larger numbers harder to test • Thread workloads – Uneven – Hard to predict Art of Multiprocessor 17 Programming Issues • Higher ranges have fewer primes • Yet larger numbers harder to test • Thread workloads – Uneven – Hard to predict • Need dynamic load balancing Art of Multiprocessor 18 Programming Shared Counter 19 18 each thread takes a number 17 Art of Multiprocessor 19 Programming Procedure for Thread i int counter = new Counter(1); void primePrint { long j = 0; while (j < 1010) { j = counter.getAndIncrement(); if (isPrime(j)) print(j); } } Art of Multiprocessor 20 Programming Procedure for Thread i Counter counter = new Counter(1); void primePrint { long j = 0; while (j < 1010) { j = counter.getAndIncrement(); if (isPrime(j)) Shared counter print(j); object } } Art of Multiprocessor 21 Programming Where Things Reside code void primePrint { int i = ThreadID.get(); // IDs Local in {0..9} variables for (j = i*109+1, j<(i+1)*109; j++) { if (isPrime(j)) print(j); } cache cache cache } Bus Bus shared 1 memory shared counter Art of Multiprocessor 22 Programming Procedure for Thread i Counter counter = new Counter(1); void primePrint { long j = 0; while (j < 1010) { Stop when every value j = counter.getAndIncrement();taken if (isPrime(j)) print(j); } } Art of Multiprocessor 23 Programming Procedure for Thread i Counter counter = new Counter(1); void primePrint { long j = 0; while (j < 1010) { j = counter.getAndIncrement(); if (isPrime(j)) print(j); } } Increment & return each new value Art of Multiprocessor 24 Programming Counter Implementaon public class Counter { private long value; public long getAndIncrement() { return value++; } } Art of Multiprocessor 25 Programming Counter Implementaon public class Counter { private long value; public long getAndIncrement() { return value++; } } OK for single thread, not for concurrent threads Art of Multiprocessor 26 Programming What It Means public class Counter { private long value; public long getAndIncrement() { return value++; } } Art of Multiprocessor 27 Programming What It Means public class Counter { private long value; public long getAndIncrement() { return value++; temp = value; } value = value + 1; } return temp; Art of Multiprocessor 28 Programming Not so good… Value… 1 2 3 2 read write read write 1 2 2 3 read write 1 2 me Art of Multiprocessor 29 Programming Is this problem inherent? write read write read If we could only glue reads and writes… Art of Multiprocessor 30 Programming Challenge public class Counter { private long value; public long getAndIncrement() { temp = value; value = temp + 1; return temp; } } Art of Multiprocessor 31 Programming Challenge public class Counter { private long value; public long getAndIncrement() { temp = value; value = temp + 1; return temp; } Make these steps } atomic (indivisible) Art of Multiprocessor How do we do this? 32 Programming Atomic ac$ons Operaons A and B are atomic with respect to each other if, from the perspec$ve of a thread execu$ng A, when another thread executes B, either all of B has executed or none of it has The operaon is indivisible Hardware Solu$on public class Counter { private long value; public long getAndIncrement() { temp = value; value = temp + 1; return temp; } } ReadModifyWrite() instruc$on Art of Multiprocessor 34 Programming Mutual exclusion in Java Programmer must implement cri$cal sec$ons – “The compiler” has no idea what interleavings should or shouldn’t be allowed in your program – Buy you need language primi$ves to do it! Mutual exclusion in Java: Thread safe classes One way we could fix this is by using an exis$ng thread-safe atomic variable class java.util.concurrent.atomic contains atomic variable classes for effec$ng atomic state transi$ons on numbers and object references. e.g. can replace a long counter with AtomicLong to ensure that all ac$ons that access the counter state are atomic Mutual exclusion in Java • Atomic variable only make a class thread-safe if ONE variable defines the class state • to preserve state consistency, you should update related state variables in a single atomic operaon – exercise: give an example showing why this is Another example: atomic won’t work Correct code in a single-threaded world class BankAccount { private int balance = 0; int getBalance() { return balance; } void setBalance(int x) { balance = x; } void withdraw(int amount) { int b = getBalance(); if(amount > b) throw new WithdrawTooLargeException(); setBalance(b – amount); } … // other operations like deposit,