CPUCruncher.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/Algorithm.h>
#include <GaudiKernel/DataObjectHandle.h>
#include <GaudiKernel/ICPUCrunchSvc.h>
#include <GaudiKernel/IRndmGenSvc.h>
#include <GaudiKernel/RegistryEntry.h>
#include <GaudiKernel/RndmGenerators.h>
#include <tbb/concurrent_hash_map.h>
 
//------------------------------------------------------------------------------

class CPUCruncher : public Algorithm {
 
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                  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<unsigned int> m_rwRepetitions{ this, "RwRepetitions", 1, "Increase access to the WB" };
  Gaudi::Property<double>       m_sleepFraction{
      this, "SleepFraction", 0.0,
      "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" };
  Gaudi::Property<int>          m_nParallel{ this, "NParallel", -1, "Run N parallel crunching tasks" };
 
  // 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;
 
  // CPUCrunchSvc
  SmartIF<ICPUCrunchSvc> m_crunchSvc;
};