c# - 执行并行分解时发生溢出异常

Question

我正在尝试编写一个不太智能的分解程序，并尝试使用 TPL 并行执行它。但是，在 core 2 duo 机器上运行大约 15 分钟后，我得到一个聚合异常，其中有一个溢出异常。堆栈跟踪中的所有条目都是 .NET 框架的一部分，溢出并非来 self 的代码。在弄清楚为什么会发生这种情况时，我们将不胜感激。

这是注释代码，希望它足够简单易懂:

class Program
{
    static List<Tuple<BigInteger, int>> factors = new List<Tuple<BigInteger, int>>();

    static void Main(string[] args)
    {
        BigInteger theNumber = BigInteger.Parse(
            "653872562986528347561038675107510176501827650178351386656875178" +
            "568165317809518359617865178659815012571026531984659218451608845" +
            "719856107834513527");
        Stopwatch sw = new Stopwatch();
        bool isComposite = false;
        sw.Start();

        do
        {
            /* Print out the number we are currently working on. */
            Console.WriteLine(theNumber);

            /* Find a factor, stop when at least one is found
               (using the Any operator). */
            isComposite = Range(theNumber)
                          .AsParallel()
                          .Any(x => CheckAndStoreFactor(theNumber, x));

            /* Of the factors found, take the one with the lowest base. */
            var factor = factors.OrderBy(x => x.Item1).First();
            Console.WriteLine(factor);

            /* Divide the number by the factor. */
            theNumber = BigInteger.Divide(
                            theNumber, 
                            BigInteger.Pow(factor.Item1, factor.Item2));

            /* Clear the discovered factors cache, and keep looking. */
            factors.Clear();
        } while (isComposite);

        sw.Stop();
        Console.WriteLine(isComposite + " " + sw.Elapsed);
    }

    static IEnumerable<BigInteger> Range(BigInteger squareOfTarget)
    {
        BigInteger two = BigInteger.Parse("2");
        BigInteger element = BigInteger.Parse("3");
        while (element * element < squareOfTarget)
        {
            yield return element;
            element = BigInteger.Add(element, two);
        }
    }

    static bool CheckAndStoreFactor(BigInteger candidate, BigInteger factor)
    {
        BigInteger remainder, dividend = candidate;
        int exponent = 0;
        do
        {
            dividend = BigInteger.DivRem(dividend, factor, out remainder);
            if (remainder.IsZero)
            {
                exponent++;
            }
        } while (remainder.IsZero);
        if (exponent > 0)
        {
            lock (factors)
            {
                factors.Add(Tuple.Create(factor, exponent));
            }
        }
        return exponent > 0;
    }
}

这是抛出的异常:

Unhandled Exception: System.AggregateException: One or more errors occurred. ---
> System.OverflowException: Arithmetic operation resulted in an overflow.
   at System.Linq.Parallel.PartitionedDataSource`1.ContiguousChunkLazyEnumerator.MoveNext(T& currentElement, Int32& currentKey)
   at System.Linq.Parallel.AnyAllSearchOperator`1.AnyAllSearchOperatorEnumerator`1.MoveNext(Boolean& currentElement, Int32& currentKey)
   at System.Linq.Parallel.StopAndGoSpoolingTask`2.SpoolingWork()
   at System.Linq.Parallel.SpoolingTaskBase.Work()
   at System.Linq.Parallel.QueryTask.BaseWork(Object unused)
   at System.Linq.Parallel.QueryTask.<.cctor>b__0(Object o)
   at System.Threading.Tasks.Task.InnerInvoke()
   at System.Threading.Tasks.Task.Execute()
   --- End of inner exception stack trace ---
   at System.Linq.Parallel.QueryTaskGroupState.QueryEnd(Boolean userInitiatedDispose)
   at System.Linq.Parallel.SpoolingTask.SpoolStopAndGo[TInputOutput,TIgnoreKey](QueryTaskGroupState groupState, PartitionedStream`2 partitions, SynchronousChannel`1[] channels, TaskScheduler taskScheduler)
   at System.Linq.Parallel.DefaultMergeHelper`2.System.Linq.Parallel.IMergeHelper<TInputOutput>.Execute()
   at System.Linq.Parallel.MergeExecutor`1.Execute[TKey](PartitionedStream`2 partitions, Boolean ignoreOutput, ParallelMergeOptions options, TaskScheduler taskScheduler, Boolean isOrdered, CancellationState cancellationState, Int32 queryId)

   at System.Linq.Parallel.PartitionedStreamMerger`1.Receive[TKey](PartitionedStream`2 partitionedStream)
   at System.Linq.Parallel.AnyAllSearchOperator`1.WrapPartitionedStream[TKey](PartitionedStream`2 inputStream, IPartitionedStreamRecipient`1 recipient, BooleanpreferStriping, QuerySettings settings)
   at System.Linq.Parallel.UnaryQueryOperator`2.UnaryQueryOperatorResults.ChildResultsRecipient.Receive[TKey](PartitionedStream`2 inputStream)
   at System.Linq.Parallel.ScanQueryOperator`1.ScanEnumerableQueryOperatorResults.GivePartitionedStream(IPartitionedStreamRecipient`1 recipient)
   at System.Linq.Parallel.UnaryQueryOperator`2.UnaryQueryOperatorResults.GivePartitionedStream(IPartitionedStreamRecipient`1 recipient)
   at System.Linq.Parallel.QueryOperator`1.GetOpenedEnumerator(Nullable`1 mergeOptions, Boolean suppressOrder, Boolean forEffect, QuerySettings querySettings)
   at System.Linq.Parallel.QueryOpeningEnumerator`1.OpenQuery()
   at System.Linq.Parallel.QueryOpeningEnumerator`1.MoveNext()
   at System.Linq.Parallel.AnyAllSearchOperator`1.Aggregate()
   at System.Linq.ParallelEnumerable.Any[TSource](ParallelQuery`1 source, Func`2 predicate)
   at PFact.Program.Main(String[] args) in d:\myprojects\PFact\PFact\Program.cs:line 34

如有任何帮助，我们将不胜感激。

谢谢!

编辑

根据 Simon 的回复，我再次运行代码，这次使用了 catch(AggregateException x) 子句，我检查了 InnerExceptions 集合中的所有元素。恰好有 2 个元素(我假设每个执行线程一个，因为我有 2 个 CPU 内核，TPL 将优化为仅使用 2 个线程)。两个异常是相同的(都是 OverflowException)...所以这不是答案。

解决方案

Henk 的回答被证明是正确的，这里是来自微软博客的半官方链接确认:What's New in Beta 2 for PLINQ

Answer 1

查看你的堆栈跟踪，靠近顶部，我看到了这个:

at System.Linq.Parallel.PartitionedDataSource`1.
  ContiguousChunkLazyEnumerator.MoveNext(T& currentElement, Int32& currentKey)
at System.Linq.Parallel.AnyAllSearchOperator`1.
  AnyAllSearchOperatorEnumerator`1.MoveNext(Boolean& currentElement, Int32& currentKey)

现在这看起来 TPL 枚举器正在使用 Int32 作为它自己的内部簿记，而你做的可能不仅仅是 Int32.MaxValue 迭代...

为了确保您必须查看为迭代器 block 生成的状态机的 IL。