inet::SchedulerBase Class Reference

Base class for packet schedulers. More...

#include <SchedulerBase.h>

Inheritance diagram for inet::SchedulerBase:

Public Member Functions
	SchedulerBase ()
virtual	~SchedulerBase ()
virtual void	requestPacket () override
	The queue should send a packet whenever this method is invoked. More...
virtual int	getNumPendingRequests () override
	Returns number of pending requests. More...
virtual bool	isEmpty () override
	Return true when queue is empty, otherwise return false. More...
virtual void	clear () override
	Clear all queued packets and stored requests. More...
virtual cMessage *	pop () override
	Returns a packet directly from the queue, bypassing the primary, send-on-request mechanism. More...
virtual void	packetEnqueued (IPassiveQueue *inputQueue) override
	A packet arrived and it was added to the queue (the queue length increased by one). More...
virtual void	addListener (IPassiveQueueListener *listener) override
	Adds a new listener to the listener list. More...
virtual void	removeListener (IPassiveQueueListener *listener) override
	Removes a listener from the listener list. More...
Public Member Functions inherited from inet::IPassiveQueue
virtual	~IPassiveQueue ()
Public Member Functions inherited from inet::IPassiveQueueListener
virtual	~IPassiveQueueListener ()

Protected Member Functions
virtual void	initialize () override
virtual void	finalize ()
virtual void	handleMessage (cMessage *msg) override
virtual void	sendOut (cMessage *msg)
virtual void	notifyListeners ()
virtual bool	schedulePacket ()=0

Protected Attributes
int	packetsRequestedFromUs
int	packetsToBeRequestedFromInputs
std::vector< IPassiveQueue * >	inputQueues
cGate *	outGate
std::list< IPassiveQueueListener * >	listeners

Detailed Description

Base class for packet schedulers.

Schedulers are attached to the 'out' end of queues and decide from which queue a packet needs to be dequeued.

Schedulers behave as passive queues (they provide a view for the actual queues behind them), and can be cascaded. They must be able to notice when a new packet arrives at one of their inputs without dequeueing it, so they hook themselves as listeners on their inputs.

Constructor & Destructor Documentation

inet::SchedulerBase::SchedulerBase

(

)

    : packetsRequestedFromUs(0), packetsToBeRequestedFromInputs(0), outGate(nullptr)
{
}

inet::SchedulerBase::~SchedulerBase ( )

virtual

{
}

Member Function Documentation

void inet::SchedulerBase::addListener ( IPassiveQueueListener *  listener )

overridevirtual

Adds a new listener to the listener list.

It does nothing, if the listener list already contains the listener (by pointer equality).

Implements inet::IPassiveQueue.

{
    auto it = find(listeners.begin(), listeners.end(), listener);
    if (it == listeners.end())
        listeners.push_back(listener);
}

void inet::SchedulerBase::clear ( )

overridevirtual

Clear all queued packets and stored requests.

Implements inet::IPassiveQueue.

{
    for (auto & elem : inputQueues)
        (elem)->clear();

    packetsRequestedFromUs = 0;
    packetsToBeRequestedFromInputs = 0;
}

void inet::SchedulerBase::finalize ( )

protectedvirtual

{
    for (auto & elem : inputQueues)
        (elem)->removeListener(this);
}

virtual int inet::SchedulerBase::getNumPendingRequests ( )

inlineoverridevirtual

Returns number of pending requests.

Implements inet::IPassiveQueue.

{ return packetsRequestedFromUs; }

void inet::SchedulerBase::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    ASSERT(packetsRequestedFromUs > 0);
    packetsRequestedFromUs--;
    sendOut(msg);
}

void inet::SchedulerBase::initialize ( )

overrideprotectedvirtual

Reimplemented in inet::WRRScheduler.

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

