inet::ieee80211::NonQosRecoveryProcedure Class Reference

#include <NonQosRecoveryProcedure.h>

Inheritance diagram for inet::ieee80211::NonQosRecoveryProcedure:

Public Member Functions
virtual void	multicastFrameTransmitted (StationRetryCounters *stationCounters)
virtual void	ctsFrameReceived (StationRetryCounters *stationCounters)
virtual void	ackFrameReceived (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &ackedHeader, StationRetryCounters *stationCounters)
virtual void	rtsFrameTransmissionFailed (const Ptr< const Ieee80211DataOrMgmtHeader > &protectedHeader, StationRetryCounters *stationCounters)
virtual void	dataOrMgmtFrameTransmissionFailed (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &failedHeader, StationRetryCounters *stationCounters)
virtual int	getRetryCount (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &header)
virtual int	getShortRetryCount (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &dataOrMgmtHeader)
virtual int	getLongRetryCount (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &dataOrMgmtHeader)
virtual bool	isRetryLimitReached (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &failedHeader)
virtual bool	isRtsFrameRetryLimitReached (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &protectedHeader)
virtual void	retryLimitReached (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &header)
virtual int	getLongRetryLimit ()
virtual int	getShortRetryLimit ()
Public Member Functions inherited from inet::ieee80211::IRecoveryProcedure
virtual	~IRecoveryProcedure ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	incrementCounter (const Ptr< const Ieee80211DataOrMgmtHeader > &header, std::map< SequenceControlField, int > &retryCounter)
virtual void	incrementContentionWindow ()
virtual void	resetContentionWindow ()
virtual int	getRc (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &header, std::map< SequenceControlField, int > &retryCounter)
virtual bool	isMulticastFrame (const Ptr< const Ieee80211MacHeader > &header)
virtual void	incrementStationSrc (StationRetryCounters *stationCounters)
virtual void	incrementStationLrc (StationRetryCounters *stationCounters)

Protected Attributes
ICwCalculator *	cwCalculator = nullptr
std::map< SequenceControlField, int >	shortRetryCounter
std::map< SequenceControlField, int >	longRetryCounter
int	shortRetryLimit = -1
int	longRetryLimit = -1
int	rtsThreshold = -1

Additional Inherited Members
Static Public Attributes inherited from inet::ieee80211::IRecoveryProcedure
static simsignal_t	contentionWindowChangedSignal = cComponent::registerSignal("contentionWindowChanged")
static simsignal_t	retryLimitReachedSignal = cComponent::registerSignal("retryLimitReached")

Member Function Documentation

ackFrameReceived()

void inet::ieee80211::NonQosRecoveryProcedure::ackFrameReceived ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  ackedHeader, StationRetryCounters *  stationCounters  )

virtual

{
    auto id = SequenceControlField(ackedHeader->getSequenceNumber().get(), ackedHeader->getFragmentNumber());
    if (packet->getByteLength() >= rtsThreshold) {
        stationCounters->resetStationLongRetryCount();
        auto it = longRetryCounter.find(id);
        if (it != longRetryCounter.end())
            longRetryCounter.erase(it);
    }
    else {
        stationCounters->resetStationShortRetryCount();
        auto it = shortRetryCounter.find(id);
        if (it != shortRetryCounter.end())
            shortRetryCounter.erase(it);
    }
 
    //
    // The CW shall be reset to aCWmin after every successful attempt to transmit a frame containing
    // all or part of an MSDU or MMPDU
    //
    resetContentionWindow();
}

ctsFrameReceived()

void inet::ieee80211::NonQosRecoveryProcedure::ctsFrameReceived ( StationRetryCounters *  stationCounters )

virtual

{
    stationCounters->resetStationShortRetryCount();
}

dataOrMgmtFrameTransmissionFailed()

void inet::ieee80211::NonQosRecoveryProcedure::dataOrMgmtFrameTransmissionFailed ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  failedHeader, StationRetryCounters *  stationCounters  )

virtual

{
    if (packet->getByteLength() >= rtsThreshold) {
        incrementStationLrc(stationCounters);
        incrementCounter(failedHeader, longRetryCounter);
    }
    else {
        incrementStationSrc(stationCounters);
        incrementCounter(failedHeader, shortRetryCounter);
    }
}

getLongRetryCount()

int inet::ieee80211::NonQosRecoveryProcedure::getLongRetryCount ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  dataOrMgmtHeader  )

virtual

{
    return getRc(packet, dataOrMgmtHeader, longRetryCounter);
}

getLongRetryLimit()

