Programming for Multi-core processors

BANGALORE, INDIA: Multi-core processorsadvanced a lot and are being used in mobile phones and PDAs today. To harness these multi-core capabilities, developers need to parallelize their code. Microsoft Visual Studio 2010 and .NET Framework 4.0 Beta 1 are filled with features to help developers write efficient code for multi-core machines and that too without drilling deep to thread level. Parallel programming support in latest version of VS comprises of following features:

• Task Parallel Library (TPL), for implementation of 'For' and 'ForEach' loop which in turn help in defining concurrent tasks
• Data structures for parallel programming
• Parallel diagnostic tools which include debugger window for tasks and parallel tasks
• PLINQ -the parallel implementation of LINQ. PLINQ can be used to enhance performance where one needs to process large sets of data like trade analysis, scientific computing etc.

PLINQ

Parallel Language Integrated Query (PLINQ) is the parallel implementation of LINQ to objects. PLINQ combines the simplicity and readability of LINQ syntax with the power of parallel programming. Based on the capability of host computer, PLINQ queries parallelize themselves. Executing queries using PLINQ is similar to the way queries are executed with LINQ.

All the operators supported by 'System.Linq.Enurmables' can be used in writing PLINQ queries. One point to note here is that, LINQ-to-SQL and LINQ-to-Entities cannot be parallelized as these queries would still be executed by respective databases. Writing a PLINQ query is similar to writing LINQ query with addition of two simple steps.

First one needs to add reference to 'System.Threading.dll' assembly during compilation, then wrap data source around the 'IParallelEnumerable' interface using a call to the 'AsParallel' extension method. 'AsParallel' method instructs compiler to use 'IParallelEnumerable' rather then 'Enumerable'. Here is some sample PLINQ code that displays all the numbers between 1 to 1000 that give zero reminder after division with 10. We have written this code using Visual Studio 2010 and used C# as programming language:

namespace ConsoleApplication2

{

class Program

{

static void Main(string<> args)

{

var source = Enumerable.Range(1, 1000);

var parallelQuery = from num in source.AsParallel()

where num % 10 ==0

select num;

} } }

Output Processing

Like LINQ, PLINQ also has deferred execution, parallelism does not get introduced until output is processed. There are three ways to process output in PLINQ. In the pipeline processing model, thread doing enumeration is separated from the threads running query. This means if your machine has n processors then n-1 would be used for running PLINQ query and 1 would be used to run 'foeach' loop on output of PLINQ query. Here is the sample code that processes output of the above PLINQ query:

foreach (var q in parallelQuery)

{

Console.WriteLine(q);

}

Second processing model is stop-and-go processing. In this model, the thread that starts enumeration joins all the other threads to execute PLINQ query. And once all threads have finished processing query, the thread then moves to enumerating output. Finally there is inverted enumeration model, here a lambda function is provided to PLINQ that is run in parallel, once for each in element in the output. To use this output processing model, special 'ForAll' API is used. Here is the sample code that processes output of above PLINQ query:

parallelQuery.ForAll(q => Console.WriteLine(q));

Exception handling

As queries are executed in parallel, there is a different mechanism of handling exceptions in PLINQ. Consider the following code snippet:

string<> arrStr = new string<>{"1","2","g","3","4","5","6","7","8","9",""};

var query = from a in arrStr.AsParallel()

select int.Parse(a);

query.ForAll(q => Console.WriteLine(q));

This snippet should throws two exceptions, but, as query is processed in parallel depending on the number of processors in your machine, you might get different exceptions in different order. When an exception occurs in a thread, PLINQ tries to stop all other threads as quickly as possible. Once all threads are stopped, PLINQ aggregates all exceptions into a new

System.Threading.AggregateException

and throws it. These exceptions are available as inner exceptions along with their stack trace. Besides making application run faster, PLINQ also enables you to do more computation on large data set in given amount of time.