Change parallelism paradigm to be determinist

Author: SamFlt

modules/tracker/rbt/src/features/vpRBDenseDepthTracker.cpp

@@ -67,10 +67,22 @@ void vpRBDenseDepthTracker::extractFeatures(const vpRBFeatureTrackerInput &frame
   m_depthPoints.clear();
   m_depthPoints.reserve(static_cast<size_t>(bb.getArea() / (m_step * m_step * 2)));
 
+  std::vector<std::vector<vpDepthPoint>> pointsPerThread;
+#ifdef VISP_HAVE_OPENMP
+  const unsigned int numThreads = omp_get_num_threads();
+#else
+  const unsigned int numThreads = 1;
+#endif
+  pointsPerThread.resize(numThreads);
 #ifdef VISP_HAVE_OPENMP
 #pragma omp parallel
 #endif
   {
+#ifdef VISP_HAVE_OPENMP
+    unsigned int threadIdx = omp_get_thread_num();
+#else
+    unsigned int threadIdx = 1;
+#endif
     vpDepthPoint point;
     vpColVector cameraRay(3);
 #ifdef VISP_HAVE_OPENMP
@@ -132,13 +144,10 @@ void vpRBDenseDepthTracker::extractFeatures(const vpRBFeatureTrackerInput &frame
       }
     }
 
-// If we use openmp, add to the global vector. If we're not using openmp, no need to do so
-#ifdef VISP_HAVE_OPENMP
-#pragma omp critical
-    {
-      m_depthPoints.insert(m_depthPoints.end(), localPoints.begin(), localPoints.end());
-    }
-#endif
+    pointsPerThread[threadIdx] = std::move(localPoints);
+  }
+  for (const std::vector<vpDepthPoint> &points: pointsPerThread) {
+    m_depthPoints.insert(m_depthPoints.end(), std::make_move_iterator(points.begin()), std::make_move_iterator(points.end()));
   }
   m_depthPointSet.build(m_depthPoints);
 

modules/tracker/rbt/src/features/vpRBSilhouetteCCDTracker.cpp

@@ -166,10 +166,22 @@ void vpRBSilhouetteCCDTracker::extractFeatures(const vpRBFeatureTrackerInput &fr
   const vpHomogeneousMatrix cMo = frame.renders.cMo;
   const vpHomogeneousMatrix oMc = cMo.inverse();
 
+  std::vector<std::vector<vpRBSilhouetteControlPoint>> pointsPerThread;
+#ifdef VISP_HAVE_OPENMP
+  pointsPerThread.resize(omp_get_num_threads());
+#else
+  pointsPerThread.resize(1);
+#endif
+
 #ifdef VISP_HAVE_OPENMP
 #pragma omp parallel
 #endif
   {
+#ifdef VISP_HAVE_OPENMP
+    unsigned int threadIdx = omp_get_thread_num();
+#else
+    unsigned int threadIdx = 0;
+#endif
     std::vector<vpRBSilhouetteControlPoint> localControlPoints;
 #ifdef VISP_HAVE_OPENMP
 #pragma omp for nowait
@@ -205,14 +217,21 @@ void vpRBSilhouetteCCDTracker::extractFeatures(const vpRBFeatureTrackerInput &fr
       }
       localControlPoints.push_back(std::move(pccd));
     }
-#ifdef VISP_HAVE_OPENMP
-#pragma omp critical
-#endif
+
+
     {
-      m_controlPoints.insert(m_controlPoints.end(), localControlPoints.begin(), localControlPoints.end());
+      pointsPerThread[threadIdx] = std::move(localControlPoints);
     }
   }
+  unsigned int numElements = 0;
+  for (const std::vector<vpRBSilhouetteControlPoint> &points: pointsPerThread) {
+    numElements += points.size();
+  }
 
