inet::NetPerfMeter Class Reference

Implementation of NetPerfMeter. More...

#include <NetPerfMeter.h>

Inheritance diagram for inet::NetPerfMeter:

Classes
class	ReceiverStatistics
class	SenderStatistics
struct	TraceEntry

Public Member Functions
	NetPerfMeter ()
	~NetPerfMeter ()
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	finish () override
virtual void	handleMessage (cMessage *msg) override
virtual void	refreshDisplay () const override
void	establishConnection ()
void	successfullyEstablishedConnection (cMessage *msg, const unsigned int queueSize)
void	teardownConnection (const bool stopTimeReached=false)
void	receiveMessage (cMessage *msg)
void	resetStatistics ()
void	writeStatistics ()
void	sendSCTPQueueRequest (const unsigned int queueSize)
void	sendTCPQueueRequest (const unsigned int queueSize)

Protected Types
enum	Protocol { SCTP = 0, TCP = 1, UDP = 2 }
enum	TimerType {   TIMER_CONNECT = 1, TIMER_START = 2, TIMER_RESET = 3, TIMER_STOP = 4,   TIMER_TRANSMIT = 5, TIMER_OFF = 6, TIMER_ON = 7 }

Protected Attributes
Protocol	TransportProtocol = static_cast<Protocol>(-1)
bool	ActiveMode = false
bool	SendingAllowed = false
bool	HasFinished = false
unsigned int	MaxMsgSize = 0
unsigned int	QueueSize = 0
double	UnorderedMode = NAN
double	UnreliableMode = NAN
bool	DecoupleSaturatedStreams = false
simtime_t	ConnectTime
simtime_t	StartTime
simtime_t	ResetTime
simtime_t	StopTime
cMessage *	ConnectTimer = nullptr
cMessage *	StartTimer = nullptr
cMessage *	StopTimer = nullptr
cMessage *	ResetTimer = nullptr
cMessage *	OffTimer = nullptr
cMessage *	OnTimer = nullptr
unsigned int	OnOffCycleCounter = 0
int	MaxOnOffCycles = 0
std::vector< NetPerfMeterTransmitTimer * >	TransmitTimerVector
unsigned int	RequestedOutboundStreams = 0
unsigned int	MaxInboundStreams = 0
unsigned int	ActualOutboundStreams = 0
unsigned int	ActualInboundStreams = 0
std::vector< cDynamicExpression >	FrameRateExpressionVector
std::vector< cDynamicExpression >	FrameSizeExpressionVector
SctpSocket *	SocketSCTP = nullptr
SctpSocket *	IncomingSocketSCTP = nullptr
TcpSocket *	SocketTCP = nullptr
TcpSocket *	IncomingSocketTCP = nullptr
UdpSocket *	SocketUDP = nullptr
int	ConnectionID = 0
L3Address	PrimaryPath
std::vector< TraceEntry >	TraceVector
size_t	TraceIndex = 0
simtime_t	TransmissionStartTime
simtime_t	ConnectionEstablishmentTime
simtime_t	StatisticsResetTime
unsigned int	LastStreamID = 0
simtime_t	StatisticsStartTime

Private Member Functions
SenderStatistics *	getSenderStatistics (const unsigned int streamID)
ReceiverStatistics *	getReceiverStatistics (const unsigned int streamID)
double	getFrameRate (const unsigned int streamID)
unsigned long	getFrameSize (const unsigned int streamID)
void	startSending ()
void	stopSending ()
void	sendDataOfTraceFile (const unsigned long long bytesAvailableInQueue)
void	sendDataOfSaturatedStreams (const unsigned long long bytesAvailableInQueue, const Ptr< const SctpSendQueueAbatedReq > &sendQueueAbatedIndication)
void	sendDataOfNonSaturatedStreams (const unsigned long long bytesAvailableInQueue, const unsigned int streamID)
unsigned long	transmitFrame (const unsigned int frameSize, const unsigned int streamID)
void	createAndBindSocket ()
void	handleTimer (cMessage *msg)

Static Private Member Functions
static opp_string	format (const char *formatString,...)
static void	parseExpressionVector (std::vector< cDynamicExpression > &expressionVector, const char *string, const char *delimiters=nullptr)

Private Attributes
std::map< unsigned int, SenderStatistics * >	SenderStatisticsMap
std::map< unsigned int, ReceiverStatistics * >	ReceiverStatisticsMap

Detailed Description

Implementation of NetPerfMeter.

See NED file for more details.

Member Enumeration Documentation

Protocol

enum inet::NetPerfMeter::Protocol

protected

Enumerator
SCTP
TCP
UDP

                  {
        SCTP = 0, TCP = 1, UDP = 2
    };

TimerType

enum inet::NetPerfMeter::TimerType

protected

Enumerator
TIMER_CONNECT
TIMER_START
TIMER_RESET
TIMER_STOP
TIMER_TRANSMIT
TIMER_OFF
TIMER_ON

                   {
        TIMER_CONNECT  = 1,
        TIMER_START    = 2,
        TIMER_RESET    = 3,
        TIMER_STOP     = 4,
        TIMER_TRANSMIT = 5,
        TIMER_OFF      = 6,
        TIMER_ON       = 7
    };

Constructor & Destructor Documentation

NetPerfMeter()

inet::NetPerfMeter::NetPerfMeter

(

)

{
    SendingAllowed = false;
    ConnectionID = 0;
    resetStatistics();
}

~NetPerfMeter()

inet::NetPerfMeter::~NetPerfMeter

(

)

{
    cancelAndDelete(ConnectTimer);
    ConnectTimer = nullptr;
    cancelAndDelete(StartTimer);
    StartTimer = nullptr;
    cancelAndDelete(ResetTimer);
    ResetTimer = nullptr;
    cancelAndDelete(StopTimer);
    StopTimer = nullptr;
    for (auto& elem : TransmitTimerVector) {
        cancelAndDelete(elem);
        elem = nullptr;
    }
    if (SocketUDP != nullptr) {
        delete SocketUDP;
        SocketUDP = nullptr;
    }
    if (SocketTCP != nullptr) {
        delete SocketTCP;
        SocketTCP = nullptr;
    }
    if (IncomingSocketTCP != nullptr) {
        delete IncomingSocketTCP;
        IncomingSocketTCP = nullptr;
    }
    if (SocketSCTP != nullptr) {
        delete SocketSCTP;
        SocketSCTP = nullptr;
    }
    if (IncomingSocketSCTP != nullptr) {
        delete IncomingSocketSCTP;
        IncomingSocketSCTP = nullptr;
    }
}

Member Function Documentation

createAndBindSocket()

void inet::NetPerfMeter::createAndBindSocket ( )

private

{
    const char *localAddress = par("localAddress");
    const int localPort = par("localPort");
    if ((ActiveMode == false) && (localPort == 0)) {
        throw cRuntimeError("No local port number given in active mode!");
    }
    L3Address localAddr;
    if (*localAddress)
        localAddr = L3AddressResolver().resolve(localAddress);
 
    if (TransportProtocol == SCTP) {
        assert(SocketSCTP == nullptr);
        SocketSCTP = new SctpSocket;
        SocketSCTP->setInboundStreams(MaxInboundStreams);
        SocketSCTP->setOutboundStreams(RequestedOutboundStreams);
        SocketSCTP->setOutputGate(gate("socketOut"));
        SocketSCTP->bind(localPort);
        if (ActiveMode == false) {
            SocketSCTP->listen(true);
        }
    }
    else if (TransportProtocol == TCP) {
        assert(SocketTCP == nullptr);
        SocketTCP = new TcpSocket;
        SocketTCP->setOutputGate(gate("socketOut"));
        SocketTCP->bind(localAddr, localPort);
        if (ActiveMode == false) {
            SocketTCP->listen();
        }
    }
    else if (TransportProtocol == UDP) {
        assert(SocketUDP == nullptr);
        SocketUDP = new UdpSocket;
        SocketUDP->setOutputGate(gate("socketOut"));
        SocketUDP->bind(localAddr, localPort);
    }
}

