Here’s a simple example that will help you understand the power of SIMD instructions. The next Figure shows a diagram that represents the PABSD instruction. This instruction is part of the Supplemental Streaming SIMD Extensions 3 (SSSE 3) introduced with the Intel Core 2 architecture.

The PABSD mnemonic means packed absolute value for double-word. This assembly instruction receives a 128-bit input parameter that contains four 32-bit signed integers. The instruction returns a 128-bit output that contains the absolute value for each of the four 32-bit signed integers, packed in the 128-bit output.

You can calculate the absolute values for four 32-bit signed integers with a single call to the PABSD instruction. If you have to calculate the absolute values for 1,000 32-bit signed integers, you can do it with 250 calls to this instruction instead of using a single instruction for each 32-bit signed integer. You can achieve very important speedups. However, because it is necessary to pack the data before calling the SIMD instruction and then unpack the output, it is also important to measure this overhead that adds some code.

If you have to calculate the absolute values for four 32-bit signed integers, the additional overhead will reduce the overall speedup. However, if you have to calculate the absolute values for 100 32-bit signed integers, you will usually benefit from the usage of this kind of SIMD instruction.

If you have to calculate the absolute values for 1,000 32-bit signed integers and you are running the code on a CPU with two physical cores that support the SSSE3 extended instruction set, you can run PABSD instructions in parallel to increase throughput. You can calculate these values with 125 calls to this instruction in each physical core and achieve a speedup through parallelism combined with the execution of SIMD instructions. The absolute value calculation would be as follows:

125 calls x 2 physical cores x 4 integers per PABSD instruction call = 1,000 32-bit signed integers

The next figure shows a diagram that represents the execution of the PABSD in parallel on two physical cores.

Each SIMD instruction can typically work with different packed data types. For example, the SSSE3 extended instruction set includes three assembly SIMD instructions that calculate packed absolute values for the following data types:

• PABSB — Calculates the absolute value for 16 signed bytes
• PABSW — Calculates the absolute value for eight 16-bit signed integers (words)
• PABSD — Calculates the absolute value for four 32-bit signed integers (double-words)

The aforementioned SIMD instructions can also calculate the absolute values for a lower number of packed values. For example, PABSB can calculate the absolute value for 8 signed bytes instead of 16.

Many applications written in C and C++ take advantage of these instruction sets to work on vectors and matrixes. They are very useful to improve performance in algorithms that need to perform multiple calculations on many data blocks. Most modern C and C++ compilers optimize loops to take advantage of SIMD instruction sets. Therefore, they are able to perform an auto-vectorization when you follow certain guidelines for writing the loops that perform operations on arrays.

.NET Framework 4 does not provide direct support for SIMD or auto-vectorization. This means that your C# code cannot call SIMD instructions, and the C# compiler doesn’t provide an option to enable the usage of SIMD instructions when you perform operations on arrays. However, you can use libraries that are optimized to take advantage of the performance improvements offered by SIMD instructions. You can call the functions provided by these libraries, and you can combine them with the advantages of task-based programming. Intel develops two performance libraries that take advantage of both parallelism and SIMD instructions, targeting several application domains. These libraries are Intel Math Kernel Library (MKL) and Intel Integrated Performance Primitives (IPP)

Modern microprocessors can execute SIMD instructions. However, these instructions are part of different extended instruction sets. Because the need for greater computing performance continues to grow across industry segments, Intel has incorporated extended instruction sets in their new CPU models. At the time of this writing, the most advanced Intel CPU includes support for the following SIMD instruction sets:

• MMX — MultiMedia eXtensions
• SSE — Streaming SIMD Extensions
• SSE2 — Streaming SIMD Extensions 2
• SSE3 — Streaming SIMD Extensions 3
• SSSE3 — Supplemental Streaming SIMD Extensions 3
• SSE4.1 — Streaming SIMD Extensions 4.1
• SSE4.2 — Streaming SIMD Extensions 4.2
• AES-NI — Advanced Encryption Standard New Instructions
• AVX — Advanced Vector eXtensions

