Parallel Computing with VS 2010 Beta 1

Here is a sample implementation to show performance enhancement by parallel processing using the Task Parallel Libraries

Wednesday, October 07, 2009

Print

Comment

Email

Digg

Del.icio.us

Reddit

Twitter

In the article 'Programming for Multi-core Processors' carried in this issue, we have talked about how you can utilize your the capabilities of your multi-core machine. Here, we'll talk about another way of doing the same by using Task Parallel Library (TPL). TPL is designed to automatically utilize all the processors in a machine which results in enhanced performance, as displayed in this sample implementation. TPL contains algorithms that automatically adapt to a particular machine. For example, if you are running a parallel for loop on a single core machine, it will perform as normal for loop. But if the same is run on a multi-core machine, it will parallelize automatically. If any exception is thrown in any of the iterations, all iterations are canceled and the first thrown exception is re-thrown in the calling thread ensuring that exceptions are properly propagated and never lost. One point to keep in mind while using TPL is that, it does not support synchronization therefore, it is important for programmers to take in account safe synchronous execution.

Though one can use thread pool for parallelizing their code, it is very complicated when compared with usage of TPL. When using thread pool instead of TPL, one often divides work statically which leads to uneven work distribution. TPL on the other hand uses work-stealing techniques to dynamically adapt and distribute work items over the worker threads. TPL has task manager that by default assigns one worker thread per processor. This ensures minimum thread switching by OS. Each thread has its own queue of tasks and when this queue becomes empty, thread tries to 'Steal' work from other queues of worker threads.

Implementation
To show how parallel processing can boost your application performance, we have created a sample code that measures time of processing. We ran this code in three different scenarios. First, we used simple 'for' loop and calculated time of execution on single core, then we used 'Parallel.For' loop to parallelize execution of conventional 'for' loop. We executed 'Parallel.For' loop on two different machines one with two cores and other with four. To start with, create a console application in Visual Studio. We have used C# as programming language. Now add 'System.Threading' reference to program and add following code:

The comparative graph shows execution of 'for' loop and 'Parallel.For' loop. Parallel for loop is executed on quad core and dual core machines.

using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
var source = Enumerable.Range(1, 1000);
using System.Linq;
using System.Text;
using System.Threading;

namespace ParallelTPL
{
class Program
{
static void Main(string[] args)
{

DateTime startTime = DateTime.Now;
Console.WriteLine(startTime);

/*for (int i = 0; i < 1000; i++)
{
Thread.Sleep(100);
Console.WriteLine(i);
}*/

Parallel.For(0, 1000, delegate(int i)
{
Thread.Sleep(100);
Console.WriteLine(i);
});

DateTime stopTime = DateTime.Now;
Console.WriteLine(stopTime);

TimeSpan duration = stopTime - startTime;
Console.WriteLine(duration);

Console.ReadLine();
}
}
}

Output of conventional 'for' loop. Results are displayed on order as execution happens in sequence.	Output of 'Parallel.For' loop on quad core machine. Results are out of order as execution happens in parallel.

There are three important parts to this code -first is the code that calculates and displays time of execution. This code again has three parts, first it gets current time (before execution) via following code:

DateTime T = DateTime.Now;
Console.WriteLine(T)

After these lines, add your code for which you want to calculate processing time, then again get current time (after execution) and finally subtract two to get time elapsed in execution. Second important part of the sample code is conventional 'for' loop. In this loop, every iteration is executed in sequence. Finally third part of the code is 'Parallel.For' loop, where 'for' loop is executed in parallel using multiple cores of machine. As one can see 'Parallel.For' loop takes three arguments, first two arguments specify the iteration limits with last argument being delegate expression.

Results
When we compared time of execution of the same code, we found out that conventional 'for' loop was able to execute in 100 seconds. When we executed 'Parallel.For' loop in dual core machine, execution time was 25 seconds while that for quad core machine was just 11 seconds. These results show how one can boost application performance using Task Parallel Library present in .NET Framework

Page(s)   1