inet::PingApp Class Reference

Generates ping requests and calculates the packet loss and round trip parameters of the replies. More...

#include <PingApp.h>

Inheritance diagram for inet::PingApp:

Public Member Functions
	PingApp ()
virtual	~PingApp ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	finish () override
virtual void	refreshDisplay () const override
virtual void	parseDestAddressesPar ()
virtual void	startSendingPingRequests ()
virtual void	stopSendingPingRequests ()
virtual void	scheduleNextPingRequest (simtime_t previous, bool withSleep)
virtual void	cancelNextPingRequest ()
virtual bool	isNodeUp ()
virtual bool	isEnabled ()
virtual std::vector< L3Address >	getAllAddresses ()
virtual void	sendPing ()
virtual void	processPingResponse (PingPayload *msg)
virtual void	countPingResponse (int bytes, long seqNo, simtime_t rtt)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...

Protected Attributes
L3Address	destAddr
L3Address	srcAddr
std::vector< L3Address >	destAddresses
int	packetSize = 0
cPar *	sendIntervalPar = nullptr
cPar *	sleepDurationPar = nullptr
int	hopLimit = 0
int	count = 0
int	destAddrIdx = -1
simtime_t	startTime
simtime_t	stopTime
bool	printPing = false
bool	continuous = false
int	pid = 0
cMessage *	timer = nullptr
NodeStatus *	nodeStatus = nullptr
simtime_t	lastStart
long	sendSeqNo = 0
long	expectedReplySeqNo = 0
simtime_t	sendTimeHistory [PING_HISTORY_SIZE]
cStdDev	rttStat
long	sentCount = 0
long	lossCount = 0
long	outOfOrderArrivalCount = 0
long	numPongs = 0

Static Protected Attributes
static simsignal_t	rttSignal = registerSignal("rtt")
static simsignal_t	numLostSignal = registerSignal("numLost")
static simsignal_t	numOutOfOrderArrivalsSignal = registerSignal("numOutOfOrderArrivals")
static simsignal_t	pingTxSeqSignal = registerSignal("pingTxSeq")
static simsignal_t	pingRxSeqSignal = registerSignal("pingRxSeq")

Detailed Description

Generates ping requests and calculates the packet loss and round trip parameters of the replies.

See NED file for detailed description of operation.

Constructor & Destructor Documentation

inet::PingApp::PingApp

(

)

{
}

inet::PingApp::~PingApp ( )

virtual

{
    cancelAndDelete(timer);
}

Member Function Documentation

void inet::PingApp::cancelNextPingRequest ( )

protectedvirtual

Referenced by stopSendingPingRequests().

{
    cancelEvent(timer);
}

void inet::PingApp::countPingResponse ( int  bytes, long  seqNo, simtime_t  rtt  )

protectedvirtual

Referenced by processPingResponse().

{
    EV_INFO << "Ping reply #" << seqNo << " arrived, rtt=" << rtt << "\n";
    emit(pingRxSeqSignal, seqNo);

    numPongs++;

    // count only non 0 RTT values as 0s are invalid
    if (rtt > 0) {
        rttStat.collect(rtt);
        emit(rttSignal, rtt);
    }

    if (seqNo == expectedReplySeqNo) {
        // expected ping reply arrived; expect next sequence number
        expectedReplySeqNo++;
    }
    else if (seqNo > expectedReplySeqNo) {
        EV_DETAIL << "Jump in seq numbers, assuming pings since #" << expectedReplySeqNo << " got lost\n";

        // jump in the sequence: count pings in gap as lost for now
        // (if they arrive later, we'll decrement back the loss counter)
        long jump = seqNo - expectedReplySeqNo;
        lossCount += jump;
        emit(numLostSignal, lossCount);

        // expect sequence numbers to continue from here
        expectedReplySeqNo = seqNo + 1;
    }
    else {    // seqNo < expectedReplySeqNo
              // ping reply arrived too late: count as out-of-order arrival (not loss after all)
        EV_DETAIL << "Arrived out of order (too late)\n";
        outOfOrderArrivalCount++;
        lossCount--;
        emit(numOutOfOrderArrivalsSignal, outOfOrderArrivalCount);
        emit(numLostSignal, lossCount);
    }
}

