Helios++
Helios software for LiDAR simulations
MultiThreadKDTreeFactory.h
1 #pragma once
2 
3 #include <SimpleKDTreeFactory.h>
4 #include <SimpleKDTreeGeometricStrategy.h>
5 #include <KDTreeFactoryThreadPool.h>
6 #include <SharedTaskSequencer.h>
7 
8 #include <boost/thread.hpp>
9 
10 using std::shared_ptr;
11 
35 private:
36  // *** SERIALIZATION *** //
37  // *********************** //
38  friend class boost::serialization::access;
46  template <class Archive>
47  void serialize(Archive &ar, unsigned int const version){
48  boost::serialization::void_cast_register<
51  >();
52 
53  ar &boost::serialization::base_object<SimpleKDTreeFactory>(*this);
54  ar &kdtf;
56  //ar &tpNode; // No need to serialize because default built one is used
57  //ar &numJobs; // No need to serialize, inplace initialization
58  //ar &geomJobs; // No need to serialize, inplace initialization
59  //ar &gs; // No need to serialize, inplace initialization
60  //ar &maxGeometryDepth; // No need to serialize, inplace initialization
61  //ar &masters; // No need to serialize, inplace initialization
62  }
63 
64 protected:
65  // *** ATTRIBUTES *** //
66  // ******************** //
70  shared_ptr<SimpleKDTreeFactory> kdtf;
75  shared_ptr<SimpleKDTreeGeometricStrategy> gs;
98  size_t numJobs;
103  size_t geomJobs;
118  shared_ptr<SharedTaskSequencer> masters;
130  boost::mutex finishedGeomJobsMutex;
134  bool notUsed;
135 
136 public:
137  // *** CONSTRUCTION / DESTRUCTION *** //
138  // ************************************ //
144  shared_ptr<SimpleKDTreeFactory> const kdtf,
145  shared_ptr<SimpleKDTreeGeometricStrategy> const gs,
146  size_t const numJobs=2,
147  size_t const geomJobs=2
148  );
149  virtual ~MultiThreadKDTreeFactory() = default;
150 
151  // *** CLONE *** //
152  // *************** //
156  KDTreeFactory * clone() const override;
161  void _clone(KDTreeFactory *kdtf) const override;
162 
163  // *** KDTREE FACTORY METHODS *** //
164  // ******************************** //
172  vector<Primitive *> &primitives,
173  bool const computeStats=false,
174  bool const reportStats=false
175  ) override;
176 
177 protected:
178  // *** BUILDING METHODS *** //
179  // ************************** //
212  KDTreeNode *parent,
213  bool const left,
214  vector<Primitive*> &primitives,
215  int const depth,
216  int const index
217  ) override;
308  KDTreeNode *parent,
309  bool const left,
310  vector<Primitive*> &primitives,
311  int const depth,
312  int const index
313  );
320  KDTreeNode *node,
321  KDTreeNode *parent,
322  vector<Primitive *> const &primitives,
323  int const depth,
324  int const index,
325  vector<Primitive *> &leftPrimitives,
326  vector<Primitive *> &rightPrimitives,
327  int const auxiliarThreads
328  );
352  KDTreeNode *parent,
353  bool const left,
354  vector<Primitive*> &primitives,
355  int const depth,
356  int const index
357  );
362  void computeKDTreeStats(KDTreeNodeRoot *root) const override
363  {kdtf->computeKDTreeStats(root);}
369  KDTreeNodeRoot *root,
370  vector<Primitive *> const &primitives
371  ) const override
372  {kdtf->reportKDTreeStats(root, primitives);}
373 
374  // *** UTIL METHODS *** //
375  // ********************** //
388  virtual void prepareToMake();
394  virtual inline void increaseFinishedGeomJobsCount(size_t const amount){
395  boost::unique_lock<boost::mutex> lock(finishedGeomJobsMutex);
396  finishedGeomJobs += amount;
397  lock.unlock();
398  }
399 public:
400  // *** GETTERs and SETTERs *** //
401  // **************************** //
406  virtual inline shared_ptr<SimpleKDTreeFactory> getKdtf() const
407  {return kdtf;}
412  virtual inline size_t getPoolSize() const
413  {return tpNode.getPoolSize();}
418  virtual inline size_t getNumJobs() const {return numJobs;}
423  virtual inline size_t getGeomJobs() const {return geomJobs;}
428  virtual inline shared_ptr<SimpleKDTreeGeometricStrategy> getGS() const
429  {return gs;}
430 };
Class implementing a thread pool to deal with multi thread KDTree building process.
Definition: KDTreeFactoryThreadPool.h:24
Class that must be extended by any class which provides factory methods for k-dimensional trees....
Definition: KDTreeFactory.h:22
Class representing the root node of a KDTree.
Definition: KDTreeNodeRoot.h:12
Class representing a KDTree node.
Definition: KDTreeNode.h:9
Decorator for any KDTree factory which provides support for multi thread KDTree building.
Definition: MultiThreadKDTreeFactory.h:34
virtual size_t getGeomJobs() const
Obtain the number of threads for geometry-level parallelization.
Definition: MultiThreadKDTreeFactory.h:423
void _clone(KDTreeFactory *kdtf) const override
Assign attributes from MultiThreadKDTreeFactory to its clone.
Definition: MultiThreadKDTreeFactory.cpp:60
boost::mutex finishedGeomJobsMutex
Mutex to handle concurrent access to counter of finished geometry-level jobs.
Definition: MultiThreadKDTreeFactory.h:130
virtual void prepareToMake()
Prepare the MultiThreadKDTreeFactory so it is ready to start making a new KDTree.
Definition: MultiThreadKDTreeFactory.cpp:332
void serialize(Archive &ar, unsigned int const version)
Serialize a multi thread KDTree factory to a stream of bytes.
Definition: MultiThreadKDTreeFactory.h:47
size_t finishedGeomJobs
How many geometry-level jobs have fully finished during current KDT building.
Definition: MultiThreadKDTreeFactory.h:124
bool notUsed
True if the factory has not been used before, false otherwise.
Definition: MultiThreadKDTreeFactory.h:134
void computeKDTreeStats(KDTreeNodeRoot *root) const override
Call the compute KDTree stats method of decorated KDTree factory.
Definition: MultiThreadKDTreeFactory.h:362
KDTreeNode * buildRecursive(KDTreeNode *parent, bool const left, vector< Primitive * > &primitives, int const depth, int const index) override
Recursively build a KDTree for given primitives using given KDTreeFactory (kdtf). The building of upp...
Definition: MultiThreadKDTreeFactory.cpp:126
KDTreeNode * buildRecursiveGeometryLevel(KDTreeNode *parent, bool const left, vector< Primitive * > &primitives, int const depth, int const index)
Recursively build a KDTree for given primitives using given KDTreeFactory (kdtf) in a geometry-level ...
Definition: MultiThreadKDTreeFactory.cpp:144
int maxGeometryDepth
The maximum geometry depth level as explained in the MultiThreadKDTreeFactory::buildRecursiveGeometr...
Definition: MultiThreadKDTreeFactory.h:93
size_t numJobs
The maximum number of jobs (threads/workers) that this factory is allowed to use.
Definition: MultiThreadKDTreeFactory.h:98
virtual size_t getNumJobs() const
Obtain the number of threads for node-level parallelization.
Definition: MultiThreadKDTreeFactory.h:418
shared_ptr< SharedTaskSequencer > masters
All masters threads (except main thread) are handled by this shared task sequencer.
Definition: MultiThreadKDTreeFactory.h:118
size_t minTaskPrimitives
The minimum number of primitives on a given split so a new task is started to handle them.
Definition: MultiThreadKDTreeFactory.h:85
KDTreeNodeRoot * makeFromPrimitivesUnsafe(vector< Primitive * > &primitives, bool const computeStats=false, bool const reportStats=false) override
Build a KDTree which type depends on current KDTree factory (MultiThreadKDTreeFactory::kdtf) on a mul...
Definition: MultiThreadKDTreeFactory.cpp:68
KDTreeFactoryThreadPool tpNode
The thread pool to handle concurrency during recursive KDTree building at node-level.
Definition: MultiThreadKDTreeFactory.h:80
virtual void increaseFinishedGeomJobsCount(size_t const amount)
Increase count of finished geometry-level jobs in a thread safe way.
Definition: MultiThreadKDTreeFactory.h:394
shared_ptr< SimpleKDTreeFactory > kdtf
The SimpleKDTreeFactory or derived to be used to build tree nodes.
Definition: MultiThreadKDTreeFactory.h:70
shared_ptr< SimpleKDTreeGeometricStrategy > gs
The SimpleKDTreeGeometricStrategy or derived to be used to handle geometry-level parallelization duri...
Definition: MultiThreadKDTreeFactory.h:75
KDTreeNode * buildRecursiveNodeLevel(KDTreeNode *parent, bool const left, vector< Primitive * > &primitives, int const depth, int const index)
Recursively build a KDTree for given primitives using given KDTreeFactory (kdtf) in a node-level para...
Definition: MultiThreadKDTreeFactory.cpp:278
virtual size_t getPoolSize() const
Obtain the pool size of the thread pool (num jobs)
Definition: MultiThreadKDTreeFactory.h:412
void buildChildrenGeometryLevel(KDTreeNode *node, KDTreeNode *parent, vector< Primitive * > const &primitives, int const depth, int const index, vector< Primitive * > &leftPrimitives, vector< Primitive * > &rightPrimitives, int const auxiliarThreads)
Provide an alternative implementation for the building of left and right children nodes.
Definition: MultiThreadKDTreeFactory.cpp:233
virtual shared_ptr< SimpleKDTreeFactory > getKdtf() const
Obtain the SimpleKDTreeFactory used to build tree nodes.
Definition: MultiThreadKDTreeFactory.h:406
virtual shared_ptr< SimpleKDTreeGeometricStrategy > getGS() const
Obtain the geometric strategy.
Definition: MultiThreadKDTreeFactory.h:428
size_t geomJobs
The number of jobs (threads/workers) that this factory must use when building upper KDTree nodes (geo...
Definition: MultiThreadKDTreeFactory.h:103
KDTreeFactory * clone() const override
Definition: MultiThreadKDTreeFactory.cpp:46
void reportKDTreeStats(KDTreeNodeRoot *root, vector< Primitive * > const &primitives) const override
Call the report KDTree stats method of decorated KDTree factory.
Definition: MultiThreadKDTreeFactory.h:368
Class providing building methods for simple k-dimensional trees.
Definition: SimpleKDTreeFactory.h:18
virtual std::size_t getPoolSize() const
Obtain the thread pool size.
Definition: ThreadPool.h:93