This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Don’t expect your sequential program to run fasteron new processors
Still, processor technology advancesBUT the focus now is on multiple cores per chipToday’s desktops typically have 4 cores.Latest Intel multi-core chip has 48 cores.Expect 100s of cores in the near future.
Don’t expect your sequential program to run fasteron new processorsStill, processor technology advancesBUT the focus now is on multiple cores per chipToday’s desktops typically have 4 cores.Latest Intel multi-core chip has 48 cores.Expect 100s of cores in the near future.
C# provides several mechanisms for par. programming:
Explicit threads with synchronisation via locks, criticalregions etc.
The user gets full control over the parallel code.BUT orchestrating the parallel threads is trickyand error prone (race conditions, deadlocks etc)This technique requires a shared-memory model .
Options for Parallel Programming in C#C# provides several mechanisms for par. programming:Explicit threads with a message-passing library :
Threads communicate by explicitly sendingmessages, with data required/produced, betweenworkstations.Parallel code can run on a distributed-memoryarchitecture, eg. a network of workstations.The programmer has to write code for(un-)serialising the data that is sent betweenmachines.BUT threads are still explicit, and the difficulties inorchestrating the threads are the same.A common configuration is C+MPI.
C# provides several mechanisms for par. programming:OpenMP provides a standardised set of programannotations for parallelism, without explicit threads.
The annotations provide information to thecompiler where and when to generate parallelism.It uses a shared-memory model and communicationbetween (implicit) threads is through shared data.This provides a higher level of abstraction andsimplifies parallel programming.BUT it currently only works on physicalshared-memory systems.
C# provides several mechanisms for par. programming:Declarative languages, such as F# or Haskell, do notoperate on a shared program state, and thereforeprovide a high degree if inherent parallelism:
Implicit parallelism is possible, ie. no additionalcode is needed to generate parallelism.The compiler and runtime-system automaticallyintroduce parallelism.BUT the resulting parallelism is often fine-grainedand inefficient.Therefore, typically annotations are used toimprove parallel performance.
C# provides several mechanisms for par. programming:
Parallel patterns, or skeletons, capture commonpatterns of parallel computation and provide a fixedparallel implementation. They are a specific instance ofdesign patterns.
To the programmer, most parallelism is implicit.The program has to use a parallel pattern toexploit parallelism.Using such patterns requires advanced languagefeatures, in particular delegates (higher-orderfunctions).
C# supports two main models of parallelism:Data parallelism: where an operation is applied toeach element in a collection.Task parallelism: where independent computationsare executed in parallel.
The language construct for is translated into a(higher-order) function Parallel.For .The argument to Parallel.For is an anonymousmethod , specifying the code to be performed ineach loop iteration.The arguments to this anonymous method are thestart value, the end value and the iteration variable.
Parallel loops have two ways to break or stop a loopinstead of just one.
Parallel break, loopState.Break(), allows all stepswith indices lower than the break index to runbefore terminating the loop.Parallel stop, loopState.Stop(), terminates the loopwithout allowing any new steps to begin.
The parallel aggregate pattern combines dataparallelism over a collection, with the aggregationof the result values to an overall result.It is parameterised both over the operation on eachelement as well as the combination (aggregation)of the partial results to an overall results.This is a very powerful pattern, and it has becomefamous as the Google MapReduce pattern.
The ForEach loop iterates over all elements of asequence in parallel .Its arguments are:
A sequence to iterate over;options to control the parallelism (optional);a delegate initialising the result value;a delegate specifying the operation on eachelement of the sequence;a delegate specifying how to combine the partialresults;
To protect access to the variable holding theoverall result, a lock has to be used.
Another Example of Parallel Aggregatesint size = seq.Count / k; // make a partition large enough to feed k coresvar rangePartitioner = Partitioner.Create(0, seq.Count, size);Parallel.ForEach(rangePartitioner, () => 0, // The local initial partial result// The loop body for each interval(range, loopState, initialValue) => {
// a *sequential* loop to increas the granularity of the parallelismint partialSum = initialValue;for (int i = range.Item1; i < range.Item2; i++) {
partialSum += Fib(seq[i]);}return partialSum; },
// The final step of each local context(localPartialSum) => {
// Use lock to enforce serial access to shared resultlock (lockObject) {
sum += localPartialSum;}
});Hans-Wolfgang Loidl <[email protected]> Parallel Programming in C#
A Partitioner (System.Collections.Concurrent) isused to split the entire range into sub-ranges.Each call to the partitioner returns an index-pair,specifying a sub-range.Each task now works on such a sub-range, using asequential for loop.This reduces the overhead of parallelism and canimprove performance.
When independent computations are started indifferent tasks, we use a model of task parallelism.This model is more general than data parallelism,but requires more detailed control ofsynchronisation and communication.The most basic construct for task parallelism is:Parallel.Invoke(DoLeft, DoRight);
It executes the methods DoLeft and DoRight inparallel, and waits for both of them to finish.
Sometimes we want to start several computations,but need only one result value.As soon as the first computation finishes, all othercomputations can be aborted.This is a case of speculative parallelism.The following construct executes the methodsDoLeft and DoRight in parallel, waits for the firsttask to finish, and cancels the other, still running,task:Parallel.SpeculativeInvoke(DoLeft, DoRight);
FuturesA future is variable, whose result may be evaluatedby a parallel thread.
Synchronisation on a future is implicit, dependingon the evaluation state of the future upon read:
If it has been evaluated, its value is returned;if it is under evaluation by another task, the readertask blocks on the future;if evaluation has not started, yet, the reader taskwill evaluate the future itself
The main benefits of futures are:Implicit synchronisation;automatic inlining of unnecessary parallelism;asynchronous evaluation
Continuation tasks can be used to build a chain oftasks, controlled by futures.
FuturesA future is variable, whose result may be evaluatedby a parallel thread.Synchronisation on a future is implicit, dependingon the evaluation state of the future upon read:
If it has been evaluated, its value is returned;if it is under evaluation by another task, the readertask blocks on the future;if evaluation has not started, yet, the reader taskwill evaluate the future itself
The main benefits of futures are:Implicit synchronisation;automatic inlining of unnecessary parallelism;asynchronous evaluation
Continuation tasks can be used to build a chain oftasks, controlled by futures.
FuturesA future is variable, whose result may be evaluatedby a parallel thread.Synchronisation on a future is implicit, dependingon the evaluation state of the future upon read:
If it has been evaluated, its value is returned;if it is under evaluation by another task, the readertask blocks on the future;if evaluation has not started, yet, the reader taskwill evaluate the future itself
The main benefits of futures are:Implicit synchronisation;automatic inlining of unnecessary parallelism;asynchronous evaluation
Continuation tasks can be used to build a chain oftasks, controlled by futures.
FuturesA future is variable, whose result may be evaluatedby a parallel thread.Synchronisation on a future is implicit, dependingon the evaluation state of the future upon read:
If it has been evaluated, its value is returned;if it is under evaluation by another task, the readertask blocks on the future;if evaluation has not started, yet, the reader taskwill evaluate the future itself
The main benefits of futures are:Implicit synchronisation;automatic inlining of unnecessary parallelism;asynchronous evaluation
Continuation tasks can be used to build a chain oftasks, controlled by futures.
private static int par_code(int a) {// constructing a future generates potential parallelismTask<int> futureB = Task.Factory.StartNew<int>(() => F1(a));int c = F2(a);int d = F3(c);int f = F4(futureB.Result, d);return f;
Divide-and-Conquer is a common (sequential)pattern:
If the problem is atomic, solve it directly;otherwise the problem is divided into a sequence ofsub-problems;each sub-problem is solved recursively by thepattern;the results are combined into an overall solution.
Example: Partition (Argh)private static int Partition(int[] array, int from, int to, int pivot) {// requires: 0 <= from <= pivot <= to <= array.Length-1int last_pivot = -1;int pivot_val = array[pivot];if (from<0 || to>array.Length-1) {
throw new System.Exception(String.Format("Partition: indices out of bounds: from={0}, to={1}, Length={2}",from, to, array.Length));
}while (from<to) {if (array[from] > pivot_val) {
Swap(array, from, to);to--;
} else {if (array[from]==pivot_val) {
last_pivot = from;}from++;
}}if (last_pivot == -1) {
if (array[from]==pivot_val) {return from;
} else {throw new System.Exception(String.Format("Partition: pivot element not found in array"));
}}if (array[from]>pivot_val) {
// bring pivot element to end of lower halfSwap(array, last_pivot, from-1);return from-1;
} else {// done, bring pivot element to end of lower halfSwap(array, last_pivot, from);return from;
An explicit threshold is used to limit the amount ofparallelism that is generated (throttling).This parallelism threshold is not to be confusedwith the sequential threshold to pick theappropriate sorting algorithm.Here the divide step is cheap, but the combine stepis expensive; don’t expect good parallelism fromthis implementation!
A pipeline is a sequence of operations, where theoutput of the n-th stage becomes input to then + 1-st stage.Each stage is typically a large, sequentialcomputation.Parallelism is achieved by overlapping thecomputations of all stages.To communicate data between the stages aBlockingCollection<T> is used.This pattern is useful, if large computations workon many data items.
Do you need to summa-rize data by applying somekind of combination oper-ator? Do you have loopswith steps that are notfully independent?
The Parallel Aggregationpattern.Parallel aggregation intro-duces special steps in thealgorithm for merging par-tial results. This pat-tern expresses a reduc-tion operation and in-cludes map/reduce as oneof its variations.
Does your applicationperform a sequence ofoperations repetitively?Does the input data havestreaming characteris-tics? Does the order ofprocessing matter?
The Pipelines pattern.Pipelines consist of com-ponents that are con-nected by queues, in thestyle of producers andconsumers. All the com-ponents run in paralleleven though the order ofinputs is respected.
The preferred, high-level way of coding parallelcomputation in C# is through parallel patterns, aninstance of design patterns.Parallel patterns capture common patterns ofparallel computation.Two main classes of parallelism exist:
Data parallelism, which is implemented throughparallel For/Foreach loops.Task parallelism, which is implemented throughparallel method invocation.
Tuning the parallel performance often requires coderestructuring (eg. thresholding).
“Parallel Programming with Microsoft .NET —Design Patterns for Decomposition andCoordination on Multicore Architectures”, by C.Campbell, R. Johnson, A. Miller, S. Toub.Microsoft Press. August 2010. http://msdn.microsoft.com/en-us/library/ff963553.aspx“Patterns for Parallel Programming”, by T. G. Mattson,B. A. Sanders, and B. L. Massingill. Addison-Wesley,2004.“MapReduce: Simplified Data Processing on LargeClusters”, J. Dean and S. Ghemawat. In OSDI ’04 —Symp. on Operating System Design andImplementation, pages 137–150, 2004.http://labs.google.com/papers/mapreduce.html
Next term: F21DP2 “Distributed and ParallelSystems”In this course we will cover parallelprogramming in
C+MPI: threads with explicit messagepassingOpenMP: data and (limited) taskparallelismparallel Haskell: semi-explicit parallelism ina declarative language