The previously mentioned MKL and IPP performance libraries detect the available extended instruction sets and optimize their execution according to the possibilities offered by the underlying hardware. Thus, if you run the same code in two similar dual-core microprocessors, but they support diverse extended instruction sets, you might achieve very different performance results. For example, if a CPU supports Advanced Vector eXtensions (AVX), it can perform certain operations on 256-bit packed types with a single instruction.

Intel MKL is a library of highly optimized math routines for science, engineering, and financial applications. The math routines use multiple threads and SIMD instructions to achieve the best performance according to the underlying hardware. MKL 10.3 introduced a simple DLL named mkl_rt.dll, which you can call within your C# code.
Intel IPP is a library of highly optimized math software functions for digital media and data-processing applications. The functions use multiple threads and SIMD instructions to achieve the best performance according to the underlying hardware. IPP includes multiple DLLs, and you can call IPP’s functions from your C# code.

You can combine the new task-based programming model introduced in .NET Framework 4 with high-performance libraries such as Intel Math Kernel Library and Intel Integrated Performance Primitives. In this post, I explained some of the benefits of using these libraries. In subsequent posts, I will show examples that combine calls to these libraries with task-based programming to leverage both parallelism and SIMD instructions in C#.

This post includes an excerpt from my book “Professional Parallel Programming with C#: Master Parallel Extensions with .NET 4.” () The book targets advanced C# developers that want to take full advantage of the new parallel programming features introduced by .NET Framework 4 and Visual Studio 2010. I’ve been using these highly optimized libraries for many years, and therefore, I’ve included a whole chapter that explains how to work with these libraries with C# and .NET Framework 4.

You can read “Performance Library Basics” by Lori Matassa and Max Domeika. In this article, Lori and Max provide an excellent explanation of the benefits of trusting complex algorithms to highly optimized performance libraries.

James suggests that you should leave the mapping of tasks to hardware threads as a distinctly separate operation in your code. When you create tasks using an efficient task based programming model, you can create as many as you can without worrying about oversubscription. Of course, you still have to pay attention to the introduced overheads. In fact, tasks also introduce an overhead and it is always important to measure speedups.

Tasks consume software threads using many different techniques to reduce the overhead needed to schedule work and they take advantage of the underlying hardware threads (logical cores). When you work with tasks the code is easier to read than its pure thread version. One of the key advantages of tasks is that they usually require less overhead for their creation than threads. This way, some algorithms that are simple to implement using dozens of tasks reduce their overhead compared to its implementation using dozens of threads. Again, it is also important to consider that this doesn’t mean that you have to add tasks all the time. They have to be used in a smart way.

I’ve written a few posts about the new task based programming model in C# 4 with .NET 4. You can read about the specific implementation of tasks in Visual Studio 2010 in my post "Tasks Are Not Threads". I wrote it when Visual Studio 2010 was in Beta 1. Now, it is available its Release Candidate version but the concepts explained in this post are still valid.

Intel® Threading Building Blocks (Intel® TBB), Intel® Cilk++, OpenMP and QuickThread include task based programming models. It is very important to learn their possibilities in order to express parallelism at a much finer granularity. Then, you can decide whether your algorithm would run better by using tasks or threads.

You can read the eight rules in the article published by James Reinders in Dr. Dobb’s: "Rules for Parallel Programming for Multicore".

There are many tools, techniques and tips that make it possible to use your existing skills in the x86-family in order to take full advantage of the features offered by many of the Intel® Atom microprocessors. You can use these techniques to create faster and more responsive software. However, it is very important to understand the specific features offered by many of the different Intel® Atom models.

This year, I will make a presentation at the 5th Annual Multicore Expo (2010 Multicore Expo), April 26-29, Sillicon Valley 2010, McEnery Convention Center, San Jose, California, USA.

The presentation’s title is “Parallel Programming Possibilities with the Intel Atom Family” and it is scheduled on Day 1, April 27th, 08:30-09:14 a.m., as part of the “Parallelization and Application Partitioning” track.

