Just Keep Passing               the Messages                                 Dr Russel Winder                             ...
Just Keep Passing               the Messages                                 Dr Russel Winder                             ...
Just Keep Passing               the Messages                                 Prof Russel Winder                           ...
Aims and Objectives                       ●    Investigate why message passing architectures are the                      ...
Structure of the Session                       ●    Introduction.                       ●    Do stuff.                    ...
Protocol                       ●    Some slides, to kick things off.                       ●    Some programs to really de...
Audience Aims and Objectives                                 ?Copyright © 2011 Russel Winder                 7
BEGIN                       ●    History is important:                                 –   To know today, we look to yeste...
Processes / Threads   Processes / RPC                                                Threads / Shared memory              ...
Historical Summary                       ●    Shared-memory multi-threading for applications                            pr...
Concurrency                                      vs.                                  ParallelismCopyright © 2011 Russel W...
Concurrency                       ●    Running multiple tasks using time-division                            multiplexing ...
Parallelism                       ●    Running multiple tasks concurrently.                                    Note that t...
Concurrency . . .                       ●    . . . is a technique required for operating systems.                       ● ...
Parallelism . . .                       ●    . . . is about making an algorithm execute more                            qu...
Concurrency                       ●    The problem with threads is shared memory:                                 –   With...
Mutable Shared Memory is . . .                       ●    . . . anathema to parallelism.                       ●    . . . ...
Solution . . .                       ●    . . . do not use mutable shared memory.                                         ...
Operating Systems . . .                       ●    . . . are inherently a concurrency problem.                       ●    ...
Object                                 OrientationCopyright © 2011 Russel Winder                 20
Original Model                       ●    Object-based:                                 –   A set of (small) closed namesp...
Implementations                       ●    Smalltalk realized the object-oriented model                            correct...
Non-contentious (sort of) Syllogism                       ●    Object-orientation is                            about obje...
JavaCopyright © 2011 Russel Winder          24
Object-orientation                       ●    Java follows C++:                                 –   Function call replaces...
Partial Solution for JVM                       ●    Use java.util.concurrent:                                 –   Provides...
Interesting Aside                       ●    Paul King at SpringOne2GX 2011:                             “Who used synchro...
High Performance                                    Computing                                       (HPC)                 ...
Parallelism Rules                       ●    HPC has been doing parallelism for 40+ years.                       ●    Comb...
HPC Extant Solution                       ●    Message Passing Interface (MPI)                                     MPI add...
HPC Proposed Solution                       ●    Partitioned Global Address Space (PGAS)                       ●    Champi...
Return to a Better WayCopyright © 2011 Russel Winder                  32
Real Solutions?                       ●    Actor Model                       ●    Dataflow architectures                  ...
Return to objects passing                           messages to each other.                 Return to being object-oriente...
Actor Model                       ●    A program is a collection of actors that send                            messages t...
Dataflow Model                       ●    A program is a graph of operators with some data                            sour...
CSP is . . .                       ●    . . . mathematics:                                 VMS = μX. ( in2p → (chocolate →...
CSP                       ●    A program is a graph of processes running a                            sequential computati...
Commentary                       ●    Actors are non-deterministic, with chaotic                            communications...
Implementations                       ●    Actor Model:                                 –   JVM: GPars, Scala, Akka, Fanto...
AcknowledgementsCopyright © 2011 Russel Winder     41
First Example Problem                       ●    Something small, so the code is small.                       ●    Somethi...
Copyright © 2011 Russel Winder       43
What is the Value of ?                       ●    Easy, its known exactly, its  (obviously).                            ...
Approximating                        ●    What is its value represented as a floating point                            nu...
One Possible Algorithm                       ●    Use quadrature to estimate the value of the integral                    ...
Major Minor Hardware Problem                       ●    Multiple hyperthreads per core on multicore                       ...
Second Example Problem                       ●    Sleeping Barber Problem                                 –   A barber sho...
Sleeping Barber Problem . . .                       ●    . . . is an interesting recasting of a process                   ...
If the examples havent been shown                    yet, now is the time to show them!Copyright © 2011 Russel Winder     ...
Summary                       ●    Multiprocessor programming is now the norm – even                            if you don...
Summary of the Summary                       ●    Shared-memory multi-threading is like                            stacks,...
Summary of the Summary of the                Summary                       ●    If you think locks, semaphores, monitors, ...
END                     for ( person in roomContents.collect { x -> if ( x instanceof Human ) x } ) {                     ...
Blatant Advertising                       Python for Rookies                       Sarah Mount, James Shuttleworth and    ...
Just Keep Passing               the Messages                                 Dr Russel Winder                             ...
Upcoming SlideShare
Loading in...5
×

Just Keep Passing the Messages from Groovy and Grails eXchange 2011

1,001

Published on

Slides from my session at Groovy and Grails eXchange 2011. 2011-12-08T16:30

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,001
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
6
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Just Keep Passing the Messages from Groovy and Grails eXchange 2011

  1. 1. Just Keep Passing the Messages Dr Russel Winder It’z Interactive Ltd russel@itzinteractive.com @russel_winderCopyright © 2011 Russel Winder 1
  2. 2. Just Keep Passing the Messages Dr Russel Winder Independent Consultant russel@russel.org.uk @russel_winderCopyright © 2011 Russel Winder 2
  3. 3. Just Keep Passing the Messages Prof Russel Winder Wolverhampton University russel@russel.org.uk @russel_winderCopyright © 2011 Russel Winder 3
  4. 4. Aims and Objectives ● Investigate why message passing architectures are the software architectures of the future. ● Showcase GPars as the framework for concurrency and parallelism on the JVM. ● Have some fun (whilst hopefully learning something).Copyright © 2011 Russel Winder 4
  5. 5. Structure of the Session ● Introduction. ● Do stuff. ● Exit stage (left|right|front|back). There may well be significant dynamic binding of the session.Copyright © 2011 Russel Winder 5
  6. 6. Protocol ● Some slides, to kick things off. ● Some programs to really demonstrate things. ● NB Interaction between audience and presenter is probably mandatory. We reserve the right to (shelve|stash) for later any interaction that appears to go on longer than seems appropriate. NB This is a 44.99min session!Copyright © 2011 Russel Winder 6
  7. 7. Audience Aims and Objectives ?Copyright © 2011 Russel Winder 7
  8. 8. BEGIN ● History is important: – To know today, we look to yesterday. To know tomorrow, we see today as yesterday. http://wiki.answers.com/Q/Why_history_is_important –Copyright © 2011 Russel Winder 8
  9. 9. Processes / Threads Processes / RPC Threads / Shared memory Processes / IPC Multi-tasking One program at a time.Copyright © 2011 Russel Winder 9
  10. 10. Historical Summary ● Shared-memory multi-threading for applications programming is a total aberration: – Consequences of operating systems handling of concurrency have been imposed on all programmers. ● Cooperating processes is where applications development sanity is: – Operating system interprocess communication was slow, hence threads, but this lead directly to the shared-memory, multi-threading quagmire. – Erlang has shown that processes and message passing can do the job properly even after the “mainstream” had rejected process-based working.Copyright © 2011 Russel Winder 10
  11. 11. Concurrency vs. ParallelismCopyright © 2011 Russel Winder 11
  12. 12. Concurrency ● Running multiple tasks using time-division multiplexing on a single processor.Copyright © 2011 Russel Winder 12
  13. 13. Parallelism ● Running multiple tasks concurrently. Note that the word concurrency here is the English meaning whereas the previous slide gave the computing jargon meaning of the word.Copyright © 2011 Russel Winder 13
  14. 14. Concurrency . . . ● . . . is a technique required for operating systems. ● . . . can sometimes be required for applications but not as much as might be thought. ● Applications can use alternative models, for example event-driven systems. – Abstract over the control flow rather than manage it with locks, semaphores, monitors, etc.Copyright © 2011 Russel Winder 14
  15. 15. Parallelism . . . ● . . . is about making an algorithm execute more quickly in the presence of multiple processors. ● . . . is an architectural and design issue for applications.Copyright © 2011 Russel Winder 15
  16. 16. Concurrency ● The problem with threads is shared memory: – Without writeable shared memory there is no need for synchronization. ● Why impose a 1960s, operating system driven view of concurrency management on applications programmers?Copyright © 2011 Russel Winder 16
  17. 17. Mutable Shared Memory is . . . ● . . . anathema to parallelism. ● . . . anathema to concurrency. ● . . . anathema to modern applications programming. ● . . . anathema.Copyright © 2011 Russel Winder 17
  18. 18. Solution . . . ● . . . do not use mutable shared memory. Note the caveat here that opens the door to using shared immutable data.Copyright © 2011 Russel Winder 18
  19. 19. Operating Systems . . . ● . . . are inherently a concurrency problem. ● Applications on the other hand are not, they should be using higher level abstractions.Copyright © 2011 Russel Winder 19
  20. 20. Object OrientationCopyright © 2011 Russel Winder 20
  21. 21. Original Model ● Object-based: – A set of (small) closed namespaces, with methods, exchanging messages requesting services. ● Object-oriented: – Object-based plus classes and inheritanceCopyright © 2011 Russel Winder 21
  22. 22. Implementations ● Smalltalk realized the object-oriented model correctly. ● C++ did not: message passing replaced by function call. C++ destroyed correct appreciation of the object-oriented model of computation.Copyright © 2011 Russel Winder 22
  23. 23. Non-contentious (sort of) Syllogism ● Object-orientation is about objects passing messages to each other: object-orientation is not about function call in a ● C++ is not an object- shared memory context. oriented programming ● C++ is a programming language. language based on function call in a shared memory context: C++ does not have objects passing messages to each other.Copyright © 2011 Russel Winder 23
  24. 24. JavaCopyright © 2011 Russel Winder 24
  25. 25. Object-orientation ● Java follows C++: – Function call replaces message passing. ● Java beats C++, had threads 15 years before C++. ● Shared memory multi-threading requires all the locks, semaphores, monitors, etc. and Java has it all. Java is not an object-oriented language.Copyright © 2011 Russel Winder 25
  26. 26. Partial Solution for JVM ● Use java.util.concurrent: – Provides many high-level tools. – Has many low-level tools. If you are using the low-level tools then you are lost to the cause of quality application programming. Use jsr166y (Fork/Join) and extra166y (ParallelArray) in preference to using stuff in JDK6. JDK7 has Fork/Join but not ParallelArray, still have to use extra166y for this – sadly means using jsr166y.Copyright © 2011 Russel Winder 26
  27. 27. Interesting Aside ● Paul King at SpringOne2GX 2011: “Who used synchronized?” Some in audience raise their hands. “You did it wrong!”Copyright © 2011 Russel Winder 27
  28. 28. High Performance Computing (HPC) aka Real ComputingCopyright © 2011 Russel Winder 28
  29. 29. Parallelism Rules ● HPC has been doing parallelism for 40+ years. ● Combinations of architectures: – Vector processors – Multi-bus multiprocessors – ClustersCopyright © 2011 Russel Winder 29
  30. 30. HPC Extant Solution ● Message Passing Interface (MPI) MPI addresses the problem of SPMD or MIMD parallelism in the context of multiple, possibly multicore, systems.Copyright © 2011 Russel Winder 30
  31. 31. HPC Proposed Solution ● Partitioned Global Address Space (PGAS) ● Champions: – Chapel – X10 – Fortress Structure the global address space to allow for multiple processors sharing a single memory and/or to deal with distributed memory systems.Copyright © 2011 Russel Winder 31
  32. 32. Return to a Better WayCopyright © 2011 Russel Winder 32
  33. 33. Real Solutions? ● Actor Model ● Dataflow architectures ● CSP (Communicating Sequential Processes) Return to a process and message passing view of applications. Nothing wrong with threads as a tool. The problem is using shared memory.Copyright © 2011 Russel Winder 33
  34. 34. Return to objects passing messages to each other. Return to being object-oriented.Copyright © 2011 Russel Winder 34
  35. 35. Actor Model ● A program is a collection of actors that send messages to each other. ● An actor is a process with a “mailbox” for receiving messages. ● A mailbox is a (thread-safe) queue of messages.Copyright © 2011 Russel Winder 35
  36. 36. Dataflow Model ● A program is a graph of operators with some data sources and some data sinks. ● An operator is an event-triggered computation with some inputs and some output. ● An operator triggers for a certain state of its inputs.Copyright © 2011 Russel Winder 36
  37. 37. CSP is . . . ● . . . mathematics: VMS = μX. ( in2p → (chocolate → X|out1p → toffee → X) | in1p → (toffee → X|in1p → (chocolate → X|in1p → STOPαX ))) ● . . . but not scary since the mathematics can be hidden in an API, so it just becomes a programming tool.Copyright © 2011 Russel Winder 37
  38. 38. CSP ● A program is a graph of processes running a sequential computation that take input from input channels and write output to output channels. ● Data exchange down a channel realizes a rendezvous.Copyright © 2011 Russel Winder 38
  39. 39. Commentary ● Actors are non-deterministic, with chaotic communications and hence complex. ● Dataflow and CSP have much greater determinism with fixed communications channels.Copyright © 2011 Russel Winder 39
  40. 40. Implementations ● Actor Model: – JVM: GPars, Scala, Akka, Fantom – Native: C++/Just::Thread Pro, D – Alternative: Erlang ● Dataflow Model: – JVM: GPars, Pervasive DataRush – Native: C++/Just::Thread Pro ● CSP: – JVM: GPars, JCSP – Native: C++CSP2Copyright © 2011 Russel Winder 40
  41. 41. AcknowledgementsCopyright © 2011 Russel Winder 41
  42. 42. First Example Problem ● Something small, so the code is small. ● Something not too “toy”. ● Something with good parallelism. – Embarrassingly parallel to allow checking of scaling.Copyright © 2011 Russel Winder 42
  43. 43. Copyright © 2011 Russel Winder 43
  44. 44. What is the Value of ? ● Easy, its known exactly, its  (obviously). † Its simples † Aleksandr OrlovCopyright © 2011 Russel Winder 44
  45. 45. Approximating  ● What is its value represented as a floating point number? – We can only obtain an approximation. – A plethora of possible algorithms to choose from, a popular one is to employ the following integral equation.  1 1 =∫0 dx 4 1x 2Copyright © 2011 Russel Winder 45
  46. 46. One Possible Algorithm ● Use quadrature to estimate the value of the integral – which is the area under the curve. 4 n 1 = ∑i=1 n i−0.5 2 1  n With n = 3 not much to do, but potentially lots of error. Embarrassingly parallel.Copyright © 2011 Russel Winder 46
  47. 47. Major Minor Hardware Problem ● Multiple hyperthreads per core on multicore processors can be a serious waste of time. Ed: Rant about chip manufacturers and operating systems elided to avoid persecution prosecution.Copyright © 2011 Russel Winder 47
  48. 48. Second Example Problem ● Sleeping Barber Problem – A barber shop has a cutting chair and some waiting chairs. The barber sleeps in the cutting chair if there are no customers. If a customer enters, the customer checks the cutting chair and wakes the barber if the barber is asleep in the chair, sits in the chair and gets a hair cut. If the entering customer sees the cutting chair in use, the customer checks to see if there is a waiting chair free. If there is the customer sits and waits, otherwise the customer leaves dissatisfied. On finishing a customer cut, the customer leaves satisfied (we assume), and the barber checks for waiting customers. If there are any waiting customers, the customer moves to the cutting chair. If there are no waiting customers, the barber returns to sleeping in the cutting chair.Copyright © 2011 Russel Winder 48
  49. 49. Sleeping Barber Problem . . . ● . . . is an interesting recasting of a process synchronization problem in operating systems. ● . . . is due to Edsgar Dykstra http://en.wikipedia.org/wiki/Sleeping_barber_problemCopyright © 2011 Russel Winder 49
  50. 50. If the examples havent been shown yet, now is the time to show them!Copyright © 2011 Russel Winder 50
  51. 51. Summary ● Multiprocessor programming is now the norm – even if you dont actually need it. ● Hardware is rapidly heading towards distributed memory architectures, instead of shared memory multi-threading. ● Shared memory multi-threading requires locks, semaphores, monitors, etc. and programmers find it hard to get that stuff right. ● Actor Model, Dataflow Model, and CSP are higher level abstractions of managed control flow that are easier for programmers to deal with.Copyright © 2011 Russel Winder 51
  52. 52. Summary of the Summary ● Shared-memory multi-threading is like stacks, you know its there, but you just dont worry about it.Copyright © 2011 Russel Winder 52
  53. 53. Summary of the Summary of the Summary ● If you think locks, semaphores, monitors, etc. are important for your work, you are either working in the concurrency frameworks business (*) OR you are doing it wrong. (*) Which includes operating systems.Copyright © 2011 Russel Winder 53
  54. 54. END for ( person in roomContents.collect { x -> if ( x instanceof Human ) x } ) { person << "Please leave peaceably." } println "Goodbye all."Copyright © 2011 Russel Winder 54
  55. 55. Blatant Advertising Python for Rookies Sarah Mount, James Shuttleworth and Russel Winder Thomson Learning Now called Cengage Learning. Developing Java Software Third Edition Russel Winder and Graham Roberts Wiley Buy these books!Copyright © 2010 Russel Winder 55
  56. 56. Just Keep Passing the Messages Dr Russel Winder It’z Interactive Ltd russel@itzinteractive.com @russel_winderCopyright © 2011 Russel Winder 56
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×