Presentation is loading. Please wait.

Presentation is loading. Please wait.

Introduction Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit.

Similar presentations


Presentation on theme: "Introduction Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit."— Presentation transcript:

1 Introduction Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit

2 Art of Multiprocessor Programming2 Moore’s Law Clock speed flattening sharply Transistor count still rising

3 Art of Multiprocessor Programming3 Still on some of your desktops: The Uniprocesor memory cpu

4 Art of Multiprocessor Programming4 In the Enterprise: The Shared Memory Multiprocessor (SMP) cache Bus shared memory cache

5 Art of Multiprocessor Programming5 Your New Desktop: The Multicore Processor (CMP) cache Bus shared memory cache All on the same chip Sun T2000 Niagara

6 Art of Multiprocessor Programming6 Multicores Are Here “Intel's Intel ups ante with 4-core chip. New microprocessor, due this year, will be faster, use less electricity...” [San Fran Chronicle] “AMD will launch a dual-core version of its Opteron server processor at an event in New York on April 21.” [PC World] “Sun’s Niagara…will have eight cores, each core capable of running 4 threads in parallel, for 32 concurrently running threads. ….” [The Inquierer]

7 Art of Multiprocessor Programming7 Why do we care? Time no longer cures software bloat –The “free ride” is over When you double your program’s path length –You can’t just wait 6 months –Your software must somehow exploit twice as much concurrency

8 Art of Multiprocessor Programming8 Traditional Scaling Process User code Traditional Uniprocessor Speedup 1.8x 7x 3.6x Time: Moore’s law

9 Art of Multiprocessor Programming9 Multicore Scaling Process User code Multicore Speedup 1.8x7x3.6x Unfortunately, not so simple…

10 Art of Multiprocessor Programming10 Real-World Scaling Process 1.8x 2x 2.9x User code Multicore Speedup Parallelization and Synchronization require great care…

11 Art of Multiprocessor Programming11 Multicore Programming: Course Overview Fundamentals –Models, algorithms, impossibility Real-World programming –Architectures –Techniques

12 Art of Multiprocessor Programming12 Multicore Programming: Course Overview Fundamentals –Models, algorithms, impossibility Real-World programming –Architectures –Techniques We don’t necessarily want to make you experts…

13 Art of Multiprocessor Programming 13 Sequential Computation memory object thread

14 Art of Multiprocessor Programming 14 Concurrent Computation memory object threads

15 Art of Multiprocessor Programming15 Asynchrony Sudden unpredictable delays –Cache misses (short) –Page faults (long) –Scheduling quantum used up (really long)

16 Art of Multiprocessor Programming16 Model Summary Multiple threads –Sometimes called processes Single shared memory Objects live in memory Unpredictable asynchronous delays

17 Art of Multiprocessor Programming17 Road Map We are going to focus on principles first, then practice –Start with idealized models –Look at simplistic problems –Emphasize correctness over pragmatism –“Correctness may be theoretical, but incorrectness has practical impact”

18 Art of Multiprocessor Programming18 Concurrency Jargon Hardware –Processors Software –Threads, processes Sometimes OK to confuse them, sometimes not.

19 Art of Multiprocessor Programming19 Parallel Primality Testing Challenge –Print primes from 1 to Given –Ten-processor multiprocessor –One thread per processor Goal –Get ten-fold speedup (or close)

20 Art of Multiprocessor Programming20 Load Balancing Split the work evenly Each thread tests range of 10 9 … … · P0P0 P1P1 P9P9

