Known Correctness Bugs with the Parallel Extensions CTP December 2007


Here are known correctness bugs as of our December 2007 CTP release:

  • Common
    • The setup for Parallel Extensions may fail on Windows Server 2008 (both 32-bit and 64-bit).  As a workaround, Parallel Extensions may be installed manually:
      • From a prompt with administrator privileges: msiexec /a ParallelExtensions_Dec07CTP.msi TARGETDIR=”%TMP%ParallelExtensions” /qn
      • This extracts the contents of the MSI to the target folder. The System.Threading.dll can be GAC’d manually from there using the gacutil tool.
    • The spin waiting used in the libraries doesn’t always consider all runnable threads for switching due to dependency on SwitchToThread.
    • AggregateException.Flatten should recursively flatten all AggregateExceptions such that the final output contains no aggregates.
    • On an empty sequence, LINQ to Objects’ Min/Max will throw an exception whereas PLINQ’s will not.
    • Calling Dispose on a PLINQ enumerator does not always properly dispose of resources allocated by the query.
    • LINQ to Objects throws an exception when the predicate delegate passed to First is null; PLINQ does not.
    • Max(double.NaN, null) is returned as null using PLINQ and double.NaN using LINQ to Objects.
    • Calling Reset on an unopened enumerator throws a NullReferenceException.
    • Cast with order-preservation enabled doesn’t handle invalid casts.
    • ToArray(int[] lengths) does not handle dimension values of 0 correctly.
    • Union throws IndexOutOfRangeException when order-preservation is enabled
    • SkipWhile, TakeWhile, Select, SelectMany, Where incorrectly handle overflow conditions.
    • TakeWhile followed by Take hangs or throws an out of memory exception when used on an infinite enumerable.
    • Range incorrectly handles Int32.MaxValue.
    • ToArray on a null source throws a NullReferenceException rather than an ArgumentNullException as in LINQ to Objects.
    • No verification is performed on the PLINQ_DOP/PLINQ_PRESERVE_ORDER environment variables before parsing them.
    • Range partitioning fairness needs to be improved.  In certain cases, threads will be starved of work. For example, if input.Count = 9 and DOP = 8, PLINQ will partition input into partitions of sizes {2,2,2,2,1,0,0,0} instead of {2,1,1,1,1,1,1,1}.
    • SelectMany may throw out of memory exceptions for medium-to-large sized data sources.
    • PLINQ is designed to wrap all exceptions thrown from a query in an AggregateException, but sometimes unwrapped exceptions may escape.
  • Task Parallel Library
    • A rare race condition exists that causes some task joins to be missed.
    • The Value property on a Future<T> created with the parameterless Create method is supposed to block in its get accessor until the Value property has been set, but it doesn’t.
    • Worker threads are not cleaned up when the associated task manager is disposed.
    • Tasks blocked for significant periods of time may cause runaway thread injection and out of memory conditions when the default policy is used.
    • Task.CancelAndWait is supposed to eat the TaskCanceledException for the task being canceled, but it’s currently not doing so.
    • TaskManager(TaskManagerPolicy) should demand Infrastructure permission, not ControlEvidence and ControlPolicy.
    • The implementation of Task.Completed is incorrect and can lead to a completion handler being invoked more than once.
    • TaskCoordinator.WaitAll only works with Task[] (and not TaskCoordinator[] as documented and as exposed through the API).  This means it can’t currently be used with parameter arrays.
    • Task.IsCompleted may throw a NullReferenceException when used with self-replicating tasks.
    • TaskManager fails to initialize if execution context flow already suppressed.
    • Parallel.Do will hang if the associated TaskManager has been shutdown.
    • Task.Create(Action, string) conflicts with Task.Create(Action, object), in that a user may try to provide a string as the state to the action, but will end up naming the task instead.
    • ExecutionContext is not flowed correct through some asynchronous points
    • The threadLocalCleanup delegate provided to Parallel.ForEach may not be called. 
  • Samples
    • Most of the samples included with the CTP reference the wrong version number of System.Threading.dll, which will prevent the samples from compiling/executing.  A simple workaround is to remove the System.Threading reference from the sample project and then readd the reference.


Comments are closed. Login to edit/delete your existing comments