inet::MatrixCloudDelayer Class Reference

Implementation of MatrixCloudDelayer. More...

#include <MatrixCloudDelayer.h>

Inheritance diagram for inet::MatrixCloudDelayer:

Classes
class	Descriptor
class	Matcher
class	MatrixEntry

Protected Types
typedef std::pair< int, int >	IdPair
typedef std::map< IdPair, Descriptor >	IdPairToDescriptorMap
typedef std::vector< MatrixEntry * >	MatrixEntryPtrVector

Protected Member Functions
virtual	~MatrixCloudDelayer ()
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	calculateDropAndDelay (const cMessage *msg, int srcID, int destID, bool &outDrop, simtime_t &outDelay) override
	returns isDrop and delay for this msg More...
MatrixCloudDelayer::Descriptor *	getOrCreateDescriptor (int srcID, int destID)
std::string	getPathOfConnectedNodeOnIfaceID (int id)
	returns path of connected node for the interface specified by 'id' More...
Protected Member Functions inherited from inet::CloudDelayerBase
virtual void	finish () override
virtual void	handleMessage (cMessage *msg) override
virtual INetfilter::IHook::Result	datagramPreRoutingHook (Packet *datagram) override
	This is the first hook called by the network protocol before it routes a datagram that was received from the lower layer. More...
virtual INetfilter::IHook::Result	datagramForwardHook (Packet *datagram) override
	This is the second hook called by the network protocol before it sends a datagram to the lower layer. More...
virtual INetfilter::IHook::Result	datagramPostRoutingHook (Packet *datagram) override
	This is the last hook called by the network protocol before it sends a datagram to the lower layer. More...
virtual INetfilter::IHook::Result	datagramLocalInHook (Packet *datagram) override
	This is the last hook called by the network protocol before it sends a datagram to the upper layer. More...
virtual INetfilter::IHook::Result	datagramLocalOutHook (Packet *datagram) override
	This is the first hook called by the network protocol before it routes a datagram that was received from the upper layer. More...

Protected Attributes
MatrixEntryPtrVector	matrixEntries
IdPairToDescriptorMap	idPairToDescriptorMap
ModuleRefByPar< IInterfaceTable >	ift
cModule *	host = nullptr
Protected Attributes inherited from inet::CloudDelayerBase
ModuleRefByPar< INetfilter >	networkProtocol
Protected Attributes inherited from inet::NetfilterBase::HookBase
std::vector< INetfilter * >	netfilters

Additional Inherited Members
Public Types inherited from inet::INetfilter::IHook
enum	Type {   PREROUTING, LOCALIN, FORWARD, POSTROUTING,   LOCALOUT }
enum	Result { ACCEPT, DROP, QUEUE, STOLEN }
Public Member Functions inherited from inet::CloudDelayerBase
	CloudDelayerBase ()
	~CloudDelayerBase ()
Public Member Functions inherited from inet::NetfilterBase::HookBase
virtual	~HookBase ()
void	registeredTo (INetfilter *nf)
void	unregisteredFrom (INetfilter *nf)
bool	isRegisteredHook (INetfilter *nf)
Public Member Functions inherited from inet::INetfilter::IHook
virtual	~IHook ()

Detailed Description

Implementation of MatrixCloudDelayer.

See NED file for details.

Member Typedef Documentation

IdPair

typedef std::pair<int, int> inet::MatrixCloudDelayer::IdPair

protected

IdPairToDescriptorMap

typedef std::map<IdPair, Descriptor> inet::MatrixCloudDelayer::IdPairToDescriptorMap

protected

MatrixEntryPtrVector

typedef std::vector<MatrixEntry *> inet::MatrixCloudDelayer::MatrixEntryPtrVector

protected

Constructor & Destructor Documentation

~MatrixCloudDelayer()

inet::MatrixCloudDelayer::~MatrixCloudDelayer ( )

protectedvirtual

{
    for (auto& elem : matrixEntries)
        delete elem;
    matrixEntries.clear();
}

Member Function Documentation

calculateDropAndDelay()

void inet::MatrixCloudDelayer::calculateDropAndDelay ( const cMessage *  msg, int  srcID, int  destID, bool &  outDrop, simtime_t &  outDelay  )

overrideprotectedvirtual

returns isDrop and delay for this msg

Reimplemented from inet::CloudDelayerBase.

{
    Descriptor *descriptor = getOrCreateDescriptor(srcID, destID);
    outDrop = descriptor->dropPar->boolValue(this);
    outDelay = SIMTIME_ZERO;
    if (!outDrop) {
        outDelay = descriptor->delayPar->doubleValue(this, "s");
        double datarate = descriptor->dataratePar->doubleValue(this, "bps");
        ASSERT(outDelay >= 0);
        ASSERT(datarate > 0.0);
        simtime_t curTime = simTime();
        if (curTime + outDelay < descriptor->lastSent)
            outDelay = descriptor->lastSent - curTime;
 
        const cPacket *pk = dynamic_cast<const cPacket *>(msg);
        if (pk)
            outDelay += pk->getBitLength() / datarate;
 
        descriptor->lastSent = curTime + outDelay;
    }
}

getOrCreateDescriptor()

MatrixCloudDelayer::Descriptor * inet::MatrixCloudDelayer::getOrCreateDescriptor ( int  srcID, int  destID  )