In this session, I will show real-life examples of the different possibilities offered by Atom N270 (2 logical cores, 32-bits) and Atom 330 (4 logical cores, 64-bits). Besides, I’ll also add the newest Atom D510 (4 logical cores, 64-bits).

I will explain Hyper-Threading’s capabilities in detail, with its advantages and its drawbacks. I will explain the usual power management system used with these microprocessors and the advantages of using parallel programming techniques to reduce both the microprocessor’s frequency and power consumption.

Besides, I will explain the SIMD instruction set found in these microprocessors and how to take advantage of it to maximize both parallelism and application’s performance.

The ideas shown in this session can be applied on any operating system.

I do believe year 2010 will be another exciting year for the Intel® Atom family. What do you think? I can’t wait for Multicore Expo 2010. If you’re interested in parallel programming, multicore and Intel® Atom, you can check the information about the session. Besides, comments and ideas about this topic are always welcome.

I’ve written a few posts related to this topic on Dr. Dobb’s Go Parallel and Dr. Dobb’s:

* Downsizing Multicore Programming Skills To Take Advantage of Intel® Atom

* Moblin 2.0 Is Multicore Ready

I’m working with Windows 7 RTM and I wanted to install Intel® Parallel Advisor Lite. Its latest version is a Windows Installer Package (.MSI), Advisor_Lite_update1_win.msi. The package has to be installed with Administrator rights. Therefore, if you just double click on the file, the installation is not going to work as expected.

As Windows 7 hasn’t been released yet, Intel® Parallel Advisor Lite doesn’t offer official support for this operating system. However, I’m already working with Windows 7 and I wanted to optimize some code for multicore microprocessors taking advantage of the new performance improvements offered by the new Windows 7 kernel.

There is a very simple way to successfully install Intel® Parallel Advisor Lite on Windows 7. Besides, the same steps work with Windows Vista:

1. Run a Command Prompt as Administrator: Start Menu, All Programs, Accesories. Right-click on “Command Prompt” and select “Run as administrator” from the context menu that appears, as shown in the following picture.

2. A command line (terminal) Window will appear displaying the title “Administrator: Command Prompt”. Go to the folder where you downloaded the Advisor_Lite_update1_win.msi file. Remember that you have to use the CD command. For example, if the file is in C:\downloads, you just have to type:

CD C:\downloads

Important note: As a developer, you should know the CD command. However, I wanted to keep things as simple as possible for those who don’t use command line commands in Windows.

3. Run msiexec with the /i option and the Windows Installer Package (.MSI) as a parameter:

msiexec /i Advisor_Lite_update1_win.msi

The installation will start because you’re running the Advisor_Lite_update1_win.msi package as an Administrator. You’ll be able to enjoy Intel® Parallel Advisor Lite. Follow the advice and tackle the multicore revolution!

In the last months, I’ve began working with Moblin v2.0 beta for Netbooks and Nettops. I am very interested in exploring this new platform and I’m working with parallel programming, taking advantage of Hyper-Threading technology and SSE instructions found in most Intel Atom microprocessors.

I consider myself an old Linux + Windows warrior. So far, I’ve installed hundreds of Linux distributions combined with hundreds of Windows versions. Therefore, I’m going to share some tips to install Moblin v2.0 beta in Netbooks.

Most ASUS EeePC netbooks have Windows XP Home Edition preinstalled. Besides, they have a very fast BIOST POST and hidden partitions in order to recover the operating system installation. What about installing Moblin v2.0 in an ASUS EeePC without killing the existing Windows XP Home Edition?

DISCLAIMER: I’m trying to provide tips to help. However, do it at your own risk. Working with beta versions is not recommended for beginners. Backup all your data before following these steps.

The first problem is the need to change partitions. You don’t want to delete any existing partition because the official operating system is Windows XP Home. I’m going to use an ASUS EeePC 1005HA Seashell as an example. You can create an empty partition in order to make it possible to install Moblin v2.0 beta following these steps:

