DybDualEventLoopMgr.cpp

Go to the documentation of this file.

#include "DybDualEventLoopMgr.h"

#include "DybKernel/HybridExecutionIncident.h"
#include "DybKernel/IAesFeeder.h"

#include "GaudiKernel/ListItem.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/ThreadGaudi.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IDataStoreAgent.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/DataObject.h"

#include <vector>
#include <string>

typedef std::list<IAlgorithm*>   ListAlg;


class ELMState {
public:
    ListAlg topAlgList;
    int total_nevt;

    ELMState() 
        : topAlgList()
        , total_nevt(0)
    {      }
};

#include "DybDualELM_HEIHandler.h"


DybDualEventLoopMgr::DybDualEventLoopMgr(const std::string& nam, ISvcLocator* svcLoc)
  : DybEventLoopMgr(nam, svcLoc)
  , m_theState(0)
  , m_state1(new ELMState)
  , m_state2(new ELMState)
  , m_incsvc(0)
  , m_heiHandler(0)
{
    // My additional properties
    declareProperty("EventBuilderAlg",m_eventBuilderAlgName = "EventBuilderAlg",
                    "Name of the algorithm responsible for building events (def: EventBuilderAlg)");
}

DybDualEventLoopMgr::~DybDualEventLoopMgr()
{
}

StatusCode DybDualEventLoopMgr::initialize()
{
    MsgStream log(msgSvc(), name());

    log << MSG::DEBUG
        << "calling DybEventLoopMgr::intialize(),"
        << " state = " << FSMState() 
        << " targeting " << targetFSMState()
        << endreq;

    StatusCode sc = DybEventLoopMgr::initialize();
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to initialize DybEventLoopMgr base class" << endreq;
        return sc;
    }
    log << MSG::DEBUG
        << "returned from DybEventLoopMgr::intialize()"
        << " state = " << FSMState() 
        << " targeting " << targetFSMState()
        << endreq;


    sc = m_evtDataSvc->queryInterface(IAesFeeder::interfaceID(),(void**)&m_aesfeed);
    if (sc.isFailure()) {
        log << MSG::ERROR
            << "Failed to get interface IAesFeeder from event data service."
            << endreq;
        return sc;
    }

    sc = this->initialize_algs();
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to initialize algorithms" << endreq;
        return sc;
    }

    // Connect to "HybridExecutionIncident"
    sc = this->service("IncidentSvc",m_incsvc,true);
    if (sc.isFailure()) {
        log << MSG::ERROR
            << "Failed to get IncidentSvc" << endreq;
        return sc;
    }
    
    m_heiHandler = new HEIHandler(m_theState, m_state1, m_state2);
    m_incsvc->addListener(m_heiHandler,"HybridExecutionIncident");

    return StatusCode::SUCCESS;
}


StatusCode DybDualEventLoopMgr::initialize_algs()
{
    MsgStream log(msgSvc(), name());
    StatusCode sc = StatusCode::SUCCESS;

    log << MSG::DEBUG
        << "initializing top alg lists with "
        << m_topAlgList.size()
        << " algorithms."
        << endreq;

    ELMState* theState = m_state1;
    ListAlg::iterator it, done = m_topAlgList.end();
    for (it = m_topAlgList.begin(); it != done; ++it) {
        IAlgorithm* ialg = *it;
        SmartIF<IStateful> istate(IID_IStateful,ialg);
        
        std::string name = ialg->name();

        log << MSG::DEBUG
            << "Algorithm \"" << name << "\"" 
            << " in state " << istate->FSMState() 
            << " targetting " << istate->targetFSMState() 
            << endreq;
        
        theState->topAlgList.push_back(ialg);
        if (name == m_eventBuilderAlgName) {
            theState = m_state2; // switch to second list
            theState->topAlgList.push_back(ialg); // event builder goes in both
        }            
    }

    if (!m_state2->topAlgList.size()) {
        log << MSG::WARNING
            << "Did not find event builder algorithm: \"" 
            << m_eventBuilderAlgName << "\""
            << endreq;
        //return StatusCode::FAILURE;
    }

    // Start with list #1
    m_theState = m_state1;
    switch_state(true);
    return sc;
}

static void dump_algs(MsgStream& log, ListAlg& algs)
{
    ListAlg::iterator it, done = algs.end();
    for (it = algs.begin(); it != done; ++it) {
        log << MSG::DEBUG
            << "\t" << (*it)->name()
            << endreq;
    }
}

bool DybDualEventLoopMgr::switch_state(bool force)
{
    MsgStream log(msgSvc(), name());

    if (!force && m_theLastState == m_theState) {
        log << MSG::DEBUG
            << "switch_state("<<force<<") keeping state " 
            << (m_theState == m_state1 ? "one" : "two")
            << endreq;
        return false;
    }

    // Set MinimalEventLoopMgr's TopAlg list
    m_theLastState = m_theState;
    m_topAlgList = m_theState->topAlgList;

    log << MSG::DEBUG
        << "switch_state("<<force<<") switched state to " 
        << (m_theState == m_state1 ? "one" : "two")
        << " with algs:"
        << endreq;
    dump_algs(log,m_topAlgList);
    return true;
}


void DybDualEventLoopMgr::union_alg_list()
{
    m_topAlgList.clear();
    m_topAlgList.insert(m_topAlgList.end(), 
                        m_state1->topAlgList.begin(), 
                        m_state1->topAlgList.end()); 
    if (m_state2->topAlgList.size()) {
        m_topAlgList.insert(m_topAlgList.end(), 
                            ++m_state2->topAlgList.begin(), 
                            m_state2->topAlgList.end()); 
    }
}