Referenced by establishConnection(), and initialize().

establishConnection()

void inet::NetPerfMeter::establishConnection

(

)

{
    const char *remoteAddress = par("remoteAddress");
    const int remotePort = par("remotePort");
 
    // ====== Establish connection ===========================================
    if (ActiveMode == true) {
        createAndBindSocket();
 
        const char *primaryPath = par("primaryPath");
        PrimaryPath = (primaryPath[0] != 0x00) ? L3AddressResolver().resolve(primaryPath) : L3Address();
 
        if (TransportProtocol == SCTP) {
            AddressVector remoteAddressList;
            remoteAddressList.push_back(L3AddressResolver().resolve(remoteAddress));
            SocketSCTP->connectx(remoteAddressList, remotePort);
        }
        else if (TransportProtocol == TCP) {
            SocketTCP->renewSocket();
            SocketTCP->connect(L3AddressResolver().resolve(remoteAddress), remotePort);
        }
        else if (TransportProtocol == UDP) {
            SocketUDP->connect(L3AddressResolver().resolve(remoteAddress), remotePort);
            // Just start sending, since UDP is connection-less
            successfullyEstablishedConnection(nullptr, 0);
        }
        ConnectionEstablishmentTime = simTime();
    }
    else {
        // ------ Handle UDP on passive side ----------------
        if (TransportProtocol == UDP) {
//            SocketUDP->connect(L3AddressResolver().resolve(remoteAddress), remotePort);
            successfullyEstablishedConnection(nullptr, 0);
        }
    }
    EV << simTime() << ", " << getFullPath() << ": Sending allowed" << endl;
    SendingAllowed = true;
}

Referenced by handleTimer().

finish()

void inet::NetPerfMeter::finish ( )

overridevirtual

{
    if (TransportProtocol == SCTP) {
    }
    else if (TransportProtocol == TCP) {
    }
    else if (TransportProtocol == UDP) {
    }
 
    std::map<unsigned int, SenderStatistics *>::iterator senderStatisticsIterator = SenderStatisticsMap.begin();
    while (senderStatisticsIterator != SenderStatisticsMap.end()) {
        delete senderStatisticsIterator->second;
        SenderStatisticsMap.erase(senderStatisticsIterator);
        senderStatisticsIterator = SenderStatisticsMap.begin();
    }
    std::map<unsigned int, ReceiverStatistics *>::iterator receiverStatisticsIterator = ReceiverStatisticsMap.begin();
    while (receiverStatisticsIterator != ReceiverStatisticsMap.end()) {
        delete receiverStatisticsIterator->second;
        ReceiverStatisticsMap.erase(receiverStatisticsIterator);
        receiverStatisticsIterator = ReceiverStatisticsMap.begin();
    }
}

format()

opp_string inet::NetPerfMeter::format ( const char *  formatString,   ...  )

staticprivate

{
    char str[1024];
    va_list args;
    va_start(args, formatString);
    vsnprintf(str, sizeof(str), formatString, args);
    va_end(args);
    return opp_string(str);
}

Referenced by writeStatistics().

getFrameRate()

double inet::NetPerfMeter::getFrameRate ( const unsigned int  streamID )

private

{
    double frameRate;
    if (FrameRateExpressionVector.size() == 0) {
        frameRate = par("frameRate");
    }
    else {
        frameRate = FrameRateExpressionVector[streamID % FrameRateExpressionVector.size()].doubleValue(this, "Hz");
        if (frameRate < 0) {
            frameRate = par("frameRate");
        }
    }
    return frameRate;
}

Referenced by sendDataOfNonSaturatedStreams(), and sendDataOfSaturatedStreams().

getFrameSize()

unsigned long inet::NetPerfMeter::getFrameSize ( const unsigned int  streamID )

private

{
    unsigned long frameSize;
    if (FrameSizeExpressionVector.size() == 0) {
        frameSize = par("frameSize");
    }
    else {
        double doubleSize = FrameSizeExpressionVector[streamID % FrameSizeExpressionVector.size()].doubleValue(this, "B");
        frameSize = (doubleSize >= 0.0) ? (long)doubleSize : par("frameSize");
    }
    return frameSize;
}

Referenced by sendDataOfNonSaturatedStreams(), and sendDataOfSaturatedStreams().

getReceiverStatistics()

ReceiverStatistics* inet::NetPerfMeter::getReceiverStatistics ( const unsigned int  streamID )

inlineprivate

                                                                                  {
        auto found = ReceiverStatisticsMap.find(streamID);
        assert(found != ReceiverStatisticsMap.end());
        return found->second;
    }

Referenced by receiveMessage().

getSenderStatistics()

SenderStatistics* inet::NetPerfMeter::getSenderStatistics ( const unsigned int  streamID )

inlineprivate

                                                                              {
        auto found = SenderStatisticsMap.find(streamID);
        assert(found != SenderStatisticsMap.end());
        return found->second;
    }

Referenced by transmitFrame().

handleMessage()

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

overridevirtual

