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
const Protocol &	getProtocol () const override
Public Member Functions inherited from inet::NetworkProtocolBase
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override
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 Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual void	handleUpperPacket (Packet *packet) override
	Handle messages from upper layer. More...
virtual void	handleLowerPacket (Packet *packet) 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 void	encapsulate (Packet *packet)
	Returns a network layer packet which encapsulates the upper layer packet passed to the function. More...
virtual void	decapsulate (Packet *packet)
	extracts and returns the application layer packet which is encapsulated in the network layer packet given in argument, delete network layer packet. More...
virtual void	insertNewMessage (Packet *packet, bool iAmInitialSender=false)
	Insert a new message in both known ID list and message queue. More...
virtual void	setDownControlInfo (Packet *const pMsg, const MacAddress &pDestAddr)
	Attaches a "control info" (NetwToMac) structure (object) to the message pMsg. More...
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
Protected Member Functions inherited from inet::NetworkProtocolBase
	NetworkProtocolBase ()
virtual	~NetworkProtocolBase ()
virtual void	sendUp (cMessage *message)
virtual void	sendDown (cMessage *message, int interfaceId=-1)
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	handleUpperCommand (cMessage *msg) override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Static Protected Member Functions
static long	getNextID ()

Protected Attributes
simtime_t	broadcastPeriod
	Period (in sim time) between two broadcast attempts. More...
double	beta = 0.0
	Probability of each broadcast attempt. More...
simtime_t	timeToLive
int	maxNbBcast = 0
	Maximal number of broadcast attempts for each packet. More...
simtime_t	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 = 0
	Length of the NetwPkt header Read from omnetpp.ini. More...
cMessage *	broadcastTimer = nullptr
MsgIdSet	knownMsgIds
TimeMsgMap	msgQueue
MsgIdSet	debugMsgIdSet
long	nbDataPacketsReceived = 0
long	nbDataPacketsSent = 0
long	nbHops = 0
int	debugNbMessageKnown = 0
long	nbDataPacketsForwarded = 0
cOutVector	oneHopLatencies
L3Address	myNetwAddr
Protected Attributes inherited from inet::NetworkProtocolBase
ModuleRefByPar< IInterfaceTable >	interfaceTable
std::set< const Protocol * >	upperProtocols
std::map< int, SocketDescriptor * >	socketIdToSocketDescriptor
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

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...

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

MsgIdSet

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

protected

TimeMsgMap

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

protected

tMsgDesc

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

messagesTypes

enum inet::ProbabilisticBroadcast::messagesTypes

protected

Enumerator
UNKNOWN
BROADCAST_TIMER
NEIGHBOR_TIMER
BETA_TIMER

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

Constructor & Destructor Documentation

ProbabilisticBroadcast() [1/2]

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

private

Copy constructor is not allowed.

ProbabilisticBroadcast() [2/2]

inet::ProbabilisticBroadcast::ProbabilisticBroadcast ( )

inline

{}

Member Function Documentation

debugMessageKnown()

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

protectedvirtual

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

{
    return contains(debugMsgIdSet, msgId);
}

Referenced by handleLowerPacket().

decapsulate()

void inet::ProbabilisticBroadcast::decapsulate ( Packet *  packet )

protectedvirtual

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

{
    auto networkHeader = packet->popAtFront<ProbabilisticBroadcastHeader>();
    auto payloadLength = networkHeader->getPayloadLengthField();
    if (packet->getDataLength() < payloadLength) {
        throw cRuntimeError("Data error: illegal payload length"); // FIXME packet drop
    }
    if (packet->getDataLength() > payloadLength)
        packet->setBackOffset(packet->getFrontOffset() + payloadLength);
    auto payloadProtocol = networkHeader->getProtocol();
    packet->addTagIfAbsent<NetworkProtocolInd>()->setProtocol(&getProtocol());
    packet->addTagIfAbsent<NetworkProtocolInd>()->setNetworkProtocolHeader(networkHeader);
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(payloadProtocol);
    packet->addTagIfAbsent<L3AddressInd>()->setSrcAddress(networkHeader->getSrcAddr());
}

Referenced by handleLowerPacket().

encapsulate()

