AthenaHiveEventLoopMgr.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_ATHENAHIVEEVENTLOOPMGR_H
#define ATHENASERVICES_ATHENAHIVEEVENTLOOPMGR_H
 
// Base class headers
#include "AthenaKernel/IEventSeek.h"
#include "AthenaKernel/ICollectionSize.h"
#include "GaudiKernel/IIncidentListener.h"
#include "AthenaKernel/Timeout.h"
#include "GaudiKernel/MinimalEventLoopMgr.h"
 
// Athena headers
#include "AthenaBaseComps/AthMessaging.h"
#include "AthenaKernel/IAthenaEvtLoopPreSelectTool.h"
#include "AthenaKernel/IConditionsCleanerSvc.h"
#ifndef EVENTINFO_EVENTID_H
# include "EventInfo/EventID.h"  /* number_type */
#endif
 
 
// Gaudi headers
#include "Gaudi/Property.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IAlgResourcePool.h"
#include "GaudiKernel/IEvtSelector.h"
#include "GaudiKernel/IHiveWhiteBoard.h"
#include "GaudiKernel/IScheduler.h"
#include "GaudiKernel/IAlgExecStateSvc.h"
 
// Standard includes
#include <functional>
#include <string>
#include <vector>
 
// External Libraries
#include "tbb/concurrent_queue.h"
 
// Forward declarations
class IConversionSvc;
struct IDataManagerSvc;
class IDataProviderSvc;
class IIncidentSvc;
class StoreGateSvc;
class ISvcLocator;
class IEvtIdModifierSvc;

class AthenaHiveEventLoopMgr : public extends<MinimalEventLoopMgr,
                                              IEventSeek, ICollectionSize, IIncidentListener>,
                               public Athena::TimeoutMaster,
                               public AthMessaging
{
public:
  typedef IEvtSelector::Context   EvtContext;
 
protected:
  typedef ServiceHandle<IIncidentSvc> IIncidentSvc_t;
  IIncidentSvc_t     m_incidentSvc;
 
  typedef ServiceHandle<StoreGateSvc> StoreGateSvc_t;
  StoreGateSvc_t  m_eventStore;  

  IEvtSelector*     m_evtSelector;
  EvtContext*       m_evtContext;
  StringProperty    m_evtsel;
 
  typedef ServiceHandle<IDataManagerSvc> IDataManagerSvc_t;
  IDataManagerSvc_t  m_histoDataMgrSvc;
 
  typedef ServiceHandle<IConversionSvc> IConversionSvc_t;
  IConversionSvc_t   m_histoPersSvc;
 
  typedef ServiceHandle<IEvtIdModifierSvc> IEvtIdModifierSvc_t;
  IEvtIdModifierSvc_t m_evtIdModSvc;

  StringProperty    m_histPersName;
 
  typedef EventID::number_type number_type;
  number_type m_currentRun;
  bool m_firstRun;

  IntegerProperty m_failureMode;

  UnsignedIntegerProperty m_eventPrintoutInterval;

  typedef IAthenaEvtLoopPreSelectTool          tool_type;
  typedef ToolHandleArray< tool_type >         tool_store;
  typedef tool_store::const_iterator           tool_iterator;
  typedef std::vector<unsigned int>            tool_stats;
  typedef tool_stats::const_iterator           tool_stats_iterator;
 
  tool_stats m_toolInvoke; 
  tool_stats m_toolReject; 
  tool_stats m_toolAccept; 
  tool_store m_tools;         

  void setupPreSelectTools(Gaudi::Details::PropertyBase&);

  bool m_requireInputAttributeList{};

  bool m_useSecondaryEventNumber{};

  virtual StatusCode writeHistograms(bool force=false);

  virtual StatusCode executeAlgorithms();

  StatusCode initializeAlgorithms();
 
 
  //***********************************************************//
  // for Hive
protected:

  SmartIF<IHiveWhiteBoard>  m_whiteboard;

  SmartIF<IAlgResourcePool>  m_algResourcePool;

  SmartIF<IAlgExecStateSvc>  m_aess;

  SmartIF<IProperty>        m_appMgrProperty;

  SmartIF<IScheduler> m_schedulerSvc;
  StatusCode clearWBSlot(int evtSlot);
  int declareEventRootAddress(EventContext&);
  virtual EventContext createEventContext() override;
  int drainScheduler(int& finishedEvents);
  SmartIF< IIncidentListener >  m_abortEventListener;
  std::string m_schedulerName;
  std::string m_whiteboardName;
  bool                m_scheduledStop;
 
 
 
public:
  StatusCode getEventRoot(IOpaqueAddress*& refpAddr);    
 
 
 
//***********************************************************//
 
public:
  AthenaHiveEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc);
  virtual ~AthenaHiveEventLoopMgr();
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  virtual StatusCode nextEvent(int maxevt) override;
  virtual StatusCode executeEvent( EventContext&& ctx ) override;
  virtual StatusCode executeRun(int maxevt) override;
  virtual StatusCode stopRun() override;
  virtual StatusCode stop() override;
 

  virtual StatusCode seek(int evt) override;
  virtual int curEvent() const override;
  virtual int size() override;
  virtual void handle(const Incident& inc) override;
 
  using AthMessaging::msg;
  using AthMessaging::msgLvl;
 
  //FIXME hack to workaround pylcgdict problem...
  virtual const std::string& name() const  override { return Service::name(); } //FIXME 
  
  virtual void modifyEventContext(EventContext& ctx, const EventID& eID, bool consume_modifier_stream);
 
private:
  AthenaHiveEventLoopMgr() = delete;
  AthenaHiveEventLoopMgr(const AthenaHiveEventLoopMgr&) = delete;
  AthenaHiveEventLoopMgr& operator= (const AthenaHiveEventLoopMgr&) = delete;
 
  unsigned int m_nevt;
  unsigned int m_timeStamp { 0 };
  UnsignedIntegerProperty m_writeInterval;
  bool m_writeHists;
 
protected:
  // These are now protected so we can access them in MPIHiveEventLoopMgr
 
  bool m_terminateLoop { false };
  unsigned int m_nev;
  unsigned int m_proc;
  bool m_useTools;
  bool m_doEvtHeartbeat;
 
  // Save a copy of the last event context to use
  // at the end of event processing.
  EventContext m_lastEventContext;
 
private:
  bool m_firstEventAlone;
 
  unsigned int m_flmbi, m_timeStampInt;
 
  // from MinimalEventLoopMgr
public:
  typedef std::list<SmartIF<IAlgorithm> >  ListAlg;
  // typedef std::list<IAlgorithm*>  ListAlgPtrs;
  // typedef std::list<std::string>   ListName;
  // typedef std::vector<std::string> VectorName;
 
private:
  StoreGateSvc* eventStore() const;
 
  ServiceHandle<Athena::IConditionsCleanerSvc> m_conditionsCleaner;
};
 
#endif // ATHENASERVICES_ATHENAHIVEEVENTLOOPMGR_H