Horizon » Horizon Simulation Framework

//=========================================================================

//  CSCHEDULER.CC - part of

//

//                  OMNeT++/OMNEST

//           Discrete System Simulation in C++

//

//  Author: Andras Varga, 2003

//

//=========================================================================

/*--------------------------------------------------------------*

  Copyright (C) 2003-2008 Andras Varga

  Copyright (C) 2006-2008 OpenSim Ltd.

  Monash University, Dept. of Electrical and Computer Systems Eng.

  Melbourne, Australia

  This file is distributed WITHOUT ANY WARRANTY. See the file

  `license' for details on this and other legal matters.

*--------------------------------------------------------------*/

#include "cscheduler.h"

#include "cmessage.h"

#include "csimulation.h"

#include "cmessageheap.h"

#include "globals.h"

#include "cenvir.h"

#include "cconfiguration.h"

#include "cconfigoption.h"

#include "platmisc.h" // usleep

#include "cbarriermessage.h"

USING_NAMESPACE

Register_GlobalConfigOption(CFGID_REALTIMESCHEDULER_SCALING, "realtimescheduler-scaling", CFG_DOUBLE, NULL, "When cRealTimeScheduler is selected as scheduler class: ratio of simulation time to real time. For example, scaling=2 will cause simulation time to progress twice as fast as runtime.");

cScheduler::cScheduler()

{

    sim = NULL;

}

cScheduler::~cScheduler()

{

}

void cScheduler::setSimulation(cSimulation *_sim)

{

    sim = _sim;

}

//-----

Register_Class(cSequentialScheduler);

cMessage *cSequentialScheduler::getNextEvent()

{

#ifdef NOBARRIER

    //

    // If we retrieve a valid msg from the queue, we return it:

    //

    cMessage *msg = sim->msgQueue.peekFirst();

    if (msg)

        return msg;

    //

    // if there is no event left and we don't use the threadpool, end the sim

    //

    if (!sim->threadPool)

        throw cTerminationException(eENDEDOK);

    //

    // If we did not get a valid msg from the queue, but there are still

    // barrier messages left, we wait:

    //

    while (sim->msgQueue.empty() && !sim->threadPool->barrierEmpty())

    {

        __asm__ ("pause");

    }

    msg = sim->msgQueue.peekFirst();

    //

    // If there is a msg now, we return it:

    //

    if (msg)

        return msg;

    //

    // If there is still no message in the queue, there are

    // also no barriers left (else we would have waited), and we quit:

    //

    else

        throw cTerminationException(eENDEDOK);

#else

    cMessage *msg = sim->msgQueue.peekFirst();

    if (!msg)

        throw cTerminationException(eENDEDOK);

    return msg;

#endif

}

//-----

Register_Class(cEEFScheduler)

;

cEEFScheduler::cEEFScheduler()

{

}

cEEFScheduler::~cEEFScheduler()

{

}

cMessage *cEEFScheduler::getNextEvent()

{

#ifdef NOBARRIER

    //

    // If we retrieve a valid msg from the queue, we return it:

    //

    cMessage *msg = sim->msgQueue.peekFirst();

    if (msg)

    return msg;

    //

    // if there is no event left and we don't use the threadpool, end the sim

    //

    if (!sim->threadPool)

    throw cTerminationException(eENDEDOK);

    //

    // If we did not get a valid msg from the queue, but there are still

    // barrier messages left, we wait:

    //

    while (sim->msgQueue.empty() && !sim->threadPool->barrierEmpty())

    {

        __asm__ ("pause");

    }

    msg = sim->msgQueue.peekFirst();

    //

    // If there is a msg now, we return it:

    //

    if (msg)

    return msg;

    //

    // If there is still no message in the queue, there are

    // also no barriers left (else we would have waited), and we quit:

    //

    else

    throw cTerminationException(eENDEDOK);

#else

    cMessage *msg;

    cBarrierMessage* barrier;

    while (!sim->msgQueue.empty())

    {

        msg = sim->msgQueue.peekFirst();

        barrier = dynamic_cast<cBarrierMessage*> (msg);

        if (barrier != NULL)

        {

            return independentEventsHeap.empty() ? msg

                    : independentEventsHeap.peekFirst();

        }

        independentEventsHeap.insert(sim->msgQueue.removeFirst());

    }

    if (independentEventsHeap.empty()) {

        throw cTerminationException(eENDEDOK);

    }

    return independentEventsHeap.peekFirst();

#endif

}

