ForWorker64< TLocal >()

static ParallelLoopResult System.Threading.Tasks.Parallel.ForWorker64< TLocal > ( long fromInclusive, long toExclusive, ParallelOptions parallelOptions, Action< long > body, Action< long, ParallelLoopState > bodyWithState, Func< long, ParallelLoopState, TLocal, TLocal > bodyWithLocal, Func< TLocal > localInit, Action< TLocal > localFinally )

inlinestaticprivate

Definition at line 599 of file Parallel.cs.

    {
        ParallelLoopResult result = default(ParallelLoopResult);
        if (toExclusive <= fromInclusive)
        {
            result._completed = true;
            return result;
        }
        ParallelLoopStateFlags64 sharedPStateFlags = new ParallelLoopStateFlags64();
        parallelOptions.CancellationToken.ThrowIfCancellationRequested();
        int nNumExpectedWorkers = ((parallelOptions.EffectiveMaxConcurrencyLevel == -1) ? Environment.ProcessorCount : parallelOptions.EffectiveMaxConcurrencyLevel);
        RangeManager rangeManager = new RangeManager(fromInclusive, toExclusive, 1L, nNumExpectedWorkers);
        OperationCanceledException oce = null;
        CancellationTokenRegistration cancellationTokenRegistration = ((!parallelOptions.CancellationToken.CanBeCanceled) ? default(CancellationTokenRegistration) : parallelOptions.CancellationToken.UnsafeRegister((Action<object?>)delegate
        {
            oce = new OperationCanceledException(parallelOptions.CancellationToken);
            sharedPStateFlags.Cancel();
        }, (object?)null));
        int forkJoinContextID = 0;
        if (ParallelEtwProvider.Log.IsEnabled())
        {
            forkJoinContextID = Interlocked.Increment(ref s_forkJoinContextID);
            ParallelEtwProvider.Log.ParallelLoopBegin(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID, ParallelEtwProvider.ForkJoinOperationType.ParallelFor, fromInclusive, toExclusive);
        }
        try
        {
            try
            {
                TaskReplicator.Run(delegate(ref RangeWorker currentWorker, int timeout, out bool replicationDelegateYieldedBeforeCompletion)
                {
                    if (!currentWorker.IsInitialized)
                    {
                        currentWorker = rangeManager.RegisterNewWorker();
                    }
                    replicationDelegateYieldedBeforeCompletion = false;
                    if (!currentWorker.FindNewWork(out var nFromInclusiveLocal, out var nToExclusiveLocal) || sharedPStateFlags.ShouldExitLoop(nFromInclusiveLocal))
                    {
                        return;
                    }
                    if (ParallelEtwProvider.Log.IsEnabled())
                    {
                        ParallelEtwProvider.Log.ParallelFork(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID);
                    }
                    TLocal val = default(TLocal);
                    bool flag = false;
                    try
                    {
                        ParallelLoopState64 parallelLoopState = null;
                        if (bodyWithState != null)
                        {
                            parallelLoopState = new ParallelLoopState64(sharedPStateFlags);
                        }
                        else if (bodyWithLocal != null)
                        {
                            parallelLoopState = new ParallelLoopState64(sharedPStateFlags);
                            if (localInit != null)
                            {
                                val = localInit();
                                flag = true;
                            }
                        }
                        int timeoutOccursAt = ComputeTimeoutPoint(timeout);
                        do
                        {
                            if (body != null)
                            {
                                for (long num2 = nFromInclusiveLocal; num2 < nToExclusiveLocal; num2++)
                                {
                                    if (sharedPStateFlags.LoopStateFlags != 0 && sharedPStateFlags.ShouldExitLoop())
                                    {
                                        break;
                                    }
                                    body(num2);
                                }
                            }
                            else if (bodyWithState != null)
                            {
                                for (long num3 = nFromInclusiveLocal; num3 < nToExclusiveLocal && (sharedPStateFlags.LoopStateFlags == 0 || !sharedPStateFlags.ShouldExitLoop(num3)); num3++)
                                {
                                    parallelLoopState.CurrentIteration = num3;
                                    bodyWithState(num3, parallelLoopState);
                                }
                            }
                            else
                            {
                                for (long num4 = nFromInclusiveLocal; num4 < nToExclusiveLocal && (sharedPStateFlags.LoopStateFlags == 0 || !sharedPStateFlags.ShouldExitLoop(num4)); num4++)
                                {
                                    parallelLoopState.CurrentIteration = num4;
                                    val = bodyWithLocal(num4, parallelLoopState, val);
                                }
                            }
                            if (CheckTimeoutReached(timeoutOccursAt))
                            {
                                replicationDelegateYieldedBeforeCompletion = true;
                                break;
                            }
                        }
                        while (currentWorker.FindNewWork(out nFromInclusiveLocal, out nToExclusiveLocal) && (sharedPStateFlags.LoopStateFlags == 0 || !sharedPStateFlags.ShouldExitLoop(nFromInclusiveLocal)));
                    }
                    catch (Exception source)
                    {
                        sharedPStateFlags.SetExceptional();
                        ExceptionDispatchInfo.Throw(source);
                    }
                    finally
                    {
                        if (localFinally != null && flag)
                        {
                            localFinally(val);
                        }
                        if (ParallelEtwProvider.Log.IsEnabled())
                        {
                            ParallelEtwProvider.Log.ParallelJoin(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID);
                        }
                    }
                }, parallelOptions, stopOnFirstFailure: true);
            }
            finally
            {
                if (parallelOptions.CancellationToken.CanBeCanceled)
                {
                    cancellationTokenRegistration.Dispose();
                }
            }
            if (oce != null)
            {
                throw oce;
            }
        }
        catch (AggregateException ex)
        {
            ThrowSingleCancellationExceptionOrOtherException(ex.InnerExceptions, parallelOptions.CancellationToken, ex);
        }
        finally
        {
            int loopStateFlags = sharedPStateFlags.LoopStateFlags;
            result._completed = loopStateFlags == 0;
            if (((uint)loopStateFlags & 2u) != 0)
            {
                result._lowestBreakIteration = sharedPStateFlags.LowestBreakIteration;
            }
            if (ParallelEtwProvider.Log.IsEnabled())
            {
                long num = 0L;
                num = ((loopStateFlags == 0) ? (toExclusive - fromInclusive) : (((loopStateFlags & 2) == 0) ? (-1) : (sharedPStateFlags.LowestBreakIteration - fromInclusive)));
                ParallelEtwProvider.Log.ParallelLoopEnd(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID, num);
            }
        }
        return result;
    }

References System.Threading.Tasks.Parallel.CheckTimeoutReached(), System.Threading.Tasks.Parallel.ComputeTimeoutPoint(), System.Threading.Tasks.TaskScheduler.Current, System.Threading.Tasks.Task< TResult >.CurrentId, System.Threading.Interlocked.Increment(), System.L, System.Threading.Tasks.ParallelEtwProvider.Log, System.Environment.ProcessorCount, System.Threading.Tasks.Parallel.s_forkJoinContextID, System.source, System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw(), System.Threading.Tasks.Parallel.ThrowSingleCancellationExceptionOrOtherException(), and System.timeout.