Timing.cpp

Go to the documentation of this file.

//Copyright GSI 2012
#include <fesa-core/Synchronization/Timing.h>
#include <fesa-core-gsi/Exception/GSIException.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Synchronization/SynchronizationLabObjectFactory.h>
#include <fesa-core-gsi/Synchronization/GSICycleDescriptor.h>
#include <fesa-core-gsi/Exception/GSIException.h>
extern "C"
{
#include <tim/TimLib.h>
}

#include <sys/time.h>

#include <math.h>
#include <string>
#include <iostream>
#include <sstream>

namespace fesa
{

void parseCycleSelector(const std::string& cycleSelector,
                fesa::CycleSelector& cycleSelectorStructure) {

        std::size_t sep1 = cycleSelector.find('.');
        if (sep1 == std::string::npos) {
                throw fesaGSI::GSIException(__FILE__, __LINE__, FESAGSIErrorParsingTimingDescriptor.c_str(),
                                cycleSelector.c_str());
        }
        cycleSelectorStructure.domain_ = cycleSelector.substr(0, sep1);

        std::size_t sep2 = cycleSelector.find('.', sep1 + 1);
        // In case of multiplexing manager names: PSB.USER
        // but in case of extra-criterions: PSB.PARTY.PROT
        if (sep2 == std::string::npos) {
                sep2 = cycleSelector.size();
        }

        cycleSelectorStructure.criterion_ = cycleSelector.substr(sep1 + 1, sep2
                        - sep1 - 1);
        cycleSelectorStructure.value_ = cycleSelector;

}

void validateCycleSelector(fesa::CycleSelector& cycleSelector,
                fesa::RequestType requestType) {
        if (requestType == fesa::SUBSCRIBE) {
                // check if the cycleSelector is using valid group: exclusif or numerical but not bit-pattern
                //            fesa::CycleDescriptor* td = fesa::CycleDescriptor::getCycleDescriptor(cycleSelector.domain_, cycleSelector.criterion_);
                //            fesaGSI::GSICycleDescriptor* ctd = static_cast<fesaGSI::GSICycleDescriptor*>(td);
                //TODO CycleDescriptor should implement getGroupType: Exclusif, numerical, bitpattern
                //            if(ctd->getGroupType() == bitpattern)
                //                throw fesaCERN::CERNException(__FILE__, __LINE__, FesaErrorTimingLibAccessFailed.c_str());
        }
}

bool match(const std::string& cycleSelector, fesa::MultiplexingContext* context) {
        if (cycleSelector.empty()) {
                return true;
        }

        size_t sep1 = cycleSelector.find('.');
        size_t sep2 = cycleSelector.rfind('.');
        if ((sep1 == std::string::npos) || (sep2 == std::string::npos)) {
                return false;
        }

        std::string machineName = cycleSelector.substr(0, sep1 - 1);
        std::string groupName = cycleSelector.substr(sep1 + 1, sep2 - sep1 - 1);
        std::string lineName = cycleSelector.substr(sep2 + 1,
                        cycleSelector.length() - sep2 - 1);

        if (groupName == "USER") {
                if (!(context->getCycleName().empty())) {
                        if ((cycleSelector != context->getCycleName())) {
                                return false;
                        }
                }
        } else {
                // Checking timingDomain
                if (machineName.compare(context->getTimingDomainName()) != 0) {
                        return false;
                }

                // Getting the CycleDescriptor of the given group in order to find out the group number and line number
                fesa::SynchronizationLabObjectFactory* syncFactory = fesa::SynchronizationLabObjectFactory::getInstance();
        fesaGSI::GSICycleDescriptor* pCd =  static_cast<fesaGSI::GSICycleDescriptor*>(syncFactory->getCycleDescriptor(machineName, groupName));

                unsigned long groupNumber = (unsigned long) pCd->getTgmGroupId();
                unsigned long lineNumber = (unsigned long) pCd->getCycleSelectorId(
                                lineName);

                // Getting the current group value for the given lineName
                unsigned long lineValueFromTiming;
                unsigned long next = 0; //TODO = (anticipated_) ? 1 : 0;
                TimLibError err;
                TimLibTime time;
                time.Second = (long long) (round(context->getCycleStamp()
                                / (long long) 1000000000));
                time.Nano = context->getCycleStamp() - time.Second;

                if ((err = TimLibGetGroupValueFromStamp(time, groupNumber, next,
                                &lineValueFromTiming)) == TimLibErrorSUCCESS) {
                        if (lineNumber != lineValueFromTiming) {
                                return false;
                        }
                } else //Error from timing library
                {
                        //TODO ERRLOG
            throw fesaGSI::GSIException(__FILE__, __LINE__, FesaErrorTimingLibAccessFailed.c_str());
                        return false;
                }
        }
        return true;
}

long long getActualTime(bool& isHwTime) {
        TimLibTime hwtime;
        TimLibError err = TimLibGetTime(0, &hwtime);

        if (!err) {
                isHwTime = true;
                return (hwtime.Second * (long long) 1000000000 + hwtime.Nano);
        } else {
                isHwTime = false;
                struct timeval now;
                gettimeofday(&now, 0);
                return (now.tv_sec * (long long) 1000000000 + now.tv_usec
                                * (long long) 1000);
        }
}

std::string getTimeString(long long time, char* format) {

        if (time == 0) {
                bool isHwTime;
                time = getActualTime(isHwTime);
        }

        int seconds = time / (long long) 1000000000;
        int nanos = time - (long long) 1000000000 * seconds;

        char timestring[32];
        strftime(timestring, sizeof(timestring), format, localtime(
                        (time_t *) &seconds));

        //ostringstream ost; // this crashes, so we code it with stringbuf and ostream
        std::stringbuf stb("", std::ios::out);
        std::ostream ost(&stb);

        ost << timestring << ".";
        ost.width(6);
        ost.fill('0');
        ost << nanos / 1000;

        return stb.str();
}

int getCycleTime() {
        // Force systematically an initialization because it can be call
        // from a ServerAction....
        TimLibError err = TimLibInitialize(TimLibDevice_ANY);
        if (err != 0) {
                std::cout << "Timing::getCycleTime() error: " << TimLibErrorToString(err)
                                << std::endl;
                return -1;
        }
        TimLibTime hwtime;
        err = TimLibGetTime(0, &hwtime);

        if (!err)
                return hwtime.CTrain;
        return -1;
}
}