A Beginner's Guide to PLINQ

Language Integrated Query (LINQ) is a feature introduced in .NET Framework 3.5 which, helps in querying various data sources like the in-memory objects, SQL databases and XMLs. LINQ to objects is the most commonly used one across most applications. It performs the query against an in-memory collection in a sequential manner. In .NET Framework 4.0, as part of the parallel programming features, Parallel LINQ (PLINQ) has been introduced. It is a parallel implementation of querying on collections. This takes care of dividing the collection into subsets and spawning new threads for processing each set of records. It differs from the normal threading operation by running these tasks parallel on different processors available on the machine. Parallel LINQ makes maximum use of a multi-core processor. In most of the scenarios Parallel LINQ is supposed to bring a good amount of increase in the performance but in some cases a sequential operation would be a better option. I will highlight some cases where PLINQ can slow down the performance under the "Things to Consider" section later in this article.

Making LINQ Parallel

Below is a normal LINQ query, which performs the sequential processing on the list of names. You should also know that LINQ always executes in a deferred way i.e. the querying of the object actually happens only when the result set is accessed or some function is run over the result set.

            var names = GetNames();
            var fiveLetterNames = from name in names
                                  where name.Length == 5
                                  select name;
 

In order to convert the above LINQ to PLINQ all it needs is an extension method named AsParallel. Below is the converted code.

     var names = GetNames();
            var fiveLetterNamesP = from name in names.AsParallel()
                                  where name.Length == 5
                                  select name;

Some Important Parallel LINQ Features

In this section let us discuss some important things that can be leveraged from Parallel LINQ.

1. Maintaining the order of the result set: Since PLINQ processes the data parallel by dividing into different subsets, by default the result set will not be ordered (Ascending or Descending). You can force PLINQ to order the result set but this yields to a delay in the performance as the result sets from different threads should be buffered, combined together and then sorted. Below is the syntax to yield ordered result set.

            var names = GetNames();
            var fiveLetterNamesP = from name in names.AsParallel().AsOrdered()
                                  where name.Length == 5
                                  select name;

2.Controlling the processor usage: By default PLINQ makes use of all the processors available on the machine. It can make use of up to 64 numbers. If you want to control the processor usage say only on 3 processors the PLINQ tasks should be executed then use the extension method WithDegreeOfParallelism.

var fiveLetterNamesP = from name in names.AsParallel().WithDegreeOfParallelism(3)
                       where name.Length == 5
                       select name;

3. Cancellation of the query tasks: The query tasks that are running on different threads can be cancelled by issuing a cancellation token.

4. Exception Handling in PLINQ: PLINQ uses the new .NET Framework 4.0 exception type named AggregateException to bundle all the exceptions that happened in a PLINQ query and sends it to the caller.

Things to be Considered While Using PLINQ

1. The golden rule is to always compare the query performance on a machine imitating the deployment server and with a similar set of production data.

2. Avoid using AsOrdered because this may slow down the performance. This may even make PLINQ to perform slower than the sequential LINQ.

3. Do not use PLINQ on a single core machine as this would be slower than the normal LINQ most times.

4. PLINQ doesn't perform well when the collection is small and the operation delegate is light weighted. This is because PLINQ involves the extra overhead of partitioning the data, creating new threads and merging the resultant data.

I hope this article provided a good introduction to the Parallel LINQ feature of .NET Framework 4.0. I will dig deeper into the PLINQ features in future articles.

Happy Reading!



About the Author

V.N.S Arun

I work for an MNC in Bangalore, India. I am fond of writing articles, posting answers in forums and submitting tips in dotnet. To contact me please feel free to make use of the "Send Email" option next to the display name.

Related Articles

Comments

  • There are no comments yet. Be the first to comment!

Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • It's time high-level executives and IT compliance officers recognize and acknowledge the danger of malicious insiders, an increased attack surface and the potential for breaches caused by employee error or negligence. See why there is extra emphasis on insider threats.

  • Download the Information Governance Survey Benchmark Report to gain insights that can help you further establish business value in your Records and Information Management (RIM) program and across your entire organization. Discover how your peers in the industry are dealing with this evolving information lifecycle management environment and uncover key insights such as: 87% of organizations surveyed have a RIM program in place 8% measure compliance 64% cannot get employees to "let go" of information for …

Most Popular Programming Stories

More for Developers

Latest Developer Headlines

RSS Feeds