HiveEventLoopMgr.h

Go to the documentation of this file.

#ifndef GAUDIHIVE_HIVEEVENTLOOPMGR_H
#define GAUDIHIVE_HIVEEVENTLOOPMGR_H 1

// Framework include files
#include "GaudiKernel/IAlgResourcePool.h"
#include "GaudiKernel/IEvtSelector.h"
#include "GaudiKernel/IHiveWhiteBoard.h"
#include "GaudiKernel/MinimalEventLoopMgr.h"

// std includes
#include <atomic>

//include boost
#include <boost/dynamic_bitset.hpp>

// include tbb
#include "tbb/concurrent_vector.h"
#include "tbb/concurrent_queue.h"

// typedef for the event and algo state
typedef boost::dynamic_bitset<> state_type;

// Forward declarations
class IIncidentSvc;
class IDataManagerSvc;
class IDataProviderSvc;

namespace tbb {
  class task_scheduler_init;
}

class HiveEventLoopMgr : public MinimalEventLoopMgr   {
public:

protected:
  SmartIF<IDataManagerSvc>  m_evtDataMgrSvc;
  SmartIF<IDataProviderSvc> m_evtDataSvc;
  SmartIF<IEvtSelector>     m_evtSelector;
  IEvtSelector::Context*      m_evtContext;
  std::string       m_evtsel;
  SmartIF<IDataManagerSvc>  m_histoDataMgrSvc;
  SmartIF<IConversionSvc>   m_histoPersSvc;
  SmartIF<IHiveWhiteBoard>  m_whiteboard;
  SmartIF<IAlgResourcePool>  m_algResourcePool;
  std::string       m_histPersName;
  SmartIF<IProperty>        m_appMgrProperty;
  bool              m_endEventFired;
  bool              m_warnings;
  
  // Variables for the concurrency  
  unsigned int m_max_parallel;
  tbb::task_scheduler_init* m_tbb_scheduler_init;  
  void find_dependencies();
  state_type m_termination_requirement;
  std::vector<state_type> m_all_requirements;
  std::map<std::string,unsigned int> m_product_indices;
  std::atomic_uint m_total_algos_in_flight;
  unsigned int  m_numberOfAlgos;
  bool m_DumpQueues;
  unsigned int m_evts_parallel;
  unsigned int m_num_threads;
  bool m_CloneAlgorithms;
  // keep room for a class hashing strings instead of strings
  typedef std::vector<std::vector<std::string>> algosDependenciesCollection;
  // We just need the dependencies and not the algo names.
  algosDependenciesCollection m_AlgosDependencies;
  // Number of products to deal with
  unsigned int m_nProducts;

public:
  HiveEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc);
  virtual ~HiveEventLoopMgr();
  StatusCode getEventRoot(IOpaqueAddress*& refpAddr);  
  
  virtual StatusCode initialize();
  virtual StatusCode reinitialize();
  virtual StatusCode stop();
  virtual StatusCode finalize();
  virtual StatusCode nextEvent(int maxevt);
  virtual StatusCode executeEvent(void* par);
  virtual StatusCode executeRun(int maxevt);

  void taskFinished(IAlgorithm*& algo);

};
#endif // GAUDIHIVE_HIVEEVENTLOOPMGR_H