1. Download and install EASEUS partition Master Home Edition. This software is a free edition (it runs on Windows XP, 32-bits). There are other commercial editions. The free edition provides the necessary tools to change partitions in most netbooks running Windows XP Home Edition.

2. You will find the following partitions. Two of them have assigned letters (C: and D:).

Existing partitions.

3. You can shrink the second NTFS partition (D:). Right-click on it and select Resize/Move from the context menu that appears. If you were working with this partition, it is very convenient to defragment its free space before trying to resize it.

Context menu to shrink

4. Enter the desired space to use for Moblin v2.0 in “Unallocated Space After”. In this case, I’ve created an empty 30,960.4 MB partition.

Desired space

5. Click on OK.

6. The new partition map will appear. The new partition will be shown with the Unallocated label (30.23 GB). If you apply the changes, it will lock drive D: and it will resize the existing NTFS partition.

New partition map

7. Check the new partition properties (click on the Properties button).

Properties

8. Are you sure? Click on Apply.

Are you sure?

9. Are you really sure? Did you backup your data? Click on Yes. You will see the progress.

Progress

10. Now, you can check it using Disk Manager or running EASEUS Partition Manager Home Edition again. You will see the resized NTFS partition (D:) and the new Unallocated space (ready for Moblin v2.0).

A new partition ready for Moblin

As you can see, it’s easy to create the necessary free space to install Moblin v2.0.
Stay tuned. I’ll be adding detailed step-by-step information about installing and working with Moblin v2.0. Feedbacks and comments are always welcome.

