12

I'm trying to iterate over a map in c++ using openMP, but I got three error messages saying
that the initialization, termination and increment of my loop has improper form and I'm quite new in using openmp, so is there any way to get around this problem while getting the same results as the serial ones? the following is the code I used

map< int,string >::iterator datIt;
#pragma omp parallel for
for(datIt=dat.begin();datIt!=dat.end();datIt++) //construct the distance matrix
{
...............
}
Improve this question

4 Answers 4

Reset to default
8

It could be done also by using a simple index based for loop clubbed with std::advance to reach to a particular map element. OpenMP 2.0 supports index based for loops very well.

#pragma omp parallel for
    for(int i = 0; i < dat.size(); i++) {
        auto datIt = dat.begin();
        advance(datIt, i);
        //construct the distance matrix using iterator datIt
    }

In each thread the iterator datIt will point to a map item and can be used to perform operations on it.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

4

It's likely your implementation of OpenMP is incompatible with STL iterators. While there have been some changes to the standard to make OMP more compatible with the STL, I think you'll find your implementation doesn't support such behaviour. Most OpenMP implementations I've encountered are at most version 2.5, Microsoft C++ is 2.0. The only compiler I'm aware of that supports 3.0 is the Intel C++ compiler.

A few other points, you should use std::begin, and std::end. Also, you either need to declare your loop invariant as private, or have OpenMP figure that out by itself, like so:

#pragma omp parallel for
for(map< int,string >::iterator datIt = std::begin(dat);
    datIt != std::end(dat);
    datIt++)
{
     //construct the distance matrix...
}

But without 3.0 support, this is beside the point.

Improve this answer

8 Comments

gcc supports OpenMP 3.0 since version 4.4 and will have support for 3.1 in version 4.7, so it's mostly visual c++ which is stuck in the stone age. Besides even with openmp 3.0 only random_access_iterators are allowed as loop variable, but map only supports bidrectional_iterators, so that doesn't help. And why should std::begin, std::end be preferred over the member functions, I don't see any benefit from that, since it does nothing but call the memberfunction anyways.
@Grizzly I wasn't aware of the GCC OpenMP support, thanks for that. And you should use the non-member begin(...) and end(...) because they can be specialised to support containers that lack a begin and end member function. This places the emphasis on generic programming, which is what good C++ is all about. And if you won't take my word for it, take Herb Sutter's.
Considering the type of the iterator is explicitly mentioned in the code that doesn't make it any more generic. Besides std::begin generally can't be specialized for containers which lack the member functions, since you can't partially specialize function templates and adding overloads in std is not allowed. To make it more generic you would need to use an unqualified version (begin(), end()) coupled with using namespace std; or using std::begin; using std::end;, since I would assume that containers are more likely to have the memberfunctions then a freestanding namespace version
Besides isn't the freestanding version only availible since C++11, so not an option yet for a lot of programmers? I'm not really disagreeing with the principle of using free functions for a more generic interface, but your answer doesn't provide any additional genericity, making your advice kind of pointless
@Grizzly First of all, I didn't give this advice solely in the context of the example, and you should be both consistent and adhere to best practices. Second, specialising std::begin or std::end doesn't require partial specialisation. Third, you're not supposed to overload standard library functions, you are however permitted to specialise them. Fourth, const char* does have .begin/end(), there's one of many examples. Finally, VS2010 supports std::begin/end(), as does GCC 4.6 onwards: that aside, they're a pair of 4 line functions, totalling a trivial 8 line change to the standard library.
|
2

OpenMP 3.0 available now on gcc and Intel compiler has task directive that allow a thread to delegate task to a pool of thread

Inspired from : this response and this course, I wrote these kind of code that work fine for me :

map< int,string >::iterator datIt;
...
#pragma omp parallel for
#pragma omp single nowait
 {
  for(datIt=dat.begin();datIt!=dat.end();datIt++) //construct the distance matrix
  {
   #pragma omp task firstprivate(datIt)
   {
    ...............
   } 
  }
 }

One task (single directive) loop over the whole map and put every task to do for every element in map into a pool of tasks. Other OMP threads process tasks remains in this pool. There is not necessary for others OMP task to wait the end of for loop to start task processing (nowait). Every task has a pointer of element in map to process (firstprivate(datIt)).

Constraint : Every task must be independent and map mustn't change before the end.

Improve this answer

Comments

-1

Try this way if its helpful.

#pragma omp parallel for shared(dat) private(datIt) 
for(map< int,string >::iterator datIt=dat.begin();datIt!=dat.end();datIt++) 
{
 ...............
}
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.