inet::ProbabilisticBroadcast Class Reference

This class offers a data dissemination service using probabilistic broadcast. More...

#include <ProbabilisticBroadcast.h>

Inheritance diagram for inet::ProbabilisticBroadcast:

Classes
struct	tMsgDesc
	Store messages in a structure so that we can keep some information needed by the protocol. More...

Public Member Functions
	ProbabilisticBroadcast ()
virtual int	numInitStages () const override
	Initialization of the module and some variables. More...
virtual void	initialize (int) override
virtual void	finish () override
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::INetworkProtocol
virtual	~INetworkProtocol ()

Protected Types
enum	messagesTypes { UNKNOWN = 0, BROADCAST_TIMER, NEIGHBOR_TIMER, BETA_TIMER }
typedef struct inet::ProbabilisticBroadcast::tMsgDesc	tMsgDesc
	Store messages in a structure so that we can keep some information needed by the protocol. More...
typedef std::set< unsigned int >	MsgIdSet
typedef std::multimap< simtime_t, tMsgDesc * >	TimeMsgMap

Protected Member Functions
virtual void	handleUpperPacket (cPacket *msg) override
	Handle messages from upper layer. More...
virtual void	handleLowerPacket (cPacket *msg) override
	Handle messages from lower layer. More...
virtual void	handleSelfMessage (cMessage *msg) override
	Handle self messages. More...
virtual bool	messageKnown (unsigned int msgId)
	Checks whether a message is known (= kept in memory) or not. More...
virtual bool	debugMessageKnown (unsigned int msgId)
	Checks whether a message is known (= kept in memory) or not. More...
virtual void	insertMessage (simtime_t_cref bcastDelay, tMsgDesc *msgDesc)
	Insert a message in both known ID list and message queue. More...
virtual tMsgDesc *	popFirstMessageUpdateQueue (void)
	Returns the descriptor of the first message in the queue, then remove its pointer from the queue and its id from the known IDs list. More...
virtual cPacket *	encapsMsg (cPacket *msg)
	Returns a network layer packet which encapsulates the upper layer packet passed to the function. More...
virtual cPacket *	decapsMsg (ProbabilisticBroadcastDatagram *msg)
	extracts and returns the application layer packet which is encapsulated in the network layer packet given in argument. More...
virtual void	insertNewMessage (ProbabilisticBroadcastDatagram *pkt, bool iAmInitialSender=false)
	Insert a new message in both known ID list and message queue. More...
virtual cObject *	setDownControlInfo (cMessage *const pMsg, const MACAddress &pDestAddr)
	Attaches a "control info" (NetwToMac) structure (object) to the message pMsg. More...
Protected Member Functions inherited from inet::NetworkProtocolBase
	NetworkProtocolBase ()
virtual void	handleUpperCommand (cMessage *message) override
virtual void	sendUp (cMessage *message, int transportProtocol)
virtual void	sendDown (cMessage *message, int interfaceId=-1)
virtual bool	isUpperMessage (cMessage *message) override
virtual bool	isLowerMessage (cMessage *message) override
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalBase
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual bool	handleNodeStart (IDoneCallback *doneCallback)
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback)
virtual void	handleNodeCrash ()
virtual void	setOperational (bool isOperational)

Static Protected Member Functions
static long	getNextID ()

Protected Attributes
simtime_t	broadcastPeriod
	Period (in sim time) between two broadcast attempts. More...
double	beta
	Probability of each broadcast attempt. More...
simtime_t	timeToLive
int	maxNbBcast
	Maximal number of broadcast attempts for each packet. More...
int	maxFirstBcastBackoff
	Maximal back-off before first broadcast attempt [seconds]. More...
simtime_t	timeInQueueAfterDeath
	How long the message should be kept in queue after its died. More...
int	headerLength
	Length of the NetwPkt header Read from omnetpp.ini. More...
cMessage *	broadcastTimer
MsgIdSet	knownMsgIds
TimeMsgMap	msgQueue
MsgIdSet	debugMsgIdSet
long	nbDataPacketsReceived
long	nbDataPacketsSent
long	nbHops
int	debugNbMessageKnown
long	nbDataPacketsForwarded
cOutVector	oneHopLatencies
L3Address	myNetwAddr
Protected Attributes inherited from inet::NetworkProtocolBase
ProtocolMapping	protocolMapping
IInterfaceTable *	interfaceTable
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Static Protected Attributes
static long	id_counter = 0

