ACCU 2012: Go, D, C++ and The Multicore Revolution

Go, D, C++ and the
Multicore Revolution

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

Copyright © 2011–2012 Russel Winder 1

Aims, Goals and Objects
● Show that shared memory multi-threading should
return to being an operating systems development
technique and not continue to be pushed as an
applications programming technique.
● Show, possibly, that the C++11 standard may,
perhaps, have saved C++ from the dustbin of
obscurity.


Structure

A beginning.

A middle.

An end.


Protocol
● Questions or short comments during the session are
entirely in order.
● Let me know you have an interjection by raising
your hand, and when I come to an appropriate
pause, I'll pass you the token.

Questions, answers, comments, etc. appearing
to get too long as interjections may get stacked
to be unstacked at a break.


Interstitial Advertisement


A Beginning


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.


Software technology
is now lagging
hardware technology
by decades.


Operating systems manage cores
with kernel threads.

Operating systems are fundamentally shared
memory multi-threaded systems.

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


Operating systems really rather need
to be native code systems.


Constructive dichotomies…


Native code languages.

vs.

Virtual machine based languages.


Statically typed languages.

vs.

Dynamically typed languages.


Compiled languages.

vs.

Scripting languages languages.


Imperative languages.

vs.

Declarative languages.


Sequential.

vs.

Parallel.


Computationally intensive.

vs.

I/O intensive.


Batch flow.

vs.

Event driven.


Monolithic systems.

vs.

Cooperating subsystems.


Computationally intensive systems or
subsystems definitely have to be parallel.

Other systems likely use concurrency
but not parallelism.


Concurrency is a design tool.

Parallelism is a tool to improve
computational performance.


Static vs. Dynamic
● Fortran ● Python, Jython
● C ● Lisp, Clojure
● C++ ● Ruby, JRuby
● D ● Groovy
● Go
● JavaScript
● Rust
● Java
● Dart
● Scala
● Ceylon
● Kotlin COBOL


A Middle


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


Shared memory multi-threading is an
operating system technique.


Applications and tools programmers
need computational models with
integrated synchronization.


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

CSP
Sequential processes
connected by channels
using synchronous message
exchange (rendezvous).

Actors
Independent processes
communicating via
asynchronous exchange
of messages


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


CSP
Sequential processes
connected by channels
using synchronous message
exchange (rendezvous).

Need examples.




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

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


Scatter – Gather

map reduce

Code!


Need another 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


More code!


Note to Self:

Did you, in fact, show all
the examples in:
● C
● D
● Go
● C++
● Python


An End


Native code language are just as
much scripting languages as
virtual machine languages
and interpreted ones.


Virtual machine languages are
just as fast as native code
languages when using JITs.


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, CSP and Dataflow
are the future of
applications structure.


Passing messages between
processes is the way forward.


Shared memory concurrency
is a dead end for applications.


Surreptitious Advertisement


The End


Go, D, C++ and the
Multicore Revolution

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


ACCU 2012: Go, D, C++ and The Multicore Revolution

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a ACCU 2012: Go, D, C++ and The Multicore Revolution

Semelhante a ACCU 2012: Go, D, C++ and The Multicore Revolution (20)

Mais de Russel Winder

Mais de Russel Winder (20)

Último

Último (20)

ACCU 2012: Go, D, C++ and The Multicore Revolution