protected

{
    IdPair idPair(srcID, destID);
    auto it = idPairToDescriptorMap.find(idPair);
    if (it != idPairToDescriptorMap.end())
        return &(it->second);
 
    std::string src = getPathOfConnectedNodeOnIfaceID(srcID);
    std::string dest = getPathOfConnectedNodeOnIfaceID(destID);
 
    // find first matching node in XML
    MatrixEntry *reverseMatrixEntry = nullptr;
    for (auto& elem : matrixEntries) {
        MatrixEntry *matrixEntry = elem;
        if (matrixEntry->matches(src.c_str(), dest.c_str())) {
            MatrixCloudDelayer::Descriptor& descriptor = idPairToDescriptorMap[idPair];
            descriptor.delayPar = &matrixEntry->delayPar;
            descriptor.dataratePar = &matrixEntry->dataratePar;
            descriptor.dropPar = &matrixEntry->dropPar;
            descriptor.lastSent = simTime();
            if (matrixEntry->symmetric) {
                if (reverseMatrixEntry) // existing previous asymmetric entry which matching to (dest,src)
                    throw cRuntimeError("Inconsistent xml config between '%s' and '%s' nodes (at %s and %s)",
                            src.c_str(), dest.c_str(), matrixEntry->entity->getSourceLocation(),
                            reverseMatrixEntry->entity->getSourceLocation());
                IdPair reverseIdPair(destID, srcID);
                MatrixCloudDelayer::Descriptor& rdescriptor = idPairToDescriptorMap[reverseIdPair];
                rdescriptor = descriptor;
            }
            return &descriptor;
        }
        else if (!matrixEntry->symmetric && !reverseMatrixEntry && matrixEntry->matches(dest.c_str(), src.c_str())) {
            // store first matched asymmetric reverse entry to reverseMatrixEntry
            reverseMatrixEntry = matrixEntry;
        }
    }
    throw cRuntimeError("The 'traffic' xml entity not found for communication from '%s' to '%s' node", src.c_str(),
            dest.c_str());
}

Referenced by calculateDropAndDelay().

getPathOfConnectedNodeOnIfaceID()

std::string inet::MatrixCloudDelayer::getPathOfConnectedNodeOnIfaceID ( int  id )

protected

returns path of connected node for the interface specified by 'id'

{
    NetworkInterface *ie = ift->getInterfaceById(id);
    if (!ie)
        throw cRuntimeError("The interface id=%i not found in interfacetable", id);
 
    int gateId;
    cGate *connectedGate = nullptr;
 
    if ((gateId = ie->getNodeOutputGateId()) != -1)
        connectedGate = host->gate(gateId)->getPathEndGate();
    else if ((gateId = ie->getNodeInputGateId()) != -1)
        connectedGate = host->gate(gateId)->getPathStartGate();
 
    if (!connectedGate)
        throw cRuntimeError("Interface '%s' (id=%i) not connected", ie->getFullName(), id);
 
    cModule *connNode = findContainingNode(connectedGate->getOwnerModule());
    if (!connNode)
        throw cRuntimeError("The connected node is unknown at interface '%s' (id=%i)", ie->getFullName(), id);
 
    return connNode->getFullPath();
}

Referenced by getOrCreateDescriptor().

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::CloudDelayerBase.

{
    using namespace xmlutils;
 
    CloudDelayerBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        host = getContainingNode(this);
        ift.reference(this, "interfaceTableModule", true);
        cXMLElement *configEntity = par("config");
        // parse XML config
        if (strcmp(configEntity->getTagName(), "internetCloud"))
            throw cRuntimeError("Cannot read internetCloud configuration, unaccepted '%s' entity at %s", configEntity->getTagName(),
                    configEntity->getSourceLocation());
        bool defaultSymmetric = getAttributeBoolValue(configEntity, "symmetric");
        const cXMLElement *parameterEntity = getUniqueChild(configEntity, "parameters");
        cXMLElementList trafficEntities = parameterEntity->getChildrenByTagName("traffic");
        for (auto& trafficEntitie : trafficEntities) {
            cXMLElement *trafficEntity = trafficEntitie;
            MatrixEntry *matrixEntry = new MatrixEntry(trafficEntity, defaultSymmetric);
            matrixEntries.push_back(matrixEntry);
        }
    }
}

numInitStages()

virtual int inet::MatrixCloudDelayer::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::CloudDelayerBase.

{ return NUM_INIT_STAGES; }

Member Data Documentation

host

cModule* inet::MatrixCloudDelayer::host = nullptr

protected

Referenced by getPathOfConnectedNodeOnIfaceID(), and initialize().

idPairToDescriptorMap

IdPairToDescriptorMap inet::MatrixCloudDelayer::idPairToDescriptorMap

protected

Referenced by getOrCreateDescriptor().

ift

ModuleRefByPar<IInterfaceTable> inet::MatrixCloudDelayer::ift

protected

Referenced by getPathOfConnectedNodeOnIfaceID(), and initialize().

matrixEntries

MatrixEntryPtrVector inet::MatrixCloudDelayer::matrixEntries

protected

Referenced by getOrCreateDescriptor(), initialize(), and ~MatrixCloudDelayer().

---

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

• MatrixCloudDelayer.h
• MatrixCloudDelayer.cc