Private Member Functions
	ProbabilisticBroadcast (const ProbabilisticBroadcast &)
	Copy constructor is not allowed. More...
ProbabilisticBroadcast &	operator= (const ProbabilisticBroadcast &)
	Assignment operator is not allowed. More...

Additional Inherited Members
Static Public Attributes inherited from inet::LayeredProtocolBase
static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")
static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")
static simsignal_t	packetFromUpperDroppedSignal = registerSignal("packetFromUpperDropped")
static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")
static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")
static simsignal_t	packetFromLowerDroppedSignal = registerSignal("packetFromLowerDropped")

Detailed Description

This class offers a data dissemination service using probabilistic broadcast.

Each packet which arrives from upper layer or from the network is (re-)transmitted n times with n = floor(TTL/bcperiod) with probability beta.

Author

Damien Piguet

Member Typedef Documentation

typedef std::set<unsigned int> inet::ProbabilisticBroadcast::MsgIdSet

protected

typedef std::multimap<simtime_t, tMsgDesc *> inet::ProbabilisticBroadcast::TimeMsgMap

protected

typedef struct inet::ProbabilisticBroadcast::tMsgDesc inet::ProbabilisticBroadcast::tMsgDesc

protected

Store messages in a structure so that we can keep some information needed by the protocol.

Member Enumeration Documentation

enum inet::ProbabilisticBroadcast::messagesTypes

protected

Enumerator
UNKNOWN
BROADCAST_TIMER
NEIGHBOR_TIMER
BETA_TIMER

                       {
        UNKNOWN = 0,
        BROADCAST_TIMER,
        NEIGHBOR_TIMER,
        BETA_TIMER,
    };

Constructor & Destructor Documentation

inet::ProbabilisticBroadcast::ProbabilisticBroadcast ( const ProbabilisticBroadcast &  )

private

Copy constructor is not allowed.

inet::ProbabilisticBroadcast::ProbabilisticBroadcast ( )

inline

        : NetworkProtocolBase()
        , broadcastPeriod()
        , beta(0)
        , timeToLive()
        , maxNbBcast(0)
        , maxFirstBcastBackoff(0)
        , timeInQueueAfterDeath(0)
        , headerLength(0)
        , broadcastTimer(nullptr)
        , knownMsgIds()
        , msgQueue()
        , debugMsgIdSet()
        , nbDataPacketsReceived(0)
        , nbDataPacketsSent(0)
        , nbHops(0)
        , debugNbMessageKnown(0)
        , nbDataPacketsForwarded(0)
        , oneHopLatencies()
    {}

Member Function Documentation

bool inet::ProbabilisticBroadcast::debugMessageKnown ( unsigned int  msgId )

protectedvirtual

Checks whether a message is known (= kept in memory) or not.

Referenced by handleLowerPacket().

{
    auto pos = debugMsgIdSet.find(msgId);
    return pos != debugMsgIdSet.end();
}

cPacket * inet::ProbabilisticBroadcast::decapsMsg ( ProbabilisticBroadcastDatagram *  msg )

protectedvirtual

extracts and returns the application layer packet which is encapsulated in the network layer packet given in argument.

Referenced by handleLowerPacket().

{
    cPacket *m = msg->decapsulate();
    SimpleNetworkProtocolControlInfo *const controlInfo = new SimpleNetworkProtocolControlInfo();
    controlInfo->setSourceAddress(msg->getSrcAddr());
    controlInfo->setProtocol(msg->getTransportProtocol());
    m->setControlInfo(controlInfo);
    delete msg;
    return m;
}

cPacket * inet::ProbabilisticBroadcast::encapsMsg ( cPacket *  msg )

protectedvirtual

Returns a network layer packet which encapsulates the upper layer packet passed to the function.

Referenced by handleUpperPacket().

