inet::RealTimeScheduler Class Reference

This class implements the event scheduler interface of OMNeT++ to provide a real time scheduling mechanism. More...

#include <RealTimeScheduler.h>

Inheritance diagram for inet::RealTimeScheduler:

Classes
class	BeginSimulationEvent
class	Entry
class	ICallback

Public Member Functions
	RealTimeScheduler ()
virtual	~RealTimeScheduler ()
void	addCallback (int fd, ICallback *callback)
	To be called from the module which wishes to receive data from the fd. More...
void	removeCallback (int fd, ICallback *callback)
virtual void	startRun () override
	Called at the beginning of a simulation run. More...
virtual void	endRun () override
	Called at the end of a simulation run. More...
virtual void	executionResumed () override
	Recalculates "base time" from current wall clock time. More...
virtual cEvent *	guessNextEvent () override
	Returns the first event in the Future Event Set. More...
virtual cEvent *	takeNextEvent () override
	Scheduler function – it comes from the cScheduler interface. More...
virtual void	putBackEvent (cEvent *event) override
	Scheduler function – it comes from the cScheduler interface. More...

Public Attributes
int64_t	baseTime = 0

Protected Member Functions
virtual void	advanceSimTime ()
virtual bool	receiveWithTimeout (int64_t timeout)
virtual int	receiveUntil (int64_t targetTime)

Protected Attributes
std::vector< Entry >	callbackEntries

Detailed Description

This class implements the event scheduler interface of OMNeT++ to provide a real time scheduling mechanism.

The events are scheduled so that the events are executed according to the time of the underlying operating system. All time values are measured in nanoseconds.

Constructor & Destructor Documentation

RealTimeScheduler()

inet::RealTimeScheduler::RealTimeScheduler

(

)

                                     : cScheduler()
{
}

~RealTimeScheduler()

inet::RealTimeScheduler::~RealTimeScheduler ( )

virtual

{
}

Member Function Documentation

addCallback()

void inet::RealTimeScheduler::addCallback	(	int	fd,
		ICallback *	callback
	)

To be called from the module which wishes to receive data from the fd.

The method must be called from the module's initialize() function.

{
    if (fd < 0)
        throw cRuntimeError("RealTimeScheduler::addCallback(): fd is invalid");
    if (!callback)
        throw cRuntimeError("RealTimeScheduler::addCallback(): callback must be non-nullptr");
    callbackEntries.push_back(Entry(fd, callback));
}

Referenced by inet::ExtLowerUdp::open().

advanceSimTime()

void inet::RealTimeScheduler::advanceSimTime ( )

protectedvirtual

{
    int64_t curTime = opp_get_monotonic_clock_nsecs();
    simtime_t t(curTime - baseTime, SIMTIME_NS);
    if (!sim->getFES()->isEmpty())
        t = std::min(t, sim->getFES()->peekFirst()->getArrivalTime());
    sim->setSimTime(t);
}

Referenced by guessNextEvent(), and receiveWithTimeout().

endRun()

void inet::RealTimeScheduler::endRun ( )

overridevirtual

Called at the end of a simulation run.

{
    callbackEntries.clear();
}

executionResumed()

void inet::RealTimeScheduler::executionResumed ( )

overridevirtual

Recalculates "base time" from current wall clock time.

{
    baseTime = opp_get_monotonic_clock_nsecs();
    baseTime = baseTime - sim->getSimTime().inUnit(SIMTIME_NS);
}

guessNextEvent()

cEvent * inet::RealTimeScheduler::guessNextEvent ( )

overridevirtual

Returns the first event in the Future Event Set.

{
    advanceSimTime();
    return sim->getFES()->peekFirst();
}

putBackEvent()

void inet::RealTimeScheduler::putBackEvent ( cEvent *  event )

overridevirtual

Scheduler function – it comes from the cScheduler interface.

{
    sim->getFES()->putBackFirst(event);
}

receiveUntil()

int inet::RealTimeScheduler::receiveUntil ( int64_t  targetTime )

protectedvirtual

