RoundRobinSchedulerSvc Class Reference

The RoundRobinSchedulerSvc implements the IScheduler interface. More...

#include <src/RoundRobinSchedulerSvc.h>

Inheritance diagram for RoundRobinSchedulerSvc:

Collaboration diagram for RoundRobinSchedulerSvc:

Public Member Functions
	RoundRobinSchedulerSvc (const std::string &name, ISvcLocator *svc)
	Constructor. More...
	~RoundRobinSchedulerSvc ()
	Destructor. More...
virtual StatusCode	initialize ()
	Initialise. More...
virtual StatusCode	finalize ()
	Finalise. More...
virtual StatusCode	pushNewEvent (EventContext *eventContext)
	Make an event available to the scheduler. More...
virtual StatusCode	pushNewEvents (std::vector< EventContext * > &eventContexts)
virtual StatusCode	popFinishedEvent (EventContext *&eventContext)
	Blocks until an event is availble. More...
virtual StatusCode	tryPopFinishedEvent (EventContext *&eventContext)
	Try to fetch an event from the scheduler. More...
virtual unsigned int	freeSlots ()
	Get free slots number. More...
Public Member Functions inherited from extends< BASE, Interfaces >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...
	~extend_interfaces () override=default
	Virtual destructor. More...

Private Member Functions
StatusCode	processEvents ()

Private Attributes
bool	m_useTopAlgList
	Decide if the top alglist or its flat version has to be used. More...
SmartIF< IAlgResourcePool >	m_algResourcePool
concurrency::ExecutionFlowManager	m_controlFlow
std::vector< std::string >	m_algname_vect
	Vector to bookkeep the information necessary to the index2name conversion. More...
std::unordered_map< std::string, unsigned int >	m_algname_index_map
	Map to bookkeep the information necessary to the name2index conversion. More...
std::vector< std::vector< std::string > >	m_algosDependencies
	Ugly, will disappear when the deps are declared only within the C++ code of the algos. More...
std::list< IAlgorithm * >	m_algList
	Cache the list of algs to be executed. More...
tbb::concurrent_bounded_queue< EventContext * >	m_finishedEvents
	Queue of finished events. More...
unsigned int	m_freeSlots
	The number of free slots (0 or 1) More...
std::vector< EventContext * >	m_evtCtx_buffer

Additional Inherited Members
Public Types inherited from extends< BASE, Interfaces >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
Public Types inherited from extend_interfaces< Interfaces...>
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Detailed Description

The RoundRobinSchedulerSvc implements the IScheduler interface.

It deals with multiple events and tries to handle all events algorithm type by algorithm type, using one single thread. It serves as simple implementation against the concurrent state machine and provides a test for instruction cache locality

Author

Benedikt Hegner

Version

1.0

Definition at line 39 of file RoundRobinSchedulerSvc.h.

Constructor & Destructor Documentation

RoundRobinSchedulerSvc::RoundRobinSchedulerSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Constructor.

Definition at line 26 of file RoundRobinSchedulerSvc.cpp.

                                                                                          :
 base_class(name,svcLoc){
  declareProperty("UseTopAlgList", m_useTopAlgList=true);
  declareProperty("SimultaneousEvents", m_freeSlots=1);
}

RoundRobinSchedulerSvc::~RoundRobinSchedulerSvc

(

)

Destructor.

Definition at line 33 of file RoundRobinSchedulerSvc.cpp.

{}

Member Function Documentation

StatusCode RoundRobinSchedulerSvc::finalize ( )

virtual

Finalise.

Definition at line 78 of file RoundRobinSchedulerSvc.cpp.

                                           {
  StatusCode sc(Service::finalize());
  if (!sc.isSuccess())
      warning () << "Base class could not be finalized" << endmsg;
  return sc;
}

unsigned int RoundRobinSchedulerSvc::freeSlots ( )

virtual

Get free slots number.

Given that the scheduler is sequential and its methods non reentrant, this is always 1.

Definition at line 280 of file RoundRobinSchedulerSvc.cpp.