{
    ProbabilisticBroadcastDatagram *pkt = new ProbabilisticBroadcastDatagram(msg->getName());
    cObject *controlInfo = msg->removeControlInfo();
    INetworkProtocolControlInfo *networkControlInfo = check_and_cast<INetworkProtocolControlInfo *>(controlInfo);
    L3Address broadcastAddress = myNetwAddr.getAddressType()->getBroadcastAddress();

    ASSERT(networkControlInfo);
    pkt->setByteLength(headerLength);
    pkt->setSrcAddr(myNetwAddr);
    pkt->setDestAddr(broadcastAddress);
    pkt->setInitialSrcAddr(myNetwAddr);
    pkt->setFinalDestAddr(broadcastAddress);
    pkt->setAppTtl(timeToLive);
    pkt->setId(getNextID());
    pkt->setTransportProtocol(networkControlInfo->getTransportProtocol());

    setDownControlInfo(pkt, MACAddress::BROADCAST_ADDRESS);
    //encapsulate the application packet
    pkt->encapsulate(msg);

    // clean-up
    delete controlInfo;

    return pkt;
}

void inet::ProbabilisticBroadcast::finish ( )

overridevirtual

{
    EV << "PBr: " << simTime() << " n" << myNetwAddr << " finish()" << endl;
    cancelAndDelete(broadcastTimer);
    // if some messages are still in the queue, delete them.
    while (!msgQueue.empty()) {
        auto pos = msgQueue.begin();
        tMsgDesc *msgDesc = pos->second;
        msgQueue.erase(pos);
        delete msgDesc->pkt;
        delete msgDesc;
    }
    recordScalar("nbDataPacketsReceived", nbDataPacketsReceived);
    recordScalar("debugNbMessageKnown", debugNbMessageKnown);
    recordScalar("nbDataPacketsForwarded", nbDataPacketsForwarded);
    if (nbDataPacketsReceived > 0) {
        recordScalar("meanNbHops", (double)nbHops / (double)nbDataPacketsReceived);
    }
    else {
        recordScalar("meanNbHops", 0);
    }
}

static long inet::ProbabilisticBroadcast::getNextID ( )

inlinestaticprotected

Referenced by encapsMsg().

    {
        long nextID = id_counter;
        id_counter++;
        return nextID;
    }

void inet::ProbabilisticBroadcast::handleLowerPacket ( cPacket *  msg )

overrideprotectedvirtual

Handle messages from lower layer.

Implements inet::LayeredProtocolBase.

Reimplemented in inet::AdaptiveProbabilisticBroadcast.

Referenced by inet::AdaptiveProbabilisticBroadcast::handleLowerPacket().

{
    MACAddress macSrcAddr;
    ProbabilisticBroadcastDatagram *m = check_and_cast<ProbabilisticBroadcastDatagram *>(msg);
    IMACProtocolControlInfo *cInfo = check_and_cast<IMACProtocolControlInfo *>(m->removeControlInfo());
    m->setNbHops(m->getNbHops() + 1);
    macSrcAddr = cInfo->getSourceAddress();
    delete cInfo;
    ++nbDataPacketsReceived;
    nbHops = nbHops + m->getNbHops();
    oneHopLatencies.record(SIMTIME_DBL(simTime() - m->getTimestamp()));
    // oneHopLatency gives us an estimate of how long the message spent in the MAC queue of
    // its sender (compared to that, transmission delay is negligible). Use this value
    // to update the TTL of the message. Dump it if it is dead.
    //m->setAppTtl(m->getAppTtl().dbl() - oneHopLatency);
    if (    /*(m->getAppTtl() <= 0) || */ (messageKnown(m->getId()))) {
        // we got this message already, ignore it.
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " handleLowerMsg(): Dead or Known message ID=" << m->getId() << " from node "
           << macSrcAddr << " TTL = " << m->getAppTtl() << endl;
        delete m;
    }
    else {
        if (debugMessageKnown(m->getId())) {
            ++debugNbMessageKnown;
            EV << "PBr: " << simTime() << " n" << myNetwAddr << " ERROR Message should be known TTL= " << m->getAppTtl() << endl;
        }
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " handleLowerMsg(): Unknown message ID=" << m->getId() << " from node "
           << macSrcAddr << endl;
        // Unknown message. Insert message in queue with random backoff broadcast delay.
        // Because we got the message from lower layer, we need to create and add a new
        // control info with the MAC destination address = broadcast address.
        setDownControlInfo(m, MACAddress::BROADCAST_ADDRESS);
        // before inserting message, update source address (for this hop, not the initial source)
        m->setSrcAddr(myNetwAddr);
        insertNewMessage(m);

        // until a subscription mechanism is implemented, duplicate and pass all received packets
        // to the application layer who will be able to compute statistics.
        // TODO: implement an application subscription mechanism.
        if (true) {
            int protocol = m->getTransportProtocol();
            ProbabilisticBroadcastDatagram *mCopy = check_and_cast<ProbabilisticBroadcastDatagram *>(m->dup());
            sendUp(decapsMsg(mCopy), protocol);
        }
    }
}

