CODEWITHSUNDEEP
c#.netperformanceparallel-processing
anchandra
anchandra

Reputation: 1099

Performance of running Parallel.Foreach on several threads

I have 3 main processing threads, each of them performing operations on the values of ConcurrentDictionaries by means of Parallel.Foreach. The dictionaries vary in size from 1,000 elements to 250,000 elements

TaskFactory factory = new TaskFactory();
Task t1 = factory.StartNew(() =>
{
        Parallel.ForEach(dict1.Values, item => ProcessItem(item));
});

Task t2 = factory.StartNew(() =>
{                                
        Parallel.ForEach(dict2.Values, item => ProcessItem(item));
});

Task t3 = factory.StartNew(() =>
{                           
        Parallel.ForEach(dict3.Values, item => ProcessItem(item));
});
t1.Wait();
t2.Wait();
t3.Wait();

I compared the performance (total execution time) of this construct with just running the Parallel.Foreach in the main thread and the performance improved a lot (the execution time was reduced approximately 5 times)

My questions are:

  1. Is there something wrong with the approach above? If yes, what and how can it be improved?
  2. What is the reason for the different execution times?
  3. What is a good way to debug/analyze such a situation?

EDIT: To further clarify the situation: I am mocking the client calls on a WCF service, that each comes on a separate thread (the reason for the Tasks). I also tried to use ThreadPool.QueueUserWorkItem instead of Task, without a performance improvement. The objects in the dictionary have between 20 and 200 properties (just decimals and strings) and there is no I/O activity

I solved the problem by queuing the processing requests in a BlockingCollection and processing them one at the time

Upvotes: 5

Views: 5349

Answers (3)

Henk Holterman
Henk Holterman

Reputation: 273179

First of all, a Task is not a Thread.

Your Parallel.ForEach() calls are run by a scheduler that uses the ThreadPool and should try to optimize Thread usage. The ForEach applies a Partitioner. When you run these in parallel they cannot coordinate very well.

Only if there is a performance problem, consider helping with extra tasks or DegreeOfParallelism directives. And then always profile and analyze first.

An explanation of your results is difficult, it could be caused by many factors (I/O for example) but the advantage of the 'single main task' is that the scheduler has more control and the CPU and Cache are used better (locality).

Upvotes: 3

digEmAll
digEmAll

Reputation: 57210

You're probably over-parallelizing.

You don't need to create 3 tasks if you already use a good (and balanced) parallelization inside each one of them.

Parallel.Foreach already try to use the right number of threads to exploit the full CPU potential without saturating it. And by creating other tasks having Parallel.Foreach you're probably saturating it.
(EDIT: as Henk said, they probably have some problems in coordinating the number of threads to spawn when run in parallel, and at least this leads to a bigger overhead).

Have a look here for some hints.

Upvotes: 8

Ade Miller
Ade Miller

Reputation: 13723

The dictionaries vary widely in size and by the looks of it (given everything finishes in <5s) the amount of processing work is small. Without knowing more it's hard to say what's actually going on. How big are your dictionary items? The main thread scenario you're comparing this to looks like this right?

Parallel.ForEach(dict1.Values, item => ProcessItem(item)); 
Parallel.ForEach(dict2.Values, item => ProcessItem(item)); 
Parallel.ForEach(dict3.Values, item => ProcessItem(item));

By adding the Tasks around each ForEach your adding more overhead to manage the tasks and probably causing memory contention as dict1, dict2 and dict3 all try and be in memory and hot in cache at the same time. Remember, CPU cycles are cheap, cache misses are not.

Upvotes: 2

Related Questions