GaudiParallelizer.h

Go to the documentation of this file.

#ifndef LIB_GAUDIPARALLELIZER_H
#define LIB_GAUDIPARALLELIZER_H 1
// Include files
// from Gaudi
#include "GaudiAlg/GaudiAlgorithm.h"

#include <boost/bind.hpp>
#include <tbb/task_group.h>
#include <tbb/task_scheduler_init.h>

// Forward declarations
class ISequencerTimerTool;

class GaudiParallelizer : public GaudiAlgorithm
{
public:
  GaudiParallelizer( const std::string& name, ISvcLocator* pSvcLocator );
  ~GaudiParallelizer() noexcept( true ) override {}
  StatusCode initialize() override; 
  StatusCode execute() override;    
  StatusCode finalize() override;   

  void membershipHandler( Gaudi::Details::PropertyBase& theProp );

protected:
  class AlgorithmEntry
  {
  public:
    AlgorithmEntry( Algorithm* alg )
    {
      m_algorithm = alg;
      m_reverse   = false;
      m_timer     = 0;
    }

    virtual ~AlgorithmEntry(){}; 
    void setReverse( bool flag ) { m_reverse = flag; }

    Algorithm* algorithm() const { return m_algorithm; }
    bool reverse() const { return m_reverse; }
    void setTimer( int nb ) { m_timer = nb; }
    int timer() const { return m_timer; }

    void run( GaudiParallelizer& prlzr )
    {
      if ( prlzr.m_measureTime ) prlzr.m_timerTool->start( timer() );
      m_returncode = m_algorithm->sysExecute();
      if ( prlzr.m_measureTime ) prlzr.m_timerTool->stop( timer() );
      algorithm()->setExecuted( true );
    }

    StatusCode m_returncode; 

  private:
    Algorithm* m_algorithm; 
    bool m_reverse;         
    int m_timer;            
  };

  StatusCode decodeNames();

private:
  Gaudi::Property<std::vector<std::string>> m_names{this, "Members", {}, "list of algorithms"};
  Gaudi::Property<bool> m_modeOR{this, "ModeOR", false, "use OR loginc instead of AND"};
  Gaudi::Property<bool> m_measureTime{this, "MeasureTime", false, "measure time"};
  Gaudi::Property<bool> m_returnOK{this, "ReturnOK", false, "forces the sequencer to return a good status"};
  Gaudi::Property<unsigned short> m_nthreads{this, "NumberOfThreads", 0, "number of threads in the thread pool"};

  std::vector<AlgorithmEntry> m_entries; 

  ISequencerTimerTool* m_timerTool = nullptr; 
  int m_timer;                                

  tbb::task_group m_task_group; 
};

#endif // LIB_GAUDIPARALLELIZER_H