void inet::ProbabilisticBroadcast::handleSelfMessage ( cMessage *  msg )

overrideprotectedvirtual

Handle self messages.

Reimplemented from inet::LayeredProtocolBase.

Reimplemented in inet::AdaptiveProbabilisticBroadcast.

Referenced by inet::AdaptiveProbabilisticBroadcast::handleSelfMessage().

{
    if (msg == broadcastTimer) {
        tMsgDesc *msgDesc;
        ProbabilisticBroadcastDatagram *pkt;

        // called method pops the first message from the message queue and
        // schedules the message timer for the next one. The message is embedded
        // into a container of type tMsgDesc.
        msgDesc = popFirstMessageUpdateQueue();
        pkt = msgDesc->pkt;
        // if the packet is alive, duplicate it and insert the copy in the queue,
        // then perform a broadcast attempt.
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " handleSelfMsg(): Message ID= " << pkt->getId() << " TTL= " << pkt->getAppTtl() << endl;
        if (pkt->getAppTtl() > 0) {
            // check if we are allowed to re-transmit the message on more time.
            if (msgDesc->nbBcast < maxNbBcast) {
                ProbabilisticBroadcastDatagram *pktCopy;
                bool sendForSure = msgDesc->initialSend;

                // duplicate packet and insert the copy in the queue.
                // two possibilities: the packet will be alive at next
                // broadcast period => insert it with delay = broadcastPeriod.
                // Or the packet will be dead at next broadcast period (TTL <= broadcastPeriod)
                // => insert it with delay = TTL. So when the copy will be popped out of the
                // queue, it will be considered as dead and discarded.
                pktCopy = pkt->dup();
                // control info is not duplicated with the message, so we have to re-create one here.
                setDownControlInfo(pktCopy, MACAddress::BROADCAST_ADDRESS);
                // it the copy that is re-inserted into the queue so update the container accordingly
                msgDesc->pkt = pktCopy;
                // increment nbBcast field of the descriptor because at this point, it is sure that
                // the message will go through one more broadcast attempt.
                msgDesc->nbBcast++;
                // for sure next broadcast attempt will not be the initial one.
                msgDesc->initialSend = false;
                // if msg TTL > broadcast period, the message will be broadcasted one more
                // time, insert it with delay = broadcast period. Otherwise, the message
                // will be dead at next broadcast attempt. Keep it in the list with
                // delay = TTL + timeInQueueAfterDeath. insertMessage() will update its
                // TTL to -timeInQueueAfterDeath, a negative value. That way, the message
                // is known to the system, de-synchronization between copies of the same message
                // is therefore handled and when the message will be popped out, its TTL will
                // be smaller than zero, thus the message will be discarded, not broadcasted.
                if (pktCopy->getAppTtl() > broadcastPeriod)
                    insertMessage(broadcastPeriod, msgDesc);
                else
                    insertMessage(pktCopy->getAppTtl() + timeInQueueAfterDeath, msgDesc);
                // broadcast the message with probability beta
                if (sendForSure) {
                    EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Send packet down for sure." << endl;
                    pkt->setTimestamp();
                    sendDown(pkt);
                    ++nbDataPacketsForwarded;
                }
                else {
                    if (bernoulli(beta)) {
                        EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Bernoulli test result: TRUE. Send packet down." << endl;
                        pkt->setTimestamp();
                        sendDown(pkt);
                        ++nbDataPacketsForwarded;
                    }
                    else {
                        EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Bernoulli test result: FALSE" << endl;
                        delete pkt;
                    }
                }
            }
            else {
                // we can't re-transmit the message because maxNbBcast is reached.
                // re-insert-it in the queue with delay = TTL so that its ID is still
                // known by the system.
                EV << "PBr: " << simTime() << " n" << myNetwAddr << "     maxNbBcast reached." << endl;
                insertMessage(pkt->getAppTtl() + timeInQueueAfterDeath, msgDesc);
            }
        }
        else {
            EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Message TTL zero, discard." << endl;
            delete msgDesc;
            delete pkt;
        }
    }
    else {
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " Received unexpected self message" << endl;
    }
}

