Hi,
I'm studying for an exam coming up soon and I'm trying to figure out what is the functional difference between these two approaches:
#pragma omp parallel for
for(unsigned int i = 0; i < G.Out.bucket_count(); i++){
for(auto itv = G.Out.begin(i); itv != G.Out.end(i); itv++){
unsigned int v = itv->first;
#pragma omp parallel for
for(unsigned int j = 0; j < G.Out[v]._map.bucket_count(); j++){
for(auto ite = G.Out[v]._map.begin(j); ite != G.Out[v]._map.end(j); ite++){
unsigned int w = ite->first;
if(o[v] > o[w])
#pragma omp critical
p[o[v]] = min(p[o[v]],o[w]);
}
}
}
and
#pragma omp parallel for
for(unsigned int i = 0; i < G.Out.bucket_count(); i++){
for(auto itv = G.Out.begin(i); itv != G.Out.end(i); itv++){
unsigned int v = itv->first;
if(p[v] == v){
unsigned int parent = v; //=p[v]
#pragma omp parallel for reduction(min : parent)
for(unsigned int j = 0; j < G.Out[v]._map.bucket_count(); j++){
for(auto ite = G.Out[v]._map.begin(j); ite != G.Out[v]._map.end(j); ite++){
unsigned int w = ite->first;
if(v > w)
parent = min(parent,w);
}
}
p[v] = parent;
if(p[v] != v) changes = 1;
}
}
}
In the first example, the minimum between the two values is calculated using a critical section, while the second one uses a reduction. Both work, and they seem equivalent to me, when would one choose one or the other?
Thanks, and sorry if the question is too niche. Any other info about OpenMP is greatly appreciated :D
Critical section uses a shared variable so any case you have multiple threads writing to a variable you should have a critical section, it's very general. I don't have much experience with reduction but it seems geared towards all loops preforming the same function as part of a larger function and they take approximately the same amount of time to complete plus are expected to start and end together. Something like parallelizing an integral by spliting it into ranges would be simpler with reduction. Also if the threads need to read and write to the global, seems like that would need a critical section.