{return m_freeSlots;}

StatusCode RoundRobinSchedulerSvc::initialize ( )

virtual

Initialise.

Definition at line 36 of file RoundRobinSchedulerSvc.cpp.

                                             {

  // Initialise mother class (read properties, ...)
  StatusCode sc(Service::initialize());
  if (!sc.isSuccess())
    warning () << "Base class could not be initialized" << endmsg;

  // Get the algo resource pool
 m_algResourcePool =  serviceLocator()->service("AlgResourcePool");
  if (!m_algResourcePool.isValid()){
    error() << "Error retrieving AlgResourcePool" << endmsg;
    return StatusCode::FAILURE;
  }

  // Get the list of algorithms
  m_algList = m_useTopAlgList ? m_algResourcePool->getTopAlgList() : m_algResourcePool->getFlatAlgList();
  info() << "Found " <<  m_algList.size() << " algorithms" << endmsg;

  // Fill the containers to convert algo names to index
    m_algname_index_map.reserve(m_algList.size());
    m_algname_vect.reserve(m_algList.size());
    unsigned int index=0;
    for (IAlgorithm* algo : m_algList){
        const std::string& name = algo->name();
        m_algname_index_map[name]=index;
        m_algname_vect.emplace_back(name);
        index++;
    }

  //initialize control flow manager
    const AlgResourcePool* algPool = dynamic_cast<const AlgResourcePool*>(m_algResourcePool.get());

    m_controlFlow.initialize(algPool->getExecutionFlowGraph(), m_algname_index_map);

  return StatusCode::SUCCESS;

  // prepare the event slots
  // TODO !

}

StatusCode RoundRobinSchedulerSvc::popFinishedEvent ( EventContext *&  eventContext )

virtual

Blocks until an event is availble.

Definition at line 251 of file RoundRobinSchedulerSvc.cpp.

                                                                              {

    if(m_finishedEvents.empty() && !m_evtCtx_buffer.empty())
        processEvents();

    m_finishedEvents.pop(eventContext);
  m_freeSlots++;
  debug() << "Popped slot " << eventContext->slot() << "(event "
          << eventContext->evt() << ")" << endmsg;
  return StatusCode::SUCCESS;
}

StatusCode RoundRobinSchedulerSvc::processEvents ( )

private

