TimingSimulationEventSource.cpp

Go to the documentation of this file.

//Copyright GSI 2012
#include <fesa-core-gsi/RealTime/TimingSimulationEventSource.h>
#include <fesa-core-gsi/Synchronization/TimingSimulationContext.h>

#include <vector>
#include <fesa-core/Utilities/XMLParser.h>
#include <fesa-core/Diagnostic/FesaLogger.h>
#include <fesa-core/Utilities/ParserElements/EventElement.h>
#include <fesa-core/Utilities/ParserElements/ParserElementDefs.h>
#include <fesa-core/Diagnostic/Diagnostics.h>

#include <cmw-log/Logger.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
{
        TimingSimulationEventSource::SimulationEvent::SimulationEvent(std::string& className, CycleConfig& cycle, DomainConfig* domain, long absOff,long relativEventTimeInCycle, EventConfig* eventConfig) :
                delay_(0), absOffset_(absOff), nextEvent_(NULL),eventConfig_(eventConfig)
        {

                className_ = className;
                cycleID_ = cycle.cycleID_;
                cycleName_  = cycle.cycleName_;
                domainName_ = domain->name_;
                relativEventTimeInCycle_ = relativEventTimeInCycle;

                //TODO: extra condition-behaviour ... to be added later
//              if( cycle.telegramData_ != NULL)
//              {
//                      if(cycle.telegramData_->destination_ != "")
//                      {
//                              std::string temp = domain->name_ + ".DEST." + cycle.telegramData_->destination_;
//                              context->setExtraCondition(temp);
//                      }
//                      if(cycle.telegramData_->particleType_ != "")
//                      {
//                              std::string temp = domain->name_ + ".PARTY." + cycle.telegramData_->particleType_;
//                              context->setExtraCondition(temp);
//                      }
//                      if(cycle.telegramData_->spCon_ != "")
//                      {
//                              std::string temp = domain->name_ + ".SPCON." + cycle.telegramData_->spCon_;
//                              context->setExtraCondition(temp);
//                      }
//              }
        }

    TimingSimulationEventSource::TimingSimulationEventSource(const std::string& name,const std::string& timingSimulationConfigFile,fesa::EventSourceType type) : fesa::AbstractEventSource(name,type)
    {
        timingConfiguration_ = new TimingSimulationConfig(timingSimulationConfigFile);
        simulationEventSequence_ = NULL;
        eventSequenceBuild_ = false;
        fillEventCollection();
    }

    TimingSimulationEventSource::~TimingSimulationEventSource()
    {
        // loop on all the simulation events
        SimulationEvent * pEventSequence = simulationEventSequence_;
        while (pEventSequence)
        {
            SimulationEvent * pTmp = pEventSequence;
            pEventSequence = pEventSequence->nextEvent_;
            delete pTmp;
        }
        delete timingConfiguration_;
    }

    fesa::RTEvent* TimingSimulationEventSource::wait()
    {
                if (!eventSequenceBuild_)
                {
                        buildEventSequence();
                        currentEvent_ = simulationEventSequence_;
                        superCycleCount_ = timingConfiguration_->superCycleRepetition_;
                }

                while (superCycleCount_ != 0)
                {
                        if (currentEvent_->delay_)
                        { // else: no waiting if the delay is 0
                                time_t sec = currentEvent_->delay_ / 1000;
                                long long nsec = (currentEvent_->delay_ - sec * 1000) * 1000000;
                                //UNIX variants often use a kernel timer resolution (HZ value)
                                //of about 10ms. So it' not possible to manage delays less than 10ms
                                //to wait 10ms you need specify a delay 0 othewise your delay will b 20ms
                                nsec -= 10000000;
                                if (nsec < 0)
                                        nsec = 0;
                                struct timespec delay = { sec, nsec }; // ms -> {s, ns}
                                nanosleep(&delay, 0);
                        }

                        if (currentEvent_->nextEvent_ == NULL) // the last event in the sequence was reached
                        {
                                if(superCycleCount_ != -1)
                                        superCycleCount_--;
                                currentEvent_ = simulationEventSequence_;
                        }
                        else
                        {
                                currentEvent_ = currentEvent_->nextEvent_;
                        }

                        if (currentEvent_->className_ == "")//event is not registered for any class
                        {
                std::stringstream buf;
                std::ostringstream errorStrStream;
                errorStrStream << "| The execution of the event " << currentEvent_->eventConfig_->eventName_ << " was skipped, since there is no class in this fesa-equipment which is triggered by the event |";
                LOG_ERROR_IF(logger, errorStrStream.str());

                                throw GSIException(__FILE__,__LINE__,FesaGSIUnusedEventSkipped.c_str(),currentEvent_->eventConfig_->eventName_.c_str());
                        }

                        std::string fullEventname = currentEvent_->className_+"::"+currentEvent_->eventConfig_->eventName_;

                        //The MuxContext is deleted automatically after usage ... so we have to re-create it per event.
                        TimingSimulationContext *context = new TimingSimulationContext(currentEvent_->domainName_,currentEvent_->cycleID_, currentEvent_->cycleName_,currentEvent_->relativEventTimeInCycle_);

                        //set the actual cycle-timestamp (the "now"-stamp))
                        context->setCycleTimeStamp();

                        fesa::RTEvent * rtEvent = new fesa::RTEvent(fullEventname, context,this);
                        return rtEvent;
                }

                // timing simulation finished .. enter infinite sleep-loop
                struct timespec delay = { 20, 0 }; // 20sec. like the real timing
        std::stringstream buf;
        std::ostringstream errorStrStream;
        errorStrStream << "|Timing simulation finished. Running infinite sleep-loop now|";
        LOG_ERROR_IF(logger, errorStrStream.str());

                while(true)
                {
                        nanosleep(&delay, 0);
                }
    }

    void TimingSimulationEventSource::fillEventCollection()
    {
        std::vector<DomainConfig*>::iterator domainIter;
        std::vector<CycleConfig>::iterator cycleIter;
        std::vector<EventConfig*>::iterator eventIter;
        for (domainIter = timingConfiguration_->timingDomainCol_.begin(); domainIter != timingConfiguration_->timingDomainCol_.end(); domainIter++)
        {
                for(cycleIter = (*domainIter)->superCycle_.cycleCol_.begin(); cycleIter != (*domainIter)->superCycle_.cycleCol_.end(); cycleIter++)
                {
                        cycleIter->eventSequenceRef_->events_.begin();
                                for (eventIter = cycleIter->eventSequenceRef_->events_.begin(); eventIter != cycleIter->eventSequenceRef_->events_.end(); eventIter++)
                                {
                                        std::map<std::string, std::vector<std::string> >::iterator tempIter;
                                        tempIter = eventClassRelationCol_.find((*eventIter)->eventName_);
                                if (tempIter == eventClassRelationCol_.end())
                                {//not found --> is a new event --> add to map
                                        std::vector<std::string> vec;
                                        eventClassRelationCol_.insert(make_pair((*eventIter)->eventName_,vec));
                                }
                                }
                }
        }
    }

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

        // objectName are formatted like this:
        // "ClassName::BX.WCY200-CT#CTIM#202" or "ClassName::EX.SCY-MTG#LTIM#16 or ClassName::EX.SCY-MTG#LTIM-HARD#16"
        size_t pos= concreteEventName.find(':');
        std::string className = concreteEventName.substr(0, pos);
        std::string eventName = concreteEventName.substr(pos+2);

        std::map<std::string, std::vector<std::string> >::iterator iter;
        iter = eventClassRelationCol_.find(eventName);
        if (iter == eventClassRelationCol_.end())
        {//not found --> event is missing in TimingSimulation Config --> throw exception
                        throw GSIException(__FILE__,__LINE__,FesaGSIMissingEventConfiguration.c_str(),eventName.c_str());
        }
        else //event found --> add class
        {
            (*iter).second.push_back(className);
        }
    }

    void TimingSimulationEventSource::buildEventSequence()
    {
        long absStartCycleOffset = 0;

        // calculate super cycle length, it modifies the attribute superCycleLenght_
        computeSuperCycleLength();

        // check the timing simulation
        checkTimingSimulationConfig();

        std::vector<DomainConfig*>::iterator domainIter;
        for (domainIter = timingConfiguration_->timingDomainCol_.begin(); domainIter != timingConfiguration_->timingDomainCol_.end(); domainIter++)
        {
            if(!(*domainIter)->enable_)
                continue;//jump directly to next element

            absStartCycleOffset += (*domainIter)->superCycle_.shiftDelay_;

            std::vector<CycleConfig>::iterator cycleIter;
            for (cycleIter = (*domainIter)->superCycle_.cycleCol_.begin(); cycleIter != (*domainIter)->superCycle_.cycleCol_.end(); cycleIter++)
            {
                std::vector<EventConfig*>::iterator eventIter;
                for (eventIter = cycleIter->eventSequenceRef_->events_.begin(); eventIter != cycleIter->eventSequenceRef_->events_.end(); eventIter++)
                {
                    createSimulationEvent(*eventIter, absStartCycleOffset, *cycleIter, *domainIter);

                }// loop on the events

                absStartCycleOffset += cycleIter->basicPeriodMultiple_ * timingConfiguration_->basicPeriodLengthMs_;

                if (absStartCycleOffset > superCycleLength_)
                    absStartCycleOffset = absStartCycleOffset - superCycleLength_;
            } // end loop on cycles

            computeDelays();
        }// end loop on timing domains

        eventSequenceBuild_ = true;
    }

    void TimingSimulationEventSource::insertSorted(SimulationEvent * newEvent)
    {
        if (simulationEventSequence_ == NULL)// still empty?
        {
            simulationEventSequence_ = newEvent;
            return;
        }

        if (newEvent->absOffset_ <= simulationEventSequence_->absOffset_)// we have to replace the head?
        {
                newEvent->nextEvent_ = simulationEventSequence_;
            simulationEventSequence_ = newEvent;
            return;
        }

        SimulationEvent * temp = simulationEventSequence_->nextEvent_;
        SimulationEvent * prev = simulationEventSequence_;
        while(temp!= NULL)
        {
                if(newEvent->absOffset_ <= temp->absOffset_)
                {//insert here
                newEvent->nextEvent_ = temp;
                prev->nextEvent_ = newEvent;
                return;
                }
                else
                {//next one
                prev = temp;
                temp = temp->nextEvent_;
                }
        }
        prev->nextEvent_ = newEvent;//if we reach the end, we just put it there
    }

    // compute the delays for each event from the previous one after having built the entire sequence
    void TimingSimulationEventSource::computeDelays()
    {
        long prevOffset = 0;
        SimulationEvent * pEvent = simulationEventSequence_;
        while (pEvent)
        {
            pEvent->delay_ = pEvent->absOffset_ - prevOffset;
            prevOffset = pEvent->absOffset_;
            pEvent = pEvent->nextEvent_;
        }
    }

    void TimingSimulationEventSource::computeSuperCycleLength()
    {
        long maxSuperCycleLenght = 0; // the number of basic periods

        std::vector<DomainConfig*>::iterator timingDomainColIter;
        for (timingDomainColIter = timingConfiguration_->timingDomainCol_.begin(); timingDomainColIter != timingConfiguration_->timingDomainCol_.end(); timingDomainColIter++)
        {
            if(!(*timingDomainColIter)->enable_)
                continue;//jump directly to next element

            std::vector<CycleConfig>::iterator cycleColIter;
            for (cycleColIter = (*timingDomainColIter)->superCycle_.cycleCol_.begin();cycleColIter!=(*timingDomainColIter)->superCycle_.cycleCol_.end();cycleColIter++)
            {
                maxSuperCycleLenght += cycleColIter->basicPeriodMultiple_;
            }
        }// end loop on domains
        superCycleLength_ = maxSuperCycleLenght * timingConfiguration_->basicPeriodLengthMs_;
    }

    void TimingSimulationEventSource::checkTimingSimulationConfig()
    {
        int scShiftDelayFlag = 0; // In case of multiple domain, only one of them must have shiftDelay 0
        bool enabledDomainON = false; // At least one domain should be enabled ON

        std::vector<DomainConfig*>::iterator domainColIter;
        for (domainColIter = timingConfiguration_->timingDomainCol_.begin(); domainColIter != timingConfiguration_->timingDomainCol_.end(); domainColIter++)
        {
            if(!(*domainColIter)->enable_)
                continue;//jump directly to next element

            enabledDomainON |= (*domainColIter)->enable_;

            // count how many delays are equal to 0
            if ((*domainColIter)->superCycle_.shiftDelay_ == 0)
                scShiftDelayFlag++;

            long absStartCycleOffset = (*domainColIter)->superCycle_.shiftDelay_;

            std::vector<CycleConfig> cycleCol = (*domainColIter)->superCycle_.cycleCol_;
            long lastCycleLength = cycleCol.end()->basicPeriodMultiple_;
            long prevStartCycleOffset = (*domainColIter)->superCycle_.shiftDelay_ + superCycleLength_
                            - lastCycleLength * timingConfiguration_->basicPeriodLengthMs_;
            if (prevStartCycleOffset > superCycleLength_)
                prevStartCycleOffset = prevStartCycleOffset - superCycleLength_;

                std::vector<CycleConfig>::iterator cycleIter;
                std::vector<EventConfig*>::iterator eventIter;
                for(cycleIter= cycleCol.begin();cycleIter!= cycleCol.end();cycleIter++)
                {
                        for(eventIter=cycleIter->eventSequenceRef_->events_.begin();eventIter!=cycleIter->eventSequenceRef_->events_.end();eventIter++)
                        {
                                if((*eventIter)->type_ == EventBurst)
                                {
                                        EventBurstConfig* burstElement = static_cast<EventBurstConfig*> (*eventIter);

                                                for (unsigned long m = burstElement->occurrences_; m > 0; m--)
                                                {
                                                        long eventAbsOffset = absStartCycleOffset + burstElement->delay_
                                                                                        + (burstElement->occurrences_ - m) * burstElement->period_;

                                                        if (eventAbsOffset < 0)
                                                                eventAbsOffset = eventAbsOffset + superCycleLength_;

                                                        long cycleEnd = absStartCycleOffset + cycleIter->basicPeriodMultiple_ * timingConfiguration_->basicPeriodLengthMs_;

                                                        if (((burstElement->delay_ > 0) && (eventAbsOffset > cycleEnd)) || ((burstElement->delay_ < 0) && (eventAbsOffset < prevStartCycleOffset)))
                                                        {
                                                                std::stringstream buf;
                                                                buf << burstElement->delay_;
                                                                throw GSIException(__FILE__,__LINE__,FESAGSIErrorEventDelayOutOfRange.c_str(),
                                                                                                burstElement->eventName_.c_str(), cycleIter->cycleName_.c_str(),
                                                                                                buf.str().c_str());
                                                        }
                                                }// end occurrences loop
                                }// end if event is burst
                        }// end loop on events
                }// end loop cycles

            if (enabledDomainON == false)
                        throw GSIException(__FILE__,__LINE__,FESAGSIErrorNoneDomainEnabled.c_str());

            if (scShiftDelayFlag > 1)
                throw GSIException(__FILE__,__LINE__,FESAGSIErrorMoreThanOneDomainShift0.c_str());
        }// end loop domains
    }

    void TimingSimulationEventSource::createSimulationEvent(EventConfig *config, long absStartCycleOffset, CycleConfig& cycle, DomainConfig* domain)
       {
           long eventPeriod = 0;
           unsigned long eventOccurence = 1;

           EventBurstConfig* burstElement = NULL;
           if (config->type_ == EventBurst)
           {
               burstElement = static_cast<EventBurstConfig*> (config);
               eventOccurence = burstElement->occurrences_;
               eventPeriod = burstElement->period_;
           }

           for (unsigned i = eventOccurence; i > 0; i--)
           { // only in case of "burst" this value can be bigger than 1
               long eventAbsOffset = absStartCycleOffset + config->delay_ + (eventOccurence - i) * eventPeriod;
               long relativEventTimeInCycle = config->delay_+ (eventOccurence - i) * eventPeriod;
               // checking whether the delay specified is within the current cycle or the previous one in case negative one:
               if (eventAbsOffset < 0)
                   eventAbsOffset = eventAbsOffset + superCycleLength_;
               else if (eventAbsOffset > superCycleLength_)
               {
                   eventAbsOffset = eventAbsOffset - superCycleLength_;
               }

               //Check if event is used by Fesa-Equipment (connect triggered)
               std::map<std::string, std::vector<std::string> >::iterator iter;
               iter = eventClassRelationCol_.find(config->eventName_);
               if (iter->second.size() != 0)
               {//there are classes, using this sim-event
                           std::vector<std::string>::iterator classIter;
                           for(classIter = iter->second.begin();classIter != iter->second.end();classIter++)
                           {
                                   //multiply event for each class which needs it
                                   SimulationEvent * simEvent = new SimulationEvent(*classIter,cycle,domain, eventAbsOffset,relativEventTimeInCycle,config);
                                   insertSorted(simEvent);
                           }
               }
               else//no classes defined to use this event
               {
                   //event added anyway (without classname) ... error will be thrown later, on execution of the unused event
                   std::string empty = "";
                   SimulationEvent * simEvent = new SimulationEvent(empty,cycle,domain, eventAbsOffset,relativEventTimeInCycle,config);
                   insertSorted(simEvent);
               }
           }
       }
}//end namespace