BT

What Is .NET 4.0 Beta 1 Going to Bring to PLINQ?

by Abel Avram on Apr 30, 2009 |

Ed Essey, a Program Manager on the Microsoft Parallel Computing team, wrote on the latest enhancements to PLINQ that are to appear in .NET 4.0 Beta 1 that is to be released soon. Some of them are: “With” Operators Pattern, Execution Mode, Cancellation, Refactoring, Performance Improvements.

The complete list of PLINQ enhancements in Beta 1 is:

  • With- Operators Pattern
  • Execution Mode
  • Cancellation
  • Custom Partitioning
  • Refactoring
  • Merge Options
  • AsMerged Renamed Back to AsSequential
  • Binary Operators Now Require AsParallel on Both Sides
  • Performance Improvements
  • Removed Seldom Used Operators

“With” Operators Pattern. There are 4 new methods:

  • e.AsParallel().WithDegreeOfParallelism
  • e.AsParallel().WithExecutionMode
  • e.AsParallel().WithCancellation
  • e.AsParallel().WithMergeOptions

Execution Mode. PLINQ was tuned to consume similar resources to a LINQ-to-Objects query, especially related to memory consumption. When a PLINQ call is considered to consume a lot more resources, the call is executed sequentially instead of in parallel. The decision to switch to a sequential execution is made based on query’s shape. These queries are executed sequentially:

  • Queries contain indexed Select, indexed Where, indexed SelectMany, or ElementAt in a position where the indices are no longer in the original order. Index ordering is senstive to operators that change ordering (e.g. OrderBy) and operators that remove elements (e.g. Where).
  • Queries that contain operators Take, TakeWhile, Skip, SkipWhile when indices are not in the original order (see above bullet).
  • Queries that contain Zip, SequenceEquals, unless one of the data sources has an originally ordered index and the other data source is indexible (i.e. an array or IList<T>).
  • Queries that contain Concat, unless it is applied to indexible data sources.
  • Queries that contain Reverse, unless applied to an indexible data source.

To force parallel execution one can use:

e.AsParallel().WithExecutionMode(ParallelExecutionMode.ForceParallelism)

Cancellation. Parallel operations can be cancelled as this example shows:

var cts = new CancellationTokenSource();

var q = a.AsParallel().WithCancellation(cts.Token).Where(x=>Filter(x)).Select(x=>DoWork(x);

-- separate thread --

foreach (var e in q) { … }  // Statement 1

-- separate thread --

var l = q.ToList(); // Statement 2

-- separate thread --

cts.Cancel(); // this will attempt to cancel any in-flight queries,

// including both statements 1 and 2

Custom Partitioning. The classes Partitioner<TSource>, OrderablePartitioner<TSource> and the factory class Partitioner offer control on how data is partitioned.

Refactoring.  The interfaces IParallelEnumerable, IParallelEnumerable<T>, and IParallelOrderedEnumerable<T> are no longer interfaces but abstract classes that cannot be extended: ParalellQuery, ParalellQuery<TSource>, and OrderedParallelQuery<TSource>. The reason is that they were not intended to be extended in the first place.

Merge Options. “Handling of ParallelMergeOptions has been moved out of AsMerged.  Merge buffering is now specified via the  WithMergeOptions method.”

AsMerged. AsMerged has been renamed AsSequential for similarity with AsParallel as it used to be.

Binary Operators. LINQ operators with 2 data sources need AsParallel on both sides. Operations like:

a.AsParallel().AsOrdered().Zip(b, (x, y) => x*y);

are to be parallelized as:

a.AsParallel().AsOrdered().Zip(b.AsParallel(), (x, y) => x*y);

or

a.AsParallel().AsOrdered().Zip(b.AsParallel().AsOrdered(), (x, y) => x*y);

Operators affected: Zip, Join, GroupJoin, Concat, SequenceEqual, Union, Intersect, Except.

Performance Improvements.

1. Order-preserving pipelining merges – Previously, just putting AsOrdered on a query forced the entire query to execute before a single element is yielded.  This is now optimized so that elements from the query can be yielded as they are produced with Default (AutoBuffered) and NotBuffered values of MergeOptions.

2. Improved partitioning fairness for data sources that don't implement IList<T>

3. Better performance of some queries over IList<T> or an array

4. Chunk partitioning size tuning - Chunk partitioning is the most common partitioning scheme for queries over data sources other that IList<T> and arrays (i.e. non-indexible data sources). The sizes of these chunks now grow as more and more chunks are accessed. This is to balance between the cases of a) queries with small data sets but expensive delegates in the queries and b) queries with large data sets but inexpensive delegates in the queries.

5. Removal of likely false sharing cases, which have had up to 6x improvements in some cases

Removed Seldom Used Operators. Some operators that were created for performance reasons but did not offer any performance over LINQ were removed. It was not specified which operators were removed.

Hello stranger!

You need to Register an InfoQ account or to post comments. But there's so much more behind being registered.

Get the most out of the InfoQ experience.

Tell us what you think

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Email me replies to any of my messages in this thread
Community comments

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Email me replies to any of my messages in this thread

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Email me replies to any of my messages in this thread

Discuss

Educational Content

General Feedback
Bugs
Advertising
Editorial
InfoQ.com and all content copyright © 2006-2013 C4Media Inc. InfoQ.com hosted at Contegix, the best ISP we've ever worked with.
Privacy policy
BT