void inet::PingApp::finish ( )

overrideprotectedvirtual

{
    if (sendSeqNo == 0) {
        if (printPing)
            EV_DETAIL << getFullPath() << ": No pings sent, skipping recording statistics and printing results.\n";
        return;
    }

    lossCount += sendSeqNo - expectedReplySeqNo;
    // record statistics
    recordScalar("Pings sent", sendSeqNo);
    recordScalar("ping loss rate (%)", 100 * lossCount / (double)sendSeqNo);
    recordScalar("ping out-of-order rate (%)", 100 * outOfOrderArrivalCount / (double)sendSeqNo);

    // print it to stdout as well
    if (printPing) {
        cout << "--------------------------------------------------------" << endl;
        cout << "\t" << getFullPath() << endl;
        cout << "--------------------------------------------------------" << endl;

        cout << "sent: " << sendSeqNo << "   received: " << numPongs << "   loss rate (%): " << (100 * lossCount / (double)sendSeqNo) << endl;
        cout << "round-trip min/avg/max (ms): " << (rttStat.getMin() * 1000.0) << "/"
             << (rttStat.getMean() * 1000.0) << "/" << (rttStat.getMax() * 1000.0) << endl;
        cout << "stddev (ms): " << (rttStat.getStddev() * 1000.0) << "   variance:" << rttStat.getVariance() << endl;
        cout << "--------------------------------------------------------" << endl;
    }
}

std::vector< L3Address > inet::PingApp::getAllAddresses ( )

protectedvirtual

Referenced by parseDestAddressesPar().

{
    std::vector<L3Address> result;

    int lastId = getSimulation()->getLastComponentId();

    for (int i = 0; i <= lastId; i++)
    {
        IInterfaceTable *ift = dynamic_cast<IInterfaceTable *>(getSimulation()->getModule(i));
        if (ift) {
            for (int j = 0; j < ift->getNumInterfaces(); j++) {
                InterfaceEntry *ie = ift->getInterface(j);
                if (ie && !ie->isLoopback()) {
#ifdef WITH_IPv4
                    if (ie->ipv4Data()) {
                        IPv4Address address = ie->ipv4Data()->getIPAddress();
                        if (!address.isUnspecified())
                            result.push_back(L3Address(address));
                    }
#endif // ifdef WITH_IPv4
#ifdef WITH_IPv6
                    if (ie->ipv6Data()) {
                        for (int k = 0; k < ie->ipv6Data()->getNumAddresses(); k++) {
                            IPv6Address address = ie->ipv6Data()->getAddress(k);
                            if (!address.isUnspecified() && address.isGlobal())
                                result.push_back(L3Address(address));
                        }
                    }
#endif // ifdef WITH_IPv6
                }
            }
        }
    }
    return result;
}

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

overrideprotectedvirtual

{
    if (!isNodeUp()) {
        if (msg->isSelfMessage())
            throw cRuntimeError("Self message '%s' received when %s is down", msg->getName(), getComponentType()->getName());
        else {
            EV_WARN << "PingApp is down, dropping '" << msg->getName() << "' message\n";
            delete msg;
            return;
        }
    }
    if (msg->isSelfMessage()) {
        if (msg->getKind() == PING_FIRST_ADDR) {
            srcAddr = L3AddressResolver().resolve(par("srcAddr"));
            parseDestAddressesPar();
            if (destAddresses.empty()) {
                return;
            }
            destAddrIdx = 0;
            msg->setKind(PING_CHANGE_ADDR);
        }

        if (msg->getKind() == PING_CHANGE_ADDR) {
            if (destAddrIdx >= (int)destAddresses.size())
                return;
            destAddr = destAddresses[destAddrIdx];
            EV_INFO << "Starting up: dest=" << destAddr << "  src=" << srcAddr << "seqNo=" << sendSeqNo << endl;
            ASSERT(!destAddr.isUnspecified());
            msg->setKind(PING_SEND);
        }

        ASSERT2(msg->getKind() == PING_SEND, "Unknown kind in self message.");

        // send a ping
        sendPing();

        if (count > 0 && sendSeqNo % count == 0) {
            // choose next dest address
            destAddrIdx++;
            msg->setKind(PING_CHANGE_ADDR);
            if (destAddrIdx >= (int)destAddresses.size()) {
                if (continuous) {
                    destAddrIdx = destAddrIdx % destAddresses.size();
                }
            }
        }

        // then schedule next one if needed
        scheduleNextPingRequest(simTime(), msg->getKind() == PING_CHANGE_ADDR);
    }
    else {
        // process ping response
        processPingResponse(check_and_cast<PingPayload *>(msg));
    }
}