virtual int inet::ieee80211::NonQosRecoveryProcedure::getLongRetryLimit ( )

inlinevirtual

{ return longRetryLimit; }

getRc()

int inet::ieee80211::NonQosRecoveryProcedure::getRc ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  header, std::map< SequenceControlField, int > &  retryCounter  )

protectedvirtual

{
    auto count = retryCounter.find(SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()));
    return (count != retryCounter.end()) ? count->second : 0;
}

Referenced by getLongRetryCount(), getRetryCount(), getShortRetryCount(), isRetryLimitReached(), and isRtsFrameRetryLimitReached().

getRetryCount()

int inet::ieee80211::NonQosRecoveryProcedure::getRetryCount ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  header  )

virtual

{
    if (packet->getByteLength() >= rtsThreshold)
        return getRc(packet, header, longRetryCounter);
    else
        return getRc(packet, header, shortRetryCounter);
}

getShortRetryCount()

int inet::ieee80211::NonQosRecoveryProcedure::getShortRetryCount ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  dataOrMgmtHeader  )

virtual

{
    return getRc(packet, dataOrMgmtHeader, shortRetryCounter);
}

getShortRetryLimit()

virtual int inet::ieee80211::NonQosRecoveryProcedure::getShortRetryLimit ( )

inlinevirtual

{ return shortRetryLimit; }

incrementContentionWindow()

void inet::ieee80211::NonQosRecoveryProcedure::incrementContentionWindow ( )

protectedvirtual

{
    auto oldCw = cwCalculator->getCw();
    cwCalculator->incrementCw();
    auto newCw = cwCalculator->getCw();
    if (oldCw != newCw)
        emit(contentionWindowChangedSignal, newCw);
}

Referenced by incrementStationLrc(), and incrementStationSrc().

incrementCounter()

void inet::ieee80211::NonQosRecoveryProcedure::incrementCounter ( const Ptr< const Ieee80211DataOrMgmtHeader > &  header, std::map< SequenceControlField, int > &  retryCounter  )

protectedvirtual

{
    auto id = SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber());
    if (containsKey(retryCounter, id))
        retryCounter[id]++;
    else
        retryCounter.insert(std::make_pair(id, 1));
}

Referenced by dataOrMgmtFrameTransmissionFailed(), and rtsFrameTransmissionFailed().

incrementStationLrc()

void inet::ieee80211::NonQosRecoveryProcedure::incrementStationLrc ( StationRetryCounters *  stationCounters )

protectedvirtual

{
    stationCounters->incrementStationLongRetryCount();
    EV_INFO << "Incremented station LRC: stationLongRetryCounter = " << stationCounters->getStationLongRetryCount() << ".\n";
    if (stationCounters->getStationLongRetryCount() == longRetryLimit) // 9.3.3 Random backoff time
        resetContentionWindow();
    else
        incrementContentionWindow();
}

Referenced by dataOrMgmtFrameTransmissionFailed().

incrementStationSrc()

void inet::ieee80211::NonQosRecoveryProcedure::incrementStationSrc ( StationRetryCounters *  stationCounters )

protectedvirtual

{
    stationCounters->incrementStationShortRetryCount();
    EV_INFO << "Incremented station SRC: stationShortRetryCounter = " << stationCounters->getStationShortRetryCount() << ".\n";
    if (stationCounters->getStationShortRetryCount() == shortRetryLimit) // 9.3.3 Random backoff time
        resetContentionWindow();
    else
        incrementContentionWindow();
}

Referenced by dataOrMgmtFrameTransmissionFailed(), and rtsFrameTransmissionFailed().

initialize()

void inet::ieee80211::NonQosRecoveryProcedure::initialize ( int  stage )

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LAST) {
        auto rtsPolicy = check_and_cast<IRtsPolicy *>(getModuleByPath(par("rtsPolicyModule")));
        cwCalculator = check_and_cast<ICwCalculator *>(getModuleByPath(par("cwCalculatorModule")));
        rtsThreshold = rtsPolicy->getRtsThreshold();
        shortRetryLimit = par("shortRetryLimit");
        longRetryLimit = par("longRetryLimit");
        emit(contentionWindowChangedSignal, cwCalculator->getCw());
        WATCH_MAP(shortRetryCounter);
        WATCH_MAP(longRetryCounter);
    }
}

isMulticastFrame()

bool inet::ieee80211::NonQosRecoveryProcedure::isMulticastFrame ( const Ptr< const Ieee80211MacHeader > &  header )

protectedvirtual