{
    // ====== Timer handling =================================================
    if (msg->isSelfMessage()) {
        handleTimer(msg);
    }
    // ====== SCTP ===========================================================
    else if (TransportProtocol == SCTP) {
        switch (msg->getKind()) {
            // ------ Data -----------------------------------------------------
            case SCTP_I_DATA:
                receiveMessage(msg);
                break;
            // ------ Data Arrival Indication ----------------------------------
            case SCTP_I_DATA_NOTIFICATION: {
                // Data has arrived -> request it from the SCTP module.
                auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
                auto dataIndication = tags.getTag<SctpCommandReq>();
//                SctpInfoReq* command = new SctpInfoReq("SendCommand");
                SctpInfoReq *command = new SctpInfoReq();
                command->setSocketId(dataIndication->getSocketId());
                command->setSid(dataIndication->getSid());
                command->setNumMsgs(dataIndication->getNumMsgs());
                Packet *cmsg = new Packet("ReceiveRequest", SCTP_C_RECEIVE);
                auto cmd = cmsg->addTag<SctpSendReq>();
                cmd->setSocketId(dataIndication->getSocketId());
                cmd->setSid(dataIndication->getSid());
                cmsg->addTag<SocketReq>()->setSocketId(dataIndication->getSocketId());
                cmsg->addTag<DispatchProtocolReq>()->setProtocol(&inet::Protocol::sctp);
                send(cmsg, "socketOut");
                break;
            }
            // ------ Connection available -----------------------------------
            case SCTP_I_AVAILABLE: {
                EV_INFO << "SCTP_I_AVAILABLE arrived\n";
                Message *message = check_and_cast<Message *>(msg);
                int newSockId = message->getTag<SctpAvailableReq>()->getNewSocketId();
                EV_INFO << "new socket id = " << newSockId << endl;
                Request *cmsg = new Request("SCTP_C_ACCEPT_SOCKET_ID", SCTP_C_ACCEPT_SOCKET_ID);
                cmsg->addTag<SctpAvailableReq>()->setSocketId(newSockId);
                cmsg->addTag<DispatchProtocolReq>()->setProtocol(&inet::Protocol::sctp);
                cmsg->addTag<SocketReq>()->setSocketId(newSockId);
                EV_INFO << "Sending accept socket id request ..." << endl;
                send(cmsg, "socketOut");
                break;
            }
            // ------ Connection established -----------------------------------
            case SCTP_I_ESTABLISHED: {
                Message *message = check_and_cast<Message *>(msg);
                auto& tags = message->getTags();
                auto connectInfo = tags.getTag<SctpConnectReq>();
                ActualOutboundStreams = connectInfo->getOutboundStreams();
                if (ActualOutboundStreams > RequestedOutboundStreams) {
                    ActualOutboundStreams = RequestedOutboundStreams;
                }
                ActualInboundStreams = connectInfo->getInboundStreams();
                if (ActualInboundStreams > MaxInboundStreams) {
                    ActualInboundStreams = MaxInboundStreams;
                }
                LastStreamID = ActualOutboundStreams - 1;
                // NOTE: Start sending on stream 0!
                successfullyEstablishedConnection(msg, QueueSize);
                break;
            }
            // ------ Queue indication -----------------------------------------
            case SCTP_I_SENDQUEUE_ABATED: {
                Message *message = check_and_cast<Message *>(msg);
                auto& tags = message->getTags();
                const auto& sendQueueAbatedIndication = tags.getTag<SctpSendQueueAbatedReq>();
                assert(sendQueueAbatedIndication != nullptr);
                // Queue is underfull again -> give it more data.
                SendingAllowed = true;
                if (TraceVector.size() == 0) {
                    sendDataOfSaturatedStreams(sendQueueAbatedIndication->getBytesAvailable(), sendQueueAbatedIndication);
                }
                break;
            }
            case SCTP_I_SENDQUEUE_FULL:
                SendingAllowed = false;
                break;
            // ------ Errors ---------------------------------------------------
            case SCTP_I_PEER_CLOSED:
            case SCTP_I_CLOSED:
            case SCTP_I_CONNECTION_REFUSED:
            case SCTP_I_CONNECTION_RESET:
            case SCTP_I_TIMED_OUT:
            case SCTP_I_ABORT:
            case SCTP_I_CONN_LOST:
            case SCTP_I_SHUTDOWN_RECEIVED:
                teardownConnection();
                break;
            default:
//                printf("SCTP: kind=%d\n", msg->getKind());
                break;
        }
    }
    // ====== TCP ============================================================
    else if (TransportProtocol == TCP) {
        short kind = msg->getKind();
        switch (kind) {
            // ------ Data -----------------------------------------------------
            case TCP_I_DATA:
            case TCP_I_URGENT_DATA:
                receiveMessage(msg);
                break;
            // ------ Connection available -----------------------------------
            case TCP_I_AVAILABLE: {
                EV_INFO << "TCP_I_AVAILABLE arrived\n";
                TcpAvailableInfo *availableInfo = check_and_cast<TcpAvailableInfo *>(msg->getControlInfo());
                int newSockId = availableInfo->getNewSocketId();
                EV_INFO << "new socket id = " << newSockId << endl;
                Request *cmsg = new Request("TCP_C_ACCEPT", TCP_C_ACCEPT);
                auto *acceptCmd = new TcpAcceptCommand();
                cmsg->setControlInfo(acceptCmd);
                cmsg->addTag<DispatchProtocolReq>()->setProtocol(&inet::Protocol::tcp);
                cmsg->addTag<SocketReq>()->setSocketId(newSockId);
                EV_INFO << "Sending accept socket id request ..." << endl;
                send(cmsg, "socketOut");
                break;
            }
            // ------ Connection established -----------------------------------
            case TCP_I_ESTABLISHED:
                successfullyEstablishedConnection(msg, 0);
                break;
            // ------ Queue indication -----------------------------------------
            case TCP_I_SEND_MSG: {
                const TcpCommand *tcpCommand = check_and_cast<TcpCommand *>(msg->getControlInfo());
                // Queue is underfull again -> give it more data.
                if (SocketTCP != nullptr) { // T.D. 16.11.2011: Ensure that there is still a TCP socket!
                    SendingAllowed = true;
                    if (TraceVector.size() == 0) {
                        sendDataOfSaturatedStreams(tcpCommand->getUserId(), nullptr);
                    }
                }
            }
            break;
            // ------ Errors ---------------------------------------------------
            case TCP_I_PEER_CLOSED:
            case TCP_I_CLOSED:
            case TCP_I_CONNECTION_REFUSED:
            case TCP_I_CONNECTION_RESET:
            case TCP_I_TIMED_OUT:
                teardownConnection();
                break;
        }
    }
    // ====== UDP ============================================================
    else if (TransportProtocol == UDP) {
        switch (msg->getKind()) {
            // ------ Data -----------------------------------------------------
            case UDP_I_DATA:
                receiveMessage(msg);
                break;
            // ------ Error ----------------------------------------------------
            case UDP_I_ERROR:
                teardownConnection();
                break;
        }
    }
 
    delete msg;
}

handleTimer()

void inet::NetPerfMeter::handleTimer ( cMessage *  msg )

private

{
    // ====== Transmit timer =================================================
    const NetPerfMeterTransmitTimer *transmitTimer = dynamic_cast<NetPerfMeterTransmitTimer *>(msg);
    if (transmitTimer) {
        TransmitTimerVector[transmitTimer->getStreamID()] = nullptr;
        if (TraceVector.size() > 0) {
            sendDataOfTraceFile(QueueSize);
        }
        else {
            sendDataOfNonSaturatedStreams(QueueSize, transmitTimer->getStreamID());
        }
    }
    // ====== Off timer ======================================================
    else if (msg == OffTimer) {
        EV << simTime() << ", " << getFullPath() << ": Entering OFF mode" << endl;
        OffTimer = nullptr;
        stopSending();
    }
    // ====== On timer =======================================================
    else if (msg == OnTimer) {
        EV << simTime() << ", " << getFullPath() << ": Entering ON mode" << endl;
        OnTimer = nullptr;
        startSending();
    }
    // ====== Reset timer ====================================================
    else if (msg == ResetTimer) {
        EV << simTime() << ", " << getFullPath() << ": Reset" << endl;
 
        ResetTimer = nullptr;
        resetStatistics();
 
        assert(StopTimer == nullptr);
        if (StopTime > 0.0) {
            StopTimer = new cMessage("StopTimer", TIMER_STOP);
            scheduleAfter(StopTime, StopTimer);
        }
    }
    // ====== Stop timer =====================================================
    else if (msg == StopTimer) {
        EV << simTime() << ", " << getFullPath() << ": STOP" << endl;
 
        StopTimer = nullptr;
        if (OffTimer) {
            cancelAndDelete(OffTimer);
            OffTimer = nullptr;
        }
        if (OnTimer) {
            cancelAndDelete(OnTimer);
            OnTimer = nullptr;
        }
 
        if (TransportProtocol == SCTP) {
            if (IncomingSocketSCTP != nullptr) {
                IncomingSocketSCTP->close();
            }
            else if (SocketSCTP != nullptr) {
                SocketSCTP->close();
            }
        }
        else if (TransportProtocol == TCP) {
            if (SocketTCP != nullptr) {
                SocketTCP->close();
            }
        }
        teardownConnection(true);
    }
    // ====== Start timer ====================================================
    else if (msg == StartTimer) {
        EV << simTime() << ", " << getFullPath() << ": Start" << endl;
 
        StartTimer = nullptr;
        startSending();
    }
    // ====== Connect timer ==================================================
    else if (msg == ConnectTimer) {
        EV << simTime() << ", " << getFullPath() << ": Connect" << endl;
 
        ConnectTimer = nullptr;
        establishConnection();
    }
}

Referenced by handleMessage().

initialize()

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

overridevirtual

