Parallel.ForEach can cause a “Out Of Memory” exception if working with a enumerable with a large object

by

The default options for Parallel.ForEach only work well when the task is CPU-bound and scales linearly. When the task is CPU-bound, everything works perfectly. If you have a quad-core and no other processes running, then Parallel.ForEach uses all four processors. If you have a quad-core and some other process on your computer is using one full CPU, then Parallel.ForEach uses roughly three processors.

But if the task is not CPU-bound, then Parallel.ForEach keeps starting tasks, trying hard to keep all CPUs busy. Yet no matter how many tasks are running in parallel, there is always more unused CPU horsepower and so it keeps creating tasks.

How can you tell if your task is CPU-bound? Hopefully just by inspecting it. If you are factoring prime numbers, it is obvious. But other cases are not so obvious. The empirical way to tell if your task is CPU-bound is to limit the maximum degree of parallelism with ParallelOptions.MaximumDegreeOfParallelism and observe how your program behaves. If your task is CPU-bound then you should see a pattern like this on a quad-core system:

  • ParallelOptions.MaximumDegreeOfParallelism = 1: use one full CPU or 25% CPU utilization
  • ParallelOptions.MaximumDegreeOfParallelism = 2: use two CPUs or 50% CPU utilization
  • ParallelOptions.MaximumDegreeOfParallelism = 4: use all CPUs or 100% CPU utilization

If it behaves like this then you can use the default Parallel.ForEach options and get good results. Linear CPU utilization means good task scheduling.

But if I run your sample application on my Intel i7, I get about 20% CPU utilization no matter what maximum degree of parallelism I set. Why is this? So much memory is being allocated that the garbage collector is blocking threads. The application is resource-bound and the resource is memory.

Likewise an I/O-bound task that performs long running queries against a database server will also never be able to effectively utilize all the CPU resources available on the local computer. And in cases like that the task scheduler is unable to “know when to stop” starting new tasks.

If your task is not CPU-bound or the CPU utilization doesn’t scale linearly with the maximum degree of parallelism, then you should advise Parallel.ForEach not to start too many tasks at once. The simplest way is to specify a number that permits some parallelism for overlapping I/O-bound tasks, but not so much that you overwhelm the local computer’s demand for resources or overtax any remote servers. Trial and error is involved to get the best results:

static void Main(string[] args)
{
    Parallel.ForEach(CreateData(),
        new ParallelOptions { MaxDegreeOfParallelism = 4 },
        (data) =>
            {
                data[0] = 1;
            });
}

More Related Contents:

  1. An async/await example that causes a deadlock
  2. How to cancel Task await after a timeout period
  3. How to cancel a Task in await?
  4. When to use BlockingCollection and when ConcurrentBag instead of List?
  5. Why should I prefer single ‘await Task.WhenAll’ over multiple awaits?
  6. General purpose FromEvent method
  7. Cancellation token in Task constructor: why?
  8. Is it considered acceptable to not call Dispose() on a TPL Task object?
  9. Starting Tasks In foreach Loop Uses Value of Last Item [duplicate]
  10. Is Task.Run considered bad practice in an ASP .NET MVC Web Application?
  11. Synchronously waiting for an async operation, and why does Wait() freeze the program here
  12. Multiple Parallel.ForEach loops in .Net
  13. A Task’s exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was
  14. How to put a task to sleep (or delay) in C# 4.0?
  15. OutOfMemoryException while populating MemoryStream: 256MB allocation on 16GB system
  16. Simplest way to do a fire and forget method in c# 4.0
  17. Retry a task multiple times based on user input in case of an exception in task
  18. Revisiting Task.ConfigureAwait(continueOnCapturedContext: false)
  19. If my interface must return Task what is the best way to have a no-operation implementation?
  20. ThreadPool.QueueUserWorkItem vs Task.Factory.StartNew
  21. Can .NET Task instances go out of scope during run?
  22. Is there a Task based replacement for System.Threading.Timer?
  23. TaskCreationOptions.LongRunning option and ThreadPool
  24. Correct way to delay the start of a Task
  25. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  26. Synchronous implementation of interface that returns Task
  27. Best way to limit the number of active Tasks running via the Parallel Task Library
  28. Transform IEnumerable asynchronously by awaiting each task
  29. How to implement Task.WhenAny() with a predicate
  30. Create a completed Task

Leave a Comment