1. Sankarsan Bose
11th July 2010

2.  Concurrency
 Parallel Programming
 Parallel Extensions in .NET 4.0
 Coordination Data Structures
 Task Parallelism
 Parallel Loop /Data Parallelism
 Parallel LINQ

3. Concurrency

4. • Perform multiple Program A Program B
computations
What in overlapping time Step 1 T
periods Step1 I
Step2 M
E
• Responsive UI Step2
• Asynchronous
Why Processing
Step3
Step3
• Better performance(??)
Concurrency is almost everywhere…..
OS,Database,Web Servers,GUI programs, File processing….

5. Program
Concurrent Concurrent Concurrent
Component 1 Component 2 Component N
Read/Write
Shared Memory
Shared Memory Model of Concurrency

6. OS Process
Thread 1 Thread 2 Thread N
Read/Write
Shared Memory
Operating System View

7. Managed Program in CLR App Domain
Managed Managed Managed
Thread 1 Thread 2 Thread N
Read/Write
Shared Memory
.NET Common Language Runtime View

8. Create ThreadStart delegate
with the method to be
executed
Create instance of Thread
class with the ThreadStart
delegate
Start the thread execution

9.  Synchronization Issues
 Race Condition
 Deadlock
 Dependency on Memory Model & Hardware Architecture
 Debugging becomes complicated

10. Demo1

11. Run
Suspend
Thread1 Thread1
Suspend
Thread2 Thread2
Run Single Core
Program
Processor

12. Run
Thread1 Thread1
Core1
Run
Thread2 Thread2
Core2
Program
Multi Core Processor
Concurrency - Perform multiple computations in overlapping time periods
Parallel - Perform multiple computations simultaneously

13. Parallel
Programming

14.  No more increase in clock
speed
 Increase in number of
processors
 Sequential programs
won’t scale
 Parallel Programming
 To leverage hardware
advances
Source: PDC 09 Patterns of Parallel Programming Workshop

15.  Decompose the program into parts e.g. methods,
statements etc.
 Identify the parts which can be executed in parallel
 Assign each part to separate tasks
 Perform the tasks in parallel on different cores
 Each task is likely to perform different actions

16.  Partition the input data into multiple chunks
 Perform action on each chunk in parallel on different cores
 Merge the output results
 Can be scaled up with more processors as data volume grows

17. To develop applications for the multicore processors we need
 Design
 Identify parallel parts
 Apply correct design patterns
 Libraries
 Sophisticated synchronization features to avoid deadlocks/race etc.
 Thread safe data structures & containers
 Language/API support for common parallel programming patterns to achieve task/data
parallelism.
 Tools
 For debugging parallel applications
 For profiling parallel applications
Parallel Extensions in .NET 4.0

18. Parallel
Extensions in
.NET 4.0

19. Integrated Programming Models Programming Models
Tooling
PLINQ
Parallel Task Parallel Parallel Pattern Agents
Debugger Library Library
Library
Toolwindows
Data Structures
Data Structures
Concurrency Runtime Concurrency Runtime
ThreadPool
Profiler Task Scheduler
Concurrency Task Scheduler
Analysis
Resource Manager
Resource Manager
Operating System
Threads
Key: Managed Library Native Library Tools
Source: PDC 08 Daniel Moth’s Presentation

20. Thread-safe collections Phased Operation
ConcurrentStack<T>
ConcurrentQueue<T>
ConcurrentDictionary<TKey,TValue>
Locks
Work exchange
BlockingCollection<T>
IProducerConsumerCollection<T>
Initialization
LazyInit<T>
Source: PDC 08 Daniel Moth’s Presentation

21. Demo2

22. Demo3

23.  APIs provided under System.Threading & Sytem.Threading.Tasks
 Behind the scenes uses CLR Thread Pool
 Uses sophisticated algorithms to assign number of threads to
maximize performance
 More programmatic control than thread or work item
 Create/Start Tasks
 Return result values from tasks
 Chain Multiple Tasks
 Nested & Child Tasks
 Exception Handling