StatusCode DybDualEventLoopMgr::finalize()
{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "A useless message about me finalizing" << endreq;

    m_incsvc->removeListener(m_heiHandler,"HybridExecutionIncident");
    delete m_heiHandler; m_heiHandler = 0;
    m_incsvc->release();
    m_incsvc = 0;

    union_alg_list();
    return DybEventLoopMgr::finalize();    
}


StatusCode DybDualEventLoopMgr::reinitialize()
{
    MsgStream log(msgSvc(), name());
    log << MSG::WARNING << "Why am I being reinitialized?" << endreq;
    return StatusCode::SUCCESS;
}

static void dump_tes(IDataManagerSvc* evtDataMgrSvc, MsgStream& log)
{
    class Visitor : public IDataStoreAgent {
    public:
        MsgStream& log;
        int count;
        Visitor(MsgStream& lg) : log(lg), count(0) {}
        virtual ~Visitor() {}
        virtual bool analyse(IRegistry* pObject, int level) {
            ++count;
            log << MSG::DEBUG
                << count << ": " << pObject->name()
                << " @ " << level
                << " ref# " << pObject->object()->refCount()
                << endreq;
            return true;
        }
    } visitor(log);
    evtDataMgrSvc->traverseTree(&visitor);
    log << MSG::DEBUG 
        << "Event data store now has " << visitor.count << " objects" 
        << endreq;
}

StatusCode DybDualEventLoopMgr::nextEvent(int maxevt)
{
    StatusCode        sc = StatusCode::SUCCESS;
    MsgStream         log( msgSvc(), name() );

    log << MSG::DEBUG
        << "nextEvent(" << maxevt << ")"
        << endreq;

    ListAlg save_topAlgList = m_topAlgList;

    // force starting at state 1
    m_theState = m_state1;
    switch_state(true);

    // loop over events if the maxevt (received as input) if different from -1. 
    // if evtmax is -1 it means infinite loop
    int nevt = 0;
    bool been_here = false;
    while (true) {

        switch_state();

        log << MSG::DEBUG
            << "Event #" << nevt 
            << " in state " << (m_theState == m_state1 ? "one" : "two")
            << " with " << m_theState->topAlgList.size() << " algorithms"
            << endreq;
        dump_algs(log,m_theState->topAlgList);

        if (m_theState == m_state2) {
            if (maxevt != -1 && nevt >= maxevt) {
                break;
            }
            ++nevt;
        }

        log << MSG::DEBUG
            << "Executing event loop #" << nevt << endreq;

        // Check if there is a scheduled stop issued by some algorithm/sevice
        if (m_scheduledStop) {
            m_scheduledStop = false;
            log << MSG::ALWAYS
                << "Terminating event processing loop due to scheduled stop" << endreq;
            m_topAlgList = save_topAlgList;
            return StatusCode::SUCCESS;
        }

        if (true) {             // this block is for debugging and can be turned off

            // Want to avoid getting readout-phase objects tangled up
            // in AES and OHS.
            if (m_theState == m_state1) {
                log << MSG::DEBUG << "Inhibiting AES feeding" << endreq;
                m_aesfeed->inhibit();
            }
            else {
                log << MSG::DEBUG << "Enabling AES feeding" << endreq;
                m_aesfeed->enable();
            }

            dump_tes(m_evtDataMgrSvc,log);
        }

        if (been_here) {
            sc = m_evtDataMgrSvc->clearStore();
            if (sc.isFailure()) {
                log << MSG::WARNING << "Clear of Event data store failed" << endreq;
            }
            log << MSG::DEBUG << "Cleared event store" << endreq;
            dump_tes(m_evtDataMgrSvc,log);
        }
        else {
            been_here = true;
        }
        // Setup event in the event store only in state1
        if (m_theState == m_state1 && m_evtContext) {
            IOpaqueAddress* addr = 0;
            // Only if there is a EventSelector
            sc = getEventRoot(addr);
            if (sc.isFailure())  {
                log << MSG::INFO << "No more events in event selection " << endreq;
                m_topAlgList = save_topAlgList;
                return StatusCode::SUCCESS;
            }

            // Set root clears the event data store first
            sc = m_evtDataMgrSvc->setRoot("/Event", addr);
            if (sc.isFailure())  {
                log << MSG::WARNING << "Error declaring event root address." << endreq;
                continue; // not failure?
            }
            DataObject* pObject = 0;
            sc = m_evtDataSvc->retrieveObject("/Event", pObject);
            if( sc.isFailure() ) {
                log << MSG::WARNING << "Unable to retrieve Event root object" << endreq;
                m_topAlgList = save_topAlgList;
                return StatusCode::FAILURE;
            }
        }
        else {
            sc = m_evtDataMgrSvc->setRoot ("/Event", new DataObject());
            if (sc.isFailure() )  {
                log << MSG::WARNING << "Error declaring event root DataObject" << endreq;
            } 
        }
        // Execute event for all required algorithms
        sc = executeEvent(NULL);
        if (sc.isFailure()){
            log << MSG::ERROR << "Terminating event processing loop due to errors" << endreq;
            m_topAlgList = save_topAlgList;
            return StatusCode::FAILURE;
        }
    }
    m_topAlgList = save_topAlgList;
    return StatusCode::SUCCESS;
}

StatusCode DybDualEventLoopMgr::executeRun(int maxevt)
{
    union_alg_list();
    return MinimalEventLoopMgr::executeRun(maxevt);
}