Move num_threads_ to pcl_base.

Set number of threads using omp_get_num_procs in initCompute.

Author: larshg

benchmarks/filters/radius_outlier_removal.cpp

@@ -15,6 +15,7 @@ BM_RadiusOutlierRemoval(benchmark::State& state, const std::string& file)
   ror.setInputCloud(cloud);
   ror.setRadiusSearch(0.02);
   ror.setMinNeighborsInRadius(14);
+  ror.setNumberOfThreads(1);
 
   pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_voxelized(
       new pcl::PointCloud<pcl::PointXYZ>);

common/include/pcl/impl/pcl_base.hpp

@@ -167,6 +167,15 @@ pcl::PCLBase<PointT>::initCompute ()
     for (auto i = indices_size; i < indices_->size (); ++i) { (*indices_)[i] = i; }
   }
 
+   // Set the number of threads
+#ifdef _OPENMP
+  num_threads_ = num_threads_ != 0 ? num_threads_ : omp_get_num_procs();
+#else
+  if (num_threads_ != 1) {
+    PCL_WARN("OpenMP is not available. Keeping number of threads unchanged at 1\n");
+  }
+#endif
+
   return (true);
 }
 

common/include/pcl/pcl_base.h

@@ -155,6 +155,11 @@ namespace pcl
       /** \brief If no set of indices are given, we construct a set of fake indices that mimic the input PointCloud. */
       bool fake_indices_;
 
+      /**
+       * @brief Number of threads used if the algorithm supports parallelization
+       */
+      unsigned int num_threads_{0};
+
       /** \brief This method should get called before starting the actual computation.
         *
         * Internally, initCompute() does the following:
@@ -233,6 +238,11 @@ namespace pcl
       /** \brief If no set of indices are given, we construct a set of fake indices that mimic the input PointCloud. */
       bool fake_indices_;
 
+      /**
+       * @brief Number of threads used during filtering
+       */
+      unsigned int num_threads_{0};
+
       /** \brief The size of each individual field. */
       std::vector<uindex_t> field_sizes_;
 

common/src/pcl_base.cpp

@@ -130,6 +130,15 @@ pcl::PCLBase<pcl::PCLPointCloud2>::initCompute ()
       std::iota(indices_->begin () + indices_size, indices_->end (), indices_size);
   }
 
+   // Set the number of threads
+#ifdef _OPENMP
+  num_threads_ = num_threads_ != 0 ? num_threads_ : omp_get_num_procs();
+#else
+  if (num_threads_ != 1) {
+    PCL_WARN("OpenMP is not available. Keeping number of threads unchanged at 1\n");
+  }
+#endif
+
   return (true);
 }
 

features/include/pcl/features/fpfh_omp.h

@@ -119,9 +119,6 @@ namespace pcl
     public:
       /** \brief The number of subdivisions for each angular feature interval. */
       int nr_bins_f1_{11}, nr_bins_f2_{11}, nr_bins_f3_{11};
-    private:
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
   };
 }
 

features/include/pcl/features/intensity_gradient.h

@@ -117,8 +117,6 @@ namespace pcl
     protected:
       ///intensity field accessor structure
       IntensitySelectorT intensity_;
-      ///number of threads to be used
-      unsigned int num_threads_{1};
   };
 }
 

features/include/pcl/features/normal_3d_omp.h

@@ -88,9 +88,6 @@ namespace pcl
       setNumberOfThreads (unsigned int num_threads = 0);
 
     protected:
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
-
       /** \brief Chunk size for (dynamic) scheduling. */
       int chunk_size_;
     private:

features/include/pcl/features/principal_curvatures.h

@@ -111,9 +111,6 @@ namespace pcl
       setNumberOfThreads (unsigned int num_threads = 0);
 
     protected:
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
-
       /** \brief Chunk size for (dynamic) scheduling. */
       int chunk_size_;
 

features/include/pcl/features/shot_lrf_omp.h