{
    int numInputs = gateSize("in");
    for (int i = 0; i < numInputs; ++i) {
        cGate *inGate = isGateVector("in") ? gate("in", i) : gate("in");
        cGate *connectedGate = inGate->getPathStartGate();
        if (!connectedGate)
            throw cRuntimeError("Scheduler input gate %d is not connected", i);
        IPassiveQueue *inputModule = dynamic_cast<IPassiveQueue *>(connectedGate->getOwnerModule());
        if (!inputModule)
            throw cRuntimeError("Scheduler input gate %d should be connected to an IPassiveQueue", i);
        inputModule->addListener(this);
        inputQueues.push_back(inputModule);
    }

    outGate = gate("out");

    // TODO update state when topology changes
}

bool inet::SchedulerBase::isEmpty ( )

overridevirtual

Return true when queue is empty, otherwise return false.

Implements inet::IPassiveQueue.

Referenced by pop(), and inet::WRRScheduler::schedulePacket().

{
    for (auto & elem : inputQueues)
        if (!(elem)->isEmpty())
            return false;

    return true;
}

void inet::SchedulerBase::notifyListeners ( )

protectedvirtual

Referenced by packetEnqueued().

{
    for (auto & elem : listeners)
        (elem)->packetEnqueued(this);
}

void inet::SchedulerBase::packetEnqueued ( IPassiveQueue *  queue )

overridevirtual

A packet arrived and it was added to the queue (the queue length increased by one).

Therefore a subsequent requestPacket() call can deliver a packet immediately.

Implements inet::IPassiveQueueListener.

Referenced by notifyListeners().

{
    Enter_Method("packetEnqueued(...)");

    if (packetsToBeRequestedFromInputs > 0) {
        bool success = schedulePacket();
        if (success)
            packetsToBeRequestedFromInputs--;
    }
    else if (packetsRequestedFromUs == 0)
        notifyListeners();
}

cMessage * inet::SchedulerBase::pop ( )

overridevirtual

Returns a packet directly from the queue, bypassing the primary, send-on-request mechanism.

Returns nullptr if the queue is empty.

Implements inet::IPassiveQueue.

{
    for (auto & elem : inputQueues)
        if (!(elem)->isEmpty())
            return (elem)->pop();

    return nullptr;
}

void inet::SchedulerBase::removeListener ( IPassiveQueueListener *  listener )

overridevirtual

Removes a listener from the listener list.

It does nothing if the listener was not found on the listener list.

Implements inet::IPassiveQueue.

Referenced by finalize().

{
    auto it = find(listeners.begin(), listeners.end(), listener);
    if (it != listeners.end())
        listeners.erase(it);
}

void inet::SchedulerBase::requestPacket ( )

overridevirtual

The queue should send a packet whenever this method is invoked.

If the queue is currently empty, it should send a packet when when one becomes available.

Implements inet::IPassiveQueue.

{
    Enter_Method("requestPacket()");

    packetsRequestedFromUs++;
    packetsToBeRequestedFromInputs++;
    bool success = schedulePacket();
    if (success)
        packetsToBeRequestedFromInputs--;
}

virtual bool inet::SchedulerBase::schedulePacket ( )

protectedpure virtual

Implemented in inet::WRRScheduler, and inet::PriorityScheduler.

Referenced by packetEnqueued(), and requestPacket().

void inet::SchedulerBase::sendOut ( cMessage *  msg )

protectedvirtual

Referenced by handleMessage().

{
    send(msg, outGate);
}

Member Data Documentation

std::vector<IPassiveQueue *> inet::SchedulerBase::inputQueues

protected

Referenced by clear(), finalize(), inet::WRRScheduler::initialize(), initialize(), isEmpty(), pop(), inet::PriorityScheduler::schedulePacket(), and inet::WRRScheduler::schedulePacket().

std::list<IPassiveQueueListener *> inet::SchedulerBase::listeners

protected

Referenced by addListener(), notifyListeners(), and removeListener().

cGate* inet::SchedulerBase::outGate

protected

Referenced by initialize(), and sendOut().

int inet::SchedulerBase::packetsRequestedFromUs

protected

Referenced by clear(), handleMessage(), packetEnqueued(), and requestPacket().

int inet::SchedulerBase::packetsToBeRequestedFromInputs

protected

Referenced by clear(), packetEnqueued(), and requestPacket().

---

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

• SchedulerBase.h
• SchedulerBase.cc