Technology Corner

Home » Parallel Programming

Category Archives: Parallel Programming

Follow Technology Corner on WordPress.com

Parallel programming coding guidelines

 

This is awesome book from Microsoft on Parallel programming coding guidelines.

You can download here:

Below is Table content of this book

Table of Contents

  1. Primitives for Parallel Programming
  2. Tasks
  3. Parallel.For and Parallel.ForEach
  4. Parallel LINQ
  5. Concurrent Collections
  6. Coordination Primitives
  7. Correctness
  8. Thread Safety
  9. Locks
  10. Performance
  11. Measure
  12. Memory Allocations and Performance
  13. Caches and Performance
  14. Performance Tools
  15. Library Development
  16. Thread Safety and Documentation
  17. Optional Parallelism
  18. Exceptions
  19. Cancellation
  20. Testing
  21. Concurrency Testing
  22. Testing Tools
  23. Interactions
  24. User Interfaces
  25. ASP.NET
  26. Silverlight
Advertisements

Task Cancellation: Parallel Programming – III

This is my third article on Parallel programming. Last two articles are on Data Parallelism and Task Parallelism.

You can read my previous article here:

Begin with Parallel programming in Dotnet 4.0

Task Parallelism: Parallel programming – II

Today I am writing about how to cancel parallel tasks in cooperative manner i.e. dotnet framework doesn’t force your tasks to finish the task.

Task execution can be cancelled through use of cancellation Token which is new in DotNet Framework4.0. Task class supports Cancellation with the integration with System.Threading.CancellationTokenSource class and the System.Threading.CancellationToken class. Many of the constructors in the System.Threading.Tasks.Task class take a CancellationToken as an input parameter. Many of the StartNew overloads also take a CancellationToken.

CancellationTokenSource contains CancellationToken and Cancel method  through which cancellation request can be raised. I’ll cover following type of cancellation here:

  1. Cancelling a task.
  2. Cancelling Many Tasks
  3. Monitor tokens

Cancelling Task

Following steps will describe how to cancel a task:

    1. First create instance of CancellationTokenSource class
    2. Create instance of CancellationToken by setting Token property of CancellationTokenSource class.
    3. Start task by TaskFactory.StartNew method or Task.Start().
    4. Check for token.IsCancellationRequested property or token.ThrowIfCancellationRequested() for Cancellation Request.
    5. Execute Cancel method of CancellationTokenSource class to send cancellation request to Task.

SourceCode

            CancellationTokenSource tokenSource = new CancellationTokenSource();
            CancellationToken token = tokenSource.Token;

            int i = 0;
            Console.WriteLine("Calling from Main Thread {0}", System.Threading.Thread.CurrentThread.ManagedThreadId);
            var task = Task.Factory.StartNew(() =>
            {
		while (true)
                {
                    if (token.IsCancellationRequested)
                    {
                        Console.WriteLine("Task cancel detected");
                        throw new OperationCanceledException(token);
                    }
                    Console.WriteLine("Thread:{0} Printing: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, i++);
                }
            });

            Console.WriteLine("Cancelling task");
            
            tokenSource.Cancel();

 

When tokenSource.Cancel method execute then token.IsCancellationRequested property will gets true then you need to cancel execution of task. In above example I am throwing OperationCanceledException which should have parameter as token, but you need to catch this exception otherwise it will give error “Unhandled Exception”. If you don’t want to throw exception explicitly then you can use ThrowIfCancellationRequested method which internally throw OperationCanceledException and no need to explicitly check for token.IsCancellationRequested property.

	    CancellationTokenSource tokenSource = new CancellationTokenSource();
            CancellationToken token = tokenSource.Token;

            int i = 0;
            Console.WriteLine("Calling from Main Thread {0}", System.Threading.Thread.CurrentThread.ManagedThreadId);
            var task = Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    try
                    {
                        token.ThrowIfCancellationRequested();
                    }
                    catch (OperationCanceledException)
                    {
                        Console.WriteLine("Task cancel detected");
                        break;
                    }
                    Console.WriteLine("Thread:{0} Printing: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, i++);
                }


            });

            Console.WriteLine("Cancelling task");
            Thread.Sleep(10);
            tokenSource.Cancel();//Cancelling task
           Console.WriteLine("Task Status:{0}", task.Status);

Output

Calling from Main Thread 10

Cancelling task

Thread:6 Printing: 0

Thread:6 Printing: 1

Thread:6 Printing: 2

Thread:6 Printing: 3

Thread:6 Printing: 4

Thread:6 Printing: 5

