inet::ieee80211::Contention Class Reference

The default implementation of IContention. More...

#include <Contention.h>

Inheritance diagram for inet::ieee80211::Contention:

Public Types
enum	State { IDLE, DEFER, IFS_AND_BACKOFF }
enum	EventType { START, MEDIUM_STATE_CHANGED, CORRUPTED_FRAME_RECEIVED, CHANNEL_ACCESS_GRANTED }

Public Member Functions
	Contention ()
	~Contention ()
virtual void	startContention (int cw, simtime_t ifs, simtime_t eifs, simtime_t slotTime, ICallback *callback) override
virtual void	mediumStateChanged (bool mediumFree) override
virtual void	corruptedFrameReceived () override
virtual bool	isContentionInProgress () override
Public Member Functions inherited from inet::ieee80211::IContention
virtual	~IContention ()
virtual void	startContention (int cw, simtime_t ifs, simtime_t eifs, simtime_t slotTime, ICallback *callback)=0

Static Public Attributes
static simsignal_t	stateChangedSignal = registerSignal("stateChanged")

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleWithFSM (EventType event)
virtual void	scheduleTransmissionRequest ()
virtual void	scheduleTransmissionRequestFor (simtime_t txStartTime)
virtual void	cancelTransmissionRequest ()
virtual void	switchToEifs ()
virtual void	computeRemainingBackoffSlots ()
virtual void	revokeBackoffOptimization ()
virtual void	updateDisplayString (simtime_t expectedChannelAccess)
const char *	getEventName (EventType event)

Protected Attributes
Ieee80211Mac *	mac = nullptr
ICallback *	callback = nullptr
cMessage *	startTxEvent = nullptr
cMessage *	channelGrantedEvent = nullptr
simtime_t	ifs = SIMTIME_ZERO
simtime_t	eifs = SIMTIME_ZERO
simtime_t	slotTime = SIMTIME_ZERO
cFSM	fsm
simtime_t	endEifsTime = SIMTIME_ZERO
int	backoffSlots = 0
simtime_t	scheduledTransmissionTime = SIMTIME_ZERO
simtime_t	lastChannelBusyTime = SIMTIME_ZERO
simtime_t	lastIdleStartTime = SIMTIME_ZERO
simtime_t	backoffOptimizationDelta = SIMTIME_ZERO
bool	mediumFree = true
bool	backoffOptimization = true
simtime_t	startTime = SIMTIME_ZERO

Detailed Description

The default implementation of IContention.

Member Enumeration Documentation

enum inet::ieee80211::Contention::EventType

Enumerator
START
MEDIUM_STATE_CHANGED
CORRUPTED_FRAME_RECEIVED
CHANNEL_ACCESS_GRANTED

{ START, MEDIUM_STATE_CHANGED, CORRUPTED_FRAME_RECEIVED, CHANNEL_ACCESS_GRANTED };

enum inet::ieee80211::Contention::State

Enumerator
IDLE
DEFER
IFS_AND_BACKOFF

{ IDLE, DEFER, IFS_AND_BACKOFF };

Constructor & Destructor Documentation

inet::ieee80211::Contention::Contention ( )

inline

{}

inet::ieee80211::Contention::~Contention

(

)

{
    cancelAndDelete(channelGrantedEvent);
    cancelAndDelete(startTxEvent);
}

Member Function Documentation

void inet::ieee80211::Contention::cancelTransmissionRequest ( )

protectedvirtual

Referenced by handleWithFSM(), revokeBackoffOptimization(), and switchToEifs().

{
    cancelEvent(startTxEvent);
    callback->expectedChannelAccess(-1);
    if (hasGUI())
        updateDisplayString(-1);
}

void inet::ieee80211::Contention::computeRemainingBackoffSlots ( )

protectedvirtual

Referenced by handleWithFSM(), and revokeBackoffOptimization().

{
    simtime_t remainingTime = scheduledTransmissionTime - simTime();
    int remainingSlots = (remainingTime.raw() + slotTime.raw() - 1) / slotTime.raw();
    if (remainingSlots < backoffSlots) // don't count IFS
        backoffSlots = remainingSlots;
}

void inet::ieee80211::Contention::corruptedFrameReceived ( )

overridevirtual

Implements inet::ieee80211::IContention.

{
    Enter_Method("corruptedFrameReceived()");
    handleWithFSM(CORRUPTED_FRAME_RECEIVED);
}