{
    // if there's more than 2*UI_REFRESH_TIME to wait, wait in UI_REFRESH_TIME chunks
    // in order to keep UI responsiveness by invoking getEnvir()->idle()
    int64_t curTime = opp_get_monotonic_clock_nsecs();
 
    while ((targetTime - curTime) >= 2 * UI_REFRESH_TIME) {
        if (receiveWithTimeout(UI_REFRESH_TIME))
            return 1;
        if (getEnvir()->idle())
            return -1;
        curTime = opp_get_monotonic_clock_nsecs();
    }
 
    // difference is now at most UI_REFRESH_TIME, do it at once
    int64_t remaining = targetTime - curTime;
    if (remaining > 0)
        if (receiveWithTimeout(remaining))
            return 1;
    return 0;
}

Referenced by takeNextEvent().

receiveWithTimeout()

bool inet::RealTimeScheduler::receiveWithTimeout ( int64_t  timeout )

protectedvirtual

{
#ifdef __linux__
    bool found = false;
    timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = timeout / 1000;
 
    int32_t fdVec[FD_SETSIZE], maxfd;
    fd_set rdfds;
    FD_ZERO(&rdfds);
    maxfd = -1;
    for (uint16_t i = 0; i < callbackEntries.size(); i++) {
        fdVec[i] = callbackEntries.at(i).fd;
        if (fdVec[i] > maxfd)
            maxfd = fdVec[i];
        FD_SET(fdVec[i], &rdfds);
    }
    if (select(maxfd + 1, &rdfds, nullptr, nullptr, &tv) < 0)
        return found;
    advanceSimTime();
    for (uint16_t i = 0; i < callbackEntries.size(); i++) {
        if (!(FD_ISSET(fdVec[i], &rdfds)))
            continue;
        if (callbackEntries.at(i).callback->notify(fdVec[i]))
            found = true;
    }
    return found;
#else
    bool found = false;
    timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = timeout / 1000;
    advanceSimTime();
    for (uint16_t i = 0; i < callbackEntries.size(); i++) {
        if (callbackEntries.at(i).callback->notify(callbackEntries.at(i).fd))
            found = true;
    }
    if (!found)
        select(0, nullptr, nullptr, nullptr, &tv);
    return found;
#endif
}

Referenced by receiveUntil().

removeCallback()

void inet::RealTimeScheduler::removeCallback	(	int	fd,
		ICallback *	callback
	)

{
    for (auto it = callbackEntries.begin(); it != callbackEntries.end();) {
        if (fd == it->fd && callback == it->callback)
            it = callbackEntries.erase(it);
        else
            ++it;
    }
}

Referenced by inet::ExtLowerUdp::close().

startRun()

void inet::RealTimeScheduler::startRun ( )

overridevirtual

Called at the beginning of a simulation run.

{
    baseTime = opp_get_monotonic_clock_nsecs();
}

takeNextEvent()

cEvent * inet::RealTimeScheduler::takeNextEvent ( )

overridevirtual

Scheduler function – it comes from the cScheduler interface.

{
    int64_t targetTime;
 
    // calculate target time
    cEvent *event = sim->getFES()->peekFirst();
    if (!event)
        // as far into the future as reasonable (hoping we will never overflow - it is unlikely)
        targetTime = INT64_MAX;
    else {
        // use time of next event
        simtime_t eventSimtime = event->getArrivalTime();
        targetTime = baseTime + eventSimtime.inUnit(SIMTIME_NS);
    }
 
    // if needed, wait until that time arrives
    int64_t curTime = opp_get_monotonic_clock_nsecs();
 
    if (targetTime > curTime) {
        int status = receiveUntil(targetTime);
        if (status == -1)
            return nullptr; // interrupted by user
        if (status == 1)
            event = sim->getFES()->peekFirst(); // received something
    }
    else {
        // we're behind -- customized versions of this class may
        // alert if we're too much behind, whatever that means
        int64_t diffTime = curTime - targetTime;
        EV_TRACE << "We are behind: " << diffTime * 1e-9 << " seconds\n";
    }
    cEvent *tmp = sim->getFES()->removeFirst();
    ASSERT(tmp == event);
    return event;
}

Member Data Documentation

baseTime

int64_t inet::RealTimeScheduler::baseTime = 0

Referenced by advanceSimTime(), executionResumed(), startRun(), and takeNextEvent().

callbackEntries

std::vector<Entry> inet::RealTimeScheduler::callbackEntries

protected

Referenced by addCallback(), endRun(), receiveWithTimeout(), and removeCallback().

---

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

• RealTimeScheduler.h
• RealTimeScheduler.cc