.Net Framework 4.0 with its Parallel Extensions, still in Beta 1, will add the possibility to work with tasks. It is very important to understand that tasks aren't threads. Tasks run using threads. However, it doesn't mean they replace threads.
By Gaston Hillar
August 01, 2009
URL : http://www.drdobbs.com/parallel/tasks-are-not-threads-in-net-4-beta-1/228800457
.Net Framework 4.0 with its Parallel Extensions, still in Beta 1, will add the possibility to work with tasks. It is very important to understand that tasks aren't threads. Tasks run using threads. However, it doesn't mean they replace threads.Whilst working with Parallel Extensions CTP (Community Technology Preview) it was very difficult to debug code working with the new parallelism model. It wasn't easy to understand what was going on with parallelized loops. It was difficult to debug the new task-based programming code. The big problem was that the CTP didn't add debugging features for tasks. The IDE (Visual Studio 2008) was prepared for debugging threads. Thus, it wasn't able to debug tasks properly.
If you understand C style coding, the following line will summarize the situation:
(Threads != Tasks) && (Thread != Task)
You can take a look at the excellent diagram prepared by Cameron Hughes and Tracey Hughes in their post "Find John Fast!!". They've shown seven levels, from the domain model level to the hardware level. The Application Task Level (Level 3) is over both the Logical Task Level (Level 4) and the Process/Thread Level (Level 5).
As explained in the aforementioned diagram, tasks run on a different level. However, threads support tasks' executions. Hence, the tasks steal work from different threads to use processor time. I've already explained this mechanism in my previous post "Work Stealing queues in .Net 4 and in Previous Versions".
When you work with tasks, they run their code using underlying threads (software threads, scheduled on certain hardware threads or logical cores). However, there isn't a 1-to-1 relationship between tasks and threads. This means you're not creating a new thread each time you create a new task. The CLR creates the necessary threads to support the tasks' execution needs. Of course, this is a simplified vision of what goes on when creating tasks.
You can take advantage of most of the techniques you've learned so far working with threads when using task-based programming. However, you require new debugging techniques. Therefore, Visual Studio 2010, still in Beta 1, offers two new debugging windows:
• Parallel Stacks • Parallel Tasks
These new windows allow you to understand the relationship between the running tasks and their related threads, at run-time. This way, you can debug the task-based code without the problems found during the CTP tests.
It is very important to understand the differences between tasks and threads before starting to code task-based algorithms. The new debugging windows offer nice information for developers to understand what's going on in those parallelized loops and concurrent tasks.
Many developers worked with Parallel Extensions CTP and as they didn't have an appropriate debugger to understand what was going on, they thought tasks were difficult to control. They were indeed difficult to understand without these new debugging windows.
A Danish proverb says "Speedy execution is the mother of good fortune". Thus, stay tuned to Go Parallel using a successful task-based programming. I'll be adding a new post about debugging tasks soon.
Copyright © 2012 UBM Techweb