CPUCruncher.h

Go to the documentation of this file.

#include "GaudiAlg/GaudiAlgorithm.h"
#include "GaudiKernel/IRndmGenSvc.h"
#include "GaudiKernel/RegistryEntry.h"
#include "GaudiKernel/RndmGenerators.h"

#include <tbb/concurrent_hash_map.h>

//------------------------------------------------------------------------------

class CPUCruncher : public GaudiAlgorithm
{

public:
  typedef tbb::concurrent_hash_map<std::string, unsigned int> CHM;

  bool isClonable() const override { return true; }

  StatusCode execute() override;
  StatusCode initialize() override;
  StatusCode finalize() override;

  double get_runtime() const { return m_avg_runtime; }

  CPUCruncher( const std::string& name,   // the algorithm instance name
               ISvcLocator*       pSvc ); // the Service Locator

  virtual ~CPUCruncher(); // virtual & protected desctrustor

private:
  CPUCruncher(); // no default constructor
  CPUCruncher( const CPUCruncher& ); // no copy constructor
  CPUCruncher& operator=( const CPUCruncher& ); // no assignement
  void findPrimes( const unsigned long int );

  void              calibrate();
  long unsigned int getNCaliIters( double );

  void                  declareRuntimeRequestedOutputs();
  bool                  m_declAugmented{false};
  Gaudi::Property<bool> m_loader{this, "Loader", false, "Declare the algorithm to be a data loader"};

  Gaudi::Property<std::vector<std::string>> m_inpKeys{this, "inpKeys", {}, ""};
  Gaudi::Property<std::vector<std::string>> m_outKeys{this, "outKeys", {}, ""};

  Gaudi::Property<double> m_avg_runtime{this, "avgRuntime", 1., "Average runtime of the module."};
  Gaudi::Property<double> m_var_runtime{this, "varRuntime", 0.01, "Variance of the runtime of the module."};
  Gaudi::Property<bool> m_local_rndm_gen{this, "localRndm", true, "Decide if the local random generator is to be used"};
  Gaudi::Property<bool> m_shortCalib{this, "shortCalib", false, "Enable coarse grained calibration"};
  Gaudi::Property<unsigned int> m_rwRepetitions{this, "RwRepetitions", 1, "Increase access to the WB"};
  Gaudi::Property<float>        m_sleepFraction{
      this, "SleepFraction", 0.0f,
      "Fraction of time, between 0 and 1, when an algorithm is actually sleeping instead of crunching"};
  Gaudi::Property<bool>         m_invertCFD{this, "InvertDecision", false, "Invert control flow decision."};
  Gaudi::Property<unsigned int> m_failNEvents{this, "FailNEvents", 0, "Return FAILURE on every Nth event"};

  // To calib only once
  static std::vector<unsigned int> m_niters_vect;
  static std::vector<double>       m_times_vect;

  // For the concurrency
  const uint MAX_INPUTS  = 40;
  const uint MAX_OUTPUTS = 10;

  std::vector<DataObjectHandle<DataObject>*> m_inputHandles;
  std::vector<DataObjectHandle<DataObject>*> m_outputHandles;

  static CHM m_name_ncopies_map;
};