• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
 

ParallelFx, bringing Mono applications in the multicore era

on

  • 745 views

ulticore computer are now part of our everyday life. Most desktop and laptop machines out there bundle a dual-core processor, quad-core processor or even 8-core processor by default. This ...

ulticore computer are now part of our everyday life. Most desktop and laptop machines out there bundle a dual-core processor, quad-core processor or even 8-core processor by default. This multiplication of the number of core on the same chip is destined to become the way for manufacturers to remain competitive. However, developers were a bit left out in this process, having written sequential programs for ages whereas they were now required to parallelize their program to make them efficient which isn't an easy step to take.

That's why we now see the apparition of framework designed to help programmers to take advantage of this new architecture of processor by hiding away the parallel difficulty under primitives that they are used to. ParallelFx is one of such framework for the Mono and .NET world. By providing several new parallel constructs and concurrent data structures, it allows Mono applications to enter painlessly in this new multicore era.

Statistics

Views

Total Views
745
Views on SlideShare
742
Embed Views
3

Actions

Likes
0
Downloads
3
Comments
0

1 Embed 3

http://www.linkedin.com 3

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

CC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike LicenseCC Attribution-NonCommercial-ShareAlike License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    ParallelFx, bringing Mono applications in the multicore era ParallelFx, bringing Mono applications in the multicore era Presentation Transcript

    • ParallelFxBringing 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
    • OutlineWhy bother? The free lunch An awesome idea Remaining performantParallelFx The big picture Tasks and co PLinq State of thingsA note for the future
    • Why bother? ParallelFx A note for the future QuestionsWhy are we bothering with parallelization 3 / 23
    • Why bother? ParallelFx A note for the future QuestionsWhy are we bothering with parallelization Everyone loves his single thread 3 / 23
    • Why bother? ParallelFx A note for the future QuestionsWhy are we bothering with parallelization Everyone loves his single thread“The ideal number of thread you should use is 1” – Alan Mc Govern Mono hacker 3 / 23
    • Why bother? ParallelFx A note for the future QuestionsWhy are we bothering with parallelization Everyone loves his single thread – Alan Mc Govern Mono hacker 3 / 23
    • Why bother? ParallelFx A note for the future QuestionsWhy are we bothering with parallelization 4 / 23
    • Why bother? ParallelFx A note for the future QuestionsWhy are we bothering with parallelization Because the free lunch is over! 4 / 23
    • Why bother? ParallelFx A note for the future QuestionsFree 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
    • Why bother? ParallelFx A note for the future QuestionsThe awesome idea6 / 23
    • Why bother? ParallelFx A note for the future QuestionsThe awesome idea Can’t scale vertically? Scale horizontally!6 / 23
    • Why bother? ParallelFx A note for the future QuestionsTrend of things Number of cores 1 2 4 12ish 80 Core 2 IntelPentium Core Duo Core i7-980X Quad prototype 7 / 23
    • Why bother? ParallelFx A note for the future QuestionsProblem8 / 23
    • Why bother? ParallelFx A note for the future QuestionsProblem No more magical free-lunch8 / 23
    • Why bother? ParallelFx A note for the future QuestionsSolution Let’s break up work... ....and share it among cores 9 / 23
    • Why bother? ParallelFx A note for the future QuestionsErrr... 10 / 23
    • Why bother? ParallelFx A note for the future QuestionsParallelization is difficult11 / 23
    • Why bother? ParallelFx A note for the future QuestionsParallelization is difficult Hard: is that stuff really thread safe?11 / 23
    • Why bother? ParallelFx A note for the future QuestionsParallelization is difficult Hard: is that stuff really thread safe? Tedious: whose turn is it to debug deadlocks?11 / 23
    • Why bother? ParallelFx A note for the future QuestionsParallelization is difficult Hard: is that stuff really thread safe? Tedious: whose turn is it to debug deadlocks? Inefficient: how many thread to use?11 / 23
    • Why bother? ParallelFx A note for the future QuestionsParallelization is difficult Hard: is that stuff really thread safe? Tedious: whose turn is it to debug deadlocks? Inefficient: how many thread to use? Too few: it’s not scaling11 / 23
    • Why bother? ParallelFx A note for the future QuestionsParallelization is difficult Hard: is that stuff really thread safe? Tedious: whose turn is it to debug deadlocks? Inefficient: how many thread to use? Too few: it’s not scaling Too much: context-switching hurts performance11 / 23
    • Why bother? ParallelFx A note for the future QuestionsParallelization is difficult Hard: is that stuff really thread safe? Tedious: whose turn is it to debug deadlocks? Inefficient: how many thread to use? Too few: it’s not scaling Too much: context-switching hurts performance What if the number of core changes?11 / 23
    • Why bother? ParallelFx A note for the future QuestionsKISS time (Keep it simple, stupid)We need something different : 12 / 23
    • Why bother? ParallelFx A note for the future QuestionsKISS time (Keep it simple, stupid)We need something different : Automagically regulate thread usage at runtime 12 / 23
    • Why bother? ParallelFx A note for the future QuestionsKISS time (Keep it simple, stupid)We need something different : Automagically regulate thread usage at runtime As straightforward as possible 12 / 23
    • Why bother? ParallelFx A note for the future QuestionsKISS time (Keep it simple, stupid)We need something different : Automagically regulate thread usage at runtime As straightforward as possible Simulate familiar constructs 12 / 23
    • Why bother? ParallelFx A note for the future QuestionsKISS time (Keep it simple, stupid)We need something different : Automagically regulate thread usage at runtime As straightforward as possible Simulate familiar constructs Reuse existing code with only slight modification 12 / 23
    • Why bother? ParallelFx A note for the future QuestionsEnter ParallelFx ParallelFx at a glance13 / 23
    • Why bother? ParallelFx A note for the future QuestionsAt 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 thread14 / 23
    • Why bother? ParallelFx A note for the future QuestionsTasks 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
    • Why bother? ParallelFx A note for the future QuestionsFuture (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
    • Why bother? ParallelFx A note for the future QuestionsParallel.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
    • Why bother? ParallelFx A note for the future QuestionsDemo: Parallel For Demo: image processing with parallel loops18 / 23
    • Why bother? ParallelFx A note for the future QuestionsPLinq 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
    • Why bother? ParallelFx A note for the future QuestionsDemo: PLinq Demo: raytracing the PLinq way20 / 23
    • Why bother? ParallelFx A note for the future QuestionsState 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
    • Why bother? ParallelFx A note for the future QuestionsA note for the future22 / 23
    • Why bother? ParallelFx A note for the future QuestionsA note for the future GLinq: GPGPU-powered Linq22 / 23
    • Why bother? ParallelFx A note for the future QuestionsA note for the future GLinq: GPGPU-powered Linq Re-use PLinq pipeline22 / 23
    • Why bother? ParallelFx A note for the future QuestionsA note for the future GLinq: GPGPU-powered Linq Re-use PLinq pipeline Same design guidelines than PLinq: simplicity, transparency22 / 23
    • Why bother? ParallelFx A note for the future QuestionsA note for the future GLinq: GPGPU-powered Linq Re-use PLinq pipeline Same design guidelines than PLinq: simplicity, transparency Rewrite C# code in OpenCL (Expression trees FTW!)22 / 23
    • Why bother? ParallelFx A note for the future QuestionsA note for the future GLinq: GPGPU-powered Linq Re-use PLinq pipeline Same design guidelines than PLinq: simplicity, transparency Rewrite C# code in OpenCL (Expression trees FTW!) Transparent mapping of OpenCL idioms to .NET22 / 23
    • Why bother? ParallelFx A note for the future QuestionsClosing the curtains23 / 23