TimingEventSource.cpp

Go to the documentation of this file.

//Copyright GSI 2012
#include <sstream>
#include <fstream>
#include <malloc.h>
#include <sys/time.h>


#include <fesa-core-gsi/RealTime/TimingEventSource.h>
#include <fesa-core-gsi/RealTime/TimingPayload.h>
#include <fesa-core-gsi/Synchronization/TimingContext.h>
#include <fesa-core-gsi/Exception/FesaGSIExceptionDef.h>
#include <fesa-core-gsi/Synchronization/GSICycleDescriptor.h>
#include <fesa-core/Core/FesaDefs.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Utilities/ParserElements/EventElement.h>
#include <fesa-core/Utilities/ParserElements/ParserElementDefs.h>
#include <cmw-log/Logger.h>
#include <fesa-core/Diagnostic/Diagnostics.h>
#include <math.h>

namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core-gsi.RealTime.TimingEventSource");
const std::string diagTopic = fesa::DiagnosticUtils::eventTrackingStr;

} // namespace

namespace fesaGSI
{
    int TimingEventSource::ourDebugOptions_;
    int TimingEventSource::LTIM_HARD_ID_TRANS = -1;

    TimingEventSource::TimingEventSource() :
        fesa::AbstractEventSource(fesa::TIMING_EVENT_SOURCE_NAME, fesa::TimingSource)
    {
        ourDebugOptions_ = getDebugOptions();

        fd_ = TimLibFdInitialize(TimLibDevice_ANY);
        if (fd_ == 0)
        {
            char* ignore = getenv("TimingEventSource_IgnoreHardware");
            if (!ignore)
            {
                throw GSIException(__FILE__, __LINE__, FESAGSIErrorInitializingTimLib.c_str());
            }
        }
        // Set EventQueueing ON and no timeout
        TimLibFdQueue(fd_, 0, 0);

    }

    unsigned int TimingEventSource::getDebugOptions()
    {
        char* debugStr = getenv("TimingEventSource_DebugOptions");

        if (!debugStr)
        {
            return 0;
        }

        debugStr += strspn(debugStr, " \t"); /* skip white space */

        // we support hex format but not octal, hence strip leading zero's
        while (debugStr[0] == '0' && (debugStr[1] != 'x' && debugStr[1] != 'X' && debugStr[1] != '\0'))
        {
            debugStr += 1;
        }
        return strtol(debugStr, 0, 0);
    }

    TimingEventSource::~TimingEventSource()
    {
    }