24. Constructor - public Task( Action action )
Action delegate - public delegate void Action()
Lambda Expression without
input parameter and
returning nothing
Create an explicit instance of
Action delegate and pass it to
task constructor
Start the Tasks

25. Class: public class Task<TResult> : Task
Constructor: public Task( Func<TResult> function )
Delegate: public delegate TResult Func<out TResult>()
Lambda Expression
without input
parameter and
returning int
Create new instance
of Func delegate with
no input parameter
and returning int
We have instantiated
& started two tasks
which expected to
return integer value
The property Result stores the return value

26. Class: public Task ContinueWith( Action<Task> continuationAction )
Instantiate a Task
with Action delegate
Create an Action
delegate with a task
object as input and
returning nothing.
Call ContinueWith
method and pass the
Action delegate
created
Start the Task.
After this task completes it will Continue With the execution of Action
a2 automatically

27. This is a lambda
expression and Task
t1 will execute this
statements
Task t11 is created
while Task T1 is
executing.
This is a Nested Task
Task t12 is created while Task T1 is executing but with
AttachedToParent option. This is a Child Task.
Child tasks are very closely synchronized with the parent

28. Demo4

29. Method : public static void Invoke( params Action[] actions )
Three Action delegates are
created
Three Action delegates will be
invoked possibly in Parallel

30. Demo5

31. Method : public static ParallelLoopResult For( int fromInclusive, int toExclusive,
Action<int> body )
Upper & Lower
Bounds of the For
Loop
Loop Counter
Statement
executed in the
loop
When a For() loop has a small body, it might perform more slowly
Slower performance is caused by the overhead involved in partitioning the data and the
cost of invoking a delegate on each loop iteration.

32. Method : public static ParallelLoopResult ForEach<TSource>( IEnumerable<TSource>
source, Action<TSource> body )
Int Array with
values from 0 to
100000
Loop iteration
variable
Loop Body

33. Demo6

34.  Language-Integrated Query (LINQ) was introduced in the .NET
Framework version 3.0
 Querying on any System.Collections.IEnumerable or
System.Collections.Generic.IEnumerable data source
 Parallel LINQ (PLINQ) is a parallel implementation of the LINQ
pattern
 PLINQ tries to make full use of all the processors on the system
 Partitions the data source into segments
 Executes the query on each segment on separate worker threads
in parallel on multiple processors

35. Method : public static ParallelQuery<TSource> AsParallel<TSource>( this
IEnumerable<TSource> source )
Method : public static void ForAll<TSource>( this ParallelQuery<TSource> source,
Action<TSource> action )
Instructs to execute
the LINQ query in
Parallel
Invokes in parallel the
specified action for
each element in the
source.

36. Demo7

37.  PLINQ, the goal is to maximize performance while maintaining
correctness
 In some cases, correctness requires the order of the source
sequence to be preserved
 Ordering can be computationally expensive
 PLINQ by default does not preserve the order of the source
sequence
 To turn on order-preservation the AsOrdered operator is to be
used on the source sequence

38. Method : public static ParallelQuery AsOrdered( this ParallelQuery source )
Instructs to execute the LINQ query in Parallel by
preserving order

39. Demo8

40. Thank You

41. http://msdn.microsoft.com/en-us/library/dd460693.aspx
http://channel9.msdn.com/pdc2008/TL26/
http://www.ademiller.com/blogs/tech/2009/11/pdc-patterns-
of-parallel-programming-workshop/
Concurrent Programming on Windows by Joe Duffy

42. Additional
Slides

43. This is like a pointer to
function which
accepts nothing and
returns nothing
Accepts delegate D as
input
M2 has no parameter
& return value
An instance of
delegate D or a
pointer to method
M2
Call to M1 with
delegate instance d1
as a parameter.
Call to M1 with
Lambda Expression
Lambda Expression is an anonymous method
(input parameters) => (statement)