1

I have the following code (copied here from LINQPad). Obviously it looks like I am not understanding how TPL works or the code is garbage, why does the parallel version run slower than its non-parallel counterpart?

for (int i = 0; i < 100; i++)
{
    ParallelOptions ops = new ParallelOptions();
    ops.MaxDegreeOfParallelism = Environment.ProcessorCount;

    var watch = Stopwatch.StartNew();
    Parallel.ForEach<int>(Enumerable.Range(1, 10000000), ops, x => { int y = x + 1; });
    watch.Stop();
    Console.WriteLine("Parallel: {0}", watch.Elapsed.TotalSeconds);

    watch = Stopwatch.StartNew();
    foreach (var x in Enumerable.Range(1, 10000000))
    {
        int y = x + 1;
    }
    watch.Stop();
    Console.WriteLine("Non-parallel: {0}\n", watch.Elapsed.TotalSeconds);
}

First 10 results:

Parallel: 0.1991644 Non-parallel: 0.0466178

Parallel: 0.1723428 Non-parallel: 0.0447134

Parallel: 0.1141791 Non-parallel: 0.0444557

Parallel: 0.1758878 Non-parallel: 0.0444636

Parallel: 0.1687637 Non-parallel: 0.0444338

Parallel: 0.1677679 Non-parallel: 0.0445771

Parallel: 0.1191462 Non-parallel: 0.0446116

Parallel: 0.1702483 Non-parallel: 0.0454863

Parallel: 0.1143605 Non-parallel: 0.0451731

Parallel: 0.2155218 Non-parallel: 0.0450392

svick
  • 236,525
  • 50
  • 385
  • 514
hyde
  • 2,525
  • 4
  • 27
  • 49
  • starting up threads is not without a cost – Mitch Wheat Jan 09 '16 at 06:27
  • Debug mode compilation? Since when optimized the code does nothing and might be optimized away even. No point in determining which is faster: doing nothing or starting threads to do nothing. – Sami Kuhmonen Jan 09 '16 at 06:40
  • Threads are incredibly expensive; it only makes sense to hire workers when you have *huge* amounts of work for them to do. – Eric Lippert Jan 09 '16 at 07:11
  • look at the accepted answer on this [SO link](https://stackoverflow.com/questions/4031820/when-to-use-partitioner-class) – Josh Jan 09 '16 at 07:27

2 Answers2

3

Well, the best answer you can get is to run a profiler tool and measure what is going on with your code. But my educated guess is that your parallel code is slower because your code is so simple that starting up threads and switching between them add up so much cost that any advantage in the calculation speed is negligible.

But try to make some substantial computations and you eventually will have the parallel execution advantage. Your code is too simple. Modern CPUs are not to be loaded in this way.

ixSci
  • 13,100
  • 5
  • 45
  • 79
0

Since I cannot add this as a comment, I am adding another answer to post the modified code. What @ixSci said in his answer seems to be correct. I was performing a trivial operation in the parallel code body that was executing really fast but the slowness came from the fact that a lot of time was spent on context switching between threads? When I changed the code to sleep for some time instead of increasing the int value by 1, the parallel code was roughly 4 (no. of cores in my CPU) times faster than the non parallel version.

for (int i = 0; i < 100; i++)
{
    ParallelOptions ops = new ParallelOptions();
    ops.MaxDegreeOfParallelism = Environment.ProcessorCount;

    var partitioner = Partitioner.Create<int>(Enumerable.Range(1, 5000));

    var watch = Stopwatch.StartNew();
    Parallel.ForEach<int>(partitioner, ops, x => { Thread.Sleep(1); });
    watch.Stop();
    Console.WriteLine("Parallel: {0}", watch.Elapsed.TotalSeconds);

    watch = Stopwatch.StartNew();
    foreach (var x in Enumerable.Range(1, 5000))
    {
        Thread.Sleep(1);
    }
    watch.Stop();
    Console.WriteLine("Non-parallel: {0}\n", watch.Elapsed.TotalSeconds);
}

First 10 results:

Parallel: 1.2887589 Non-parallel: 5.0020569

Parallel: 1.277047 Non-parallel: 5.0011116

Parallel: 1.2790631 Non-parallel: 5.0001498

Parallel: 1.2770644 Non-parallel: 5.0052016

Parallel: 1.2770013 Non-parallel: 5.0021479

Parallel: 1.2770031 Non-parallel: 5.0001927

Parallel: 1.2799937 Non-parallel: 5.0062141

Parallel: 1.2819909 Non-parallel: 5.0171945

Parallel: 1.2780496 Non-parallel: 5.0071667

Parallel: 1.2821714 Non-parallel: 5.0082108

Parallel: 1.2777875 Non-parallel: 5.0152099

hyde
  • 2,525
  • 4
  • 27
  • 49
  • This is also not a good example. If you and the `ThreadPool` stop limiting the number of threads used (by not forcing `MaxDegreeOfParallelism` to be `ProcessorCount` and by adding something like `ThreadPool.SetMinThreads(100, 4);`), then you're going to get a speedup that's much more than the number of CPU cores. – svick Jan 09 '16 at 16:07