MSDN Magazine - October 2007 - (Page 71)

currency offerings, and what it looks like from the perspective of LINQ developers. We conclude with some example scenarios where PLINQ has already shown tremendous value. Note that the Parallel FX library, which includes PLINQ, is currently still under development, but the first Community Tech Preview (CTP) will be available from MSDN® in Fall ’07. Watch blogs.msdn.com/somasegar for details. From LINQ to PLINQ When people first hear about the PLINQ project, they usually ask: why parallelize LINQ? The simple answer is that LINQ’s setat-a-time programming model for expressing computations places an emphasis on specifying what needs to get done instead of how it is to be done. Without LINQ, the how part would typically otherwise be expressed through the use of loops and intermediary data structures, but by encoding so much specific information, the compiler and runtime cannot parallelize as easily. LINQ’s declarative nature, on the other hand, leaves the flexibility for a clever implementation like PLINQ to use parallelization to obtain the same results. The follow-up question is inevitably: if you’re going to query enough data for PLINQ to make sense, why not just use a database? And the answer to this question takes the form of a rhetorical question: what code would you have written if you weren’t using LINQ? Well, you’d likely be doing the same amount of data- and compute-intensive work, but it would have been captured inside an unstructured series of for loops, function calls, and so forth. So this question implies that all programs should reside in the database, which I’m sure very few people would agree with. With PLINQ you don’t need to move your entire database server processing logic over to in-memory LINQ-to-Objects queries in the client. Rather, PLINQ offers an incremental way of taking advantage of parallelism for existing solutions to existing problems. If your problem is data-intensive enough and would traditionally demand that you pursue a database solution, you should still pursue such a solution. PLINQ changes very little of that. However, if you have several data sources that you’d like to query together—possibly heterogeneous, spanning databases, XML files, and so on—PLINQ can take over and parallelize once data is on the client. Naturally, people then ask: why doesn’t LINQ-to-Objects itself just run queries in parallel? The parallelism would be completely hidden, and developers wouldn’t need to change a single line of code to reap the benefits of it. Sadly, there are some subtle gotchas that can arise with the move from LINQ to PLINQ that prohibit us from realizing this vision, at least for PLINQ 1.0. These will be discussed more later in the article. query any in-memory collection such as T[], List , or any other kind of IEnumerable in addition to XML documents loaded using the System.Xml.Linq APIs. If you already have a bunch of LINQ queries, PLINQ is equipped to run them. LINQ-to-SQL and LINQ-to-Entities queries will still be executed by the respective databases and query providers, so PLINQ does not offer a way to parallelize those queries. If you The LINQ programming wish to process the results model for expressing of those queries in memory, computations places an including joining the output of many heterogeneous emphasis on specifying what queries, then PLINQ can be needs to get done instead of quite useful. how it is to be done. Aside from writing LINQ queries the same way you’re used to writing them, there are two extra steps needed to make use of PLINQ: 1. Reference the System.Concurrency.dll assembly during compilation. 2. Wrap your data source in an IParallelEnumerable with a call to the System.Linq.ParallelEnumerable.AsParallel extension method. Calling the AsParallel extension method in Step 2 ensures that the C# or Visual Basic compiler binds to the System.Linq.ParallelEnumerable version of the standard query operators instead of System.Linq.Enumerable. This gives PLINQ a chance to take over control and to execute the query in parallel. AsParallel is defined as taking any IEnumerable : public static class System.Linq.ParallelEnumerable { public static IParallelEnumerable AsParallel ( this IEnumerable source); the other standard query operators } PLINQ Programming Model Using PLINQ is almost exactly like using LINQ-to-Objects and LINQ-to-XML. You can use any of the operators available through C# 3.0 and Visual Basic® 9.0 query comprehension syntax or the System.Linq.Enumerable class, including OrderBy, Join, Select, Where, and so on. PLINQ supports all of the LINQ operators, not just those available in language comprehensions. And you can IParallelEnumerable derives from IEnumerable and adds very little to it, being there simply to facilitate binding to PLINQ’s ParallelEnumerable query provider, taking advantage of the new extension method support in C# 3.0 and Visual Basic .NET 9.0. The interface derives from IEnumerable so that you can still foreach over instances and pass them to other APIs that expect IEnumerable . The standard query operators defined on ParallelEnumerable mirror those on Enumerable with the only difference being that each takes an IParallelEnumerable as its extension source argument rather than IEnumerable , returns an IParallelEnumerable rather than IEnumerable (except for the aggregations that just return simple types), and of course uses parallelism internally for query evaluation. For example, take a simple LINQ query defined in C#: IEnumerable data = ; var q = data.Where(x => p(x)).Orderby(x => k(x)).Select(x => f(x)); foreach (var e in q) a(e); All that is required to use PLINQ in this case is adding a call to AsParallel on data: IEnumerable data = ; var q = data.AsParallel().Where(x => p(x)).Orderby(x => k(x)).Select(x => f(x)); foreach (var e in q) a(e); october2007 71 http://blogs.msdn.com/somasegar

Table of Contents Feed for the Digital Edition of MSDN Magazine - October 2007

Cover Contents Toolbox CLR Inside Out Basic Instincts Data Points Cutting Edge Pooled Threads WPF Threads Parallel Linq Parallel Performance Mobile Apps Test Run Foundations Windows with C++ Netting C++ .NET Matters { End Bracket } Net Nuptials

MSDN Magazine - October 2007

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.