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.