void inet::ProbabilisticBroadcast::handleUpperPacket ( cPacket *  msg )

overrideprotectedvirtual

Handle messages from upper layer.

Implements inet::LayeredProtocolBase.

{
    ProbabilisticBroadcastDatagram *pkt;

    // encapsulate message in a network layer packet.
    pkt = check_and_cast<ProbabilisticBroadcastDatagram *>(encapsMsg(check_and_cast<cPacket *>(msg)));
    nbDataPacketsSent++;
    EV << "PBr: " << simTime() << " n" << myNetwAddr << " handleUpperMsg(): Pkt ID = " << pkt->getId() << " TTL = " << pkt->getAppTtl() << endl;
    // submit packet for first insertion in queue.
    insertNewMessage(pkt, true);
}

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

overridevirtual

Reimplemented from inet::NetworkProtocolBase.

Reimplemented in inet::AdaptiveProbabilisticBroadcast.

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

{
    NetworkProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        broadcastPeriod = par("bcperiod");
        beta = par("beta");
        maxNbBcast = par("maxNbBcast");
        headerLength = par("headerLength");
        timeInQueueAfterDeath = par("timeInQueueAfterDeath");
        timeToLive = par("timeToLive");
        broadcastTimer = new cMessage("broadcastTimer");
        maxFirstBcastBackoff = par("maxFirstBcastBackoff");
        oneHopLatencies.setName("oneHopLatencies");
        nbDataPacketsReceived = 0;
        nbDataPacketsSent = 0;
        debugNbMessageKnown = 0;
        nbDataPacketsForwarded = 0;
        nbHops = 0;
    }
    else if (stage == INITSTAGE_NETWORK_LAYER_3) {
        myNetwAddr = interfaceTable->getInterface(1)->getNetworkAddress();
    }
}

void inet::ProbabilisticBroadcast::insertMessage ( simtime_t_cref  bcastDelay, tMsgDesc *  msgDesc  )

protectedvirtual

Insert a message in both known ID list and message queue.

