Exercise 1: Learning the Basics of the PPL (Background)

Developers seeking to execute their native serial applications on multiple cores must find a way to run them in parallel. One choice is to redesign the application using threads, which can be time consuming, prone to errors, and difficult to debug.

Another option is to use the Pattern Parallel Library to enable parallel execution of loops without having to worry about the underlying mechanism. The latter mechanism is more appealing and should reduce develop and testing time. Nonetheless, this does not mean that your code is immune to the concurrency problems. You must still pay careful attention to your code.

The Parallel Patterns Library

PPL stands for the Parallel Pattern Library and is meant to provide a convenient interface to execute work in parallel. By using PPL, you can introduce parallelism without even having to manage a scheduler. Below are some of the most common patterns.

Task execution patterns:

parallel_invoke: To execute from 2 to 10 tasks in parallel

parallel_for: To execute tasks in parallel over a range of integers

parallel_for_each: To execute tasks in parallel over a collection of items in an STL container

Synchronization patterns:

reader_writer_lock: A cooperative reader-writer lock that yields to other tasks instead of preempting.

critical_section: A cooperative mutual exclusion primitive that yields to other tasks instead of preempting.

Data sharing pattern:

combinable: A scalable object that has a local copy for each thread where processing can be done lock free on the local copy and combined afterwards when parallel processing is done.

A PPL Example

Take a look at the following code that carries matrix multiplication:

The code has nothing out of this world; in fact, probably no one would ever do this for multiplying matrices in real life. But the interesting thing about it is that the outer loop is very embarrassingly parallel.

If were to use threading APIs to do this, it would require a lot of effort from our part. We would have to deal with partitioning the data, and data synchronization.

Here's that same scenario using the library “parallel_for” from the Parallel Pattern Library.

void MatrixMult(int size, double** m1, double** m2,double** result){

One thing you'll notice is that we’re using a new feature from C++ Ox called Lambda support. The syntax following the parallel_for key-word specifies iteration logic from zero to size in increment steps of 1.

By changing the code to use the parallel_for, the Concurrency Runtime Scheduler implicitly executes each iteration as an independent task.

That’s All I Have to Do to Parallelize my Code?

We all know that writing code can be a very daunting task. Writing code that executes in parallel adds even more complexity. This means that writing code that will execute in parallel can introduce new problems that did not exist in the serial version of your application.

Take a look at the following code snippet:

The code works perfectly as is. It will find the number of primes by using a function that returns whether the sent parameter is prime or not. The totalPrimes variable is incremented every time such number is found.

In order to parallelize this code using PPL, the code would look like this:

If we were to run this code on a multi-core machine, we would discover 2 things:

1. The programs runs a lot faster than before
2. The program is a lot faster but gives incorrect results with each run

We’ll talk about date races later on and you will understand why the parallel code is yielding incorrect results.

Let’s get started and parallelize some code with PPL!