    fesa::RTEvent* TimingEventSource::wait()
    {
        TimLibError err;
        TimLibClass t_class; /* Class of interrupt */
        unsigned long equip; /* PTIM CTIM or hardware mask */
        unsigned long plnum; /* Ptim line number 1..n or 0 */
        TimLibHardware source; /* Hardware source of interrupt */
        TimLibTime trigger; /* Time of counters load */
        TimLibTime start; /* Time of counters start */
        unsigned long ctim; /* CTIM trigger equipment ID */
        unsigned long module = 0; /* Module that interrupted */
        unsigned long missed = 0; /* Number of missed interrupts */
        unsigned long qsize = 0; /* Remaining interrupts on queue */
        TgmMachine tgmMachine;
        // This loop is necessary in case of error on TimLib call. For errors other
        // than TimLibTIMEOUT we have to insert our own delay to avoid to loop
        // in TimLibCall very fast consuming all CPU time.
        for (;;)
        {
            fesaGSI::TimingContext* tc = 0;
            fesa::RTEventPayload * pTimingPayload = 0;
            fesa::RTEvent* theEvent = 0;

            TimLibTime interruptStamp;
            unsigned long payload;

            try
            {

                err = TimLibFdWait(fd_, &t_class, &equip, &plnum, &source, &interruptStamp, &trigger, &start, &ctim,
                                &payload, &module, &missed, &qsize, &tgmMachine);

                if (err == TimLibErrorTIMEOUT)
                {
                    //FWK_LOGERROR(ERROR) << "TimingEventSource::wait() TimLibWait returns: " << TimLibErrorToString(err) << endl;
                    continue; // try again
                }
                // It's not a TimeOUT : so display the error and insert a sleep
                // to avoid to fall again immedialtely into the TimLibWait and
                // consume all CPU time.
                else if (err != 0)
                {
                    //FWK_LOGERROR(ERROR) << "TimingEventSource::wait() TimLibWait returns: " << TimLibErrorToString(err) << endl;
                    struct timespec retryDelay = { 2, 0 };
                    struct timespec time_left_before_wakeup;
                    nanosleep(&retryDelay, &time_left_before_wakeup);
                    continue; // try again
                }
                const boost::shared_ptr<fesa::Diagnostics>& diagnostics = fesa::AbstractEquipment::getInstance()->getDiagnostics();
                fesa::DiagnosticUtils::DiagnosticMessage diagMsg;
                diagMsg.side = fesa::DiagnosticUtils::framework;
                diagMsg.source = fesa::DiagnosticUtils::event;
                diagMsg.name = getName();
                diagMsg.msg = "TimLibWait wake-up";
                diagnostics->log(diagTopic, diagMsg);
                // Checking if event was previously registered and retrieving stored information about the event.
                TimingInfo timingInfo;

                if (t_class == TimLibClassCTIM)
                {

                    std::map<int, TimingInfo>::iterator itr = ctimEventsCol_.find(equip);

                    if (itr == ctimEventsCol_.end())
                    {
                        std::stringstream buf;
                        std::ostringstream errorStrStream;
                        errorStrStream << "ERROR: TiminEventSource::wait : received an unexpected event identified by TimingClass";
                        LOG_ERROR_IF(logger, errorStrStream.str());
                        continue;
                    }
                    else
                    {
                        timingInfo = (*itr).second;
                    }
                }
                else if (t_class == TimLibClassPTIM)
                {
                    std::map<int, TimingInfo>::iterator itr = ltimEventsCol_.find(equip);

                    if (itr == ltimEventsCol_.end())
                    {
                        std::stringstream buf;
                        std::ostringstream errorStrStream;
                        errorStrStream << "ERROR: TiminEventSource::wait : received an unexpected event identified by TimingClass";
                        LOG_ERROR_IF(logger, errorStrStream.str());
                        continue;
                    }
                    else
                    {
                        timingInfo = (*itr).second;
                    }
                }
                else if (t_class == TimLibClassHARDWARE)
                {
                    TimingKey key(equip, module);

                    std::map<TimingKey, TimingInfo>::iterator itr = ltimHardEventsCol_.find(key);

                    if (itr == ltimHardEventsCol_.end())
                    {
                        std::stringstream buf;
                        std::ostringstream errorStrStream;
                        errorStrStream << "ERROR: TiminEventSource::wait : received an unexpected event identified by TimingClass";
                        LOG_ERROR_IF(logger, errorStrStream.str());
                        continue;
                    }
                    else
                    {
                        timingInfo = (*itr).second;
                    }

                }

                interruptStamp.Machine = tgmMachine;

                pTimingPayload = new TimingPayload(payload);
                fesaGSI::TimingContext* context = new fesaGSI::TimingContext(interruptStamp, payload, timingInfo.forewarning_);
                theEvent = new fesa::RTEvent(timingInfo.concreteName_, context, this);
                // Everything is fine goes out the infinite loop and fires the event

                diagMsg.msg = "Send RT event";
                diagnostics->log(diagTopic, diagMsg);

                return theEvent;
            }
            catch (fesa::FesaException& ex)//this also covers FESACERNExceptions
            {
                if (tc != 0)
                    delete tc;
                if (pTimingPayload != 0)
                    delete pTimingPayload;
                if (theEvent != 0)
                    delete theEvent;

                std::stringstream buf;
                std::ostringstream errorStrStream;
                errorStrStream << "Event was not fired because the following exception occured: " << ex.getMessage();
                LOG_ERROR_IF(logger, errorStrStream.str());
            }
            catch (...)
            {
                if (tc != 0)
                    delete tc;
                if (pTimingPayload != 0)
                    delete pTimingPayload;
                if (theEvent != 0)
                    delete theEvent;

                std::stringstream buf;
                std::ostringstream errorStrStream;
                errorStrStream << "Event was not fired becausean unknown exception occured.";
                LOG_ERROR_IF(logger, errorStrStream.str());
            }
        }
    }