bool inet::PingApp::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overrideprotectedvirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

{
    Enter_Method_Silent();
    if (dynamic_cast<NodeStartOperation *>(operation)) {
        if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_APPLICATION_LAYER && isEnabled())
            startSendingPingRequests();
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_APPLICATION_LAYER)
            stopSendingPingRequests();
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH)
            stopSendingPingRequests();
    }
    else
        throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName());
    return true;
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        // read params
        // (defer reading srcAddr/destAddr to when ping starts, maybe
        // addresses will be assigned later by some protocol)
        packetSize = par("packetSize");
        sendIntervalPar = &par("sendInterval");
        sleepDurationPar = &par("sleepDuration");
        hopLimit = par("hopLimit");
        count = par("count");
//        if (count <= 0 && count != -1)
//            throw cRuntimeError("Invalid count=%d parameter (should use -1 or a larger than zero value)", count);
        startTime = par("startTime");
        stopTime = par("stopTime");
        if (stopTime >= SIMTIME_ZERO && stopTime < startTime)
            throw cRuntimeError("Invalid startTime/stopTime parameters");
        printPing = par("printPing").boolValue();
        continuous = par("continuous").boolValue();

        // state
        pid = -1;
        lastStart = -1;
        sendSeqNo = expectedReplySeqNo = 0;
        WATCH(sendSeqNo);
        WATCH(expectedReplySeqNo);

        // statistics
        rttStat.setName("pingRTT");
        sentCount = lossCount = outOfOrderArrivalCount = numPongs = 0;
        WATCH(lossCount);
        WATCH(outOfOrderArrivalCount);
        WATCH(numPongs);

        // references
        timer = new cMessage("sendPing", PING_FIRST_ADDR);


    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        // startup
        nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
        if (isEnabled() && isNodeUp())
            startSendingPingRequests();
    }
}

bool inet::PingApp::isEnabled ( )

protectedvirtual

Referenced by handleOperationStage(), and initialize().

{
    return par("destAddr").stringValue()[0] && (count == -1 || sentCount < count);
}

bool inet::PingApp::isNodeUp ( )

protectedvirtual

Referenced by handleMessage(), and initialize().