Definition at line 119 of file RoundRobinSchedulerSvc.cpp.

                                                {
    StatusCode sc(StatusCode::SUCCESS);

    // Get the IProperty interface of the ApplicationMgr to pass it to RetCodeGuard
    const SmartIF<IProperty> appmgr(serviceLocator());
    SmartIF<IMessageSvc> messageSvc (serviceLocator());

    //initialize control algorithm states and decisions
    AlgsExecutionStates algStates(m_algList.size(), messageSvc);
    const AlgResourcePool* algPool = dynamic_cast<const AlgResourcePool*>(m_algResourcePool.get());
    std::vector<int> nodeDecisions(algPool->getExecutionFlowGraph()->getControlFlowNodeCounter(), -1);


    m_controlFlow.updateEventState(algStates, nodeDecisions);
    m_controlFlow.promoteToControlReadyState(algStates, nodeDecisions);

    //initialize data flow manager
    //DataFlowManager dataFlow(m_scheduler->m_algosDependencies);

    info() << "Got " << m_evtCtx_buffer.size() << " events, starting loop" << endmsg;

    while(algStates.algsPresent(AlgsExecutionStates::State::CONTROLREADY) ){

        debug() << "algorithms left" << endmsg;

        //std::for_each(algStates.begin(AlgsExecutionStates::State::CONTROLREADY), algStates.end(AlgsExecutionStates::State::CONTROLREADY),

                //[&] (uint algIndex) {
        for(auto it = algStates.begin(AlgsExecutionStates::State::CONTROLREADY); it != algStates.end(AlgsExecutionStates::State::CONTROLREADY); ++it){

                uint algIndex = *it;

                std::string algName = m_algname_vect[algIndex];

                debug() << "Running algorithm [" << algIndex << "] " << algName << endmsg;

                std::vector<AlgsExecutionStates::State> algResults(m_evtCtx_buffer.size());

                //promote algorithm to data ready
                algStates.updateState(algIndex,AlgsExecutionStates::DATAREADY);

                IAlgorithm* ialgoPtr=nullptr;
                m_algResourcePool->acquireAlgorithm(algName, ialgoPtr);
                //promote algorithm to scheduled
                algStates.updateState(algIndex,AlgsExecutionStates::SCHEDULED);

                Algorithm* algoPtr = dynamic_cast<Algorithm*> (ialgoPtr); // DP: expose the setter of the context?
                algoPtr->resetExecuted();

                for (uint i = 0; i < m_evtCtx_buffer.size(); ++i) {
                  if (false == m_evtCtx_buffer[i]->evtFail()) {
                        bool eventfailed=false;

                        // m_evtCtx_buffer[i]->m_thread_id = pthread_self();
                        algoPtr->resetExecuted();
                        algoPtr->setContext(m_evtCtx_buffer[i]);
                        Gaudi::Hive::setCurrentContextId(m_evtCtx_buffer[i]->slot());
                        // Call the execute() method
                        try {
                            RetCodeGuard rcg(appmgr, Gaudi::ReturnCode::UnhandledException);
                            sc = ialgoPtr->sysExecute();
                            if (UNLIKELY(!sc.isSuccess()))  {
                                warning() << "Execution of algorithm " << algName << " failed for event " << m_evtCtx_buffer[i]->evt() << endmsg;
                                eventfailed = true;
                            }
                            rcg.ignore(); // disarm the guard
                        } catch ( const GaudiException& Exception ) {
                            error() << ".executeEvent(): Exception with tag=" << Exception.tag()
                                   << " thrown by " << algName << endmsg;
                            error() << Exception << endmsg;
                        } catch ( const std::exception& Exception ) {
                            fatal() << ".executeEvent(): Standard std::exception thrown by "
                                    << algName << endmsg;
                            error() <<  Exception.what()  << endmsg;
                        } catch(...) {
                            fatal() << ".executeEvent(): UNKNOWN Exception thrown by "
                                    << algName << endmsg;
                        }
                        m_evtCtx_buffer[i]->setFail(eventfailed);
                    }

                    if (ialgoPtr->filterPassed()){
                        algResults[i] = AlgsExecutionStates::State::EVTACCEPTED;
                    } else {
                        algResults[i] = AlgsExecutionStates::State::EVTREJECTED;
                    }

                }

                m_algResourcePool->releaseAlgorithm(algName,ialgoPtr);

                AlgsExecutionStates::State result = algResults[0];
                bool unanimous = true;
                for(uint i = 1; i < algResults.size(); ++i)
                    if(result != algResults[i])
                        unanimous = false;

                if(unanimous)
                    algStates.updateState(algIndex,result);
                else{
                    fatal() << "divergent algorithm execution" << endmsg;
                    fatal() << "Algorithm results: ";
                    for(uint i =0; i < algResults.size(); ++i){
                        fatal() << i << ": " << (algResults[i] ==  AlgsExecutionStates::State::EVTACCEPTED ? "A" : "R") << "\t";
                        if(algResults[i] ==  AlgsExecutionStates::State::EVTREJECTED){
                            //std::cerr << m_evtCtx_buffer[i]->m_evt_num << std::endl;
                        }
                    }
                    fatal() << endmsg;

                    sc = StatusCode::FAILURE;
                }
        }
        //});

        if(sc.isFailure())
            break; //abort execution of events, something went wrong

        m_controlFlow.updateEventState(algStates, nodeDecisions);
        m_controlFlow.promoteToControlReadyState(algStates, nodeDecisions);
    }
    for (EventContext* eventContext : m_evtCtx_buffer) {
        m_finishedEvents.push(eventContext);
    }

    m_evtCtx_buffer.clear();

    return sc; //TODO: define proper return value
}

StatusCode RoundRobinSchedulerSvc::pushNewEvent ( EventContext *  eventContext )