+  m_controlPoints.reserve(numElements);
+  for (const std::vector<vpRBSilhouetteControlPoint> &points: pointsPerThread) {
+    m_controlPoints.insert(m_controlPoints.end(), points.begin(), points.end());
+  }
 
   if (m_maxPoints > 0 && m_controlPoints.size() > m_maxPoints) {
     std::vector<size_t> keptIndices(m_maxPoints);
@@ -798,13 +817,28 @@ void vpRBSilhouetteCCDTracker::computeErrorAndInteractionMatrix()
       m_weights[i * 2 * normal_points_number * 3 + j] = weightPerPoint[i];
     }
   }
+  std::vector<vpColVector> gradientPerThread;
+  std::vector<vpMatrix> hessianPerThread;
+#ifdef VISP_HAVE_OPENMP
+  unsigned int numThreads = omp_get_num_threads();
+#else
+  unsigned int numThreads = 1;
+#endif
+
+  gradientPerThread.resize(omp_get_num_threads());
+  hessianPerThread.resize(omp_get_num_threads());
 
   m_gradient = 0.0;
   m_hessian = 0.0;
 #ifdef VISP_HAVE_OPENMP
 #pragma omp parallel
 #endif
   {
+#ifdef VISP_HAVE_OPENMP
+    unsigned int threadIdx = omp_get_thread_num();
+#else
+    unsigned int threadIdx = 1;
+#endif
     vpColVector localGradient(m_gradient.getRows(), 0.0);
     vpMatrix localHessian(m_hessian.getRows(), m_hessian.getCols(), 0.0);
 
@@ -826,15 +860,15 @@ void vpRBSilhouetteCCDTracker::computeErrorAndInteractionMatrix()
         }
       }
     }
-#ifdef VISP_HAVE_OPENMP
-#pragma omp critical
-#endif
-    {
-      m_gradient += localGradient;
-      m_hessian += localHessian;
-    }
+
+    gradientPerThread[threadIdx] = localGradient;
+    hessianPerThread[threadIdx] = localHessian;
   }
 
+  for (unsigned int i = 0; i < gradientPerThread.size(); ++i) {
+    m_gradient += gradientPerThread[i];
+    m_hessian += hessianPerThread[i];
+  }
 
   m_LTL = m_hessian;
   m_LTR = -m_gradient;
@@ -864,7 +898,6 @@ void vpRBSilhouetteCCDTracker::computeErrorAndInteractionMatrix()
     m_LTL = 0;
     m_LTR = 0;
 
-
     std::cerr << e.what() << std::endl;
   }
 }

modules/tracker/rbt/src/vo/vpPointMap.cpp

@@ -130,11 +130,23 @@ void vpPointMap::getVisiblePoints(const unsigned int h, const unsigned int w, co
   vpMatrix cX(m_X.getRows(), m_X.getCols());
   vpMatrix::mult2Matrices(m_X, cRw.t(), cX);
 
+  std::vector<std::vector<int>> indicesPerThread;
+#ifdef VISP_HAVE_OPENMP
+  const unsigned int numThreads = omp_get_num_threads();
+#else
+  const unsigned int numThreads = 1;
+#endif
+  indicesPerThread.resize(numThreads);
 
 #ifdef VISP_HAVE_OPENMP
 #pragma omp parallel
 #endif
   {
+#ifdef VISP_HAVE_OPENMP
+    unsigned int threadIdx = omp_get_thread_num();
+#else
+    unsigned int threadIdx = 1;
+#endif
     std::vector<int> localIndices;
     double u, v;
 
@@ -158,15 +170,12 @@ void vpPointMap::getVisiblePoints(const unsigned int h, const unsigned int w, co
       if (fabs(Z - depth[vint][uint]) > m_maxDepthErrorVisible) {
         continue;
       }
-
       localIndices.push_back(i);
     }
-#ifdef VISP_HAVE_OPENMP
-#pragma omp critical
-#endif
-    {
-      indices.insert(indices.end(), std::make_move_iterator(localIndices.begin()), std::make_move_iterator(localIndices.end()));
-    }
+    indicesPerThread[threadIdx] = std::move(localIndices);
+  }
+  for (const std::vector<int> &indicesPart: indicesPerThread) {
+    indices.insert(indices.end(), std::make_move_iterator(indicesPart.begin()), std::make_move_iterator(indicesPart.end()));
   }
 }