Thread:6 Printing: 6

Thread:6 Printing: 7

Thread:6 Printing: 8

Thread:6 Printing: 9

Task Status:Running

Task cancel detected

Wait until Task Execution Completed

You can see TaskStatus is showing status as “Running’” in above output besides Cancel method fired before than task status. So to avoid execution next statement after cancel method we should wait for task to be in complete phase for this we can use Wait method of task class.

	Console.WriteLine("Cancelling task");
	Thread.Sleep(10);
        tokenSource.Cancel();
        task.Wait();//wait for thread to completes its execution
        Console.WriteLine("Task Status:{0}", task.Status);

Output

Calling from Main Thread 9

Cancelling task

Thread:6 Printing: 0

Thread:6 Printing: 1

Thread:6 Printing: 2

Thread:6 Printing: 3

Thread:6 Printing: 4

Thread:6 Printing: 5

Task cancel detected

Task Status:RanToCompletion

Cancelling Several Tasks

You can use one instance of token to cancel several tasks like in below example:

public void CancelSeveralTasks()
        {
             CancellationTokenSource tokenSource = new CancellationTokenSource();
            CancellationToken token = tokenSource.Token;

            int i = 0;
            Console.WriteLine("Calling from Main Thread {0}", System.Threading.Thread.CurrentThread.ManagedThreadId);

            Task t1 = new Task(() =>
            {
                while (true)
                {
                    try
                    {
                        token.ThrowIfCancellationRequested();
                    }

                    catch (OperationCanceledException)
                    {
                        Console.WriteLine("Task1 cancel detected");
                        break;
                    }

                    Console.WriteLine("Task1: Printing: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, i++);
                }
            }, token);

            Task t2 = new Task(() =>
            {
                while (true)
                {
                    try
                    {
                        token.ThrowIfCancellationRequested();
                    }

                    catch (OperationCanceledException)
                    {
                        Console.WriteLine("Task2 cancel detected");
                        break;
                    }

                    Console.WriteLine("Task2: Printing: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, i++);
                }
            });

            t1.Start();
            t2.Start();
            Thread.Sleep(100);
            tokenSource.Cancel();

            t1.Wait();//wait for thread to completes its execution
            t2.Wait();//wait for thread to completes its execution
            Console.WriteLine("Task1 Status:{0}", t1.Status);
            Console.WriteLine("Task2 Status:{0}", t1.Status);
        }

Output

Calling from Main Thread 9

Task1: Printing: 0

Task1: Printing: 1

Task1: Printing: 2

Task1: Printing: 3

Task1: Printing: 4

Task1: Printing: 5

Task1: Printing: 6

Task1: Printing: 7

Task1: Printing: 8

Task1: Printing: 9

Task1: Printing: 10

Task1: Printing: 11

Task1: Printing: 12

Task1: Printing: 14

Task1: Printing: 15

Task1: Printing: 16

Task1: Printing: 17

Task1: Printing: 18

Task1: Printing: 19

Task2: Printing: 13

Task2: Printing: 21

Task2: Printing: 22

Task2: Printing: 23

Task2: Printing: 24

Task2: Printing: 25

Task2: Printing: 26

Task2: Printing: 27

Task2: Printing: 28

Task2: Printing: 29

Task1: Printing: 20

Task1: Printing: 31

Task1: Printing: 32

Task1: Printing: 33

Task1: Printing: 34

Task2: Printing: 30

Task1: Printing: 35

Task1: Printing: 37

Task1: Printing: 38

Task2: Printing: 36

Task2: Printing: 40

Task2: Printing: 41

Task1: Printing: 39

Task1 cancel detected

Task2 cancel detected

Task1 Status:RanToCompletion

Task2 Status:RanToCompletion

Monitoring Cancellation with a Delegate

You can register delegate to get status of cancellation as callback. This is useful if your task is doing some other asynchronous operations. It can be useful in showing cancellation status on UI.

        public void MonitorTaskwithDelegates()
        {
            CancellationTokenSource tokenSource = new CancellationTokenSource();
            CancellationToken token = tokenSource.Token;

            int i = 0;
            Console.WriteLine("Calling from Main Thread {0}", System.Threading.Thread.CurrentThread.ManagedThreadId);

            Task t1 = new Task(() =>
            {
                while (true)
                {
                    try
                    {
                        token.ThrowIfCancellationRequested();
                    }

                    catch (OperationCanceledException)
                    {
                        Console.WriteLine("Task1 cancel detected");
                        break;
                    }

                    Console.WriteLine("Task1: Printing: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, i++);
                }
            }, token);

            //Register Cancellation Delegate
            token.Register(new Action(GetStatus));
            t1.Start();
            Thread.Sleep(10);
            //cancelling task
            tokenSource.Cancel();
        }
	public void GetStatus()
        {
            Console.WriteLine("Cancelled called");
        }

Output

Calling from Main Thread 10

Task1: Printing: 0

Task1: Printing: 1

Task1: Printing: 2

Task1: Printing: 3

Task1: Printing: 4

Task1: Printing: 5

Task1: Printing: 6

Task1: Printing: 7

Task1: Printing: 8

Task1: Printing: 9

Task1: Printing: 10

Task1: Printing: 11

Task1: Printing: 12

Cancelled called

Task1 cancel detected

 

I hope this article will help to you to understand Cooperative Cancellation in Parallel tasks.

Exception handling in Task Parallel Library

Handling Exceptions in parallel world is always challenge. If you know exceptions can be raised from piece of code then you wrap in try catch block to handle managed exceptions. But sometimes unhandled exceptions can be raised. It is very dangerous to not handle unhandled exceptions because it can stop execution of code unpredictably. Task Parallel Library (TPL)  provides consistent way of handling unhandled exceptions that raised while executing tasks in parallel.

If any exception occur in parallel task then CLR raise AggregateException object but this exception will not be caught until you trigger Wait, WaitAll, WaitAny methods of task class. You can see in below code, parallel loop fires exception but it doesn’t catch in catch block.

	public void Execution()
        {
            try
            {

                var task1 = Task.Factory.StartNew(() =>
                            {

                                for (int i = 0; i < 100; i++)
                                {
                                    if (i == 20)
                                        throw new Exception("throwing unhandled exception");
                                }

                            }
                );

            }
            catch (AggregateException ex)
            {
                foreach (Exception innerEx in ex.InnerExceptions)
                    Console.WriteLine(innerEx.Message);

            }

        }

Output

Please Key to Execute Tasks

SimpleCancelTask : 1

CancelSeveralTasks : 2

MonitorTaskwithDelegates : 3

Exception Handling : 4

4Executing Exception Handling Samples

Press enter to exit

To catch exception you need to put task1.Wait() method. AggregateException object wraps all exceptions raised in parallel tasks in inner exception collections.

public void Execution()
        {
            try
            {

                var task1 = Task.Factory.StartNew(() =>
                            {

                                for (int i = 0; i < 100; i++)
                                {
                                    if (i == 20)
                                        throw new Exception("throwing unhandled exception");
                                }

                            }
                );

                task1.Wait();
            }
            catch (AggregateException ex)
            {
                foreach (Exception innerEx in ex.InnerExceptions)
                    Console.WriteLine(innerEx.Message);

            }

        }

Output

Please Key to Execute Tasks

SimpleCancelTask : 1

CancelSeveralTasks : 2

MonitorTaskwithDelegates : 3

Exception Handling : 4

4Executing Exception Handling Samples

throwing unhandled exception

Press enter to exit

In above output you can see exception has caught and showing exception message as inner exception.

Now I will discuss how we can capture exceptions when triggered from many parallel tasks.

Exceptions Handling in many parallel tasks

You can trigger AggregatedException object from different parallel tasks by putting Task.WaitAll method which will wait for all tasks exceptions.

public void ExecutionHandlingForManyTasks()
        {
            try
            {
                Console.WriteLine("Output");
                Console.WriteLine("============================================================");
                Console.WriteLine("\n\n");
                var task1 = Task.Factory.StartNew(() =>
                {

                    for (int i = 0; i < 100; i++)
                    {
                        if (i == 20)
                            throw new Exception("Task1: throwing unhandled exception");
                    }

                }
                );

                var task2 = Task.Factory.StartNew(() =>
                {
                    throw new Exception("Task2: throwing unhandled exception");
                }
                );

                Task.WaitAll(task1, task2);

            }
            catch (AggregateException ex)
            {
                foreach (Exception innerEx in ex.InnerExceptions)
                    Console.WriteLine(innerEx.Message);

            }

        }

Output

Please Key to Execute Tasks

SimpleCancelTask : 1

CancelSeveralTasks : 2

MonitorTaskwithDelegates : 3

Exception Handling in one task: 4

Exception Handling in many tasks: 5

5Output

============================================================

Task2: throwing unhandled exception

Task1: throwing unhandled exception

Press enter to exit

Task Parallelism: Parallel programming – II

 

Please read Begin with Parallel programming in Dotnet 4.0 article if you have not read.

Task Parallelism

This is strategy to run independent task in parallel way. It focuses on distributing execution process (threads) across different parallel computing nodes.Task parallelism emphasizes the distributed (parallelized) nature of the processing (i.e. threads), as opposed to the data parallelism. Most real programs fall somewhere on a continuum between Task parallelism and Data parallelism. Workflow of task parallelism is below:

 

image

Dot Net Framework provides Task Parallel Library (TPL)  to achieve Task Parallelism. This library provides two primary benefits:

  1. More Efficient and more scalable use of system resources.
  2. More programmatic control than is possible with a thread or work item.

Behind the scenes tasks are queued in ThreadPool, which has been enhanced with algorithms in .Net 4.0 that determine and adjust to the number of threads that maximizes throughput. This makes tasks relatively lightweight, and you can create many of them to enable fine-grained parallelism. To complement this, widely-known work-stealing algorithms are employed to provide load-balancing.

This library provides more features to control tasks like: cancellation, continuation, waiting, robust exception handling, scheduling etc.

The classes for TaskParallelism are defined in System.Threading.Tasks:

Class Purpose
Task For running unit of work concurrently.
Task<Result> For managing unit of work with return value
TaskFactory Factory Class to create Task class Instance.
TaskFactory<TResult> Factory Class to create Task class Instance and return value.
TaskScheduler for scheduling tasks.
TaskCompletionSource For manually controlling a
task’s workflow

How to Create and execute Tasks

Task Creation and Execution can be done by two ways: Implicit and Explicit.

Create and Execute Task Implicitly

Parallel.Invoke method helps to to run unit of work in parallel. you can just pass any number of Action delegates as parameters. The no. of tasks created by Invoke method is not necessarily equal to Action delegates provided because this method automatically does some optimization specially in this case.

Source Code

        private static void Run2()
        {
            Thread.Sleep(1000);
            Console.WriteLine("Run2: My Thread Id {0}", Thread.CurrentThread.ManagedThreadId);
        }

        private static void Run1()
        {
            Thread.Sleep(1000);
            Console.WriteLine("Run1: My Thread Id {0}", Thread.CurrentThread.ManagedThreadId);
        }

        static void Main(string[] args)
        {
            //Create and Run task implicitly
            Parallel.Invoke(() => Run1(), () => Run2());
            Console.ReadLine();
        }

Output

Run2: My Thread Id 11

Run1: My Thread Id 10

This approach of creating task does not give greater control over task execution, scheduling etc. Better approach is to create task by TaskFactory class.

Create and Execute Task Explicitly

You can create task by creating instance of task class and pass delegate which encapsulate the code that task will execute. These delegate can be anonyms, Action delegate, lambda express and method name etc.

Example of creating tasks:

Source Code:

        private static void Run2()
        {
            Thread.Sleep(1000);
            Console.WriteLine("Run2: My Thread Id {0}", Thread.CurrentThread.ManagedThreadId);

        }

        private static void Run1()
        {
            Thread.Sleep(1000);
            Console.WriteLine("Run1: My Thread Id {0}", Thread.CurrentThread.ManagedThreadId);

        }

        static void Main(string[] args)
        {
            // Create a task and supply a user delegate by using a lambda expression.
            // use an Action delegate and a named method
            Task task1 = new Task(new Action(Run1));

            // use a anonymous delegate
            Task task2 = new Task(delegate
                        {
                            Run1();
                        });

            // use a lambda expression and a named method
            Task task3 = new Task(() => Run1());
            // use a lambda expression and an anonymous method
            Task task4 = new Task(() =>
            {

                Run1();
            });

            task1.Start();
            task2.Start();
            task3.Start();
            task4.Start();
            Console.ReadLine();
        }

Output

Run1: My Thread Id 13

Run1: My Thread Id 12

Run1: My Thread Id 11

Run1: My Thread Id 14

If you don’t want to create and starting of task separated then you can use TaskFactory class. Task exposes “Factory” property which is instance of TaskFactory class.

Task task5= Task.Factory.StartNew(()=> {Run1();});

Task with Return Values

To get value from when task completes it execution, you can use generic version of Task class.

 public static void Main(string[] args)
        {
            //This will return string result
            Task task = Task.Factory.StartNew(() => ReturnString());
            Console.WriteLine(task.Result);// Wait for task to finish and fetch result.
            Console.ReadLine();
            
        }

        private static string ReturnString()
        {
            return "Neeraj";
        }

Task State

If you are running multiple tasks same time and you want to track progress of each task then using "State" object is better approach.

 
	public static void Main(string[] args)
        {
            //This will return string result
            for (int i = 0; i < 5; i++)
            {
                Task task = Task.Factory.StartNew(state => ReturnString(), i.ToString());
                //Show progress of task
                Console.WriteLine("Progress of this task {0}: {1}", i, task.AsyncState.ToString());
            }
            
            Console.ReadLine();

        }

        private static void  ReturnString()
        {
            //DO something here

           // Console.WriteLine("hello");
        }

Output

Progress of this task 0: 0

Progress of this task 1: 1

Progress of this task 2: 2

Progress of this task 3: 3

Progress of this task 4: 4

In Next blog, I’ll explain TaskCreationOptions,Waiting,Cancellation tasks etc.

Please keep giving your valuable feedbacks.

Begin with Parallel programming in Dotnet 4.0

 

Now a days computers are coming with multiple processors that enable multiple threads to be executed simultaneously to give performance of applications and we can expect significantly more CPUs in near future. If application is doing CPU intensive tasks and we find that one CPU is taking 100 %usage and others are idle. It might be situation when one thread is doing cpu intensive work and other threads are doing non cpu intensive work. In this case application is not utilizing all CPUs potential here. To get benefits all CPUs Microsoft launches Parallel Programming Library in DotNet Framework 4.0.

We can say “Programming to leverage multicores or multiple processors is called parallel programming”. This is a subset of the broader concept of multithreading.

To use your system’s CPU resources efficiently, you need to split your application into pieces that can run at the same time and we have CPU intensive task that should be breaks into parts like below:

  1. Partition it into small chunks.
  2. Execute those chunks in parallel via multithreading.
  3. Collate the results as they become available, in a thread-safe and performant manner.

We can also achieve this in traditional way of multithreading but partitioning and collating of chunks can be nightmare because we would need to put locking for thread safety and lot of synchronizatopm to collate everything. Parallel programming library has been designed to help in such scenarios. You don’t need to worry about partitioning and collating of chunks. These chunks will run in parallel on different CPUs.

There can be two kind of strategy for partitioning work among threads:

  1. Data Parallelism: This strategy fits in scenario in which same operation is performed concurrently on elements like collections, arrays etc.
  2. Task Parallelism: This strategy suggests independent tasks running concurrently.

Data Parallelism

In this parallelism, collection or array is partitioned so that multiple threads can operate on different segments concurrently. DotNet supports data parallelism by introducing System.Threading.Tasks.Parallel static class. This class is having methods like Parallel.For, Parallel.ForEach etc. These methods automatically partitioned data on different threads, you don’t need to write explicit implementation of thread execution.

Below is simple example of Parallel.For Method and you can see how it has utilize all cores and you are not using any synchronization here:

Parallel.For(0, 20, t => { Console.WriteLine("Thread{0}:Value:{1}",Thread.CurrentThread.ManagedThreadId,t); });

Output

Thread10:Value:0
Thread7:Value:5
Thread10:Value:1
Thread6:Value:10
Thread10:Value:2
Thread10:Value:3
Thread10:Value:4
Thread10:Value:8
Thread10:Value:9
Thread10:Value:13
Thread10:Value:14
Thread10:Value:16
Thread10:Value:17
Thread10:Value:18
Thread10:Value:19
Thread12:Value:15
Thread6:Value:11
Thread6:Value:12
Thread7:Value:6
Thread7:Value:7

Above example tells you how Parallel class is utilizing all cores. Now I am giving you example of performance of Parallel loop for CPU intensive tasks over sequential loop.

System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
    //Sequential Loop
    stopwatch.Start();
    for(int i=0;i<20000;i++)
        {
            double temp = i * new Random().Next() + Math.PI;
        }
    stopwatch.Stop();
    Console.WriteLine("Total Time (in milliseconds) Taken by Sequential loop: {0}",stopwatch.ElapsedMilliseconds);
    stopwatch.Reset();

    //Parallel Loop
    stopwatch.Start();
    Parallel.For(0, 20000, t => 
        {
            double temp = t * new Random().Next() +Math.PI;
        });
    stopwatch.Stop();
    Console.WriteLine("Total Time (in milliseconds) Taken by Parallel loop: {0}", stopwatch.ElapsedMilliseconds); 

Output

 

Total Time (in milliseconds) Taken by Sequential loop: 159
Total Time (in milliseconds) Taken by Parallel loop: 80

 


I’ll explain Task Parallelism in next blog. Please share your comments.