{
    if (stage == INITSTAGE_LOCAL) {
        // ====== Handle parameters ==============================================
        ActiveMode = par("activeMode");
        const char *protocolPar = par("protocol");
        if (strcmp(protocolPar, "TCP") == 0) {
            TransportProtocol = TCP;
        }
        else if (strcmp(protocolPar, "SCTP") == 0) {
            TransportProtocol = SCTP;
        }
        else if (strcmp(protocolPar, "UDP") == 0) {
            TransportProtocol = UDP;
        }
        else {
            throw cRuntimeError("Bad protocol setting!");
        }
 
        RequestedOutboundStreams = 1;
        MaxInboundStreams = 1;
        ActualOutboundStreams = 1;
        ActualInboundStreams = 1;
        LastStreamID = 1;
        MaxMsgSize = par("maxMsgSize");
        QueueSize = par("queueSize");
        DecoupleSaturatedStreams = par("decoupleSaturatedStreams");
        RequestedOutboundStreams = par("outboundStreams");
        if ((RequestedOutboundStreams < 1) || (RequestedOutboundStreams > 65535)) {
            throw cRuntimeError("Invalid number of outbound streams; use range from [1, 65535]");
        }
        MaxInboundStreams = par("maxInboundStreams");
        if ((MaxInboundStreams < 1) || (MaxInboundStreams > 65535)) {
            throw cRuntimeError("Invalid number of inbound streams; use range from [1, 65535]");
        }
        UnorderedMode = par("unordered");
        if ((UnorderedMode < 0.0) || (UnorderedMode > 1.0)) {
            throw cRuntimeError("Bad value for unordered probability; use range from [0.0, 1.0]");
        }
        UnreliableMode = par("unreliable");
        if ((UnreliableMode < 0.0) || (UnreliableMode > 1.0)) {
            throw cRuntimeError("Bad value for unreliable probability; use range from [0.0, 1.0]");
        }
        parseExpressionVector(FrameRateExpressionVector, par("frameRateString"), ";");
        parseExpressionVector(FrameSizeExpressionVector, par("frameSizeString"), ";");
 
        TraceIndex = ~0;
        if (strcmp(par("traceFile").stringValue(), "") != 0) {
            std::fstream traceFile(par("traceFile").stringValue());
            if (!traceFile.good()) {
                throw cRuntimeError("Unable to load trace file");
            }
            while (!traceFile.eof()) {
                TraceEntry traceEntry;
                traceEntry.InterFrameDelay = 0;
                traceEntry.FrameSize = 0;
                traceEntry.StreamID = 0;
 
                char line[256];
                traceFile.getline(line, sizeof(line), '\n');
                if (sscanf(line, "%lf %u %u", &traceEntry.InterFrameDelay, &traceEntry.FrameSize, &traceEntry.StreamID) >= 2) {
//                    std::cout << "Frame: " << traceEntry.InterFrameDelay << "\t" << traceEntry.FrameSize << "\t" << traceEntry.StreamID << endl;
                    TraceVector.push_back(traceEntry);
                }
            }
        }
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        // ====== Initialize and bind socket =====================================
        SocketSCTP = IncomingSocketSCTP = nullptr;
        SocketTCP = IncomingSocketTCP = nullptr;
        SocketUDP = nullptr;
 
        for (unsigned int i = 0; i < RequestedOutboundStreams; i++) {
            SenderStatistics *senderStatistics = new SenderStatistics;
            SenderStatisticsMap.insert(std::pair<unsigned int, SenderStatistics *>(i, senderStatistics));
        }
        for (unsigned int i = 0; i < MaxInboundStreams; i++) {
            ReceiverStatistics *receiverStatistics = new ReceiverStatistics;
            ReceiverStatisticsMap.insert(std::pair<unsigned int, ReceiverStatistics *>(i, receiverStatistics));
        }
 
        ConnectTime = par("connectTime");
        StartTime = par("startTime");
        ResetTime = par("resetTime");
        StopTime = par("stopTime");
        MaxOnOffCycles = par("maxOnOffCycles");
 
        HasFinished = false;
        OffTimer = nullptr;
        OnTimer = nullptr;
        OnOffCycleCounter = 0;
 
        EV << simTime() << ", " << getFullPath() << ": Initialize"
           << "\tConnectTime=" << ConnectTime
           << "\tStartTime=" << StartTime
           << "\tResetTime=" << ResetTime
           << "\tStopTime=" << StopTime
           << endl;
 
        if (ActiveMode == false) {
            // Passive mode: create and bind socket immediately.
            // For active mode, the socket will be created just before connect().
            createAndBindSocket();
        }
 
        // ====== Schedule Connect Timer =========================================
        ConnectTimer = new cMessage("ConnectTimer", TIMER_CONNECT);
        scheduleAt(ConnectTime, ConnectTimer);
    }
}

numInitStages()

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

inlineoverridevirtual

{ return NUM_INIT_STAGES; }

parseExpressionVector()

void inet::NetPerfMeter::parseExpressionVector ( std::vector< cDynamicExpression > &  expressionVector, const char *  string, const char *  delimiters = nullptr  )

staticprivate

{
    expressionVector.clear();
    cStringTokenizer tokenizer(string, delimiters);
    while (tokenizer.hasMoreTokens()) {
        const char *token = tokenizer.nextToken();
        cDynamicExpression expression;
        expression.parse(token);
        expressionVector.push_back(expression);
    }
}

Referenced by initialize().

receiveMessage()

void inet::NetPerfMeter::receiveMessage

(

cMessage *

msg

)

{
    if (const Packet *dataMessage = dynamic_cast<const Packet *>(msg)) {
        unsigned int streamID = 0;
        const auto& smsg = dataMessage->peekData();
 
        if (TransportProtocol == SCTP) {
            auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
            auto& receiveCommand = tags.findTag<SctpRcvReq>();
            streamID = receiveCommand->getSid();
        }
 
        ReceiverStatistics *receiverStatistics = getReceiverStatistics(streamID);
        receiverStatistics->ReceivedMessages++;
        receiverStatistics->ReceivedBytes += B(smsg->getChunkLength()).get();
        for (auto& region : smsg->getAllTags<CreationTimeTag>())
            receiverStatistics->ReceivedDelayHistogram.collect(simTime() - region.getTag()->getCreationTime());
    }
}

Referenced by handleMessage().

refreshDisplay()

void inet::NetPerfMeter::refreshDisplay ( ) const

overridevirtual

{
    unsigned long long totalSentBytes = 0;
    for (std::map<unsigned int, SenderStatistics *>::const_iterator iterator = SenderStatisticsMap.begin();
         iterator != SenderStatisticsMap.end(); iterator++)
    {
        const SenderStatistics *senderStatistics = iterator->second;
        totalSentBytes += senderStatistics->SentBytes;
    }
 
    unsigned long long totalReceivedBytes = 0;
    for (std::map<unsigned int, ReceiverStatistics *>::const_iterator iterator = ReceiverStatisticsMap.begin();
         iterator != ReceiverStatisticsMap.end(); iterator++)
    {
        const ReceiverStatistics *receiverStatistics = iterator->second;
        totalReceivedBytes += receiverStatistics->ReceivedBytes;
    }
 
    char status[64];
    snprintf(status, sizeof(status), "In: %llu, Out: %llu",
            totalReceivedBytes, totalSentBytes);
    getDisplayString().setTagArg("t", 0, status);
    // TODO also was setStatusString("Connecting"), setStatusString("Closed")
}

resetStatistics()

void inet::NetPerfMeter::resetStatistics

(

)

{
    StatisticsStartTime = simTime();
    for (auto& elem : SenderStatisticsMap) {
        SenderStatistics *senderStatistics = elem.second;
        senderStatistics->reset();
    }
    for (auto& elem : ReceiverStatisticsMap) {
        ReceiverStatistics *receiverStatistics = elem.second;
        receiverStatistics->reset();
    }
}

Referenced by handleTimer(), NetPerfMeter(), and writeStatistics().

sendDataOfNonSaturatedStreams()

void inet::NetPerfMeter::sendDataOfNonSaturatedStreams ( const unsigned long long  bytesAvailableInQueue, const unsigned int  streamID  )

private

{
    assert(OnTimer == nullptr);
 
    // ====== Is there something to send? ====================================
    const double frameRate = getFrameRate(streamID);
    if (frameRate <= 0.0) {
        // No non-saturated transmission on this stream
        // => no need to re-schedule timer!
        return;
    }
 
    // ====== Is sending allowed (i.e. space in the queue)? ==================
    if (SendingAllowed) {
        const long frameSize = getFrameSize(streamID);
        if (frameSize < 1) {
            return;
        }
        if ((frameRate <= 0.0) && ((TransportProtocol == TCP) || (TransportProtocol == UDP))) {
            throw cRuntimeError("TCP and UDP do not support \"send as much as possible\" mode (frameRate=0)!");
        }
 
        // ====== Transmit frame ==============================================
        /*
         EV << simTime() << ", " << getFullPath() << ": Stream #" << streamID
         << ":\tframeRate=" << frameRate
         << "\tframeSize=" << frameSize << endl;
         */
        transmitFrame(frameSize, streamID);
    }
    else {
        // No transmission allowed -> skip this frame!
    }
 
    // ====== Schedule next frame transmission ===============================
    assert(TransmitTimerVector[streamID] == nullptr);
    TransmitTimerVector[streamID] = new NetPerfMeterTransmitTimer("TransmitTimer", TIMER_TRANSMIT);
    TransmitTimerVector[streamID]->setStreamID(streamID);
    const double nextFrameTime = 1.0 / frameRate;
    /*
     EV << simTime() << ", " << getFullPath()
     << ": Next on stream #" << streamID << " in " << nextFrameTime << "s" << endl;
     */
    scheduleAfter(nextFrameTime, TransmitTimerVector[streamID]);
}