{
    if (auto oneAddressHeader = dynamicPtrCast<const Ieee80211OneAddressHeader>(header))
        return oneAddressHeader->getReceiverAddress().isMulticast();
    return false;
}

isRetryLimitReached()

bool inet::ieee80211::NonQosRecoveryProcedure::isRetryLimitReached ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  failedHeader  )

virtual

{
    if (packet->getByteLength() >= rtsThreshold)
        return getRc(packet, failedHeader, longRetryCounter) >= longRetryLimit;
    else
        return getRc(packet, failedHeader, shortRetryCounter) >= shortRetryLimit;
}

isRtsFrameRetryLimitReached()

bool inet::ieee80211::NonQosRecoveryProcedure::isRtsFrameRetryLimitReached ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  protectedHeader  )

virtual

{
    return getRc(packet, protectedHeader, shortRetryCounter) >= shortRetryLimit;
}

multicastFrameTransmitted()

void inet::ieee80211::NonQosRecoveryProcedure::multicastFrameTransmitted ( StationRetryCounters *  stationCounters )

virtual

{
    stationCounters->resetStationShortRetryCount();
    stationCounters->resetStationLongRetryCount();
}

numInitStages()

virtual int inet::ieee80211::NonQosRecoveryProcedure::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

resetContentionWindow()

void inet::ieee80211::NonQosRecoveryProcedure::resetContentionWindow ( )

protectedvirtual

{
    auto oldCw = cwCalculator->getCw();
    cwCalculator->resetCw();
    auto newCw = cwCalculator->getCw();
    if (oldCw != newCw)
        emit(contentionWindowChangedSignal, newCw);
}

Referenced by ackFrameReceived(), incrementStationLrc(), and incrementStationSrc().

retryLimitReached()

void inet::ieee80211::NonQosRecoveryProcedure::retryLimitReached ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  header  )

virtual

{
    EV_WARN << "Retry limit reached for " << *packet << ".\n";
    auto id = SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber());
    if (packet->getByteLength() >= rtsThreshold) {
        auto it = longRetryCounter.find(id);
        if (it != longRetryCounter.end())
            longRetryCounter.erase(it);
    }
    else {
        auto it = shortRetryCounter.find(id);
        if (it != shortRetryCounter.end())
            shortRetryCounter.erase(it);
    }
    emit(retryLimitReachedSignal, packet);
}

rtsFrameTransmissionFailed()

void inet::ieee80211::NonQosRecoveryProcedure::rtsFrameTransmissionFailed ( const Ptr< const Ieee80211DataOrMgmtHeader > &  protectedHeader, StationRetryCounters *  stationCounters  )

virtual

{
    incrementStationSrc(stationCounters);
    incrementCounter(protectedHeader, shortRetryCounter);
}

Member Data Documentation

cwCalculator

ICwCalculator* inet::ieee80211::NonQosRecoveryProcedure::cwCalculator = nullptr

protected

Referenced by incrementContentionWindow(), initialize(), and resetContentionWindow().

longRetryCounter

std::map<SequenceControlField, int> inet::ieee80211::NonQosRecoveryProcedure::longRetryCounter

protected

Referenced by ackFrameReceived(), dataOrMgmtFrameTransmissionFailed(), getLongRetryCount(), getRetryCount(), initialize(), isRetryLimitReached(), and retryLimitReached().

longRetryLimit

int inet::ieee80211::NonQosRecoveryProcedure::longRetryLimit = -1

protected

Referenced by incrementStationLrc(), initialize(), and isRetryLimitReached().

rtsThreshold

int inet::ieee80211::NonQosRecoveryProcedure::rtsThreshold = -1

protected

Referenced by ackFrameReceived(), dataOrMgmtFrameTransmissionFailed(), getRetryCount(), initialize(), isRetryLimitReached(), and retryLimitReached().

shortRetryCounter

std::map<SequenceControlField, int> inet::ieee80211::NonQosRecoveryProcedure::shortRetryCounter

protected

Referenced by ackFrameReceived(), dataOrMgmtFrameTransmissionFailed(), getRetryCount(), getShortRetryCount(), initialize(), isRetryLimitReached(), isRtsFrameRetryLimitReached(), retryLimitReached(), and rtsFrameTransmissionFailed().

shortRetryLimit

int inet::ieee80211::NonQosRecoveryProcedure::shortRetryLimit = -1

protected

Referenced by incrementStationSrc(), initialize(), isRetryLimitReached(), and isRtsFrameRetryLimitReached().

---

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

• NonQosRecoveryProcedure.h
• NonQosRecoveryProcedure.cc