ParallelFx, bringing Mono applications in the multicore era

ParallelFx
Bringing Mono applications in the multicore era

Jérémie Laval

@ jeremie.laval@gmail.com
http://blog.neteril.org
http://twitter.com/jeremie_laval
IRC Garuma on #mono @ GIMPNet.org

Outline

Why bother?
The free lunch
An awesome idea
Remaining performant

ParallelFx
The big picture
Tasks and co
PLinq
State of things

A note for the future

Why bother? ParallelFx A note for the future Questions

Why are we bothering with parallelization

3 / 23



Everyone loves his single thread

3 / 23




“The ideal number of thread you should use is 1”

– Alan Mc Govern
Mono hacker

3 / 23




– Alan Mc Govern
Mono hacker

3 / 23



4 / 23



Because the free lunch is over!

4 / 23


Free lunch?

70’s - 2005: Moore’s law in action

Intel Processor Clock Speed (MHz)
10000
Pentium 4 (Prescott)

Core 2
Extreme
1000
Pentium III

Celeron Multicore crisis
Pentium is here !
100

80486

80386

10
80286
8080

1
1968 1973 1979 1984 1990 1995 2001 2006

0.1

Source: Smoothspan blog

5 / 23


The awesome idea

6 / 23


The awesome idea

Can’t scale vertically? Scale horizontally!

6 / 23


Trend of things

Number of cores

1 2 4 12ish 80

Core 2 Intel
Pentium Core Duo Core i7-980X
Quad prototype

7 / 23


Problem

8 / 23


Problem

No more magical free-lunch

8 / 23


Solution
Let’s break up work...

....and share it among cores
9 / 23


Errr...

10 / 23


Parallelization is difﬁcult

11 / 23



Hard: is that stuff really thread safe?

11 / 23




Tedious: whose turn is it to debug deadlocks?

11 / 23





Inefﬁcient: how many thread to use?

11 / 23





Too few: it’s not scaling

11 / 23





Too much: context-switching hurts performance

11 / 23





Too much: context-switching hurts performance
What if the number of core changes?

11 / 23


KISS time (Keep it simple, stupid)

We need something different :

12 / 23




Automagically regulate thread usage at runtime

12 / 23





As straightforward as possible

12 / 23





Simulate familiar constructs

12 / 23





Simulate familiar constructs
Reuse existing code with only slight modiﬁcation

12 / 23


Enter ParallelFx

ParallelFx at a glance

13 / 23


At the heart

Work-stealing scheduler

Mono Application

Shared
ParallelFX library
work
pool (Scheduler)

Retrieve

Local work Steal Local work
pool pool

Thread Manage Thread
Worker Worker

OS OS
thread thread

14 / 23


Tasks

CancellationTokenSource source = new CancellationTokenSource ();

Task task = Task.Factory.StartNew (() => DoSomeStuff (), source.Token);

Task continuation = task.ContinueWith ((t) => Console.WriteLine ("task finished");

source.Cancel ();

t.Wait ();

15 / 23


Future (Task<T>)

static int SumParallel (Tree<int> tree, int curDepth)
{
const int SequentialThreshold = 3;

if (tree == null) return 0;

if (curDepth > SequentialThreshold)
return SumSequentialInternal (tree);

int right = SumParallel (tree.Right, curDepth + 1);

Task<int> left =
Task.Factory.StartNew (() => SumParallel (tree.Left, curDepth + 1));

return tree.Data + left.Value + right;
}

16 / 23


Parallel.For

Fractal fractal = new Fractal (width, height);

ColorChooser colorChooser = new ColorChooser ();

Parallel.For (0, width, (i) => {
for (int j = 0; j < height; j++) {
ProcessPixel (i, j, fractal, colorChooser);
}
});

17 / 23


Demo: Parallel For

Demo: image processing with parallel
loops

18 / 23


PLinq

ParallelEnumerable.Range (1, 1000)./* ... */
ParallelEnumerable.Repeat (‘‘Rupert’’, 1000)./* ... */
enumerable.AsParallel ()./* ... */

var query = from x in Directory.GetFiles ("/etc/")
.AsParallel ()
where x.EndsWith (".conf")
select x;

query.ForAll ((e) => {
Console.WriteLine ("{0} from {1}", e,
Thread.CurrentThread.ManagedThreadId);
});

19 / 23


Demo: PLinq

Demo: raytracing the PLinq way

20 / 23


State of things

Mono 2.6 (December 2009): .NET 4 beta 1
Task, Future, Parallel loops
Concurrent collections
Coordination data structures

Mono 2.8 (or git master): .NET 4 compliant
Enabled by default
Tons of improvement
With PLinq!

21 / 23



22 / 23



GLinq: GPGPU-powered Linq

22 / 23



Re-use PLinq pipeline

22 / 23



Same design guidelines than PLinq: simplicity, transparency

22 / 23



Rewrite C# code in OpenCL (Expression trees FTW!)

22 / 23



Rewrite C# code in OpenCL (Expression trees FTW!)
Transparent mapping of OpenCL idioms to .NET

22 / 23


Closing the curtains

23 / 23

ParallelFx, bringing Mono applications in the multicore era

Recommandé

Recommandé

Contenu connexe

Dernier

Dernier (20)

En vedette

En vedette (20)

ParallelFx, bringing Mono applications in the multicore era