Helios++
Helios software for LiDAR simulations
PulseWarehouseThreadPool.h
1 #pragma once
2 
3 #include <WarehouseThreadPool.h>
4 #include <PulseThreadPoolInterface.h>
5 #include <scanner/detector/PulseTaskDropper.h>
6 #include <noise/RandomnessGenerator.h>
7 #include <noise/UniformNoiseSource.h>
8 
9 #include <memory>
10 
11 using std::shared_ptr;
12 using std::make_shared;
13 
21  public WarehouseThreadPool<PulseTaskDropper>,
23 {
24 #ifdef DATA_ANALYTICS
25 public:
26 #else
27 protected:
28 #endif
29  // *** ATTRIBUTES *** //
30  // ******************** //
35  std::vector<std::vector<double>> *apMatrices;
36 
45  RandomnessGenerator<double> *randGens2; // To substitute BoxMuller
50 
51 public:
52  // *** CONSTRUCTION / DESTRUCTION *** //
53  // ************************************ //
61  std::size_t const _pool_size,
62  double const deviceAccuracy,
63  std::size_t const maxTasks=256
64  ) :
65  WarehouseThreadPool<PulseTaskDropper>(_pool_size, maxTasks)
66  {
67  // Allocate
68  apMatrices = new std::vector<std::vector<double>>[this->pool_size];
69  randGens = new RandomnessGenerator<double>[this->pool_size];
70  randGens2 = new RandomnessGenerator<double>[this->pool_size];
71  intersectionHandlingNoiseSources =
73 
74  // Initialize
75  for (std::size_t i = 0; i < this->pool_size; ++i){
76  randGens[i] = *DEFAULT_RG;
78  randGens[i].computeNormalDistribution(0.0, deviceAccuracy);
79  randGens2[i] = *DEFAULT_RG;
82  *DEFAULT_RG, 0.0, 1.0
83  );
84  }
85  }
86 
87  virtual ~PulseWarehouseThreadPool(){
88  // Release memory
89  delete[] apMatrices;
90  delete[] randGens;
91  delete[] randGens2;
93  }
94 
95  // *** PULSE THREAD POOL INTERFACE *** //
96  // ************************************ //
100  inline void run_pulse_task(
101  TaskDropper<
102  PulseTask,
104  std::vector<std::vector<double>>&,
108  > &dropper
109  ) override {
110  throw HeliosException(
111  "PulseWarehouseThreadPool::run_pulse_task is not supported.\n"
112  "Try using try_run_pulse_task instead"
113  );
114  }
118  inline bool try_run_pulse_task(
119  TaskDropper<
120  PulseTask,
122  std::vector<std::vector<double>>&,
126  > &dropper
127  ) override {
128  return post(make_shared<PulseTaskDropper>(
129  static_cast<PulseTaskDropper &>(dropper)
130  ));
131  }
135  inline void join() override{
137  }
138 
139 protected:
140  // *** WAREHOUSE THREADPOOL *** //
141  // ****************************** //
151  void doTask(size_t const tid, shared_ptr<PulseTaskDropper> task) override {
152  (*task)(
153  apMatrices[tid],
154  randGens[tid],
155  randGens2[tid],
157  );
158  }
159 };
Base class for Helios exceptions.
Definition: HeliosException.h:12
Class implementing a task dropper to deal with pulse tasks.
Definition: PulseTaskDropper.h:27
Pulse task interface.
Definition: PulseTask.h:13
Interface for thread pools supporting pulse tasks.
Definition: PulseThreadPoolInterface.h:18
Class implementing a warehouse thread pool to deal with pulse tasks.
Definition: PulseWarehouseThreadPool.h:23
RandomnessGenerator< double > * randGens2
Second randomness generators (to substitute old box muller), one per thread.
Definition: PulseWarehouseThreadPool.h:45
void doTask(size_t const tid, shared_ptr< PulseTaskDropper > task) override
Thread execute given task using its associated resources. It is, its apMatrix, its randomness generat...
Definition: PulseWarehouseThreadPool.h:151
UniformNoiseSource< double > * intersectionHandlingNoiseSources
Intersection handling noise sources, one per thread.
Definition: PulseWarehouseThreadPool.h:49
void join() override
Definition: PulseWarehouseThreadPool.h:135
PulseWarehouseThreadPool(std::size_t const _pool_size, double const deviceAccuracy, std::size_t const maxTasks=256)
Pulse warehouse thread pool constructor.
Definition: PulseWarehouseThreadPool.h:60
bool try_run_pulse_task(TaskDropper< PulseTask, PulseThreadPoolInterface, std::vector< std::vector< double >> &, RandomnessGenerator< double > &, RandomnessGenerator< double > &, NoiseSource< double > & > &dropper) override
Definition: PulseWarehouseThreadPool.h:118
std::vector< std::vector< double > > * apMatrices
Definition: PulseWarehouseThreadPool.h:35
RandomnessGenerator< double > * randGens
First randomness generators (general purpose), one per thread.
Definition: PulseWarehouseThreadPool.h:40
void run_pulse_task(TaskDropper< PulseTask, PulseThreadPoolInterface, std::vector< std::vector< double >> &, RandomnessGenerator< double > &, RandomnessGenerator< double > &, NoiseSource< double > & > &dropper) override
Definition: PulseWarehouseThreadPool.h:100
void computeUniformRealDistribution(RealType lowerBound, RealType upperBound)
Compute a uniform real distribution using the specified real data type.
Definition: RandomnessGenerator.h:354
void computeNormalDistribution(RealType mean, RealType stdev)
Compute a normal distribution using the specified real data type.
Definition: RandomnessGenerator.h:400
Class which handles tasks dropping. It is, executing and then removing each task when dropping.
Definition: TaskDropper.h:22
Thread pool which starts thread so they are always waiting for new tasks to be posted to the warehous...
Definition: WarehouseThreadPool.h:18
std::size_t pool_size
Size of thread pool (number of threads)
Definition: ThreadPool.h:47
virtual void join()
Lock until warehouse is empty.
Definition: WarehouseThreadPool.h:151
virtual bool post(shared_ptr< PulseTaskDropper > task)
Expose the warehouse post method.
Definition: WarehouseThreadPool.h:100