Referenced by handleTimer(), and startSending().

sendDataOfSaturatedStreams()

void inet::NetPerfMeter::sendDataOfSaturatedStreams ( const unsigned long long  bytesAvailableInQueue, const Ptr< const SctpSendQueueAbatedReq > &  sendQueueAbatedIndication  )

private

{
    if (OnTimer != nullptr) {
        // We are in Off mode -> nothing to send!
        return;
    }
 
    // ====== Is sending allowed (i.e. space in the queue)? ==================
    if (SendingAllowed) {
        // ====== SCTP tells current queue occupation for each stream =========
        unsigned long long contingent;
        unsigned long long queued[ActualOutboundStreams];
        if (sendQueueAbatedIndication == nullptr) {
            // At the moment, the actual queue size is unknown.
            // => Assume it to be bytesAvailableInQueue.
            contingent = bytesAvailableInQueue / ActualOutboundStreams;
            for (unsigned int streamID = 0; streamID < ActualOutboundStreams; streamID++) {
                queued[streamID] = 0;
            }
        }
        else {
            assert(ActualOutboundStreams <= sendQueueAbatedIndication->getQueuedForStreamArraySize());
            for (unsigned int streamID = 0; streamID < ActualOutboundStreams; streamID++) {
                queued[streamID] = sendQueueAbatedIndication->getQueuedForStream(streamID);
            }
            contingent = sendQueueAbatedIndication->getBytesLimit() / ActualOutboundStreams;
        }
 
        // ====== Send, but care for per-stream contingent ====================
        LastStreamID = (LastStreamID + 1) % ActualOutboundStreams;
        unsigned int startStreamID = LastStreamID;
        unsigned long long newlyQueuedBytes = 0;
        bool progress;
        do {
            // ====== Perform one round ========================================
            progress = false; // Will be set to true on any transmission progress
                              // during the next round
            do {
                const double frameRate = getFrameRate(LastStreamID);
                if (frameRate < 0.0000001) { // Saturated stream
                    if ((DecoupleSaturatedStreams == false) || (queued[LastStreamID] < contingent)) {
                        // ====== Send one frame ==================================
                        const unsigned long frameSize = getFrameSize(LastStreamID);
                        if (frameSize >= 1) {
                            const unsigned long long sent = transmitFrame(frameSize, LastStreamID);
                            newlyQueuedBytes += sent;
                            queued[LastStreamID] += sent;
                            progress = true;
                        }
                    }
                }
                LastStreamID = (LastStreamID + 1) % ActualOutboundStreams;
            } while (LastStreamID != startStreamID);
        } while ((newlyQueuedBytes < bytesAvailableInQueue) && (progress == true));
    }
}

Referenced by handleMessage(), and startSending().

sendDataOfTraceFile()

void inet::NetPerfMeter::sendDataOfTraceFile ( const unsigned long long  bytesAvailableInQueue )

private

{
    if (TraceIndex < TraceVector.size()) {
        const unsigned int frameSize = TraceVector[TraceIndex].FrameSize;
        unsigned int streamID = TraceVector[TraceIndex].StreamID;
        if (streamID >= ActualOutboundStreams) {
            if (TransportProtocol == SCTP) {
                throw cRuntimeError("Invalid streamID in trace");
            }
            streamID = 0;
        }
        transmitFrame(frameSize, streamID);
        TraceIndex++;
    }
 
    if (TraceIndex >= TraceVector.size()) {
        TraceIndex = 0;
    }
 
    // ====== Schedule next frame transmission ===============================
    if (TraceIndex < TraceVector.size()) {
        const double nextFrameTime = TraceVector[TraceIndex].InterFrameDelay;
        assert(TransmitTimerVector[0] == nullptr);
        TransmitTimerVector[0] = new NetPerfMeterTransmitTimer("TransmitTimer", TIMER_TRANSMIT);
        TransmitTimerVector[0]->setStreamID(0);
 
//        std::cout << simTime() << ", " << getFullPath()
//                  << ": Next in " << nextFrameTime << "s" << endl;
 
        scheduleAfter(nextFrameTime, TransmitTimerVector[0]);
    }
}

Referenced by handleTimer(), and startSending().

sendSCTPQueueRequest()

void inet::NetPerfMeter::sendSCTPQueueRequest

(

const unsigned int

queueSize

)

{
    assert(SocketSCTP != nullptr);
 
    // Tell SCTP to limit the send queue to the number of bytes specified.
    // When the queue is able accept more data again, it will be indicated by
    // SCTP_I_SENDQUEUE_ABATED!
 
    Request *cmsg = new Request("QueueRequest", SCTP_C_QUEUE_BYTES_LIMIT);
    auto queueInfo = cmsg->addTag<SctpInfoReq>();
    queueInfo->setText(queueSize);
    queueInfo->setSocketId(ConnectionID);
 
    if (IncomingSocketSCTP) {
        IncomingSocketSCTP->sendRequest(cmsg);
    }
    else {
        SocketSCTP->sendRequest(cmsg);
    }
}

Referenced by successfullyEstablishedConnection().

sendTCPQueueRequest()

void inet::NetPerfMeter::sendTCPQueueRequest

(

const unsigned int

queueSize

)

{
    assert(SocketTCP != nullptr);
 
    // Tell TCP to limit the send queue to the number of bytes specified.
    // When the queue is able accept more data again, it will be indicated by
    // TCP_I_SEND_MSG!
 
    TcpCommand *queueInfo = new TcpCommand();
    queueInfo->setUserId(queueSize);
 
    auto request = new Request("QueueRequest", TCP_C_QUEUE_BYTES_LIMIT);
    request->setControlInfo(queueInfo);
    request->addTag<SocketReq>()->setSocketId(ConnectionID);
    if (IncomingSocketTCP) {
        IncomingSocketTCP->sendCommand(request);
    }
    else {
        SocketTCP->sendCommand(request);
    }
}

Referenced by successfullyEstablishedConnection().

startSending()

void inet::NetPerfMeter::startSending ( )

private

{
    if (TraceVector.size() > 0) {
        sendDataOfTraceFile(QueueSize);
    }
    else {
        for (unsigned int streamID = 0; streamID < ActualOutboundStreams; streamID++) {
            sendDataOfNonSaturatedStreams(QueueSize, streamID);
        }
        sendDataOfSaturatedStreams(QueueSize, nullptr);
    }
 
    // ------ On/Off handling ------------------------------------------------
    const simtime_t onTime = par("onTime");
    if (onTime.dbl() > 0.0) {
        OffTimer = new cMessage("OffTimer", TIMER_OFF);
        scheduleAfter(onTime, OffTimer);
    }
}

Referenced by handleTimer().

stopSending()

void inet::NetPerfMeter::stopSending ( )

private

{
    // ------ Stop all transmission timers ----------------------------------
    for (auto& elem : TransmitTimerVector) {
        cancelAndDelete(elem);
        elem = nullptr;
    }
    OnOffCycleCounter++;
 
    // ------ Schedule On timer ----------------------------------------------
    const simtime_t offDuration = par("offTime");
    if ((offDuration.dbl() > 0.0)
        && ((MaxOnOffCycles < 0) || (OnOffCycleCounter <= (unsigned int)MaxOnOffCycles)))
    {
        OnTimer = new cMessage("OnTimer", TIMER_ON);
        scheduleAfter(offDuration, OnTimer);
    }
}