void inet::ProbabilisticBroadcast::encapsulate ( Packet *  packet )

protectedvirtual

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

{
    auto pkt = makeShared<ProbabilisticBroadcastHeader>(); // TODO msg->getName());
    cObject *controlInfo = packet->removeControlInfo();
    L3Address broadcastAddress = myNetwAddr.getAddressType()->getBroadcastAddress();
 
    pkt->setChunkLength(B(headerLength));
    pkt->setSrcAddr(myNetwAddr);
    pkt->setDestAddr(broadcastAddress);
    pkt->setInitialSrcAddr(myNetwAddr);
    pkt->setFinalDestAddr(broadcastAddress);
    pkt->setAppTtl(timeToLive);
    pkt->setId(getNextID());
    pkt->setProtocol(packet->getTag<PacketProtocolTag>()->getProtocol());
    pkt->setPayloadLengthField(packet->getDataLength());
    // clean-up
    delete controlInfo;
 
    // encapsulate the application packet
    packet->insertAtFront(pkt);
 
    setDownControlInfo(packet, MacAddress::BROADCAST_ADDRESS);
}

Referenced by handleUpperPacket().

finish()

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

getNextID()

static long inet::ProbabilisticBroadcast::getNextID ( )

inlinestaticprotected

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

Referenced by encapsulate().

getProtocol()

const Protocol& inet::ProbabilisticBroadcast::getProtocol ( ) const

inlineoverridevirtual

Implements inet::NetworkProtocolBase.

{ return Protocol::probabilistic; }

Referenced by decapsulate().

handleCrashOperation()

virtual void inet::ProbabilisticBroadcast::handleCrashOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{} // TODO implementation

handleLowerPacket()

void inet::ProbabilisticBroadcast::handleLowerPacket ( Packet *  packet )

overrideprotectedvirtual

Handle messages from lower layer.

Reimplemented from inet::LayeredProtocolBase.

Reimplemented in inet::AdaptiveProbabilisticBroadcast.

{
    MacAddress macSrcAddr;
    auto macHeader = dynamicPtrCast<ProbabilisticBroadcastHeader>(packet->popAtFront<ProbabilisticBroadcastHeader>()->dupShared());
    packet->trim();
    auto macAddressInd = packet->getTag<MacAddressInd>();
    macHeader->setNbHops(macHeader->getNbHops() + 1);
    macSrcAddr = macAddressInd->getSrcAddress();
    delete packet->removeControlInfo();
    ++nbDataPacketsReceived;
    nbHops = nbHops + macHeader->getNbHops();
    oneHopLatencies.record(SIMTIME_DBL(simTime() - packet->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(macHeader->getId()))) {
        // we got this message already, ignore it.
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " handleLowerMsg(): Dead or Known message ID=" << macHeader->getId() << " from node "
           << macSrcAddr << " TTL = " << macHeader->getAppTtl() << endl;
        delete packet;
    }
    else {
        if (debugMessageKnown(macHeader->getId())) {
            ++debugNbMessageKnown;
            EV << "PBr: " << simTime() << " n" << myNetwAddr << " ERROR Message should be known TTL= " << macHeader->getAppTtl() << endl;
        }
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " handleLowerMsg(): Unknown message ID=" << macHeader->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(packet, MacAddress::BROADCAST_ADDRESS);
        // before inserting message, update source address (for this hop, not the initial source)
        macHeader->setSrcAddr(myNetwAddr);
        packet->insertAtFront(macHeader);
        insertNewMessage(packet);
 
        // 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) {
            auto mCopy = packet->dup();
            decapsulate(mCopy);
            sendUp(mCopy);
        }
    }
}

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

handleSelfMessage()

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

overrideprotectedvirtual

Handle self messages.

Reimplemented from inet::LayeredProtocolBase.

Reimplemented in inet::AdaptiveProbabilisticBroadcast.

