GPars Workshop

GPars Workshop

Russel Winder
email: russel@winder.org.uk
xmpp: russel@winder.org.uk
twitter: @russel_winder

http://www.russel.org.uk

Copyright © 2013 Russel Winder 1

Aims, Goals and Objectives
● Gain practical experience of the various models of
concurrent and parallel behaviour available in
GPars; actors, dataflow, data parallelism, etc.
● Have some fun.


Subsidiary Aims, Goals and Objects
● Show that shared mutable memory multi-threading
should return to being an operating systems
development technique and not continue to be
pushed as an applications programming technique
– remember…


…people should tremble

in fear at the prospect of using

Shared mutable memory
multi-threading.


Structure

Introduction.
Actors.
Dataflow.
Data Parallelism.
Analysis.
Closing.


Protocol

Short presentation.
3
(Short presentation → Practical period)
Interaction.
Short presentation.

Questions or comments welcome at any time.


Interstitial Advertisement


Introduction


It is no longer contentious that
The Multicore Revolution
is well underway.


Quad core laptops and phones.

Eight and twelve core workstations.

Servers with “zillions” of cores.


Parallel capable hardware is the norm.


Software technology in use is now lagging
hardware technology by decades.


Operating systems manage cores
with kernel threads.

Operating systems are fundamentally shared
mutable memory multi-threaded systems.

Operating systems rightly use all the lock,
semaphore, monitor, etc. technologies.


Computationally intensive systems or
subsystems definitely have to be parallel.

Other systems likely use concurrency
but not parallelism.


Concurrency

Execution as co-routines:

Sequences of code give up the execution
to pass it to another coroutine.


More Concurrency

Concurrency is a technique founded in a
uniprocessor view of the world.

Time-division multiplexing.


Parallelism

Having multiple executions active
at the same time.


Concurrency is a tool for structuring execution where a
single processor is used by multiple computations.

Parallelism is about making a computation complete
faster than using a single processor.


Squirrel behaviour emulates
synchronized software behaviour.


Locks deny parallelism.


The whole purpose of a lock is to
prevent parallelism.


Parallelism is performance improvement.

Performance improvement requires parallelism.


Locks deny performance improvement.


Locks are needed only if
there is mutable shared state.


Avoid mutable shared state.


…but how…


Use appropriate architectural models.


It's all about controlling
concurrency and parallelism
with tools that applications
programmers find usable.


Shared mutable memory multi-threading
is an operating system technique.


Applications and tools programmers
need computational models with
integrated synchronization.


Use processes and message passing.


It's all easier if processes
are single threaded.


Dataflow
Operators connected by
Actors channels with activity
Independent processes triggered by arrival of
communicating via data on the channels.
asynchronous exchange
of messages.

Data Parallelism
Transform a sequence to
another sequence where all
individual actions happen
at the same time.

Agents
A wrapper for some
Active Objects shared mutable state.
An object that is actually
an actor but looks like a
full service object.
Fork/Join
An toolkit for tree structured
concurrency and parallelism.

Software Transactional Memory
Wrappers for mutable values that uses transactions
rather than locks.

Actors


Actors
Independent processes
communicating via
asynchronous exchange
of messages


Need an example.


The Sleeping Barber Problem


The Sleeping Barber Problem
● The barber's shop has a ● If the barber is cutting, a new
single cutting chair and a row customer checks to see if
of waiting seats. there is a free waiting seat.
● The barber sleeps in the ● If there is join the queue
cutting chair unless trimming to be trimmed.
a customer. ● If there isn't leave
● Customers arrive at the shop disgruntled.
at intervals.
● If the barber is asleep, the
customer wakes the barber Problem originally due
takes the cutting chair and to Edsgar Dijkstra.
gets a trim.

The cutting chair.

The waiting chairs

The barber's shop.

A new customer enters the shop,
check to see if they can go straight
to the cutting chair, if not can they
take a waiting chair, if not leave.


Wikipedia article presents the classic operating
systems approach using locks and semaphores.

http://en.wikipedia.org/wiki/Sleeping_barber_problem


Code!


Dataflow


Dataflow
Operators connected by
channels with activity
triggered by arrival of
data on the channels.


Code!


If you want the code, clone the Git repository:

http://www.russel.org.uk/Git/SleepingBarber.git


Or if you just want to browse:

http://www.russel.org.uk/gitweb


Data Parallelism


Data Parallelism
Transform a sequence to
another sequence where all
individual actions happen
at the same time.

Need an example.




What is the Value of ?

Easy, it's known exactly.

It's .

Obviously.


It's simples
Александр Орлов 2009


Approximating 
● What is it's 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 2


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
Embarrassingly 1 
parallel. n

With n = 3 not much to do,
but potentially lots of error.
Use n = 107 or n = 109?


Because addition is commutative and
associative, expression can be
decomposed into sums of partial sums.


a+b+c+d+e+f

=

(a+b)+(c+d)+(e+f)


Scatter – Gather

map reduce

Code!


If you want the code, clone the Git repository:

http://www.russel.org.uk/Git/Pi_Quadrature.git


Or if you just want to browse:

http://www.russel.org.uk/gitweb


An End


Multicore and multiprocessor are now
the norm, not the exception.


Parallelism only matters if
computational performance matters.


Unstructured synchronization
of concurrent systems
is not a feasible approach.


Actors, dataflow, and data parallelism
(and CSP, agents, fork/join,…)
are the future of applications structure.


Passing messages between
processes is the way forward.


Shared memory concurrency
is a dead end for applications.


Squirrels deny parallelism.


Squirrels deny performance enhancement.


Don't be a squirrel.


Do not use explicit locking algorithms.


Use computational architectures that promote
parallelism and hence performance
improvement:

Actors
Dataflow
Data Parallelism


Use

Go on, you know you want to…

Interstitial Advertisement


The End


GPars Workshop

Russel Winder
email: russel@winder.org.uk
xmpp: russel@winder.org.uk
twitter: @russel_winder
website: http://www.russel.org.uk


GPars Workshop

Recommended

Recommended

More Related Content

Similar to GPars Workshop

Similar to GPars Workshop (20)

More from Russel Winder

More from Russel Winder (20)

Recently uploaded

Recently uploaded (20)

GPars Workshop