If the message comes in front of the queue (i.e. it will be the next one to be broadcasted, the broadcastTimer is reset accordingly.

Parameters

bcastDelay	relative (to now) simulator time of next broadcast attempt.
msg	descriptor of the message to insert in the queue.

Referenced by handleSelfMessage(), and insertNewMessage().

{
    simtime_t bcastTime = simTime() + bcastDelay;

    EV << "PBr: " << simTime() << " n" << myNetwAddr << "         insertMessage() bcastDelay = " << bcastDelay << " Msg ID = " << msgDesc->pkt->getId() << endl;
    // update TTL field of the message to the value it will have when taken out of the list
    msgDesc->pkt->setAppTtl(msgDesc->pkt->getAppTtl() - bcastDelay);
    // insert message ID in ID list.
    knownMsgIds.insert(msgDesc->pkt->getId());
    // insert key value pair <broadcast time, pointer to message> in message queue.
    auto pos = msgQueue.insert(make_pair(bcastTime, msgDesc));
    // if the message has been inserted in the front of the list, it means that it
    // will be the next message to be broadcasted, therefore we have to re-schedule
    // the broadcast timer to the message's broadcast instant.
    if (pos == msgQueue.begin()) {
        EV << "PBr: " << simTime() << " n" << myNetwAddr << "         message inserted in the front, reschedule it." << endl;
        cancelEvent(broadcastTimer);
        scheduleAt(bcastTime, broadcastTimer);
    }
}

void inet::ProbabilisticBroadcast::insertNewMessage ( ProbabilisticBroadcastDatagram *  pkt, bool  iAmInitialSender = false  )

protectedvirtual

Insert a new message in both known ID list and message queue.

The message comes either from upper layer or from lower layer. In both cases, it will be inserted in the queue with a broadcast attempt delay taken uniformly between 0 and min(broadcast period, TTL) in order to implement a random backoff for the first broadcast of a message.

Parameters

msgDesc	descriptor of the message to insert in the queue.
iAmInitialSender	message comes from upper layer, I am its creator and initial sender.

Referenced by handleLowerPacket(), and handleUpperPacket().

{
    simtime_t ttl = pkt->getAppTtl();

    if (ttl > 0) {
        simtime_t bcastDelay;
        tMsgDesc *msgDesc;

        // insert packet in queue with delay in [0, min(TTL, broadcast period)].
        // since the insertion schedules the message for its first broadcast attempt,
        // we use a uniform random back-off taken between now and the broadcast delay
        // to avoid having all nodes in the neighborhood forward the packet at the same
        // time. Backoffs used at MAC layer are thought to be too short.
        if (broadcastPeriod < maxFirstBcastBackoff)
            bcastDelay = broadcastPeriod;
        else
            bcastDelay = maxFirstBcastBackoff;
        if (bcastDelay > ttl)
            bcastDelay = ttl;
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " insertNewMessage(): insert packet " << pkt->getId() << " with delay "
           << bcastDelay << endl;
        // create container for message and initialize container's values.
        msgDesc = new tMsgDesc;
        msgDesc->pkt = pkt;
        msgDesc->nbBcast = 0;    // so far, pkt has been forwarded zero times.
        msgDesc->initialSend = iAmInitialSender;
        debugMsgIdSet.insert(pkt->getId());
        insertMessage(uniform(0, bcastDelay), msgDesc);
    }
    else {
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " insertNewMessage(): got new packet with TTL = 0." << endl;
        delete pkt;
    }
}

bool inet::ProbabilisticBroadcast::messageKnown ( unsigned int  msgId )

protectedvirtual

Checks whether a message is known (= kept in memory) or not.

Referenced by handleLowerPacket().

{
    auto pos = knownMsgIds.find(msgId);
    return pos != knownMsgIds.end();
}

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

inlineoverridevirtual

Initialization of the module and some variables.

Reimplemented from inet::OperationalBase.

{ return NUM_INIT_STAGES; }

ProbabilisticBroadcast& inet::ProbabilisticBroadcast::operator= ( const ProbabilisticBroadcast &  )

private

Assignment operator is not allowed.

ProbabilisticBroadcast::tMsgDesc * inet::ProbabilisticBroadcast::popFirstMessageUpdateQueue ( void  )

protectedvirtual

Returns the descriptor of the first message in the queue, then remove its pointer from the queue and its id from the known IDs list.

Then re-schedule the broadcastTimer to the broadcast instant of the new first element in the list.

Referenced by handleSelfMessage().

{
    tMsgDesc *msgDesc;

    // get first message.
    ASSERT(!msgQueue.empty());
    auto pos = msgQueue.begin();
    msgDesc = pos->second;
    // remove first message from message queue and from ID list
    msgQueue.erase(pos);
    knownMsgIds.erase(msgDesc->pkt->getId());
    EV << "PBr: " << simTime() << " n" << myNetwAddr << "         pop(): just popped msg " << msgDesc->pkt->getId() << endl;
    if (!msgQueue.empty()) {
        // schedule broadcast of new first message
        EV << "PBr: " << simTime() << " n" << myNetwAddr << "         pop(): schedule next message." << endl;
        pos = msgQueue.begin();
        scheduleAt(pos->first, broadcastTimer);
    }
    return msgDesc;
}

cObject * inet::ProbabilisticBroadcast::setDownControlInfo ( cMessage *const  pMsg, const MACAddress &  pDestAddr  )

protectedvirtual

Attaches a "control info" (NetwToMac) structure (object) to the message pMsg.

Attaches a "control info" structure (object) to the down message pMsg.

This is most useful when passing packets between protocol layers of a protocol stack, the control info will contain the destination MAC address.

The "control info" object will be deleted when the message is deleted. Only one "control info" structure can be attached (the second setL3ToL2ControlInfo() call throws an error).

Parameters

pMsg	The message where the "control info" shall be attached.
pDestAddr	The MAC address of the message receiver.

Referenced by encapsMsg(), handleLowerPacket(), and handleSelfMessage().

{
    SimpleLinkLayerControlInfo *const cCtrlInfo = new SimpleLinkLayerControlInfo();
    cCtrlInfo->setDest(pDestAddr);
    pMsg->setControlInfo(cCtrlInfo);
    return cCtrlInfo;
}

Member Data Documentation

double inet::ProbabilisticBroadcast::beta

protected

Probability of each broadcast attempt.

Read from omnetpp.ini

Referenced by handleSelfMessage(), inet::AdaptiveProbabilisticBroadcast::initialize(), initialize(), and inet::AdaptiveProbabilisticBroadcast::updateBeta().

simtime_t inet::ProbabilisticBroadcast::broadcastPeriod

protected

Period (in sim time) between two broadcast attempts.

Read from omnetpp.ini

Referenced by handleSelfMessage(), initialize(), and insertNewMessage().

cMessage* inet::ProbabilisticBroadcast::broadcastTimer

protected

Referenced by finish(), handleSelfMessage(), initialize(), insertMessage(), and popFirstMessageUpdateQueue().

MsgIdSet inet::ProbabilisticBroadcast::debugMsgIdSet

protected

Referenced by debugMessageKnown(), and insertNewMessage().

int inet::ProbabilisticBroadcast::debugNbMessageKnown

protected

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

int inet::ProbabilisticBroadcast::headerLength

protected

Length of the NetwPkt header Read from omnetpp.ini.

Referenced by encapsMsg(), and initialize().

long inet::ProbabilisticBroadcast::id_counter = 0

staticprotected

MsgIdSet inet::ProbabilisticBroadcast::knownMsgIds

protected

Referenced by insertMessage(), messageKnown(), and popFirstMessageUpdateQueue().

int inet::ProbabilisticBroadcast::maxFirstBcastBackoff

protected

Maximal back-off before first broadcast attempt [seconds].

Read from omnetpp.ini

Referenced by initialize(), and insertNewMessage().

int inet::ProbabilisticBroadcast::maxNbBcast

protected

Maximal number of broadcast attempts for each packet.

Read from omnetpp.ini

Referenced by handleSelfMessage(), and initialize().

TimeMsgMap inet::ProbabilisticBroadcast::msgQueue

protected

Referenced by finish(), insertMessage(), and popFirstMessageUpdateQueue().

L3Address inet::ProbabilisticBroadcast::myNetwAddr

protected

Referenced by encapsMsg(), finish(), handleLowerPacket(), handleSelfMessage(), handleUpperPacket(), initialize(), insertMessage(), insertNewMessage(), and popFirstMessageUpdateQueue().

long inet::ProbabilisticBroadcast::nbDataPacketsForwarded

protected

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

long inet::ProbabilisticBroadcast::nbDataPacketsReceived

protected

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

long inet::ProbabilisticBroadcast::nbDataPacketsSent

protected

Referenced by handleUpperPacket(), and initialize().

long inet::ProbabilisticBroadcast::nbHops

protected

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

cOutVector inet::ProbabilisticBroadcast::oneHopLatencies

protected

Referenced by handleLowerPacket(), and initialize().

simtime_t inet::ProbabilisticBroadcast::timeInQueueAfterDeath

protected

How long the message should be kept in queue after its died.

That way the message is known if the node receives one of its copy that isn't dead because of TTL de-synchronization due to MAC backoff, propagation delay and clock drift. Read from omnetpp.ini

Referenced by handleSelfMessage(), and initialize().

simtime_t inet::ProbabilisticBroadcast::timeToLive

protected

Referenced by encapsMsg(), and initialize().

---

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

• ProbabilisticBroadcast.h
• ProbabilisticBroadcast.cc