21 Art of Multiprocessor Programming 21 Procedure for Thread i void primePrint { int i = ThreadID.get(); // IDs in {0..9} for (j = i* , j<(i+1)*10 9 ; j++) { if (isPrime(j)) print(j); }

22 Art of Multiprocessor Programming22 Issues Higher ranges have fewer primes Yet larger numbers harder to test Thread workloads –Uneven –Hard to predict

23 Art of Multiprocessor Programming23 Issues Higher ranges have fewer primes Yet larger numbers harder to test Thread workloads –Uneven –Hard to predict Need dynamic load balancing rejected

24 Art of Multiprocessor Programming Shared Counter each thread takes a number

25 Art of Multiprocessor Programming 25 Procedure for Thread i int counter = new Counter(1); void primePrint { long j = 0; while (j < ) { j = counter.getAndIncrement(); if (isPrime(j)) print(j); }

26 Art of Multiprocessor Programming 26 Counter counter = new Counter(1); void primePrint { long j = 0; while (j < ) { j = counter.getAndIncrement(); if (isPrime(j)) print(j); } Procedure for Thread i Shared counter object

27 Art of Multiprocessor Programming27 Where Things Reside cache Bus cache 1 shared counter shared memory void primePrint { int i = ThreadID.get(); // IDs in {0..9} for (j = i* , j<(i+1)*10 9 ; j++) { if (isPrime(j)) print(j); } code Local variables

28 Art of Multiprocessor Programming 28 Procedure for Thread i Counter counter = new Counter(1); void primePrint { long j = 0; while (j < ) { j = counter.getAndIncrement(); if (isPrime(j)) print(j); } Stop when every value taken

29 Art of Multiprocessor Programming 29 Counter counter = new Counter(1); void primePrint { long j = 0; while (j < ) { j = counter.getAndIncrement(); if (isPrime(j)) print(j); } Procedure for Thread i Increment & return each new value

30 Art of Multiprocessor Programming 30 Counter Implementation public class Counter { private long value; public long getAndIncrement() { return value++; }

31 Art of Multiprocessor Programming 31 Counter Implementation public class Counter { private long value; public long getAndIncrement() { return value++; } OK for single thread, not for concurrent threads

32 Art of Multiprocessor Programming 32 What It Means public class Counter { private long value; public long getAndIncrement() { return value++; }

33 Art of Multiprocessor Programming 33 What It Means public class Counter { private long value; public long getAndIncrement() { return value++; } temp = value; value = value + 1; return temp;

34 Art of Multiprocessor Programming 34 time Not so good… Value… 1 read 1 read 1 write 2 read 2 write 3 write 2 232

35 Art of Multiprocessor Programming 35 Is this problem inherent? If we could only glue reads and writes… read write read write

36 Art of Multiprocessor Programming 36 Challenge public class Counter { private long value; public long getAndIncrement() { temp = value; value = temp + 1; return temp; }

37 Art of Multiprocessor Programming 37 Challenge public class Counter { private long value; public long getAndIncrement() { temp = value; value = temp + 1; return temp; } Make these steps atomic (indivisible)

38 Art of Multiprocessor Programming 38 Hardware Solution public class Counter { private long value; public long getAndIncrement() { temp = value; value = temp + 1; return temp; } ReadModifyWrite() instruction

39 Art of Multiprocessor Programming 39 An Aside: Java™ public class Counter { private long value; public long getAndIncrement() { synchronized { temp = value; value = temp + 1; } return temp; }

40 Art of Multiprocessor Programming 40 An Aside: Java™ public class Counter { private long value; public long getAndIncrement() { synchronized { temp = value; value = temp + 1; } return temp; } Synchronized block

41 Art of Multiprocessor Programming 41 An Aside: Java™ public class Counter { private long value; public long getAndIncrement() { synchronized { temp = value; value = temp + 1; } return temp; } Mutual Exclusion

42 Art of Multiprocessor Programming42 Why do we care? We want as much of the code as possible to execute concurrently (in parallel) A larger sequential part implies reduced performance Amdahl’s law: this relation is not linear…

43 Art of Multiprocessor Programming43 Amdahl’s Law Speedup= …of computation given n CPUs instead of 1

44 Art of Multiprocessor Programming44 Amdahl’s Law Speedup=

45 Art of Multiprocessor Programming45 Amdahl’s Law Speedup= Parallel fraction

46 Art of Multiprocessor Programming46 Amdahl’s Law Speedup= Parallel fraction Sequential fraction

47 Art of Multiprocessor Programming47 Amdahl’s Law Speedup= Parallel fraction Number of processors Sequential fraction

48 Art of Multiprocessor Programming 48 Example Ten processors 60% concurrent, 40% sequential How close to 10-fold speedup?

49 Art of Multiprocessor Programming 49 Example Ten processors 60% concurrent, 40% sequential How close to 10-fold speedup? Speedup=2.17=

50 Art of Multiprocessor Programming 50 Example Ten processors 80% concurrent, 20% sequential How close to 10-fold speedup?

51 Art of Multiprocessor Programming 51 Example Ten processors 80% concurrent, 20% sequential How close to 10-fold speedup? Speedup=3.57=

52 Art of Multiprocessor Programming 52 Example Ten processors 90% concurrent, 10% sequential How close to 10-fold speedup?

53 Art of Multiprocessor Programming 53 Example Ten processors 90% concurrent, 10% sequential How close to 10-fold speedup? Speedup=5.26=

54 Art of Multiprocessor Programming 54 Example Ten processors 99% concurrent, 01% sequential How close to 10-fold speedup?

55 Art of Multiprocessor Programming 55 Example Ten processors 99% concurrent, 01% sequential How close to 10-fold speedup? Speedup=9.17=

56 Art of Multiprocessor Programming56 The Moral Making good use of our multiple processors (cores) means Finding ways to effectively parallelize our code –Minimize sequential parts –Reduce idle time in which threads wait without

57 Art of Multiprocessor Programming57 Multicore Programming This is what this course is about… –The % that is not easy to make concurrent yet may have a large impact on overall speedup Next week: –A more serious look at mutual exclusion

58 Art of Multiprocessor Programming 58 This work is licensed under a Creative Commons Attribution- ShareAlike 2.5 License.Creative Commons Attribution- ShareAlike 2.5 License You are free: –to Share — to copy, distribute and transmit the work –to Remix — to adapt the work Under the following conditions: –Attribution. You must attribute the work to “The Art of Multiprocessor Programming” (but not in any way that suggests that the authors endorse you or your use of the work). –Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license. For any reuse or distribution, you must make clear to others the license terms of this work. The best way to do this is with a link to –http://creativecommons.org/licenses/by-sa/3.0/. Any of the above conditions can be waived if you get permission from the copyright holder. Nothing in this license impairs or restricts the author's moral rights.


Download ppt "Introduction Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit."

Similar presentations


Ads by Google