Referenced by handleTimer().

successfullyEstablishedConnection()

void inet::NetPerfMeter::successfullyEstablishedConnection	(	cMessage *	msg,
		const unsigned int	queueSize
	)

{
    if (HasFinished) {
        EV << "Already finished -> no new connection!" << endl;
        SctpSocket newSocket(msg);
        newSocket.abort();
        return;
    }
 
    // ====== Update queue size ==============================================
    if (queueSize != 0) {
        QueueSize = queueSize;
        EV << simTime() << ", " << getFullPath() << ": Got queue size " << QueueSize << " from transport protocol" << endl;
    }
 
    // ====== Get connection ID ==============================================
    if (TransportProtocol == TCP) {
        if (ActiveMode == false) {
            assert(SocketTCP != nullptr);
            if (IncomingSocketTCP != nullptr) {
                delete IncomingSocketTCP;
            }
            IncomingSocketTCP = new TcpSocket(msg);
            IncomingSocketTCP->setOutputGate(gate("socketOut"));
        }
 
        ConnectionID = check_and_cast<Indication *>(msg)->getTag<SocketInd>()->getSocketId();
        sendTCPQueueRequest(QueueSize); // Limit the send queue as given.
    }
    else if (TransportProtocol == SCTP) {
        if (ActiveMode == false) {
            assert(SocketSCTP != nullptr);
            if (IncomingSocketSCTP != nullptr) {
                delete IncomingSocketSCTP;
            }
            IncomingSocketSCTP = new SctpSocket(msg);
            IncomingSocketSCTP->setOutputGate(gate("socketOut"));
        }
 
        ConnectionID = check_and_cast<Indication *>(msg)->getTag<SocketInd>()->getSocketId();
        sendSCTPQueueRequest(QueueSize); // Limit the send queue as given.
    }
 
    // ====== Initialize TransmitTimerVector =================================
    TransmitTimerVector.resize(ActualOutboundStreams);
    for (unsigned int i = 0; i < ActualOutboundStreams; i++) {
        TransmitTimerVector[i] = nullptr;
    }
 
    // ====== Schedule Start Timer to begin transmission =====================
    if (OnOffCycleCounter == 0) {
        assert(StartTimer == nullptr);
        StartTimer = new cMessage("StartTimer", TIMER_START);
        TransmissionStartTime = ConnectTime + StartTime;
        if (TransmissionStartTime < simTime()) {
            throw cRuntimeError("Connection establishment has been too late. Check startTime parameter!");
        }
        scheduleAt(TransmissionStartTime, StartTimer);
 
        // ====== Schedule Reset Timer to reset statistics ====================
        assert(ResetTimer == nullptr);
        ResetTimer = new cMessage("ResetTimer", TIMER_RESET);
        StatisticsResetTime = ConnectTime + ResetTime;
        scheduleAt(StatisticsResetTime, ResetTimer);
    }
    else {
        // ====== Restart transmission immediately ============================
        StartTimer = new cMessage("StartTimer");
        scheduleAfter(SIMTIME_ZERO, StartTimer);
    }
}

Referenced by establishConnection(), and handleMessage().

teardownConnection()

void inet::NetPerfMeter::teardownConnection

(

const bool

stopTimeReached = false

)

{
    for (auto& elem : TransmitTimerVector) {
        cancelAndDelete(elem);
        elem = nullptr;
    }
 
    if (ActiveMode == false) {
        if (TransportProtocol == SCTP) {
            if (IncomingSocketSCTP != nullptr) {
                delete IncomingSocketSCTP;
                IncomingSocketSCTP = nullptr;
            }
        }
        else if (TransportProtocol == TCP) {
            if (IncomingSocketTCP != nullptr) {
                delete IncomingSocketTCP;
                IncomingSocketTCP = nullptr;
            }
        }
    }
    if ((stopTimeReached) || (ActiveMode == true)) {
        if (TransportProtocol == SCTP) {
            if (SocketSCTP != nullptr) {
                SocketSCTP->close();
                delete SocketSCTP;
                SocketSCTP = nullptr;
            }
        }
        else if (TransportProtocol == TCP) {
            if (SocketTCP != nullptr) {
                SocketTCP->abort();
                delete SocketTCP;
                SocketTCP = nullptr;
            }
        }
        else if (TransportProtocol == UDP) {
            if (SocketUDP != nullptr) {
                delete SocketUDP;
                SocketUDP = nullptr;
            }
        }
        SendingAllowed = false;
        ConnectionID = 0;
    }
 
    if (stopTimeReached) {
        writeStatistics();
        HasFinished = true;
    }
}

Referenced by handleMessage(), and handleTimer().

transmitFrame()

unsigned long inet::NetPerfMeter::transmitFrame ( const unsigned int  frameSize, const unsigned int  streamID  )

private

{
    EV << simTime() << ", " << getFullPath() << ": Transmit frame of size "
       << frameSize << " on stream #" << streamID << endl;
    assert(OnTimer == nullptr);
 
    // ====== TCP ============================================================
    unsigned long newlyQueuedBytes = 0;
    if (TransportProtocol == TCP) {
        // TCP is stream-oriented: just pass the amount of frame data.
        auto cmsg = new Packet("NetPerfMeterDataMessage");
        auto dataMessage = makeShared<BytesChunk>();
        std::vector<uint8_t> vec;
        vec.resize(frameSize);
        for (uint32_t i = 0; i < frameSize; i++)
            vec[i] = ((i & 1) ? 'D' : 'T');
        dataMessage->setBytes(vec);
        dataMessage->addTag<CreationTimeTag>()->setCreationTime(simTime());
        cmsg->insertAtBack(dataMessage);
 
        if (IncomingSocketTCP) {
            IncomingSocketTCP->send(cmsg);
        }
        else {
            SocketTCP->send(cmsg);
        }
 
        newlyQueuedBytes += frameSize;
        SenderStatistics *senderStatistics = getSenderStatistics(0);
        senderStatistics->SentBytes += frameSize;
        senderStatistics->SentMessages++;
    }
    // ====== Message-Oriented Protocols =====================================
    else {
        unsigned int bytesToSend = frameSize;
        do {
            const unsigned int msgSize = (bytesToSend > MaxMsgSize) ? MaxMsgSize : bytesToSend;
 
            if (false) {
            }
            // ====== SCTP =====================================================
#ifdef INET_WITH_SCTP
            else if (TransportProtocol == SCTP) {
                const bool sendUnordered = (UnorderedMode > 0.0) ? (uniform(0.0, 1.0) < UnorderedMode) : false;
                const bool sendUnreliable = (UnreliableMode > 0.0) ? (uniform(0.0, 1.0) < UnreliableMode) : false;
 
                auto cmsg = new Packet("NetPerfMeterDataMessage");
                auto dataMessage = makeShared<BytesChunk>();
                std::vector<uint8_t> vec;
                vec.resize(msgSize);
                for (uint32_t i = 0; i < msgSize; i++)
                    vec[i] = ((i & 1) ? 'D' : 'T');
                dataMessage->setBytes(vec);
                dataMessage->addTag<CreationTimeTag>()->setCreationTime(simTime());
                cmsg->insertAtBack(dataMessage);
 
                cmsg->addTag<SocketReq>()->setSocketId(ConnectionID);
                auto command = cmsg->addTag<SctpSendReq>();
                command->setSocketId(ConnectionID);
                command->setSid(streamID);
                command->setSendUnordered((sendUnordered == true) ? COMPLETE_MESG_UNORDERED : COMPLETE_MESG_ORDERED);
                command->setLast(true);
                command->setPrimary(PrimaryPath.isUnspecified());
                command->setRemoteAddr(PrimaryPath);
                command->setPrValue(1);
                command->setPrMethod((sendUnreliable == true) ? 2 : 0); // PR-SCTP policy: RTX
 
                cmsg->setKind(sendUnordered ? SCTP_C_SEND_ORDERED : SCTP_C_SEND_UNORDERED);
                cmsg->addTag<DispatchProtocolReq>()->setProtocol(&inet::Protocol::sctp);
                send(cmsg, "socketOut");
 
                SenderStatistics *senderStatistics = getSenderStatistics(streamID);
                senderStatistics->SentBytes += msgSize;
                senderStatistics->SentMessages++;
            }
#endif
            // ====== UDP ===================================================
            else if (TransportProtocol == UDP) {
                auto cmsg = new Packet("NetPerfMeterDataMessage");
                auto dataMessage = makeShared<BytesChunk>();
                std::vector<uint8_t> vec;
                vec.resize(msgSize);
                for (uint32_t i = 0; i < msgSize; i++)
                    vec[i] = ((i & 1) ? 'D' : 'T');
                dataMessage->setBytes(vec);
                dataMessage->addTag<CreationTimeTag>()->setCreationTime(simTime());
                cmsg->insertAtBack(dataMessage);
 
                SocketUDP->send(cmsg);
 
                SenderStatistics *senderStatistics = getSenderStatistics(0);
                senderStatistics->SentBytes += msgSize;
                senderStatistics->SentMessages++;
            }
 
            newlyQueuedBytes += msgSize;
            bytesToSend -= msgSize;
        } while (bytesToSend > 0);
    }
    return newlyQueuedBytes;
}