const char * inet::ieee80211::Contention::getEventName ( EventType  event )

protected

Referenced by handleWithFSM().

{
#define CASE(x)   case x: return #x;
    switch (event) {
        CASE(START);
        CASE(MEDIUM_STATE_CHANGED);
        CASE(CORRUPTED_FRAME_RECEIVED);
        CASE(CHANNEL_ACCESS_GRANTED);
        default: ASSERT(false); return "";
    }
#undef CASE
}

void inet::ieee80211::Contention::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (msg == startTxEvent)
        handleWithFSM(CHANNEL_ACCESS_GRANTED);
    else if (msg == channelGrantedEvent) {
        EV_INFO << "Channel granted: contention started at " << startTime << std::endl;
        callback->channelAccessGranted();
        callback = nullptr;
    }
    else
        throw cRuntimeError("Unknown msg");
}

void inet::ieee80211::Contention::handleWithFSM ( EventType  event )

protectedvirtual

Referenced by corruptedFrameReceived(), handleMessage(), mediumStateChanged(), and startContention().

{
    emit(stateChangedSignal, fsm.getState());
    EV_DEBUG << "handleWithFSM: processing event " << getEventName(event) << "\n";
    bool finallyReportChannelAccessGranted = false;
    FSMA_Switch(fsm) {
        FSMA_State(IDLE) {
            FSMA_Enter(mac->sendDownPendingRadioConfigMsg());
            FSMA_Event_Transition(Starting-IFS-and-Backoff,
                    event == START && mediumFree,
                    IFS_AND_BACKOFF,
                    scheduleTransmissionRequest();
                    );
            FSMA_Event_Transition(Busy,
                    event == START && !mediumFree,
                    DEFER,
                    ;
                    );
            FSMA_Ignore_Event(event==MEDIUM_STATE_CHANGED);
            FSMA_Ignore_Event(event==CORRUPTED_FRAME_RECEIVED);
            FSMA_Fail_On_Unhandled_Event();
        }
        FSMA_State(DEFER) {
            FSMA_Enter(mac->sendDownPendingRadioConfigMsg());
            FSMA_Event_Transition(Restarting-IFS-and-Backoff,
                    event == MEDIUM_STATE_CHANGED && mediumFree,
                    IFS_AND_BACKOFF,
                    scheduleTransmissionRequest();
                    );
            FSMA_Event_Transition(Use-EIFS,
                    event == CORRUPTED_FRAME_RECEIVED,
                    DEFER,
                    endEifsTime = simTime() + eifs;
                    );
            FSMA_Fail_On_Unhandled_Event();
        }
        FSMA_State(IFS_AND_BACKOFF) {
            FSMA_Enter();
            FSMA_Event_Transition(Backoff-expired,
                    event == CHANNEL_ACCESS_GRANTED,
                    IDLE,
                    lastIdleStartTime = simTime();
                    finallyReportChannelAccessGranted = true;
                    );
            FSMA_Event_Transition(Defer-on-channel-busy,
                    event == MEDIUM_STATE_CHANGED && !mediumFree,
                    DEFER,
                    cancelTransmissionRequest();
                    computeRemainingBackoffSlots();
                    );
            FSMA_Event_Transition(Use-EIFS,
                    event == CORRUPTED_FRAME_RECEIVED,
                    IFS_AND_BACKOFF,
                    switchToEifs();
                    );
            FSMA_Fail_On_Unhandled_Event();
        }
    }
    emit(stateChangedSignal, fsm.getState());
    if (finallyReportChannelAccessGranted)
        scheduleAt(simTime(), channelGrantedEvent);
    if (hasGUI()) {
        if (startTxEvent->isScheduled())
            updateDisplayString(startTxEvent->getArrivalTime());
        else
            updateDisplayString(-1);
    }
}

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        backoffOptimization = par("backoffOptimization");
        lastIdleStartTime = simTime() - SimTime::getMaxTime() / 2;
        mac = check_and_cast<Ieee80211Mac *>(getContainingNicModule(this)->getSubmodule("mac"));
        startTxEvent = new cMessage("startTx");
        startTxEvent->setSchedulingPriority(1000); // low priority, i.e. processed later than most events for the same time
        // FIXME: kludge
        // The callback->channelAccessGranted() call should be the last
        // event at a simulation time in order to handle internal collisions
        // properly.
        channelGrantedEvent = new cMessage("channelGranted");
        channelGrantedEvent->setSchedulingPriority(1000);
        fsm.setName("Backoff procedure");
        fsm.setState(IDLE, "IDLE");

        WATCH(ifs);
        WATCH(eifs);
        WATCH(slotTime);
        WATCH(endEifsTime);
        WATCH(backoffSlots);
        WATCH(scheduledTransmissionTime);
        WATCH(lastChannelBusyTime);
        WATCH(lastIdleStartTime);
        WATCH(backoffOptimizationDelta);
        WATCH(mediumFree);
        WATCH(backoffOptimization);
        updateDisplayString(-1);
    }
    else if (stage == INITSTAGE_LAST) {
        if (!par("initialChannelBusy") && simTime() == 0)
            lastChannelBusyTime = simTime() - SimTime().getMaxTime() / 2;
    }
}