@@ -103,10 +103,6 @@ namespace pcl
         */
       void
       computeFeature (PointCloudOut &output) override;
-
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
-
   };
 }
 

features/include/pcl/features/shot_omp.h

@@ -119,9 +119,6 @@ namespace pcl
       /** \brief This method should get called before starting the actual computation. */
       bool
       initCompute () override;
-
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
   };
 
   /** \brief SHOTColorEstimationOMP estimates the Signature of Histograms of OrienTations (SHOT) descriptor for a given point cloud dataset
@@ -204,9 +201,6 @@ namespace pcl
       /** \brief This method should get called before starting the actual computation. */
       bool
       initCompute () override;
-
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
   };
 
 }

filters/include/pcl/filters/convolution.h

@@ -227,8 +227,6 @@ namespace pcl
         /// kernel size - 1
         int kernel_width_{};
       protected:
-        /** \brief The number of threads the scheduler should use. */
-        unsigned int num_threads_{1};
 
         void
         makeInfinite (PointOut& p)

filters/include/pcl/filters/convolution_3d.h

@@ -281,9 +281,6 @@ namespace pcl
         /** \brief The nearest neighbors search radius for each point. */
         double search_radius_;
 
-        /** \brief number of threads */
-        unsigned int num_threads_{1};
-
         /** \brief convlving kernel */
         KernelT kernel_;
     };

filters/include/pcl/filters/fast_bilateral_omp.h

@@ -87,11 +87,6 @@ namespace pcl
         */
       void
       applyFilter (PointCloud &output) override;
-
-    protected:
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
-
   };
 }
 

filters/include/pcl/filters/pyramid.h

@@ -64,8 +64,9 @@ namespace pcl
   class Pyramid : public PCLBase<PointT>
     {
     public:
-        using PointCloudPtr = typename PointCloud<PointT>::Ptr;
-        using PointCloudConstPtr = typename PointCloud<PointT>::ConstPtr;
+        using PointCloud = pcl::PointCloud<PointT>;
+        using PointCloudPtr = typename PointCloud::Ptr;
+        using PointCloudConstPtr = typename PointCloud::ConstPtr;
         using Ptr = shared_ptr< Pyramid<PointT> >;
         using ConstPtr = shared_ptr< const Pyramid<PointT> >;
 
@@ -166,9 +167,6 @@ namespace pcl
         Eigen::MatrixXf kernel_;
         /// Threshold distance between adjacent points
         float threshold_{0.01f};
-        /// \brief number of threads
-        unsigned int num_threads_{1};
-
       public:
         PCL_MAKE_ALIGNED_OPERATOR_NEW
     };

filters/include/pcl/filters/radius_outlier_removal.h

@@ -195,11 +195,6 @@ namespace pcl
 
       /** \brief The minimum number of neighbors that a point needs to have in the given search radius to be considered an inlier. */
       int min_pts_radius_{1};
-
-      /**
-       * @brief Number of threads used during filtering
-       */
-      unsigned int num_threads_{1};
   };
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

keypoints/include/pcl/keypoints/harris_2d.h

@@ -170,8 +170,6 @@ namespace pcl
       bool nonmax_;
       /// cornerness computation method
       ResponseMethod method_;
-      /// number of threads to be used
-      unsigned int num_threads_{1};
 
     private:
       Eigen::MatrixXf derivatives_rows_;

keypoints/include/pcl/keypoints/harris_3d.h

@@ -183,7 +183,6 @@ namespace pcl
       bool nonmax_{true};
       ResponseMethod method_;
       PointCloudNConstPtr normals_;
-      unsigned int num_threads_{1};
   };
 }
 

keypoints/include/pcl/keypoints/harris_6d.h

@@ -140,7 +140,6 @@ namespace pcl
       float threshold_;
       bool refine_{true};
       bool nonmax_{true};
