Parallel.Foreach c# Pause And Stop Function?

Question

What would be the most effective way to pause and stop (before it ends) parallel.foreach?

Parallel.ForEach(list, (item) =>
{
    doStuff(item);
});


        

Answer 1

To be able to stop a Parallel.ForEach, you can use one of the overloads that accepts a ParallelOptions parameter, and include a CancellationToken in those options.

See Cancellation for more details.

As for pausing, I can't think why you'd want to do that, in general. You might be looking for a Barrier (which is used to coordinate efforts between multiple threads, say if they all need to complete part A before continuing to part B), but I wouldn't think that you'd use that with Parallel.ForEach, since you don't know how many participants there will be.

Answer 2

Damien_The_Unbeliver has a good method, but that is only if you want to have some outside process stop the loop. If you want to have the loop break out like using a break in a normal for or foreach loop you will need to use a overload that has a ParallelLoopState as one of the parameters of the loop body. ParallelLoopState has two functions that are relevant to what you want to do, Stop() and Break().

The function Stop() will stop processing elements at the system's earliest convenience which means more iterations could be performed after you call Stop() and it is not guaranteed that the elements that came before the element you stopped at have even begun to process.

The function Break() performs exactly the same as Stop() however it will also evaluate all elements of the IEnumerable that came before the item that you called Break() on. This is useful for when you do not care what order the elements are processed in, but you must process all of the elements up to the point you stopped.

Inspect the ParallelLoopResult returned from the foreach to see if the foreach stopped early, and if you used Break(), what is the lowest numbered item it processed.

Parallel.ForEach(list, (item, loopState) =>
    {
        bool endEarly = doStuff(item);
        if(endEarly)
        {
            loopState.Break();
        }
    }
    );
//Equivalent to the following non parallel version, except that if doStuff ends early
//    it may or may not processed some items in the list after the break.
foreach(var item in list)
{
    bool endEarly = doStuff(item);
    if(endEarly)
    {
        break;
    }
}

---

Here is a more practical example

static bool[] list = new int[]{false, false, true, false, true, false};

long LowestElementTrue()
{
    ParallelLoopResult result = Parallel.ForEach(list, (element, loopState) =>
    {
        if(element)
            loopState.Break();
    }
    if(result.LowestBreakIteration.IsNull)
        return -1;
    else
        return result.LowestBreakIteration.Value;
}   

No matter how it splits up the work it will always return 2 as an answer.

let's say the processor dispatches two threads to process this, the first thread processes elements 0-2 and the 2nd thread processes elements 3-5.

Thread 1:                Thread 2
0, False, continue next  3, False, continue next
1, False, continue next  4, True, Break
2, True, Break           5, Don't process Broke

Now the lowest index Break was called from was 2 so ParallelLoopResult.LowestBreakIteration will return 2 every time, no-matter how the threads are broken up as it will always process up to the number 2.

Here an example how how Stop could be used.

static bool[] list = new int[]{false, false, true,  false, true, false};

long FirstElementFoundTrue()
{
    long currentIndex = -1;
    ParallelLoopResult result = Parallel.ForEach(list, (element, loopState, index) =>
    {
        if(element)
        {
             loopState.Stop();

             //index is a 64 bit number, to make it a atomic write
             // on 32 bit machines you must either:
             //   1. Target 64 bit only and not allow 32 bit machines.
             //   2. Cast the number to 32 bit.
             //   3. Use one of the Interlocked methods.
             Interlocked.Exchange (ref currentIndex , index);
        }
    }
    return currentIndex;
}   

Depending how it splits up the work it will either return 2 or 4 as the answer.

let's say the processor dispatches two threads to process this, the first thread processes elements 0-2 and the 2nd thread processes elements 3-5.

Thread 1:                 Thread 2
0, False, continue next    3, False, continue next
1, False, continue next    4, True, Stop
2, Don't process, Stopped  5, Don't process, Stopped

In this case it will return 4 as the answer. Lets see the same process but if it processes every other element instead of 0-2 and 3-5.

Thread 1:                   Thread 2
0, False, continue next     1, False, continue next
2, True, Stop               3, False, continue next
4, Don't process, Stopped   5, Don't process, Stopped

This time it will return 2 instead of 4.