{
    return !nodeStatus || nodeStatus->getState() == NodeStatus::UP;
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::PingApp::parseDestAddressesPar ( )

protectedvirtual

Referenced by handleMessage().

{
    srcAddr = L3AddressResolver().resolve(par("srcAddr"));
    const char *destAddrs = par("destAddr");
    if (!strcmp(destAddrs, "*")) {
        destAddresses = getAllAddresses();
    }
    else {
        cStringTokenizer tokenizer(destAddrs);
        const char *token;

        while ((token = tokenizer.nextToken()) != nullptr) {
            L3Address addr = L3AddressResolver().resolve(token);
            destAddresses.push_back(addr);
        }
    }
}

void inet::PingApp::processPingResponse ( PingPayload *  msg )

protectedvirtual

Referenced by handleMessage().

{
    if (msg->getOriginatorId() != pid) {
        EV_WARN << "Received response was not sent by this application, dropping packet\n";
        delete msg;
        return;
    }

    // get src, hopCount etc from packet, and print them
    INetworkProtocolControlInfo *ctrl = check_and_cast<INetworkProtocolControlInfo *>(msg->getControlInfo());
    L3Address src = ctrl->getSourceAddress();
    //L3Address dest = ctrl->getDestinationAddress();
    int msgHopCount = ctrl->getHopLimit();

    // calculate the RTT time by looking up the the send time of the packet
    // if the send time is no longer available (i.e. the packet is very old and the
    // sendTime was overwritten in the circular buffer) then we just return a 0
    // to signal that this value should not be used during the RTT statistics)
    simtime_t rtt = sendSeqNo - msg->getSeqNo() > PING_HISTORY_SIZE ?
        0 : simTime() - sendTimeHistory[msg->getSeqNo() % PING_HISTORY_SIZE];

    if (printPing) {
        cout << getFullPath() << ": reply of " << std::dec << msg->getByteLength()
             << " bytes from " << src
             << " icmp_seq=" << msg->getSeqNo() << " ttl=" << msgHopCount
             << " time=" << (rtt * 1000) << " msec"
             << " (" << msg->getName() << ")" << endl;
    }

    // update statistics
    countPingResponse(msg->getByteLength(), msg->getSeqNo(), rtt);
    delete msg;
}

void inet::PingApp::refreshDisplay ( ) const

overrideprotectedvirtual

{
    char buf[40];
    sprintf(buf, "sent: %ld pks\nrcvd: %ld pks", sentCount, numPongs);
    getDisplayString().setTagArg("t", 0, buf);
}

void inet::PingApp::scheduleNextPingRequest ( simtime_t  previous, bool  withSleep  )

protectedvirtual

Referenced by handleMessage(), and startSendingPingRequests().

{
    simtime_t next;
    if (previous < SIMTIME_ZERO)
        next = simTime() <= startTime ? startTime : simTime();
    else {
        next = previous + sendIntervalPar->doubleValue();
        if (withSleep)
            next += sleepDurationPar->doubleValue();
    }
    if (stopTime < SIMTIME_ZERO || next < stopTime)
        scheduleAt(next, timer);
}

void inet::PingApp::sendPing ( )

protectedvirtual

Referenced by handleMessage().

{
    char name[32];
    sprintf(name, "ping%ld", sendSeqNo);

    PingPayload *msg = new PingPayload(name);
    ASSERT(pid != -1);
    msg->setOriginatorId(pid);
    msg->setSeqNo(sendSeqNo);
    msg->setByteLength(packetSize + 4);

    // store the sending time in a circular buffer so we can compute RTT when the packet returns
    sendTimeHistory[sendSeqNo % PING_HISTORY_SIZE] = simTime();

    emit(pingTxSeqSignal, sendSeqNo);
    sendSeqNo++;
    sentCount++;
    IL3AddressType *addressType = destAddr.getAddressType();
    INetworkProtocolControlInfo *controlInfo = addressType->createNetworkProtocolControlInfo();
    controlInfo->setSourceAddress(srcAddr);
    controlInfo->setDestinationAddress(destAddr);
    controlInfo->setHopLimit(hopLimit);
    // TODO: remove
    controlInfo->setTransportProtocol(1);    // IP_PROT_ICMP);
    msg->setControlInfo(dynamic_cast<cObject *>(controlInfo));
    EV_INFO << "Sending ping request #" << msg->getSeqNo() << " to lower layer.\n";
    send(msg, "pingOut");
}

void inet::PingApp::startSendingPingRequests ( )

protectedvirtual

Referenced by handleOperationStage(), and initialize().

{
    ASSERT(!timer->isScheduled());
    pid = getSimulation()->getUniqueNumber();
    lastStart = simTime();
    timer->setKind(PING_FIRST_ADDR);
    sentCount = 0;
    sendSeqNo = 0;
    scheduleNextPingRequest(-1, false);
}

void inet::PingApp::stopSendingPingRequests ( )

protectedvirtual

Referenced by handleOperationStage().

{
    pid = -1;
    lastStart = -1;
    sendSeqNo = expectedReplySeqNo = 0;
    srcAddr = destAddr = L3Address();
    destAddresses.clear();
    destAddrIdx = -1;
    cancelNextPingRequest();
}

Member Data Documentation

bool inet::PingApp::continuous = false

protected

Referenced by handleMessage(), and initialize().

int inet::PingApp::count = 0

protected

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

L3Address inet::PingApp::destAddr

protected

Referenced by handleMessage(), sendPing(), and stopSendingPingRequests().

std::vector<L3Address> inet::PingApp::destAddresses

protected

Referenced by handleMessage(), parseDestAddressesPar(), and stopSendingPingRequests().

int inet::PingApp::destAddrIdx = -1

protected

Referenced by handleMessage(), and stopSendingPingRequests().

long inet::PingApp::expectedReplySeqNo = 0

protected

Referenced by countPingResponse(), finish(), initialize(), and stopSendingPingRequests().

int inet::PingApp::hopLimit = 0

protected

Referenced by initialize(), and sendPing().

simtime_t inet::PingApp::lastStart

protected

Referenced by initialize(), startSendingPingRequests(), and stopSendingPingRequests().

long inet::PingApp::lossCount = 0

protected

Referenced by countPingResponse(), finish(), and initialize().

NodeStatus* inet::PingApp::nodeStatus = nullptr

protected

Referenced by initialize(), and isNodeUp().

simsignal_t inet::PingApp::numLostSignal = registerSignal("numLost")

staticprotected

Referenced by countPingResponse().

simsignal_t inet::PingApp::numOutOfOrderArrivalsSignal = registerSignal("numOutOfOrderArrivals")

staticprotected

Referenced by countPingResponse().

long inet::PingApp::numPongs = 0

protected

Referenced by countPingResponse(), finish(), initialize(), and refreshDisplay().

long inet::PingApp::outOfOrderArrivalCount = 0

protected

Referenced by countPingResponse(), finish(), and initialize().

int inet::PingApp::packetSize = 0

protected

Referenced by initialize(), and sendPing().

int inet::PingApp::pid = 0

protected

Referenced by initialize(), processPingResponse(), sendPing(), startSendingPingRequests(), and stopSendingPingRequests().

simsignal_t inet::PingApp::pingRxSeqSignal = registerSignal("pingRxSeq")

staticprotected

Referenced by countPingResponse().

simsignal_t inet::PingApp::pingTxSeqSignal = registerSignal("pingTxSeq")

staticprotected

Referenced by sendPing().

bool inet::PingApp::printPing = false

protected

Referenced by finish(), initialize(), and processPingResponse().

simsignal_t inet::PingApp::rttSignal = registerSignal("rtt")

staticprotected

Referenced by countPingResponse().

cStdDev inet::PingApp::rttStat

protected

Referenced by countPingResponse(), finish(), and initialize().

cPar* inet::PingApp::sendIntervalPar = nullptr

protected

Referenced by initialize(), and scheduleNextPingRequest().

long inet::PingApp::sendSeqNo = 0

protected

Referenced by finish(), handleMessage(), initialize(), processPingResponse(), sendPing(), startSendingPingRequests(), and stopSendingPingRequests().

simtime_t inet::PingApp::sendTimeHistory[PING_HISTORY_SIZE]

protected

Referenced by processPingResponse(), and sendPing().

long inet::PingApp::sentCount = 0

protected

Referenced by initialize(), isEnabled(), refreshDisplay(), sendPing(), and startSendingPingRequests().

cPar* inet::PingApp::sleepDurationPar = nullptr

protected

Referenced by initialize(), and scheduleNextPingRequest().

L3Address inet::PingApp::srcAddr

protected

Referenced by handleMessage(), parseDestAddressesPar(), sendPing(), and stopSendingPingRequests().

simtime_t inet::PingApp::startTime

protected

Referenced by initialize(), and scheduleNextPingRequest().

simtime_t inet::PingApp::stopTime

protected

Referenced by initialize(), and scheduleNextPingRequest().

cMessage* inet::PingApp::timer = nullptr

protected

Referenced by cancelNextPingRequest(), initialize(), scheduleNextPingRequest(), startSendingPingRequests(), and ~PingApp().

---

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

• PingApp.h
• PingApp.cc