-      unsigned int num_threads_{1};    
       typename pcl::PointCloud<NormalT>::Ptr normals_;
       pcl::PointCloud<pcl::IntensityGradient>::Ptr intensity_gradients_;
   } ;

keypoints/include/pcl/keypoints/iss_3d.h

@@ -257,10 +257,6 @@ namespace pcl
 
       /** \brief The decision boundary (angle threshold) that marks points as boundary or regular. (default \f$\pi / 2.0\f$) */
       float angle_threshold_;
-
-      /** \brief The number of threads that has to be used by the scheduler. */
-      unsigned int num_threads_{1};
-
   };
 
 }

keypoints/include/pcl/keypoints/susan.h

@@ -180,7 +180,6 @@ namespace pcl
       float intensity_threshold_;
       float tolerance_;
       PointCloudNConstPtr normals_;
-      unsigned int num_threads_{1};
       bool geometric_validation_;
       bool nonmax_;
       /// intensity field accessor

keypoints/include/pcl/keypoints/trajkovic_2d.h

@@ -175,8 +175,6 @@ namespace pcl
       float first_threshold_;
       /// second threshold for corner evaluation
       float second_threshold_;
-      /// number of threads to be used
-      unsigned int num_threads_{1};
       /// point cloud response
       pcl::PointCloud<float>::Ptr response_;
   };

keypoints/include/pcl/keypoints/trajkovic_3d.h

@@ -214,8 +214,6 @@ namespace pcl
       float first_threshold_;
       /// second threshold for corner evaluation
       float second_threshold_;
-      /// number of threads to be used
-      unsigned int num_threads_{1};
       /// point cloud normals
       NormalsConstPtr normals_;
       /// point cloud response

registration/include/pcl/registration/correspondence_estimation.h

@@ -69,6 +69,7 @@ class CorrespondenceEstimationBase : public PCLBase<PointSource> {
   using PCLBase<PointSource>::input_;
   using PCLBase<PointSource>::indices_;
   using PCLBase<PointSource>::setIndices;
+  using PCLBase<PointSource>::num_threads_;
 
   using KdTree = pcl::search::KdTree<PointTarget>;
   using KdTreePtr = typename KdTree::Ptr;
@@ -379,8 +380,6 @@ class CorrespondenceEstimationBase : public PCLBase<PointSource> {
   /** \brief A flag which, if set, means the tree operating on the source cloud
    * will never be recomputed*/
   bool force_no_recompute_reciprocal_{false};
-
-  unsigned int num_threads_{1};
 };
 
 /** \brief @b CorrespondenceEstimation represents a simple class for

registration/include/pcl/registration/gicp.h

@@ -75,6 +75,7 @@ template <typename PointSource, typename PointTarget, typename Scalar = float>
 class GeneralizedIterativeClosestPoint
 : public IterativeClosestPoint<PointSource, PointTarget, Scalar> {
 public:
+  using PCLBase<PointSource>::num_threads_;
   using IterativeClosestPoint<PointSource, PointTarget, Scalar>::reg_name_;
   using IterativeClosestPoint<PointSource, PointTarget, Scalar>::getClassName;
   using IterativeClosestPoint<PointSource, PointTarget, Scalar>::indices_;
@@ -141,7 +142,6 @@ class GeneralizedIterativeClosestPoint
     max_iterations_ = 200;
     transformation_epsilon_ = 5e-4;
     corr_dist_threshold_ = 5.;
-    setNumberOfThreads(0);
     rigid_transformation_estimation_ = [this](const PointCloudSource& cloud_src,
                                               const pcl::Indices& indices_src,
                                               const PointCloudTarget& cloud_tgt,
@@ -532,9 +532,6 @@ class GeneralizedIterativeClosestPoint
                      Eigen::Matrix3d& ddR_dTheta_dTheta,
                      Eigen::Matrix3d& ddR_dTheta_dPsi,
                      Eigen::Matrix3d& ddR_dPsi_dPsi) const;
-
-  /** \brief The number of threads the scheduler should use. */
-  unsigned int num_threads_{1};
 };
 } // namespace pcl
 

