MSDN Magazine - October 2007 - (Page 76)

The steps introduced by PLINQ to support order preservation are in red. As you can see, it’s quite a bit of work! Obviously PLINQ implements this functionality in a much more efficient manner than if you had just written this version of the query, but the steps are logically equivalent. PLINQ Resources Joe Duffy’s blog posts on PLINQ bluebytesoftware.com/blog/SearchView.aspx?q=plinq Channel 9 video interview with Anders Hejlsberg on LINQ Side Effects PLINQ relies on something called statistical purity: most LINQ queries do not mutate data structures or perform impure operations most of the time. Another way of saying this is that most LINQ queries are strictly functional; they take some data as input, perform some calculations, and create an entirely separate copy of the data, with some changes, as output. But this best practice usage isn’t enforced in any way by the compilers or runtime. If people have written queries that break this common usage pattern, then the shift to PLINQ can become quite a bit more complicated. As an example, consider this LINQ query: var q = from x in data where (x.f-- > 0) select x; channel9.msdn.com/showpost.aspx?postid=114680 The LINQ Project at the .NET Framework Developer Center msdn2.microsoft.com/netframework/aa904594.aspx The Evolution of LINQ and Its Impact on the Design of C# by Anson Horton (MSDN Magazine, June 2007) msdn.microsoft.com/msdnmag/issues/07/06/CSharp30 LINQ Discussion in MSDN Forums forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=123&SiteID=1 Notice that the predicate in the where clause actually modifies a field of an object. This means that the query may not be safe to run in parallel without exposing race conditions and Order preservation simply concurrency bugs. By deensures that the relative fault, you must assume that ordering among output queries like this are not safe and must not be run with elements is strongly tied to PLINQ. But when would it the relative ordering among actually be safe? The races input elements. occur only if the predicate is run on multiple threads against the same object, which can only happen if data contains duplicate objects. So if data is a set, then it’s perfectly OK. There are other cases, such as where static variables are used, that are always unsafe: class C { internal static int s_cCounter; } // elsewhere… var q = from x in data where (x.f == C.s_cCounter++) select x; tem state can end up attached to the thread running some piece of code itself. This can take the form of thread-local storage, security information such as impersonation, COM apartments (particularly Single Threaded Apartments), and GUI frameworks such as Windows Forms and Windows Presentation Foundation. All of these can cause trouble when moving from LINQ to PLINQ. Whereas in the LINQ model all code in the query runs on the same thread that initiated the query, with PLINQ the code in the query is distributed over many threads. Unfortunately, it’s not always obvious when you’ve taken a dependency on thread affinity, since many services in the .NET Framework intrinsically and transparently rely on them internally. The best advice I can give is to be on the lookout for the abovementioned sources of concurrency hazards and avoid them as much as possible from within your queries. Putting PLINQ to Work PLINQ allows LINQ developers to take advantage of parallel hardware—including achieving better performance and building more intrinsically scalable software—without needing to understand concurrency or data parallelism. The programming model is simple, enabling a broader number of developers to take advantage of more parallel hardware. The “PLINQ Resources” sidebar lists some references for more information. For those already using LINQ-to-Objects, LINQ-to-XML, or LINQ to tie together heterogeneous data sources, it is a straightforward process to get your existing queries to use PLINQ. Take a look at the sidebar “Compelling Scenarios” for further possible uses of this technology. For those who have not yet begun adopting LINQ, the parallel speedup gains are another reason for you to consider using it. Even though PLINQ is not available today, using LINQ in your programs is an investment in the future. ■ If you run this query in parallel, you’re apt to be quite disappointed. You could end up with many objects with duplicate f field values, which only occurs due to the race condition. Be careful: your initial reaction and approach to solving this might be to replace C.s_cCounter++ with Interlocked.Increment(ref C.s_cCounter). While this approach leads to a correct solution, any kind of synchronization will vastly reduce the scalability of your queries. You should strive to eliminate all reliance on mutability and shared state from your queries as a first principle. The Windows® platform is very thread-centric, and a lot of sys- 76 msdnmagazine PlINQ http://bluebytesoftware.com/blog/SearchView.aspx?q=plinq http://channel9.msdn.com/showpost.aspx?postid=114680 http://msdn2.microsoft.com/netframework/aa904594.aspx http://msdn.microsoft.com/msdnmag/issues/07/06/CSharp30 http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=123&SiteID=1

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.