As I’m used to work with managed code and garbage collectors (C#, Java and Groovy, among others), I usually face many difficulties when switching to unmanaged C++.
When I finished installing Intel Parallel Studio and I saw the new toolbars integrated in Visual Studio 2008, I couldn’t help beginning to read the complete documentation for this exciting product.
I really liked the capabilities offered by Intel Parallel Studio. It helped me to work faster in order to parallelize existing serial code. It also helped me to find the most difficult bugs and to profile my applications. I do believe it is a unique tool. You’ll find a lot of information about Intel Parallel Studio on its main Website: http://software.intel.com/en-us/intel-parallel-studio-home/

A well-known proverb says “A good workman is known by his tools”. Last week, I had to begin teaching the most difficult parts of a small multi-core programming course.
I was talking about C# multi-core programming, using .Net 3.5. I’ll have a final session talking about future .Net 4.0 parallel extensions and the new features offered by Visual Studio 2010.
I realized that Intel Parallel Studio’s evaluation version could help me to teach the most difficult topics and to emphasize the performance improvements offered by parallel programming.

So far, Intel Parallel Studio does not work with C#. However, it offers amazing tools that make it easy to understand difficult topics, like:

• Scalablity problems.
• Race conditions.
• Dead-locks.
• New bottlenecks.
• New debugging techniques.
• New parallel bugs.
• New tuning challenges.

The results were really satisfying. Intel Parallel Studio helped me to teach difficult topics using an innovative approach. The feedback was really amazing. Developers attending the course understood these issues. They are going to work with C#, but they learned the necessary concepts to understand the big problems. However, they are going to use different tools to detect and to solve them.
I’d love to see Intel Parallel Studio for C# (.Net) and for Java. However, I’ll go on taking advantage of its features to teach the most difficult to learn multi-core programming issues.

Intel Parallel Studio has been recently launched (version 1.0). If you're interested in learning multi-core programming and the challanged associated with the parallelism age, you'll find is really useful to test it. If you don't work with C++, it doesn't matter because you'll still be able to learn really important techniques. Then, you'll be able to use these techniques in your programming language.

Besides, I encourage you to ask Intel to add new languages to this exciting tool. Don't leave me alone.

Disclaimer: I’m talking about a Beta 1 release. Therefore, there is a great possibility to meet differences in the final release. The features provided by Silverlight 3 (final release) could differ from the ones I’m talking about for the Beta 1 release. I’m focusing on C#. However, you can also use Visual Basic and other languages like F# to program Silverlight apps.

You can control the elements defined in XAML using C# 3.0 and a subset of .Net 3.5. Hence, you can use lambda expressions, as explained in my previous post. They are really useful to simplify parallelized code.

You have access to BackgroundWorker (System.ComponentModel.BackgroundWorker). Thus, you can use the BackgroundWorker component to create new threads without the complexity of the Thread class and/or ThreadPool. The BackgroundWorker component gives you instant access to a new thread with a component based scheme. Hence, it is simpler for beginners to start working with it. However, you must be very careful to understand what you’re doing when using it. Running code in additional threads will take advantage of multiple cores.

You have access to the Thread class (System.Threading.Thread) in order to run many concurrent threads with more control capabilities than the ones created using the BackgroundWorker component. The Thread class offers many fine tuning capabilities.

You have access to the ThreadPool class (System.Threading.ThreadPool) in order to work with pools of threads. You can queue work items using the ThreadPool class and you can also use its fine tuning capabilities.

Thus, you have access to these three main elements:
* BackgroundWorker
* Thread class
* ThreadPool class

Everything that you learned working with multithreading and multi-core programming using C# 2.0 and C# 3.0 will be really useful when working with Silverlight 3 Beta 1.

So far, Silverlight 3 Beta 1 will not offer support to Task Parallel Library or the Parallel Extensions. Hence, I guess we’ll have to wait for Silverlight 4. Nevertheless, C# 3.0 and Silverlight 3 Beta 1 will offer great opportunities for developers to tackle the multi-core revolution offering exciting RIAs.

You can find additional information about my thought about the opportunities related to RIA and parallelism reading my post in Go Parallel: http://www.ddj.com/go-parallel/blog/archives/2009/05/designing_rich.html

I used a very simple example. Now, I’m going to use a more complex example to convince you that lambda expressions and parallelized code are good friends. In this post, I’m going to forget about the Task Parallel Library Beta 1 because I’m going to use a C# example for Silverlight.

You have a Silverlight application showing a simple Button through XAML code, btnStartGame. If you want to change its properties from a non-UI thread, you have to queue commands in the UI thread. You cannot change controls’ properties from other threads.

If you have to create a new thread, start it and invoke a delegate to update the UI inside it, the code could be as complex as the following lines:

// The event handler that starts the thread
private void btnStartGame_Click(object sender, RoutedEventArgs e)
{
Thread thread = new Thread(new ThreadStart(InvokeThread));
thread.Start();
}

// The code that will run in a new thread
void InvokeThread()
{
btnStartGame.Dispatcher.BeginInvoke(UpdateContent);
}

// The code that will run in the UI thread to update the text shown in the Button
void UpdateContent()
{
btnStartGame.Content = "New title.";
}

The code is indeed complex. It contains too many lines and three methods.

Now, let’s take a look at the same code, but using lambda expressions:

private void btnStartGame_Click(object sender, RoutedEventArgs e)
{
new Thread(() =>
{
btnStartGame.Dispatcher.BeginInvoke(() => btnStartGame.Content = " New title.");
}).Start();
}

The code is indeed simpler. Just a few lines and they fit in the event handler. You can replace the creation of many methods using lambda expressions. Hence, lambda expressions in C# are good friends for task-based programming.

Just a note, you have to add using System.Threading; in order to make the code run in a Silverlight 2 or Silverlight 3 Beta 1 solution.

If you aren’t using lambda expressions in your current C# programs, you should begin learning about them before jumping into the new features. C# 3.0 introduced lambda expressions and they are very useful to simplify the parallelized code. They will help you to create code that’s easier to read, understand and maintain.

To keep things simple, a lambda expression is an anonymous function that can contain expressions and statements. It can be used to create delegates or expression tree types.

They are really useful to simplify the code when we use delegates. Parallelized code uses many delegates. Hence, lambda expressions allow you to simplify the code, reduce the complexity and understand what you’re doing. Parallelized code is more complex than serial code. Lambda expressions will help you to reduce this additional complexity.

All lambda expressions use the lambda operator =>. It is read as “goes to”.

For example, the following lines of code use the classic C# 2.0 syntax but they work with Parallel.ForEach (introduced in the Task Parallel Library):

System.Threading.Tasks.Task.Create(delegate(object myObject) {
try
{
Parallel.ForEach(myMeshes, delegate(Mesh myNextMesh)
{

Now, let’s take a look at the same code, but using lambda expressions:

System.Threading.Tasks.Task.Create(myObject =>
{
try
{
Parallel.ForEach(myMeshes, myNextMesh =>
{

The code is simpler, easier to read, understand and maintain.

Disclaimer: In the aforementioned lines of code, I’m using “System.Threading.Tasks.Task” because Task is new in the Task Parallel Library. A using statement could simplify the code even further.

The code creates a new task to run a parallelized loop asynchronously. It is an example. This is an advanced option. It is recommended for developers who understand what they are doing. I’m not recommending this practice to use in all the parallel loops. Some applications don’t need this kind of configurations.

Take into account that most developers will be using lambda expressions for parallelized code. By the way, most developers working with parallelized code using current features found in C# 3.0 and .Net 3.5 are also using lambda expressions.

Therefore, if you want to be able to understand parallelized code running in tasks and threads, you should begin working with lambda expressions.

This is an advanced option. It is recommended for developers who understand what they are doing. I’m not recommending this practice for its use in all the parallel loops. Some applications don’t need this kind of configurations.

The previous TaskManager instance was not successful in some cases. Therefore, the TPL team added the new ParallelOptions class, which adds many interesting properties.

First, you have to create a new instance of ParallelOptions. Then, in order to limit the concurrency level of parallel loops, you just have to set the desired number of logical cores to use to the MaxDegreeOfParallelism property. This property has a default value of -1 which means attempting to use all the available logical cores.

The following loop will use all the available logical cores:
var myOptions = new ParallelOptions { MaxDegreeOfParallelism = -1 };
Parallel.For(0, 60000, myOptions, i=>
{
// Code to run
});

The following loop will use no more than two logical cores, no matter the total number of available logical cores:
var myOptions = new ParallelOptions { MaxDegreeOfParallelism = 2 };
Parallel.For(0, 60000, myOptions, i=>
{
// Code to run
});

If you know the number of logical cores, you can use a relative value. For example, if myNumberOfCores stores the number of logical cores, the following loop will leave one core free:
var myOptions = new ParallelOptions { MaxDegreeOfParallelism = myNumberOfCores – 1 };
Parallel.For(0, 60000, myOptions, i=>
{
// Code to run
});

Of course, you must take into account that the additional threads created at run-time and the operating system scheduler will influence the final results.

If you have 8 logical cores, you can run two parallel loop asynchronously, each using 4 cores. It depends on your needs.

Again, this is an advanced topic. You must know what you’re doing when using these scheduling options. However, it’s good news that the old TaskManager introduced in previous TPL CTPs (Community Technology Previews), which was pretty inaccurate, can be replaced by the new ParallelOptions.

I'm preparing a sequence of posts related to fine-grained parallelism with .Net Parallel Extensions. However, as I've received this questions dozens of times in my e-mail, I thought it was a good idea to post the answer for these three programming languages.

Why do you need to know the number of logical cores? Because taking this information into account, you can decide at run-time, the number of parallel tasks that you're going to run concurrently.
If you discover that you have four cores available, you can run four tasks concurrently. This changes if you run the same application on a dual-core microprocessor.

And what about eight logical cores, like the ones offered by a Core i7. A quad-core microprocessor that offers eight logical cores via Intel's Hyper-Threading Technology.

.Net 4.0 with Parallel Extensions will offer many excellent features to decide the number of logical cores to dedicate to each parallelized task. Java 7 will also offer similar features with its fork-join framework. However, you must begin with the most simple task: counting the number of logical cores.
Just a single line of code for each programming language. It is very easy.

C#:
Environment.ProcessorCount;

Visual Basic:
Environment.ProcessorCount

Java:
Runtime.getRuntime().availableProcessors();

These lines return the number of logical cores on Windows and in other operating systems.

For example, if you run these lines on a computer with a quad-core Core i7 supporting Hyper-Threading, it will return 8.
If you run these lines on a computer with a quad-core Q6700, it will return 4.

I know it's a very simple post. However, you have to know these if you are creating applications in these programming languages.

Once you have the most important tasks, you can re-design the algorithm taking into account that you must exploit parallel architectures. Of course, you must understand how threads work and how modern multi-core microprocessors work. Then, you can use tools like a Gantt chart (yes, a Gantt chart) to find the critical sections (those areas where parallelization is extremely difficult or nearly impossible).

This time, I’m going to show a simple example taking into one of the new features offered by future .Net 4.0 Parallel Extension. If you have an application that must perform many tasks and you discover that you have more than 2 cores available, it would be very convenient to launch them in parallel.

However, which is the simplest way to launch many completely independent tasks in parallel? In C# 4.0, you’ll be able to use the new Parallel.Invoke method combined with lambda expressions:

Parallel.Invoke(
() => ConvertMeshes(myMeshes),
() => ConvertMaterials(myMaterials),
() => ConvertLights(myLights)
() => ConvertCameras(myCameras)
);

Taking into account the default options (you can even change many options taking into account your needs), if you run this code in a quad-core CPU with four logical cores, this is what will happen:

ConvertMeshes(myMeshes) will run in Core #0.
ConvertMaterials(myMaterials) will run in Core #1.
ConvertLights(myLights) will run in Core #2.
ConvertCameras(myCameras) will run in Core #3.

The current thread will be blocked until the four methods return from their execution in parallel. However, you could also run these four tasks concurrently and asynchronously. I’m trying to keep things simple.

Is the code above easy to understand? Yes, it is very easy to understand it. It is easy to maintain. It is easy to optimize it.

If you want to take full advantage of the future Parallel Extensions in .Net 4.0, it is highly recommended to learn about lambda expressions. They were introduced in C# 3.0 to shorten the code and to make it more functional.
Combining lambda expressions with the new task oriented approach that is going to be introduced in Parallel Extensions in .Net 4.0, exploiting multi-core microprocessors will be indeed easier for most C# developers.

The aforementioned example is very simple. I tried to keep things simple, this was my idea in this post.

However, please, do not forget to learn about threads. You’ll need that knowledge in the new parallel age.

Parallel Extension will offer a lot of interesting features related to multi-core programming. So, developers face many questions:

• ¿Is .Net 4.0 going to be backward compatible with my existing threading code? Luckily, the answer to this question is YES. You will be able to keep the existing code running while taking advantage of the new features. Besides, it will run faster because there are a lot of improvements in previous features offered by .Net 3.5.

• ¿Will I be able to take advantage of my training in threaded and concurrent programming? Another YES. Parallel Extensions offer new features that simplify the many multi-core and concurrent programming tasks. Your existing knowledge will be very useful to begin working with these shortcuts. You will see a lot of tasks really simplified. However, you have to understand what you’re doing in order to avoid problems.

• ¿Can I combine previous threading mechanisms with Parallel Extensions? Yes. You have to be careful with some issues. However, if you understand what you’re doing, it will work fine. For example, you can use a ThreadPool combined with PLINQ. If you use the right parameters to specify the degree of parallelism for the ThreadPool and PLINQ, you will be able to exploit the right number of cores.

• As they offer high-level concurrency structures, ¿Do I have to forget about hardware? No, no and no. Understanding multi-core hardware is the key to a successful parallelized application. A paradigm shift is needed.

Developers will be able to convert their code as needed in order to take full advantage of .Net 4.0 Parallel Extensions. There is no need to reconvert all the existing multithreading code. However, you’d rather take advantage of the new features as soon as possible.