registration/include/pcl/registration/ia_fpcs.h

@@ -474,11 +474,6 @@ class FPCSInitialAlignment : public Registration<PointSource, PointTarget, Scala
   /** \brief Normals of target point cloud. */
   NormalsConstPtr target_normals_;
 
-  /** \brief Number of threads for parallelization (standard = 1).
-   * \note Only used if run compiled with OpenMP.
-   */
-  unsigned int num_threads_{1};
-
   /** \brief Estimated overlap between source and target (standard = 0.5). */
   float approx_overlap_{0.5f};
 

sample_consensus/include/pcl/sample_consensus/sac.h

@@ -351,7 +351,7 @@ namespace pcl
       /** \brief Maximum number of iterations before giving up. */
       int max_iterations_;
 
-      /** \brief The number of threads the scheduler should use, or a negative number if no parallelization is wanted. */
+      /** Number of threads used */
       unsigned int num_threads_{1};
 
       /** \brief Boost-based random number generator algorithm. */

segmentation/include/pcl/segmentation/approximate_progressive_morphological_filter.h

@@ -173,9 +173,6 @@ namespace pcl
 
       /** \brief Exponentially grow window sizes? */
       bool exponential_{true};
-
-      /** \brief Number of threads to be used. */
-      unsigned int num_threads_{1};      
   };
 }
 

segmentation/include/pcl/segmentation/sac_segmentation.h

@@ -293,9 +293,6 @@ namespace pcl
       /** \brief Maximum number of iterations before giving up (user given parameter). */
       int max_iterations_{50};
 
-      /** \brief The number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
-
       /** \brief Desired probability of choosing at least one sample free from outliers (user given parameter). */
       double probability_{0.99};
 

surface/include/pcl/surface/mls.h

@@ -257,6 +257,7 @@ namespace pcl
 
       using PCLBase<PointInT>::input_;
       using PCLBase<PointInT>::indices_;
+      using PCLBase<PointInT>::num_threads_;
       using PCLBase<PointInT>::fake_indices_;
       using PCLBase<PointInT>::initCompute;
       using PCLBase<PointInT>::deinitCompute;
@@ -563,10 +564,6 @@ namespace pcl
       /** \brief Parameter that specifies the projection method to be used. */
       MLSResult::ProjectionMethod projection_method_{MLSResult::SIMPLE};
 
-      /** \brief The maximum number of threads the scheduler should use. */
-      unsigned int num_threads_{1};
-
-
       /** \brief A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
         */

surface/include/pcl/surface/poisson.h

@@ -257,7 +257,6 @@ namespace pcl
       bool show_residual_{false};
       int min_iterations_{8};
       float solver_accuracy_{1e-3f};
-      unsigned int num_threads_{1};
 
       template<int Degree> void
       execute (poisson::CoredVectorMeshData &mesh,

tracking/include/pcl/tracking/kld_adaptive_particle_filter_omp.h

@@ -85,9 +85,6 @@ class KLDAdaptiveParticleFilterOMPTracker
   setNumberOfThreads(unsigned int num_threads = 0);
 
 protected:
-  /** \brief The number of threads the scheduler should use. */
-  unsigned int num_threads_{1};
-
   /** \brief weighting phase of particle filter method. calculate the likelihood of all
    * of the particles and set the weights.
    */

tracking/include/pcl/tracking/particle_filter_omp.h

@@ -73,9 +73,6 @@ class ParticleFilterOMPTracker : public ParticleFilterTracker<PointInT, StateT>
   setNumberOfThreads(unsigned int num_threads = 0);
 
 protected:
-  /** \brief The number of threads the scheduler should use. */
-  unsigned int num_threads_{1};
-
   /** \brief weighting phase of particle filter method. calculate the likelihood of all
    * of the particles and set the weights.
    */