HLTEventLoopMgr.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

#include "tbb/task.h"

// Forward declarations
class IAlgExecStateSvc;
class IEvtSelector;
class IHiveWhiteBoard;
class IDataManagerSvc;
class IDataProviderSvc;
class IPrecedenceSvc;

class HLTEventLoopMgr : public extends<Service, IEventProcessor>
{

  struct HLTExecutionTask : public tbb::task {

    HLTExecutionTask( std::vector<IAlgorithm*>& algorithms, std::unique_ptr<EventContext> ctx, ISvcLocator* svcLocator,
                      IAlgExecStateSvc* aem,
                      std::function<void( std::unique_ptr<EventContext> )> promote2ExecutedClosure )
        : m_algorithms( algorithms )
        , m_evtCtx( std::move( ctx ) )
        , m_aess( aem )
        , m_serviceLocator( svcLocator )
        , m_promote2ExecutedClosure( std::move( promote2ExecutedClosure ) ){};
    tbb::task* execute() override;

    MsgStream log()
    {
      SmartIF<IMessageSvc> messageSvc( m_serviceLocator );
      return MsgStream( messageSvc, "HLTExecutionTask" );
    }

    std::vector<IAlgorithm*>& m_algorithms;
    std::unique_ptr<EventContext> m_evtCtx;
    IAlgExecStateSvc* m_aess;
    SmartIF<ISvcLocator> m_serviceLocator;
    std::function<void( std::unique_ptr<EventContext> )> m_promote2ExecutedClosure;
  };

public:
  using extends::extends;

  StatusCode initialize() override;
  StatusCode reinitialize() override { return StatusCode::FAILURE; }
  StatusCode finalize() override;

  StatusCode nextEvent( int maxevt ) override;
  StatusCode executeEvent( void* par ) override;
  StatusCode executeRun( int maxevt ) override { return nextEvent( maxevt ); }
  StatusCode stopRun() override;

private:
  StatusCode declareEventRootAddress();
  StatusCode eventFailed( EventContext* eventContext );
  void promoteToExecuted( std::unique_ptr<EventContext> eventContext );

  inline unsigned int algname2index( const std::string& algoname ) { return m_algname_index_map[algoname]; }
  inline const std::string& index2algname( unsigned int index ) { return m_algname_vect[index]; }

private:
  Gaudi::Property<std::string> m_histPersName{this, "HistogramPersistency", "", ""};
  Gaudi::Property<std::string> m_evtsel{this, "EvtSel", "", ""};
  Gaudi::Property<int> m_threadPoolSize{this, "ThreadPoolSize", -1, "Size of the threadpool initialised by TBB"};
  Gaudi::Property<std::string> m_whiteboardSvcName{this, "WhiteboardSvc", "EventDataSvc", "The whiteboard name"};

  IDataManagerSvc* m_evtDataMgrSvc;
  IEvtSelector* m_evtSelector;
  IDataManagerSvc* m_histoDataMgrSvc;
  IConversionSvc* m_histoPersSvc;
  IHiveWhiteBoard* m_whiteboard;
  IAlgExecStateSvc* m_algExecStateSvc;
  IPrecedenceSvc* m_precSvc;

  std::atomic<unsigned int> m_finishedEvt{0};
  std::condition_variable m_createEventCond;
  std::mutex m_createEventMutex;

  IEvtSelector::Context* m_evtSelContext{nullptr};

  std::vector<std::string> m_algname_vect;
  std::unordered_map<std::string, unsigned int> m_algname_index_map;
  std::vector<EventSlot> m_eventSlots;
  std::vector<IAlgorithm*> m_algos;
};