cMessage* cEEFScheduler::removeNextEvent() {

    printf ("Test");

    return independentEventsHeap.empty() ? sim->msgQueue.removeFirst() : independentEventsHeap.getFirst();

}

//-----

Register_Class(cRealTimeScheduler);

void cRealTimeScheduler::startRun()

{

    factor = ev.getConfig()->getAsDouble(CFGID_REALTIMESCHEDULER_SCALING);

    if (factor!=0)

        factor = 1/factor;

    doScaling = (factor!=0);

    gettimeofday(&baseTime, NULL);

}

void cRealTimeScheduler::endRun()

{

}

void cRealTimeScheduler::executionResumed()

{

    gettimeofday(&baseTime, NULL);

    baseTime = timeval_substract(baseTime, SIMTIME_DBL(doScaling ? factor*sim->getSimTime() : sim->getSimTime()));

}

bool cRealTimeScheduler::waitUntil(const timeval& targetTime)

{

    // if there's more than 200ms to wait, wait in 100ms chunks

    // in order to keep UI responsiveness by invoking ev.idle()

    timeval curTime;

    gettimeofday(&curTime, NULL);

    while (targetTime.tv_sec-curTime.tv_sec >=2 ||

           timeval_diff_usec(targetTime, curTime) >= 200000)

    {

        usleep(100000); // 100ms

        if (ev.idle())

            return false;

        gettimeofday(&curTime, NULL);

    }

    // difference is now at most 100ms, do it at once

    long usec = timeval_diff_usec(targetTime, curTime);

    if (usec>0)

        usleep(usec);

    return true;

}

cMessage *cRealTimeScheduler::getNextEvent()

{

#ifdef NOBARRIER

    //

    // If we retrieve a valid msg from the queue, we return it:

    //

    cMessage *msg = sim->msgQueue.peekFirst();

    if (msg)

        return msg;

    //

    // if there is no event left and we don't use the threadpool, end the sim

    //

    if (!sim->threadPool)

        throw cTerminationException(eENDEDOK);

    //

    // If we did not get a valid msg from the queue, but there are still

    // barrier messages left, we wait:

    //

    while (sim->msgQueue.empty() && !sim->threadPool->barrierEmpty())

    {

        __asm__ ("pause");

    }

    msg = sim->msgQueue.peekFirst();

    //

    // If there is a msg now, we return it:

    //

    if (msg)

        return msg;

    //

    // If there is still no message in the queue, there are

    // also no barriers left (else we would have waited), and we quit:

    //

    else

        throw cTerminationException(eENDEDOK);

#else

    cMessage *msg = sim->msgQueue.peekFirst();

    if (!msg)

        throw cTerminationException(eENDEDOK);

    // calculate target time

    simtime_t eventSimtime = msg->getArrivalTime();

    timeval targetTime = timeval_add(baseTime, SIMTIME_DBL(doScaling ? factor*eventSimtime : eventSimtime));

    // if needed, wait until that time arrives

    timeval curTime;

    gettimeofday(&curTime, NULL);

    if (timeval_greater(targetTime, curTime))

    {

        if (!waitUntil(targetTime))

            return NULL; // user break

    }

    else

    {

        // we're behind -- customized versions of this class may alert

        // if we're too much behind, or modify basetime to accept the skew

    }

    // ok, return the message

    return msg;

#endif

}