Parallel.Invoke() vs. Explicit Task Management

re: Parallel.Invoke() vs. Explicit Task Management

Yuri — Fri, 10 Jul 2009 22:57:32 GMT

Can you also explain the difference in how the parallel tasks may be canceled? For example, in hello world example, how would developer inform the Parallel.Invoke() that all pending tasks should be canceled, but those already executing should finish? What about the Task example?

Thanks!

re: Parallel.Invoke() vs. Explicit Task Management

cristina manu — Wed, 15 Jul 2009 06:26:26 GMT

[added several corrections for Beta1]

Hello Yuri,

Cancellation of Parallel Loops is supported through the concepts of CancellationTokenSource and CancellationToken. A cancellationToken can be passed to a ParallelFor through ParallelOptions.

In order to cancel a task (or more), Cancel method can be used on a task.

More info on cancellation please see at: http://blogs.msdn.com/pfxteam/archive/2009/06/22/9791840.aspx

For your specific question I added below some source code with comments that, I hope will help.

It addresses both questions: cancel a ParalleInvoke and cancel bunch of tasks.

Thanks,

Cristina

static CountdownEvent _ctd ;

public static void ParallelInvokeSample()

{

int n = System.Environment.ProcessorCount;

_ctd = new CountdownEvent(System.Environment.ProcessorCount);

//create an array of n + 1 actions

Action[] allActions = CreateActions(n + 10);

CancellationTokenSource cts = new CancellationTokenSource();

ParallelOptions pOptions = new ParallelOptions() { CancellationToken = cts.Token };

//on a different thread cancel the token by calling cancel on the tokenSource

Thread cancel = new Thread(() =>

{

//wait for the parallel invocation to start

_ctd.Wait();

cts.Cancel();

});

cancel.Start();

try

{

//pass the token to ParallelInvoke through parallelOptions

Parallel.Invoke(pOptions, allActions);

}

catch( Exception e )

{

Console.WriteLine(e.Message);

}

cancel.Join();

}

public static void TasksSample()

{

int n = System.Environment.ProcessorCount;

_ctd = new CountdownEvent(System.Environment.ProcessorCount);

try

{

//first create a factory with RespectParentCancellation option

TaskFactory factory = new TaskFactory(TaskCreationOptions.RespectParentCancellation,TaskContinuationOptions.None);

//create a number of tasks that will be cancelled through a common parent

Task[] allTasks = new Task[n + 10];

Task parent = Task.Factory.StartNew(() =>

{

for (int m = 0; m < n + 10; m++)

{

allTasks[m] = factory.StartNew(() =>

{

Console.WriteLine("hello");

try { _ctd.Signal(); }

catch

{

//ignore any exception

}

//do some long running work

for (int k = 0; k < 1000; k++)

{

Thread.Sleep(2);

}

});

}

});

//wait for some tasks to start

_ctd.Wait();

//cancell all the tasks, by cancelling the parent

parent.Cancel();

//wait on the tasks

Task.WaitAll(allTasks);

}

catch (AggregateException e)

{

Console.WriteLine(e.InnerExceptions.Select((x) => x.Message).Aggregate((x, y) => { return x + y; }));

}

static Action[] CreateActions(int n)

{

Action[] result = new Action[n];

for (int i = 0; i < n; i++)

{

result[i] = () =>

{

Console.WriteLine("hello");

try { _ctd.Signal(); }

catch

{

//ignore any exception

}

//do some long running work

for (int k = 0; k < 1000; k++)

{

Thread.Sleep(2);

}

};

}

return result;

}

re: Parallel.Invoke() vs. Explicit Task Management

Sachin — Wed, 15 Jul 2009 22:25:18 GMT

Couple of quick questions:

a) What is the performance impact (if any) of not having a "flat" task hierarchy. For example, if thread A is the main thread, what if we have:

A --> B, C and B --> D,E vs.

A --> C, D, E,

The latter obfuscates code more, but there are less tasks created. Is the "performance" significant, or is this taken care of "under the covers"

b) For the Tree Traversal code, you could have just added the actions without checking whether the left or right tree was null and it would still be functionally correct. Is there a significant performance trade-off between more concise code and doing this check before scheduling tasks?

re: Parallel.Invoke() vs. Explicit Task Management

cristina manu — Thu, 16 Jul 2009 08:22:49 GMT

Hello Sachin

For question “b”, without the checking that you mention, we would pay the cost of creating/scheduling new tasks (this means possibly creating new threads) without really needing them. So. I would say that. if possible to do some un-expensive validations, it is recommended to do them before creating new tasks.

For question “a”, if I understand correctly your scenario, the 3 tasks (C, D E ) need to be scheduled. They can be scheduled either directly ( a.2), or through the task B ( a.1). I do not see a reason for introducing task B, if it is not needed. As above, any new task created might lead to a new thread injection. Also, with a new task, probably it will be needed to wait on it ( implicitly or explicitly) - this will add a performance penalty as well. In conclusion, I would recommend to try to not create tasks as long as they are not needed. Parallel.Invoke takes care of creating the right number of tasks for executing all the actions.

Also, because you may be interested in profiling parallel applications, I think that you will find useful the new parallel profiling tools that will be shipped with Visual Studio 2010. (http://blogs.msdn.com/hshafi/archive/2009/05/18/visual-studio-2010-beta-1-parallel-performance-tools.aspx,. http://blogs.msdn.com/hshafi/archive/2009/06/02/vs2010-how-to-use-the-parallel-performance-analysis-tools.aspx)

re: Parallel.Invoke() vs. Explicit Task Management

Michal — Mon, 03 Aug 2009 16:37:42 GMT

Please, can you explain how it is with exception handling for both priciples. Imagine situation when the method TreeTraversal() fire exception. I expect, that some exception will be thrown from 'Task.WaitAll(tasks.ToArray())' or 'Parallel.Invoke(actions.ToArray())'. But the question is which expection wins when variable 'tasks' or 'actions' contains more than one task. Or all exceptions thrown in TreeTraversal() will be silently 'consumed' by framework?

For tasks I know that I can review task.Exception property to see if this task raises any exception, but which exception will be thrown from Task.WaitAll? And how it is for Parallel.Invoke?

Thanks Michal

re: Parallel.Invoke() vs. Explicit Task Management

toub — Mon, 03 Aug 2009 18:43:32 GMT

Hi Michal-

A general principle followed by the parallelism technologies in .NET 4 is that we never want to lose or eat exceptions. As such, a new exception type System.AggregateException has been introduced in .NET 4, which is an Exception-derived type that supports containing multiple inner exceptions rather than just a single inner exception. In the cases you ask about, if any of the tasks passed to Task.WaitAll complete in a faulted state, all of their exceptions will be wrapped in an AggregateException instance, and that aggregate exception will be thrown, thus allowing you to see all of the exceptions. Same goes for Parallel.Invoke: if multiple actions failed, Invoke will throw an aggregate containing all of the exceptions.

More information on this is available in a new article just posted in the latest issue of MSDN Magazine: http://msdn.microsoft.com/en-us/magazine/ee321571.aspx.