Question

I built a sample program to check the performance of tasks in parallel, with respect to the number of tasks running in parallel.

Few assumptions:
Operation is on thread is independent of another thread, so no synchronization mechanisms between threads are essential.

The idea is to check, whether it is efficient to:
1.Spawn as many tasks as possible
or
2. Restrict the number of tasks in parallel, and wait for some tasks to complete before spawning the remaining tasks.

Following is the program:

    static void Main(string[] args)
    {
        System.IO.StreamWriter writer = new System.IO.StreamWriter("C:\\TimeLogV2.csv");

        SemaphoreSlim availableSlots;


        for (int slots = 10; slots <= 20000; slots += 10)
        {
            availableSlots = new SemaphoreSlim(slots, slots);
            int maxTasks;
            CountdownEvent countDownEvent;
            Stopwatch watch = new Stopwatch();
            watch.Start();

            maxTasks = 20000;
            countDownEvent = new CountdownEvent(maxTasks);

            for (int i = 0; i < maxTasks; i++)
            {
                Console.WriteLine(i);
                Task task = new Task(() => Thread.Sleep(50));
                task.ContinueWith((t) =>
                {

                    availableSlots.Release();
                    countDownEvent.Signal();
                }
                );

                availableSlots.Wait();
                task.Start();
            }
            countDownEvent.Wait();

            watch.Stop();
            writer.WriteLine("{0},{1}", slots, watch.ElapsedMilliseconds);
            Console.WriteLine("{0}:{1}", slots, watch.ElapsedMilliseconds);
        }

        writer.Flush();
        writer.Close();
    }

Here are the results:

The Y-axis is time-taken in milliseconds, X-axis is the number of semaphore slots (refer to above program)

Essentially the trend is: More number of parallel tasks, the better. Now my question is in what conditions, does:

More number of parallel tasks = less optimal (time taken)?

One condition I suppose is that:
The tasks are interdependent, and may have to wait for certain resources to be available.

Have you in any scenario limited the number of parallel tasks?

Answer 1

The TPL will control how many threads are running at once – basically you’re just queuing up tasks to be run on those threads. You’re not really running all those tasks in parallel.

The TPL will use work-stealing queues to make it all as efficient as possible. If you have all the information about what tasks you need to run, you might as well queue them all to start with, rather than trying to micro-manage it yourself. Of course, this will take memory – so that might be a concern, if you have a huge number of tasks.

I wouldn’t try to artificially break your logical tasks into little bits just to get more tasks, however. You shouldn’t view “more tasks == better” as a general rule.

(I note that you’re including time taken to write a lot of lines to the console in your measurements, by the way. I’d remove those Console.WriteLine calls and try again – they may well make a big difference.)