OpenMP 3.0 and iterators

There is pleasant news for the developers who want to use iterators and OpenMP together in their programs. Not to say that these technologies have been incompatible until recently, but it was impossible to use them so that they could complement each other. Iterators allow you to elegantly arrange item; they are safer and so on. It has been written in many books about the advantages of iterators and we will not enumerate them here. Unfortunately, until recently OpenMP technology has imposed great limitations on the types which could be used for parallel loops. And it concerned not only iterators. In some implementations, there was no support of even such simple unsigned types as unsigned/size_t. And there could be no error - a loop written with the use of unsigned/size_t type was not just paralleled and was executed only in one thread.

OpenMP 3.0 standard changes the whole situation and makes development of parallel applications simpler and more elegant. Firstly, you can use unsigned types unsigned/size_t in loops now.

Secondly, some steps have been made to increase compatibility of OpenMP technology and STL. Let's consider an example:

for (it = list1.begin(); it != list1.end(); it++)
{
  it->compute();
}

Earlier, this code could not be paralleled by the standard OpenMP directives. You could perform paralleling of it only by using specific technologies which could have been implemented in the compiler. For example, when using Intel compiler you could use OpenMP extension - Intel's Taskqueuing:

#pragma intel omp parallel taskq
{
  for (it = list1.begin(); it != list1.end(); it++)
  {
    #pragma intel omp task
    {
      it->compute();
    }
  }
}

You could also use a simple array instead of a container and write the code like this:

int iSize = list1.size();
valarray items(lSize);
for (int i = 0; i < iSize; i++)
{
  items[l] = &(*it);
  l++;
}
#pragma omp parallel for
for (int i = 0; i compute();
}

Of course the both ways have obvious disadvantages. The first uses specific extensions and the second is too awkward.

Now, that OpenMP 3.0 appeared, you can write after all:

#pragma omp parallel for
for (it = list1.begin(); it != list1.end(); it++)
{
  it->compute();
}

Of course, it will take some time until OpenMP 3.0 is implemented in most compilers and many mistakes in the implementation are removed [2]. But still OpenMP 3.0 is an important step which will help developers create safe parallel applications easier.

References