inet::OscillatorBasedClock Class Reference

#include <OscillatorBasedClock.h>

Inheritance diagram for inet::OscillatorBasedClock:

Public Member Functions
virtual	~OscillatorBasedClock ()
virtual clocktime_t	computeClockTimeFromSimTime (simtime_t t) const override
	Returns the clock time for the specified future simulation time according to the current state of the clock. More...
virtual simtime_t	computeSimTimeFromClockTime (clocktime_t t) const override
	Returns the simulation time (first moment) for the specified future clock time according to the current state of the clock. More...
virtual void	scheduleClockEventAt (clocktime_t t, ClockEvent *event) override
	Schedules an event to be delivered to the caller module (i.e. More...
virtual void	scheduleClockEventAfter (clocktime_t delay, ClockEvent *event) override
	Schedules an event to be delivered to the caller module (i.e. More...
virtual ClockEvent *	cancelClockEvent (ClockEvent *event) override
	Cancels a previously scheduled clock event. More...
virtual void	handleClockEvent (ClockEvent *event) override
	Called by the clock event to be executed in the context of this clock. More...
virtual const char *	resolveDirective (char directive) const override
virtual void	receiveSignal (cComponent *source, int signal, cObject *obj, cObject *details) override
Public Member Functions inherited from inet::ClockBase
virtual clocktime_t	getClockTime () const override
	Returns the current clock time. More...
Public Member Functions inherited from inet::IClock
virtual	~IClock ()

Protected Member Functions
virtual void	initialize (int stage) override
Protected Member Functions inherited from inet::ClockBase
virtual int	numInitStages () const override
virtual void	finish () override
virtual void	refreshDisplay () const override
virtual void	updateDisplayString () const
cSimpleModule *	getTargetModule () const

Protected Attributes
IOscillator *	oscillator = nullptr
int64_t(*	roundingFunction )(int64_t, int64_t) = nullptr
int64_t	originClockTick = -1
std::vector< ClockEvent * >	events
Protected Attributes inherited from inet::ClockBase
clocktime_t	clockEventTime = -1
const char *	displayStringTextFormat = nullptr

Additional Inherited Members
Static Public Attributes inherited from inet::ClockBase
static simsignal_t	timeChangedSignal = cComponent::registerSignal("timeChanged")

Constructor & Destructor Documentation

~OscillatorBasedClock()

inet::OscillatorBasedClock::~OscillatorBasedClock ( )

virtual

{
    for (auto event : events)
        event->setClock(nullptr);
}

Member Function Documentation

cancelClockEvent()

ClockEvent * inet::OscillatorBasedClock::cancelClockEvent ( ClockEvent *  event )

overridevirtual

Cancels a previously scheduled clock event.

The clock event ownership is transferred to the caller.

Reimplemented from inet::ClockBase.

{
    events.erase(std::remove(events.begin(), events.end(), event), events.end());
    return ClockBase::cancelClockEvent(event);
}

Referenced by inet::SettableClock::handleOverdueClockEvent().

computeClockTimeFromSimTime()

clocktime_t inet::OscillatorBasedClock::computeClockTimeFromSimTime ( simtime_t  time ) const

overridevirtual

Returns the clock time for the specified future simulation time according to the current state of the clock.

This method implements a monotonic function with respect to the simulation time argument. It's allowed to return a different value for the same argument value if the clock is set between calls. The time argument must be greater than or equal to the current simulation time, otherwise an error is raised. See SIMTIME_AS_CLOCKTIME macro for simple type conversion.

Implements inet::IClock.

{
    ASSERT(t >= simTime());
    return ClockTime::from((originClockTick + oscillator->computeTicksForInterval(t - oscillator->getComputationOrigin())) * oscillator->getNominalTickLength());
}

computeSimTimeFromClockTime()

simtime_t inet::OscillatorBasedClock::computeSimTimeFromClockTime ( clocktime_t  time ) const

overridevirtual

Returns the simulation time (first moment) for the specified future clock time according to the current state of the clock.

This method implements a monotonic function with respect to the clock time argument. It's allowed to return a different value for the same argument value if the clock is set between calls. The time argument must be greater or than equal to the current clock time, otherwise an error is raised. See CLOCKTIME_AS_SIMTIME macro for simple type conversion.

Implements inet::IClock.

{
    ASSERT(t >= getClockTime());
    int64_t numTicks = t.raw() / oscillator->getNominalTickLength().raw();
    return oscillator->getComputationOrigin() + oscillator->computeIntervalForTicks(numTicks - originClockTick);
}

Referenced by receiveSignal(), and inet::SettableClock::setClockTime().

handleClockEvent()

void inet::OscillatorBasedClock::handleClockEvent ( ClockEvent *  event )

overridevirtual

Called by the clock event to be executed in the context of this clock.

This method is primarily useful for clock implementations to update their internal data structures related to individual clock events.

Reimplemented from inet::ClockBase.

{
    events.erase(std::remove(events.begin(), events.end(), event), events.end());
    ClockBase::handleClockEvent(event);
}

initialize()

void inet::OscillatorBasedClock::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::ClockBase.

Reimplemented in inet::SettableClock.

{
    ClockBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        auto oscillatorModule = getSubmodule("oscillator");
        oscillator = check_and_cast<IOscillator *>(oscillatorModule);
        oscillatorModule->subscribe(IOscillator::preOscillatorStateChangedSignal, this);
        oscillatorModule->subscribe(IOscillator::postOscillatorStateChangedSignal, this);
        const char *roundingMode = par("roundingMode");
        if (!strcmp(roundingMode, "up"))
            roundingFunction = roundUp;
        else if (!strcmp(roundingMode, "down"))
            roundingFunction = roundDown;
        else if (!strcmp(roundingMode, "closer"))
            roundingFunction = roundCloser;
        else if (!strcmp(roundingMode, "none"))
            roundingFunction = roundNone;
        else
            throw cRuntimeError("Unknown rounding mode");
        WATCH(originClockTick);
        WATCH_PTRVECTOR(events);
    }
    else if (stage == INITSTAGE_CLOCK) {
        simtime_t initialClockTime = par("initialClockTime");
        if (initialClockTime.raw() % oscillator->getNominalTickLength().raw() != 0)
            throw cRuntimeError("Initial clock time must be a multiple of the oscillator nominal tick length");
        originClockTick = initialClockTime.raw() / oscillator->getNominalTickLength().raw();
    }
}

Referenced by inet::SettableClock::initialize().

receiveSignal()

void inet::OscillatorBasedClock::receiveSignal ( cComponent *  source, int  signal, cObject *  obj, cObject *  details  )

overridevirtual

{
    Enter_Method("%s", cComponent::getSignalName(signal));
 
    if (signal == IOscillator::preOscillatorStateChangedSignal)
        originClockTick += oscillator->computeTicksForInterval(simTime() - oscillator->getComputationOrigin());
    else if (signal == IOscillator::postOscillatorStateChangedSignal) {
        simtime_t currentSimTime = simTime();
        for (auto event : events) {
            if (event->getRelative()) {
                simtime_t simTimeDelay = computeSimTimeFromClockTime(event->getArrivalClockTime()) - currentSimTime;
                ASSERT(simTimeDelay >= 0);
                cSimpleModule *targetModule = check_and_cast<cSimpleModule *>(event->getArrivalModule());
                cContextSwitcher contextSwitcher(targetModule);
                targetModule->rescheduleAfter(simTimeDelay, event);
            }
            else {
                clocktime_t arrivalClockTime = event->getArrivalClockTime();
                simtime_t arrivalSimTime = computeSimTimeFromClockTime(arrivalClockTime);
                ASSERT(arrivalSimTime >= currentSimTime);
                cSimpleModule *targetModule = check_and_cast<cSimpleModule *>(event->getArrivalModule());
                cContextSwitcher contextSwitcher(targetModule);
                targetModule->rescheduleAt(arrivalSimTime, event);
            }
        }
        emit(timeChangedSignal, CLOCKTIME_AS_SIMTIME(getClockTime()));
    }
}

resolveDirective()

const char * inet::OscillatorBasedClock::resolveDirective ( char  directive ) const

overridevirtual

Reimplemented from inet::ClockBase.

{
    static std::string result;
    switch (directive) {
        case 'o':
            result = std::to_string(originClockTick);
            break;
        case 'c':
            result = std::to_string(originClockTick + oscillator->computeTicksForInterval(simTime() - oscillator->getComputationOrigin()));
            break;
        default:
            return ClockBase::resolveDirective(directive);
    }
    return result.c_str();
}

scheduleClockEventAfter()

void inet::OscillatorBasedClock::scheduleClockEventAfter ( clocktime_t  delay, ClockEvent *  event  )

overridevirtual

Schedules an event to be delivered to the caller module (i.e.

the context module) after the given clock time delay has elapsed. The event is anchored to a specific clock time duration, so the actual simulation time when this event is executed is not affected if the clock time is set later. On the other hand, setting the clock drift still affects the simulation time of the event execution.

Reimplemented from inet::ClockBase.

{
    int64_t roundedDelay = roundingFunction(delay.raw(), oscillator->getNominalTickLength().raw());
    ClockBase::scheduleClockEventAfter(ClockTime().setRaw(roundedDelay), event);
    events.push_back(event);
}

scheduleClockEventAt()

void inet::OscillatorBasedClock::scheduleClockEventAt ( clocktime_t  time, ClockEvent *  event  )

overridevirtual

Schedules an event to be delivered to the caller module (i.e.

the context module) at the specified clock time. The event is anchored to a specific clock time value, so the actual simulation time when this event is executed will be affected if the clock time is set later.

Reimplemented from inet::ClockBase.

{
    int64_t roundedTime = roundingFunction(time.raw(), oscillator->getNominalTickLength().raw());
    ClockBase::scheduleClockEventAt(ClockTime().setRaw(roundedTime), event);
    events.push_back(event);
}

Member Data Documentation

events

std::vector<ClockEvent *> inet::OscillatorBasedClock::events

protected

Referenced by cancelClockEvent(), handleClockEvent(), initialize(), receiveSignal(), scheduleClockEventAfter(), scheduleClockEventAt(), inet::SettableClock::setClockTime(), and ~OscillatorBasedClock().

originClockTick

int64_t inet::OscillatorBasedClock::originClockTick = -1

protected

Referenced by computeClockTimeFromSimTime(), computeSimTimeFromClockTime(), initialize(), receiveSignal(), resolveDirective(), and inet::SettableClock::setClockTime().

oscillator

IOscillator* inet::OscillatorBasedClock::oscillator = nullptr

protected

Referenced by computeClockTimeFromSimTime(), computeSimTimeFromClockTime(), initialize(), receiveSignal(), resolveDirective(), scheduleClockEventAfter(), scheduleClockEventAt(), and inet::SettableClock::setClockTime().

roundingFunction

int64_t(* inet::OscillatorBasedClock::roundingFunction) (int64_t, int64_t) = nullptr

protected

Referenced by initialize(), scheduleClockEventAfter(), and scheduleClockEventAt().

---

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

• OscillatorBasedClock.h
• OscillatorBasedClock.cc