    void TimingEventSource::connect(boost::shared_ptr<fesa::EventElement>& eventElement)
    {
        std::string concreteEventName = eventElement->getSourceTypeSpecificData(fesa::TIMING_TAG_CONCRETE_NAME);

        // concreteEventName is formatted like this:
        // "BX.WCY200-CT#CTIM#202" or "EX.SCY-MTG#LTIM#16 or EX.SCY-MTG#LTIM-HARD#16"
        TimLibClass theTimLibClass;
        //size_t posSep0= concreteEventName.find(':');
        size_t posSep1 = concreteEventName.find('#');
        size_t posSep2 = concreteEventName.rfind('#', concreteEventName.size());
        if (posSep1 == std::string::npos || posSep2 == std::string::npos)
        {
            throw GSIException(__FILE__, __LINE__, FESAGSIErrorWrongTimingName.c_str(), concreteEventName.c_str());
        }

        //std::string objectClassName = concreteEventName.substr(posSep0+2, posSep1);
        std::string objectClassName = concreteEventName.substr(posSep1 + 1, posSep2 - posSep1 - 1);
        if (objectClassName == "CTIM")
        {
            theTimLibClass = TimLibClassCTIM;
        }
        else if (objectClassName == "LTIM")
        {
            theTimLibClass = TimLibClassPTIM;
        }
        else if (objectClassName == "LTIM-HARD")
        {
            theTimLibClass = TimLibClassHARDWARE;
        }
        else
        {
            throw GSIException(__FILE__, __LINE__, FESAGSIErrorUnknownTimingObjectClassName.c_str(),
                            concreteEventName.c_str());
        }

        int connectionId = -1;
        std::string idStr = concreteEventName.substr(posSep2 + 1);
        const char* pStr = idStr.c_str();
        if (pStr[0] == '0' && (pStr[1] == 'x' || pStr[1] == 'X'))
        {
            connectionId = strtol(pStr + 2, 0, 16);
        }
        else
        {
            connectionId = atol(pStr);
        }

        // By default we use module 0 means the system will decide which device to use
        unsigned long module = 0;
        //      // In case of LTIM-HARD the connectionId is the hardware mask which is computed from the channel(2^channel).
        //      // So we keep the original connectionId into equipId because in any case TimLibWait returns original connectionId
        //      int equipId = connectionId;
        // In case of TimLibClassHARDWARE: we have to retrieve the ptimObject using the connectionId
        if ((theTimLibClass == TimLibClassPTIM) || (theTimLibClass == TimLibClassHARDWARE))
        {
            unsigned long m; // module
            unsigned long c; // channel
            unsigned long d; // dimension
            TimLibError err = TimLibGetPtimObject(connectionId, &m, &c, &d);
            if (err != 0)
            {
                throw GSIException(__FILE__, __LINE__, FESAGSIErrorWhileGettingTimingObject.c_str(),
                                concreteEventName.c_str());
            }

            // compute the hw mask and overwite connectionId
            if (theTimLibClass == TimLibClassHARDWARE)
            {
                connectionId = (unsigned long) (pow(2, c));
            }
            // overwite the module
            module = m;
        }
        else if (theTimLibClass == TimLibClassCTIM)
        {
            module = TimLibGetModuleForCtim(connectionId);
        }

        int equipId = connectionId;
        if (theTimLibClass == TimLibClassHARDWARE)
        {
            equipId *= LTIM_HARD_ID_TRANS;
        }

        TimLibError err = TimLibFdConnect(fd_, theTimLibClass, connectionId, module);
        if (err != 0)
        {
            throw GSIException(__FILE__, __LINE__, FESAGSIErrorWhileConnectingTimingEvent.c_str(),
                            concreteEventName.c_str());
        }

        std::stringstream buf;
        std::ostringstream errorStrStream;
        errorStrStream << "TimLibConnect: " << concreteEventName << " : theTimLibClass: " << theTimLibClass << " : connectionId: " << connectionId << " : module: " << module;
        LOG_ERROR_IF(logger, errorStrStream.str());

        TimingInfo timingInfo;

        timingInfo.concreteName_ = concreteEventName;
        timingInfo.forewarning_ = false;

        if (objectClassName == "CTIM")
        {
            ctimEventsCol_.insert(std::make_pair(connectionId, timingInfo));
        }
        else if (objectClassName == "LTIM")
        {
            ltimEventsCol_.insert(std::make_pair(connectionId, timingInfo));
        }
        else if (objectClassName == "LTIM-HARD")
        {
            TimingKey key(connectionId, module);
            ltimHardEventsCol_.insert(std::make_pair(key, timingInfo));
        }

        return;
    }

}//end namespace