Referenced by sendDataOfNonSaturatedStreams(), sendDataOfSaturatedStreams(), and sendDataOfTraceFile().

writeStatistics()

void inet::NetPerfMeter::writeStatistics

(

)

{
    const simtime_t statisticsStopTime = simTime();
    const double duration = statisticsStopTime.dbl() - StatisticsStartTime.dbl();
 
    recordScalar("Total Measurement Duration", duration);
    recordScalar("On-Off Cycles", OnOffCycleCounter);
 
    // ====== Per-Stream Statistics ==========================================
    unsigned long long totalSentBytes = 0;
    unsigned long long totalSentMessages = 0;
    for (std::map<unsigned int, SenderStatistics *>::const_iterator iterator =
             SenderStatisticsMap.begin(); iterator != SenderStatisticsMap.end();
         iterator++)
    {
        const unsigned int streamID = iterator->first;
        if (streamID >= ActualOutboundStreams) {
            break;
        }
        const SenderStatistics *senderStatistics = iterator->second;
        totalSentBytes += senderStatistics->SentBytes;
        totalSentMessages += senderStatistics->SentMessages;
 
        const double transmissionBitRate = (duration > 0.0) ? (8 * senderStatistics->SentBytes / duration) : 0.0;
        const double transmissionByteRate = (duration > 0.0) ? (senderStatistics->SentBytes / duration) : 0.0;
        const double transmissionMessageRate = (duration > 0.0) ? (senderStatistics->SentMessages / duration) : 0.0;
        recordScalar(format("Transmission Bit Rate Stream #%u", streamID).c_str(), transmissionBitRate);
        recordScalar(format("Transmission Byte Rate Stream #%u", streamID).c_str(), transmissionByteRate);
        recordScalar(format("Transmission Message Rate Stream #%u", streamID).c_str(), transmissionMessageRate);
        recordScalar(format("Sent Bytes Stream #%u", streamID).c_str(), senderStatistics->SentBytes);
        recordScalar(format("Sent Messages Stream #%u", streamID).c_str(), senderStatistics->SentMessages);
    }
 
    unsigned long long totalReceivedBytes = 0;
    unsigned long long totalReceivedMessages = 0;
    for (auto& elem : ReceiverStatisticsMap) {
        const unsigned int streamID = elem.first;
        if (streamID >= ActualInboundStreams) {
            break;
        }
        ReceiverStatistics *receiverStatistics = elem.second;
        totalReceivedBytes += receiverStatistics->ReceivedBytes;
        totalReceivedMessages += receiverStatistics->ReceivedMessages;
 
        // NOTE: When sending "as much as possible", the transmission counters are
        //       set to 0 on reset. If the queue is long enough, there may be no
        //       need to fill it again => counters will be 0 here.
        const double receptionBitRate = (duration > 0.0) ? (8 * receiverStatistics->ReceivedBytes / duration) : 0.0;
        const double receptionByteRate = (duration > 0.0) ? (receiverStatistics->ReceivedBytes / duration) : 0.0;
        const double receptionMessageRate = (duration > 0.0) ? (receiverStatistics->ReceivedMessages / duration) : 0.0;
        recordScalar(format("Reception Bit Rate Stream #%u", streamID).c_str(), receptionBitRate);
        recordScalar(format("Reception Byte Rate Stream #%u", streamID).c_str(), receptionByteRate);
        recordScalar(format("Reception Message Rate Stream #%u", streamID).c_str(), receptionMessageRate);
        recordScalar(format("Received Bytes Stream #%u", streamID).c_str(), receiverStatistics->ReceivedBytes);
        recordScalar(format("Received Messages Stream #%u", streamID).c_str(), receiverStatistics->ReceivedMessages);
        receiverStatistics->ReceivedDelayHistogram.recordAs(format("Received Message Delay Stream #%u", streamID).c_str(), "s");
    }
 
    // ====== Total Statistics ===============================================
    // NOTE: When sending "as much as possible", the transmission counters are
    //       set to 0 on reset. If the queue is long enough, there may be no
    //       need to fill it again => counters will be 0 here.
    const double totalReceptionBitRate = (duration > 0.0) ? (8 * totalReceivedBytes / duration) : 0.0;
    const double totalReceptionByteRate = (duration > 0.0) ? (totalReceivedBytes / duration) : 0.0;
    const double totalReceptionMessageRate = (duration > 0.0) ? (totalReceivedMessages / duration) : 0.0;
    const double totalTransmissionBitRate = (duration > 0.0) ? (8 * totalSentBytes / duration) : 0.0;
    const double totalTransmissionByteRate = (duration > 0.0) ? (totalSentBytes / duration) : 0.0;
    const double totalTransmissionMessageRate = (duration > 0.0) ? (totalSentMessages / duration) : 0.0;
 
    // NOTE: The byte rate is redundant, but having bits and bytes
    //       makes manual reading of the results easier.
    recordScalar("Total Transmission Bit Rate", totalTransmissionBitRate);
    recordScalar("Total Transmission Byte Rate", totalTransmissionByteRate);
    recordScalar("Total Transmission Message Rate", totalTransmissionMessageRate);
    recordScalar("Total Sent Bytes", totalSentBytes);
    recordScalar("Total Sent Messages", totalSentMessages);
 
    recordScalar("Total Reception Bit Rate", totalReceptionBitRate);
    recordScalar("Total Reception Byte Rate", totalReceptionByteRate);
    recordScalar("Total Reception Message Rate", totalReceptionMessageRate);
    recordScalar("Total Received Bytes", totalReceivedBytes);
    recordScalar("Total Received Messages", totalReceivedMessages);
 
    resetStatistics(); // Make sure that it is not mistakenly used later
}

Referenced by teardownConnection().

Member Data Documentation

ActiveMode

bool inet::NetPerfMeter::ActiveMode = false

protected

Referenced by createAndBindSocket(), establishConnection(), initialize(), successfullyEstablishedConnection(), and teardownConnection().

ActualInboundStreams

unsigned int inet::NetPerfMeter::ActualInboundStreams = 0

protected

Referenced by handleMessage(), initialize(), and writeStatistics().

ActualOutboundStreams

unsigned int inet::NetPerfMeter::ActualOutboundStreams = 0

protected

Referenced by handleMessage(), initialize(), sendDataOfSaturatedStreams(), sendDataOfTraceFile(), startSending(), successfullyEstablishedConnection(), and writeStatistics().

ConnectionEstablishmentTime

simtime_t inet::NetPerfMeter::ConnectionEstablishmentTime

protected

Referenced by establishConnection().

ConnectionID

int inet::NetPerfMeter::ConnectionID = 0

protected

