TimerEventSource.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/RealTime/TimerEventSource.h>

#include <fesa-core/RealTime/RTEvent.h>
#include <fesa-core/Synchronization/NoneContext.h>
#include <fesa-core/Utilities/ParserElements.h>
#include <fesa-core/Utilities/ParserElements/TimerEventElement.h>
#include <fesa-core/Utilities/ParserElements/ParserElementDefs.h>
#include <sstream>

#include <cmw-log/Logger.h>

#include <climits>
#include <cerrno>
#include <ostream>

namespace
{
CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.RealTime.TimerEventSource");
}

namespace fesa
{
/*
 * \class TimerEventSource
 * \brief TimerEventSource is a particular event-source which requires a dedicated source
 * per concrete-event. This choice greatly simplifies the multiple period handling
 * by instantiating one thread per timer period, means per timer concrete-event.
 * This specific implementation is under responsability of the TimerEventSource class.
 * From outside point of view, only one Timer event-source is defined and accessible.
 * TIMER_EVENT_SOURCE_NAME/ DEFAULT_EVENT_SOURCE_KEY
 *
 * This mechanism requires to override the addRTScheduler method in order to register
 * the scheduler within the appropriate occurence of the timer event-source.
 */

TimerEventSource::TimerEventSource() :
    AbstractEventSource(TIMER_EVENT_SOURCE_NAME, TimerSource),
    totalDelay_(0)
{
}

TimerEventSource::~TimerEventSource()
{
}

void TimerEventSource::connect(boost::shared_ptr<fesa::EventElement>& eventElement)
{
    int32_t period;
        std::stringstream converterStream(eventElement->getSourceTypeSpecificData(TIMER_TAG_PERIOD));
        converterStream >> period;

    if (period == 0)
    {
        throw FesaBadParameterException(__FILE__, __LINE__, FesaErrorWrongTimerPeriod.c_str(), eventElement->getLogicalName().c_str());
    }
    //add info to the vectors
    eventNamesCol_.push_back(eventElement->getConcreteName());
    eventDelaysCol_.push_back(period);
    eventTotalDelaysCol_.push_back(period);
    eventsFired_.push_back(0);
}

RTEvent* TimerEventSource::wait()
{
    if (eventsToFire_.size() > 0)
    {
        return fireNextEvent();
    }
    struct timespec thePeriod;

    int64_t minimum = LLONG_MAX;
    int64_t period = 0;
    // find the closest event to fire
    for (uint32_t i = 0; i < eventTotalDelaysCol_.size(); i++)
    {
        if ((eventTotalDelaysCol_[i] - totalDelay_) < minimum)
        {
            minimum = eventTotalDelaysCol_[i] - totalDelay_;
            period = eventTotalDelaysCol_[i] - totalDelay_;
            
            while (eventsToFire_.size() > 0)
            {
                eventsToFire_.pop_front();
            }
            
            eventsToFire_.push_back(i);
        }
    }

    // update global table
    totalDelay_ += period;
    for (uint32_t i = 0; i < eventsToFire_.size(); i++)
    {
        eventTotalDelaysCol_[eventsToFire_[i]] += eventDelaysCol_[eventsToFire_[i]];
    }
    
    int32_t sec = static_cast<int32_t>(period) / 1000; // number of seconds since period is expressed in ms
    int32_t nsec = 0;
    if ((nsec = static_cast<int32_t>(period) % 1000)) // check remainder
    {
        nsec *= (int32_t) 1E6; // convert remainder into ns
    }
    thePeriod.tv_sec = sec;
    thePeriod.tv_nsec = nsec;
    int32_t ret;
    do
    {
        ret = nanosleep(&thePeriod, &thePeriod);
    }
    while ((ret == -1) && (errno == EINTR)); // check if interrupted by a signal

    return fireNextEvent();
}

RTEvent* TimerEventSource::fireNextEvent()
{
    int32_t eventIndex = eventsToFire_.front();
    eventsToFire_.pop_front();
    RTEvent* rtEvt = new RTEvent(eventNamesCol_[eventIndex], new NoneContext(), this);
    eventsFired_[eventIndex]++;
    if (logger.isLoggable(CMW::Log::Level::LL_TRACE))
    {
        std::ostringstream msg;
        msg << "firing event " << eventNamesCol_[eventIndex];
        LOG_TRACE_IF(logger, msg.str());
    }
    return rtEvt;
}

} // fesa