{
    if (msg == broadcastTimer) {
        tMsgDesc *msgDesc;
        // 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();
        auto packet = msgDesc->pkt;
        auto macHeader = packet->peekAtFront<ProbabilisticBroadcastHeader>();
        // 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= " << macHeader->getId() << " TTL= " << macHeader->getAppTtl() << endl;
        if (macHeader->getAppTtl() > 0) {
            // check if we are allowed to re-transmit the message on more time.
            if (msgDesc->nbBcast < maxNbBcast) {
                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.
                auto packetCopy = packet->dup();
                auto macHeaderCopy = packetCopy->peekAtFront<ProbabilisticBroadcastHeader>();
                // control info is not duplicated with the message, so we have to re-create one here.
                setDownControlInfo(packetCopy, MacAddress::BROADCAST_ADDRESS);
                // it the copy that is re-inserted into the queue so update the container accordingly
                msgDesc->pkt = packetCopy;
                // 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 (macHeaderCopy->getAppTtl() > broadcastPeriod)
                    insertMessage(broadcastPeriod, msgDesc);
                else
                    insertMessage(macHeaderCopy->getAppTtl() + timeInQueueAfterDeath, msgDesc);
                // broadcast the message with probability beta
                if (sendForSure) {
                    EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Send packet down for sure." << endl;
                    packet->setTimestamp();
                    sendDown(packet);
                    ++nbDataPacketsForwarded;
                }
                else {
                    if (bernoulli(beta)) {
                        EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Bernoulli test result: TRUE. Send packet down." << endl;
                        packet->setTimestamp();
                        sendDown(packet);
                        ++nbDataPacketsForwarded;
                    }
                    else {
                        EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Bernoulli test result: FALSE" << endl;
                        delete packet;
                    }
                }
            }
            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(macHeader->getAppTtl() + timeInQueueAfterDeath, msgDesc);
            }
        }
        else {
            EV << "PBr: " << simTime() << " n" << myNetwAddr << "     Message TTL zero, discard." << endl;
            delete msgDesc;
            delete packet;
        }
    }
    else {
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " Received unexpected self message" << endl;
    }
}

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

handleStartOperation()

virtual void inet::ProbabilisticBroadcast::handleStartOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{} // TODO implementation

handleStopOperation()

virtual void inet::ProbabilisticBroadcast::handleStopOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{} // TODO implementation

handleUpperPacket()

void inet::ProbabilisticBroadcast::handleUpperPacket ( Packet *  packet )

overrideprotectedvirtual

Handle messages from upper layer.

Reimplemented from inet::LayeredProtocolBase.

{
    // encapsulate message in a network layer packet.
    encapsulate(packet);
    auto macHeader = packet->peekAtFront<ProbabilisticBroadcastHeader>();
    nbDataPacketsSent++;
    EV << "PBr: " << simTime() << " n" << myNetwAddr << " handleUpperMsg(): Pkt ID = " << macHeader->getId() << " TTL = " << macHeader->getAppTtl() << endl;
    // submit packet for first insertion in queue.
    insertNewMessage(packet, true);
}

initialize()

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

overridevirtual

Reimplemented from inet::NetworkProtocolBase.

Reimplemented in inet::AdaptiveProbabilisticBroadcast.

{
    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_INTERFACE_CONFIGURATION) {
        for (int i = 0; i < interfaceTable->getNumInterfaces(); i++)
            interfaceTable->getInterface(i)->setHasModulePathAddress(true);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        if (auto ie = interfaceTable->findFirstNonLoopbackInterface())
            myNetwAddr = ie->getNetworkAddress();
        else
            throw cRuntimeError("No non-loopback interface found!");
    }
}

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

insertMessage()

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.

{
    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->trim();
    auto macHeader = msgDesc->pkt->removeAtFront<ProbabilisticBroadcastHeader>();
    macHeader->setAppTtl(macHeader->getAppTtl() - bcastDelay);
    msgDesc->pkt->insertAtFront(macHeader);
    // insert message ID in ID list.
    knownMsgIds.insert(macHeader->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;
        rescheduleAt(bcastTime, broadcastTimer);
    }
}

Referenced by handleSelfMessage(), and insertNewMessage().

insertNewMessage()