virtual

Make an event available to the scheduler.

Immediately the algortihms are executed.

Definition at line 90 of file RoundRobinSchedulerSvc.cpp.

                                                                         {

    // consistency check
    if (!m_freeSlots) {
        fatal() << "More contexts than slots provided" << m_freeSlots << endmsg;
        return StatusCode::FAILURE;
    }

    --m_freeSlots;
    m_evtCtx_buffer.push_back(eventContext);
    eventContext->setFail(false);

    return m_freeSlots > 0 ? StatusCode::SUCCESS : processEvents();
}

StatusCode RoundRobinSchedulerSvc::pushNewEvents ( std::vector< EventContext * > &  eventContexts )

virtual

Definition at line 105 of file RoundRobinSchedulerSvc.cpp.

                                                                                       {
    // consistency check
    if (eventContexts.size() > m_freeSlots) {
        fatal() << "More contexts than slots provided" << m_freeSlots << endmsg;
        return StatusCode::FAILURE;
    }
    m_freeSlots -= eventContexts.size();

    m_evtCtx_buffer.insert(m_evtCtx_buffer.end(), eventContexts.begin(), eventContexts.end());

    return m_freeSlots > 0 ? StatusCode::SUCCESS : processEvents();
}

StatusCode RoundRobinSchedulerSvc::tryPopFinishedEvent ( EventContext *&  eventContext )

virtual

Try to fetch an event from the scheduler.

Try to get a finished event, if not available just return a failure.

Definition at line 265 of file RoundRobinSchedulerSvc.cpp.

                                                                                 {
  if (m_finishedEvents.try_pop(eventContext)){
    debug() << "Try Pop successful slot " << eventContext->slot()
            << "(event " << eventContext->evt() << ")" << endmsg;
     m_freeSlots++;
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;

}

Member Data Documentation

std::list<IAlgorithm*> RoundRobinSchedulerSvc::m_algList

private

Cache the list of algs to be executed.

Definition at line 90 of file RoundRobinSchedulerSvc.h.

std::unordered_map<std::string,unsigned int> RoundRobinSchedulerSvc::m_algname_index_map

private

Map to bookkeep the information necessary to the name2index conversion.

Definition at line 84 of file RoundRobinSchedulerSvc.h.

std::vector<std::string> RoundRobinSchedulerSvc::m_algname_vect

private

Vector to bookkeep the information necessary to the index2name conversion.

Definition at line 81 of file RoundRobinSchedulerSvc.h.

std::vector<std::vector<std::string> > RoundRobinSchedulerSvc::m_algosDependencies

private

Ugly, will disappear when the deps are declared only within the C++ code of the algos.

Definition at line 87 of file RoundRobinSchedulerSvc.h.

SmartIF<IAlgResourcePool> RoundRobinSchedulerSvc::m_algResourcePool

private

Definition at line 75 of file RoundRobinSchedulerSvc.h.

concurrency::ExecutionFlowManager RoundRobinSchedulerSvc::m_controlFlow

private

Definition at line 78 of file RoundRobinSchedulerSvc.h.

std::vector<EventContext*> RoundRobinSchedulerSvc::m_evtCtx_buffer

private

Definition at line 97 of file RoundRobinSchedulerSvc.h.

tbb::concurrent_bounded_queue<EventContext*> RoundRobinSchedulerSvc::m_finishedEvents

private

Queue of finished events.

Definition at line 93 of file RoundRobinSchedulerSvc.h.

unsigned int RoundRobinSchedulerSvc::m_freeSlots

private

The number of free slots (0 or 1)

Definition at line 96 of file RoundRobinSchedulerSvc.h.

bool RoundRobinSchedulerSvc::m_useTopAlgList

private

Decide if the top alglist or its flat version has to be used.

Definition at line 74 of file RoundRobinSchedulerSvc.h.

---

The documentation for this class was generated from the following files:

• GaudiHive/src/RoundRobinSchedulerSvc.h
• GaudiHive/src/RoundRobinSchedulerSvc.cpp