Correct way to parallelise for loops on OpenMP on Visual Studio when parallel threads access a different member of the same data structure?

Question

I have written a computationally intensive program that is running serially on an ordinary terminal, but is taking about 30 s per iteration of my loop. I decided to run my code with OpenMP on Visual Studio with the Intel Compiler to parallelise the for loops in it.
Firstly, the same serial code that takes 30s per iteration is taking 600s per iteration on Visual Studio with the Intel Compiler as compared to the ordinary G++ compiler on a normal terminal.
Secondly, even on implementing parallel for loops, the code takes approximately the same time to perform one iteration. I have attached a simplistic version of the code below.
I am worried about race conditions as the parallelised loops access the same unordered map and read and write from it, but no two threads ever access the same element.

I've tried using both solutions mentioned in this SO thread, buckets for the unordered map as well as using #pragma omp task. Both give me similar times of execution. OpenMP/__gnu_parallel for an unordered_map

unordered_map <int, Cluster*> cluster_map;
while(true)
{
   #pragma omp parallel
   {
      #pragma omp for schedule(dynamic, bc/4)
      for (unsigned b = 0; b<bc; ++b)
      {
     for (auto c = clusters.begin(b); c != clusters.end(b); ++c)
     {
         //Computations involving the current cluster
         }
      }
   }
}

Overall I'm guessing the issue is with Visual Studio, but since I'm new to OpenMP it could also be with my code. My project properties are set to use the Intel Compiler and OpenMP Support is enabled.

Whats wrong with this answer: stackoverflow.com/a/26038269/2261538 ? — darune
Please create a minimal reproducible example and describe how you compile it, the system you execute it on, how you measure performance, and the specific performance results. — Zulan
If you're modifying two Cluster objects in the same cache line from different threads, that will create false sharing (cache-line ping pong). But if all the shared / nearby data is read-only, you should be fine for performance. As long as you don't modify the container itself, you should also be fine for correctness; it's not a thread-safe container, but modifying e.g. 2 adjacent elements of a char[] array from different threads is always fine according to C++11 — Peter Cordes
Update: My initial suspicion was right. The problem is with visual studio. The code runs about 3 times faster in parallel as compared to serial on a GCC compiler in Linux whereas there is hardly any difference in Visual Studio — Abhinav Reddy

darune darune · Accepted Answer · 2019-05-01T11:23:30

You could just restructure the code into using a container that supports random access:

std::unordered_map <int, Cluster*> cluster_map;
while(true)
{

   std::vector< std::pair<int, Cluster*> > cluster_vec(cluster_map.begin(), cluster_map.end());
   #pragma omp parallel for
   for(int i = 0; i < cluster_vec.size(); ++i)
   {
     //Computations involving the current cluster
   }

}

Correct way to parallelise for loops on OpenMP on Visual Studio when parallel threads access a different member of the same data structure?

1 Answers