void inet::ProbabilisticBroadcast::insertNewMessage ( Packet *  packet, 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.

{
    auto macHeader = packet->peekAtFront<ProbabilisticBroadcastHeader>();
    simtime_t ttl = macHeader->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 " << macHeader->getId() << " with delay "
           << bcastDelay << endl;
        // create container for message and initialize container's values.
        msgDesc = new tMsgDesc;
        msgDesc->pkt = packet;
        msgDesc->nbBcast = 0; // so far, pkt has been forwarded zero times.
        msgDesc->initialSend = iAmInitialSender;
        debugMsgIdSet.insert(macHeader->getId());
        insertMessage(uniform(0, bcastDelay), msgDesc);
    }
    else {
        EV << "PBr: " << simTime() << " n" << myNetwAddr << " insertNewMessage(): got new packet with TTL = 0." << endl;
        delete packet;
    }
}

Referenced by handleLowerPacket(), and handleUpperPacket().

messageKnown()

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

protectedvirtual

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

{
    return contains(knownMsgIds, msgId);
}

Referenced by handleLowerPacket().

numInitStages()

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

inlineoverridevirtual

Initialization of the module and some variables.

{ return NUM_INIT_STAGES; }

operator=()

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

private

Assignment operator is not allowed.

popFirstMessageUpdateQueue()

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.

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

Referenced by handleSelfMessage().

setDownControlInfo()

void inet::ProbabilisticBroadcast::setDownControlInfo ( Packet *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.

{
    pMsg->addTagIfAbsent<MacAddressReq>()->setDestAddress(pDestAddr);
    pMsg->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::probabilistic);
    pMsg->addTagIfAbsent<DispatchProtocolInd>()->setProtocol(&Protocol::probabilistic);
}

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

Member Data Documentation

beta

double inet::ProbabilisticBroadcast::beta = 0.0

protected

Probability of each broadcast attempt.

Read from omnetpp.ini

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

broadcastPeriod

simtime_t inet::ProbabilisticBroadcast::broadcastPeriod

protected

Period (in sim time) between two broadcast attempts.

Read from omnetpp.ini

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

broadcastTimer

cMessage* inet::ProbabilisticBroadcast::broadcastTimer = nullptr

protected

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

debugMsgIdSet

MsgIdSet inet::ProbabilisticBroadcast::debugMsgIdSet

protected

Referenced by debugMessageKnown(), and insertNewMessage().

debugNbMessageKnown

int inet::ProbabilisticBroadcast::debugNbMessageKnown = 0

protected

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

headerLength

int inet::ProbabilisticBroadcast::headerLength = 0

protected

Length of the NetwPkt header Read from omnetpp.ini.

Referenced by encapsulate(), and initialize().

id_counter

long inet::ProbabilisticBroadcast::id_counter = 0

staticprotected

knownMsgIds

MsgIdSet inet::ProbabilisticBroadcast::knownMsgIds

protected

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

maxFirstBcastBackoff

simtime_t inet::ProbabilisticBroadcast::maxFirstBcastBackoff

protected

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

Read from omnetpp.ini

Referenced by initialize(), and insertNewMessage().

maxNbBcast

int inet::ProbabilisticBroadcast::maxNbBcast = 0

protected

Maximal number of broadcast attempts for each packet.

Read from omnetpp.ini

Referenced by handleSelfMessage(), and initialize().

msgQueue

TimeMsgMap inet::ProbabilisticBroadcast::msgQueue

protected

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

myNetwAddr

L3Address inet::ProbabilisticBroadcast::myNetwAddr

protected

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

nbDataPacketsForwarded

long inet::ProbabilisticBroadcast::nbDataPacketsForwarded = 0

protected

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

nbDataPacketsReceived

long inet::ProbabilisticBroadcast::nbDataPacketsReceived = 0

protected

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

nbDataPacketsSent

long inet::ProbabilisticBroadcast::nbDataPacketsSent = 0

protected

Referenced by handleUpperPacket(), and initialize().

nbHops

long inet::ProbabilisticBroadcast::nbHops = 0

protected

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

oneHopLatencies

cOutVector inet::ProbabilisticBroadcast::oneHopLatencies

protected

Referenced by handleLowerPacket(), and initialize().

timeInQueueAfterDeath

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().

timeToLive

simtime_t inet::ProbabilisticBroadcast::timeToLive

protected

Referenced by encapsulate(), and initialize().

---

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

• ProbabilisticBroadcast.h
• ProbabilisticBroadcast.cc