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 (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHopAddress) 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 (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHopAddress) 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 (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry, const InterfaceEntry *&outputInterfaceEntry, L3Address &nextHopAddress) 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 (INetworkDatagram datagram, const InterfaceEntry inputInterfaceEntry) 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 (INetworkDatagram datagram, const InterfaceEntry &outputInterfaceEntry, L3Address &nextHopAddress) 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

IInterfaceTable *	ift = nullptr

cModule *	host = nullptr

Protected Attributes inherited from inet::CloudDelayerBase
IPv4 *	ipv4Layer

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::INetfilter::IHook
virtual	~IHook ()

Detailed Description

Implementation of MatrixCloudDelayer.

See NED file for details.

Member Typedef Documentation

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

protected

typedef std::map<IDPair, Descriptor> inet::MatrixCloudDelayer::IDPairToDescriptorMap

protected

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

protected

Constructor & Destructor Documentation

inet::MatrixCloudDelayer::~MatrixCloudDelayer ( )

protectedvirtual

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

Member Function Documentation

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;
     }
 }

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

protected

Referenced by calculateDropAndDelay().

 {
     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());
 }

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

protected

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

Referenced by getOrCreateDescriptor().

 {
     InterfaceEntry *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();
 }

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 = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
         cXMLElement *configEntity = par("config").xmlValue();
         // 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 = getBoolAttribute(*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);
         }
     }
 }