virtual bool inet::ieee80211::Contention::isContentionInProgress ( )

inlineoverridevirtual

Implements inet::ieee80211::IContention.

{ return fsm.getState() != IDLE; }

void inet::ieee80211::Contention::mediumStateChanged ( bool  mediumFree )

overridevirtual

Implements inet::ieee80211::IContention.

{
    Enter_Method_Silent(mediumFree ? "medium FREE" : "medium BUSY");
    this->mediumFree = mediumFree;
    lastChannelBusyTime = simTime();
    handleWithFSM(MEDIUM_STATE_CHANGED);
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::ieee80211::Contention::revokeBackoffOptimization ( )

protectedvirtual

{
    scheduledTransmissionTime += backoffOptimizationDelta;
    backoffOptimizationDelta = SIMTIME_ZERO;
    cancelTransmissionRequest();
    computeRemainingBackoffSlots();
    scheduleTransmissionRequest();
}

void inet::ieee80211::Contention::scheduleTransmissionRequest ( )

protectedvirtual

Referenced by handleWithFSM(), revokeBackoffOptimization(), and switchToEifs().

{
    ASSERT(mediumFree);
    simtime_t now = simTime();
    bool useEifs = endEifsTime > now + ifs;
    simtime_t waitInterval = (useEifs ? eifs : ifs) + backoffSlots * slotTime;
    EV_INFO << "backoffslots = " << backoffSlots << " slotTime = " << slotTime << std::endl;
    if (backoffOptimization && fsm.getState() == IDLE) {
        // we can pretend the frame has arrived into the queue a little bit earlier, and may be able to start transmitting immediately
        simtime_t elapsedFreeChannelTime = now - lastChannelBusyTime;
        simtime_t elapsedIdleTime = now - lastIdleStartTime;
        EV_INFO << "lastBusyTime = " << lastChannelBusyTime << " lastIdle = " << lastIdleStartTime << std::endl;
        backoffOptimizationDelta = std::min(waitInterval, std::min(elapsedFreeChannelTime, elapsedIdleTime));
        if (backoffOptimizationDelta > SIMTIME_ZERO)
            waitInterval -= backoffOptimizationDelta;
    }
    scheduledTransmissionTime = now + waitInterval;
    EV_INFO << "waitInterval = " <<  waitInterval << std::endl;
    scheduleTransmissionRequestFor(scheduledTransmissionTime);
}

void inet::ieee80211::Contention::scheduleTransmissionRequestFor ( simtime_t  txStartTime )

protectedvirtual

Referenced by scheduleTransmissionRequest().

{
    scheduleAt(txStartTime, startTxEvent);
    callback->expectedChannelAccess(txStartTime);
    if (hasGUI())
        updateDisplayString(txStartTime);
}

void inet::ieee80211::Contention::startContention ( int  cw, simtime_t  ifs, simtime_t  eifs, simtime_t  slotTime, ICallback *  callback  )

overridevirtual

{
    startTime = simTime();
    ASSERT(ifs >= 0 && eifs >= 0 && slotTime >= 0 && cw >= 0);
    Enter_Method("startContention()");
    cancelEvent(channelGrantedEvent);
    ASSERT(fsm.getState() == IDLE);
    this->ifs = ifs;
    this->eifs = eifs;
    this->slotTime = slotTime;
    this->callback = callback;
    backoffSlots = intrand(cw + 1);
    EV_DETAIL << "Starting contention: cw = " << cw << ", slots = " << backoffSlots << endl;
    handleWithFSM(START);
}

void inet::ieee80211::Contention::switchToEifs ( )

protectedvirtual

Referenced by handleWithFSM().

{
    endEifsTime = simTime() + eifs;
    cancelTransmissionRequest();
    scheduleTransmissionRequest();
}

void inet::ieee80211::Contention::updateDisplayString ( simtime_t  expectedChannelAccess )

protectedvirtual

Referenced by cancelTransmissionRequest(), handleWithFSM(), initialize(), and scheduleTransmissionRequestFor().

{
    std::string displayString(fsm.getStateName());
    if (expectedChannelAccess != -1) {
        std::ostringstream strs;
        strs << expectedChannelAccess;
        displayString += ("\nExp. access: " + strs.str());
    }
    getDisplayString().setTagArg("t", 0, displayString.c_str());
}

Member Data Documentation

bool inet::ieee80211::Contention::backoffOptimization = true

protected

Referenced by initialize(), and scheduleTransmissionRequest().

simtime_t inet::ieee80211::Contention::backoffOptimizationDelta = SIMTIME_ZERO

protected

Referenced by initialize(), revokeBackoffOptimization(), and scheduleTransmissionRequest().

int inet::ieee80211::Contention::backoffSlots = 0

protected

Referenced by computeRemainingBackoffSlots(), initialize(), scheduleTransmissionRequest(), and startContention().

ICallback* inet::ieee80211::Contention::callback = nullptr

protected

Referenced by cancelTransmissionRequest(), handleMessage(), scheduleTransmissionRequestFor(), and startContention().

cMessage* inet::ieee80211::Contention::channelGrantedEvent = nullptr

protected

Referenced by handleMessage(), handleWithFSM(), initialize(), startContention(), and ~Contention().

simtime_t inet::ieee80211::Contention::eifs = SIMTIME_ZERO

protected

Referenced by handleWithFSM(), initialize(), scheduleTransmissionRequest(), startContention(), and switchToEifs().

simtime_t inet::ieee80211::Contention::endEifsTime = SIMTIME_ZERO

protected

Referenced by handleWithFSM(), initialize(), scheduleTransmissionRequest(), and switchToEifs().

cFSM inet::ieee80211::Contention::fsm

protected

Referenced by handleWithFSM(), initialize(), scheduleTransmissionRequest(), startContention(), and updateDisplayString().

simtime_t inet::ieee80211::Contention::ifs = SIMTIME_ZERO

protected

Referenced by initialize(), scheduleTransmissionRequest(), and startContention().

simtime_t inet::ieee80211::Contention::lastChannelBusyTime = SIMTIME_ZERO

protected

Referenced by initialize(), mediumStateChanged(), and scheduleTransmissionRequest().

simtime_t inet::ieee80211::Contention::lastIdleStartTime = SIMTIME_ZERO

protected

Referenced by handleWithFSM(), initialize(), and scheduleTransmissionRequest().

Ieee80211Mac* inet::ieee80211::Contention::mac = nullptr

protected

Referenced by handleWithFSM(), and initialize().

bool inet::ieee80211::Contention::mediumFree = true

protected

Referenced by handleWithFSM(), initialize(), mediumStateChanged(), and scheduleTransmissionRequest().

simtime_t inet::ieee80211::Contention::scheduledTransmissionTime = SIMTIME_ZERO

protected

Referenced by computeRemainingBackoffSlots(), initialize(), revokeBackoffOptimization(), and scheduleTransmissionRequest().

simtime_t inet::ieee80211::Contention::slotTime = SIMTIME_ZERO

protected

Referenced by computeRemainingBackoffSlots(), initialize(), scheduleTransmissionRequest(), and startContention().

simtime_t inet::ieee80211::Contention::startTime = SIMTIME_ZERO

protected

Referenced by handleMessage(), and startContention().

cMessage* inet::ieee80211::Contention::startTxEvent = nullptr

protected

Referenced by cancelTransmissionRequest(), handleMessage(), handleWithFSM(), initialize(), scheduleTransmissionRequestFor(), and ~Contention().

simsignal_t inet::ieee80211::Contention::stateChangedSignal = registerSignal("stateChanged")

static

Referenced by handleWithFSM().

---

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

• Contention.h
• Contention.cc