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.
- PLINQ
- 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.