Referenced by NetPerfMeter(), sendSCTPQueueRequest(), sendTCPQueueRequest(), successfullyEstablishedConnection(), teardownConnection(), and transmitFrame().

ConnectTime

simtime_t inet::NetPerfMeter::ConnectTime

protected

Referenced by initialize(), and successfullyEstablishedConnection().

ConnectTimer

cMessage* inet::NetPerfMeter::ConnectTimer = nullptr

protected

Referenced by handleTimer(), initialize(), and ~NetPerfMeter().

DecoupleSaturatedStreams

bool inet::NetPerfMeter::DecoupleSaturatedStreams = false

protected

Referenced by initialize(), and sendDataOfSaturatedStreams().

FrameRateExpressionVector

std::vector<cDynamicExpression> inet::NetPerfMeter::FrameRateExpressionVector

protected

Referenced by getFrameRate(), and initialize().

FrameSizeExpressionVector

std::vector<cDynamicExpression> inet::NetPerfMeter::FrameSizeExpressionVector

protected

Referenced by getFrameSize(), and initialize().

HasFinished

bool inet::NetPerfMeter::HasFinished = false

protected

Referenced by initialize(), successfullyEstablishedConnection(), and teardownConnection().

IncomingSocketSCTP

SctpSocket* inet::NetPerfMeter::IncomingSocketSCTP = nullptr

protected

Referenced by handleTimer(), initialize(), sendSCTPQueueRequest(), successfullyEstablishedConnection(), teardownConnection(), and ~NetPerfMeter().

IncomingSocketTCP

TcpSocket* inet::NetPerfMeter::IncomingSocketTCP = nullptr

protected

Referenced by initialize(), sendTCPQueueRequest(), successfullyEstablishedConnection(), teardownConnection(), transmitFrame(), and ~NetPerfMeter().

LastStreamID

unsigned int inet::NetPerfMeter::LastStreamID = 0

protected

Referenced by handleMessage(), initialize(), and sendDataOfSaturatedStreams().

MaxInboundStreams

unsigned int inet::NetPerfMeter::MaxInboundStreams = 0

protected

Referenced by createAndBindSocket(), handleMessage(), and initialize().

MaxMsgSize

unsigned int inet::NetPerfMeter::MaxMsgSize = 0

protected

Referenced by initialize(), and transmitFrame().

MaxOnOffCycles

int inet::NetPerfMeter::MaxOnOffCycles = 0

protected

Referenced by initialize(), and stopSending().

OffTimer

cMessage* inet::NetPerfMeter::OffTimer = nullptr

protected

Referenced by handleTimer(), initialize(), and startSending().

OnOffCycleCounter

unsigned int inet::NetPerfMeter::OnOffCycleCounter = 0

protected

Referenced by initialize(), stopSending(), successfullyEstablishedConnection(), and writeStatistics().

OnTimer

cMessage* inet::NetPerfMeter::OnTimer = nullptr

protected

Referenced by handleTimer(), initialize(), sendDataOfNonSaturatedStreams(), sendDataOfSaturatedStreams(), stopSending(), and transmitFrame().

PrimaryPath

L3Address inet::NetPerfMeter::PrimaryPath

protected

Referenced by establishConnection(), and transmitFrame().

QueueSize

unsigned int inet::NetPerfMeter::QueueSize = 0

protected

Referenced by handleMessage(), handleTimer(), initialize(), startSending(), and successfullyEstablishedConnection().

ReceiverStatisticsMap

std::map<unsigned int, ReceiverStatistics *> inet::NetPerfMeter::ReceiverStatisticsMap

private

Referenced by finish(), initialize(), refreshDisplay(), resetStatistics(), and writeStatistics().

RequestedOutboundStreams

unsigned int inet::NetPerfMeter::RequestedOutboundStreams = 0

protected

Referenced by createAndBindSocket(), handleMessage(), and initialize().

ResetTime

simtime_t inet::NetPerfMeter::ResetTime

protected

Referenced by initialize(), and successfullyEstablishedConnection().

ResetTimer

cMessage* inet::NetPerfMeter::ResetTimer = nullptr

protected

Referenced by handleTimer(), successfullyEstablishedConnection(), and ~NetPerfMeter().

SenderStatisticsMap

std::map<unsigned int, SenderStatistics *> inet::NetPerfMeter::SenderStatisticsMap

private

Referenced by finish(), initialize(), refreshDisplay(), resetStatistics(), and writeStatistics().

SendingAllowed

bool inet::NetPerfMeter::SendingAllowed = false

protected

Referenced by establishConnection(), handleMessage(), NetPerfMeter(), sendDataOfNonSaturatedStreams(), sendDataOfSaturatedStreams(), and teardownConnection().

SocketSCTP

SctpSocket* inet::NetPerfMeter::SocketSCTP = nullptr

protected

Referenced by createAndBindSocket(), establishConnection(), handleTimer(), initialize(), sendSCTPQueueRequest(), successfullyEstablishedConnection(), teardownConnection(), and ~NetPerfMeter().

SocketTCP

TcpSocket* inet::NetPerfMeter::SocketTCP = nullptr

protected

Referenced by createAndBindSocket(), establishConnection(), handleMessage(), handleTimer(), initialize(), sendTCPQueueRequest(), successfullyEstablishedConnection(), teardownConnection(), transmitFrame(), and ~NetPerfMeter().

SocketUDP

UdpSocket* inet::NetPerfMeter::SocketUDP = nullptr

protected

Referenced by createAndBindSocket(), establishConnection(), initialize(), teardownConnection(), transmitFrame(), and ~NetPerfMeter().

StartTime

simtime_t inet::NetPerfMeter::StartTime

protected

Referenced by initialize(), and successfullyEstablishedConnection().

StartTimer

cMessage* inet::NetPerfMeter::StartTimer = nullptr

protected

Referenced by handleTimer(), successfullyEstablishedConnection(), and ~NetPerfMeter().

StatisticsResetTime

simtime_t inet::NetPerfMeter::StatisticsResetTime

protected

Referenced by successfullyEstablishedConnection().

StatisticsStartTime

simtime_t inet::NetPerfMeter::StatisticsStartTime

protected

Referenced by resetStatistics(), and writeStatistics().

StopTime

simtime_t inet::NetPerfMeter::StopTime

protected

Referenced by handleTimer(), and initialize().

StopTimer

cMessage* inet::NetPerfMeter::StopTimer = nullptr

protected

Referenced by handleTimer(), and ~NetPerfMeter().

TraceIndex

size_t inet::NetPerfMeter::TraceIndex = 0

protected

Referenced by initialize(), and sendDataOfTraceFile().

TraceVector

std::vector<TraceEntry> inet::NetPerfMeter::TraceVector

protected

Referenced by handleMessage(), handleTimer(), initialize(), sendDataOfTraceFile(), and startSending().

TransmissionStartTime

simtime_t inet::NetPerfMeter::TransmissionStartTime

protected

Referenced by successfullyEstablishedConnection().

TransmitTimerVector

std::vector<NetPerfMeterTransmitTimer *> inet::NetPerfMeter::TransmitTimerVector

protected

Referenced by handleTimer(), sendDataOfNonSaturatedStreams(), sendDataOfTraceFile(), stopSending(), successfullyEstablishedConnection(), teardownConnection(), and ~NetPerfMeter().

TransportProtocol

Protocol inet::NetPerfMeter::TransportProtocol = static_cast<Protocol>(-1)

protected

Referenced by createAndBindSocket(), establishConnection(), finish(), handleMessage(), handleTimer(), initialize(), receiveMessage(), sendDataOfNonSaturatedStreams(), sendDataOfTraceFile(), successfullyEstablishedConnection(), teardownConnection(), and transmitFrame().

UnorderedMode

double inet::NetPerfMeter::UnorderedMode = NAN

protected

Referenced by initialize(), and transmitFrame().

UnreliableMode

double inet::NetPerfMeter::UnreliableMode = NAN

protected

Referenced by initialize(), and transmitFrame().

---

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

• NetPerfMeter.h
• NetPerfMeter.cc