Attachment #2618 for bug #2491

View | Details | Raw Unified | Return to bug 2491
Collapse All | Expand All




#include "wifi-mac.h"
#include "mac-low.h"

#define MY_DEBUG(x) \
  NS_LOG_DEBUG (Simulator::Now () << " " << this << " " << x)

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("DcfManager");

void
DcfState::SetAifsn (uint32_t aifsn)
{
  NS_LOG_FUNCTION (this << aifsn);
  m_aifsn = aifsn;
}

void
DcfState::SetTxopLimit (Time txopLimit)
{
  NS_LOG_FUNCTION (this << txopLimit);
  NS_ASSERT_MSG ((txopLimit.GetMicroSeconds () % 32 == 0), "The TXOP limit must be expressed in multiple of 32 microseconds!");
  m_txopLimit = txopLimit;
}

void
DcfState::SetCwMin (uint32_t minCw)
{
  NS_LOG_FUNCTION (this << minCw);
  bool changed = (m_cwMin != minCw);
  m_cwMin = minCw;
  if (changed == true)

void
DcfState::SetCwMax (uint32_t maxCw)
{
  NS_LOG_FUNCTION (this << maxCw);
  bool changed = (m_cwMax != maxCw);
  m_cwMax = maxCw;
  if (changed == true)

void
DcfState::ResetCw (void)
{
  NS_LOG_FUNCTION (this << m_cwMin);
  m_cw = m_cwMin;
}


{
  //see 802.11-2012, section 9.19.2.5
  m_cw = std::min ( 2 * (m_cw + 1) - 1, m_cwMax);
  NS_LOG_DEBUG ("updated failed CW=" << m_cw);
}

void

{
  m_backoffSlots -= nSlots;
  m_backoffStart = backoffUpdateBound;
  NS_LOG_DEBUG ("update slots=" << nSlots << " slots, backoff=" << m_backoffSlots);
}

void

{
  if (m_backoffSlots != 0)
    {
      NS_LOG_DEBUG ("reset backoff from " << m_backoffSlots << " to " << nSlots << " slots");
    }
  else
    {
      NS_LOG_DEBUG ("start backoff=" << nSlots << " slots");
    }
  m_backoffSlots = nSlots;
  m_backoffStart = Simulator::Now ();

bool
DcfState::IsAccessRequested (void) const
{
  NS_LOG_FUNCTION (this << m_accessRequested);
  return m_accessRequested;
}
void
DcfState::NotifyAccessRequested (void)
{
  NS_LOG_FUNCTION (this);
  m_accessRequested = true;
}

void
DcfState::NotifyAccessGranted (void)
{
  NS_LOG_FUNCTION (this);
  NS_ASSERT (m_accessRequested);
  m_accessRequested = false;
  DoNotifyAccessGranted ();

void
DcfState::NotifyCollision (void)
{
  NS_LOG_FUNCTION (this);
  DoNotifyCollision ();
}

void
DcfState::NotifyInternalCollision (void)
{
  NS_LOG_FUNCTION (this);
  DoNotifyInternalCollision ();
}

void
DcfState::NotifyChannelSwitching (void)
{
  NS_LOG_FUNCTION (this);
  DoNotifyChannelSwitching ();
}

void
DcfState::NotifySleep (void)
{
  NS_LOG_FUNCTION (this);
  DoNotifySleep ();
}

void
DcfState::NotifyWakeUp (void)
{
  NS_LOG_FUNCTION (this);
  DoNotifyWakeUp ();
}


    {
      if (IsBusy ())
        {
          NS_LOG_DEBUG ("medium is busy: collision");
          // someone else has accessed the medium; generate a backoff.
          state->NotifyCollision ();
          DoRestartAccessTimeoutIfNeeded ();

        }
      else if (IsWithinAifs (state))
        {
          NS_LOG_DEBUG ("busy within AIFS");
          state->NotifyCollision ();
          DoRestartAccessTimeoutIfNeeded ();
          return;

           * This is the first dcf we find with an expired backoff and which
           * needs access to the medium. i.e., it has data to send.
           */
          NS_LOG_DEBUG ("dcf " << k << " needs access. backoff expired. access granted. slots=" << state->GetBackoffSlots ());
          i++; //go to the next item in the list.
          k++;
          std::vector<DcfState *> internalCollisionStates;

              if (otherState->IsAccessRequested ()
                  && GetBackoffEndFor (otherState) <= Simulator::Now ())
                {
                  NS_LOG_DEBUG ("dcf " << k << " needs access. backoff expired. internal collision. slots=" <<
                            otherState->GetBackoffSlots ());
                  /**
                   * all other dcfs with a lower priority whose backoff

              nIntSlots++;
            }
          uint32_t n = std::min (nIntSlots, state->GetBackoffSlots ());
          NS_LOG_DEBUG ("dcf " << k << " dec backoff slots=" << n);
          Time backoffUpdateBound = backoffStart + MicroSeconds (n * m_slotTimeUs);
          state->UpdateBackoffSlotsNow (n, backoffUpdateBound);
        }

  NS_LOG_DEBUG ("Access timeout needed: " << accessTimeoutNeeded);
  if (accessTimeoutNeeded)
    {
      NS_LOG_DEBUG ("expected backoff end=" << expectedBackoffEnd);
      Time expectedBackoffDelay = expectedBackoffEnd - Simulator::Now ();
      if (m_accessTimeout.IsRunning ()
          && Simulator::GetDelayLeft (m_accessTimeout) > expectedBackoffDelay)

DcfManager::NotifyRxStartNow (Time duration)
{
  NS_LOG_FUNCTION (this << duration);
  NS_LOG_DEBUG ("rx start for=" << duration);
  UpdateBackoff ();
  m_lastRxStart = Simulator::Now ();
  m_lastRxDuration = duration;

DcfManager::NotifyRxEndOkNow (void)
{
  NS_LOG_FUNCTION (this);
  NS_LOG_DEBUG ("rx end ok");
  m_lastRxEnd = Simulator::Now ();
  m_lastRxReceivedOk = true;
  m_rxing = false;

DcfManager::NotifyRxEndErrorNow (void)
{
  NS_LOG_FUNCTION (this);
  NS_LOG_DEBUG ("rx end error");
  m_lastRxEnd = Simulator::Now ();
  m_lastRxReceivedOk = false;
  m_rxing = false;

          m_rxing = false;
        }
    }
  NS_LOG_DEBUG ("tx start for " << duration);
  UpdateBackoff ();
  m_lastTxStart = Simulator::Now ();
  m_lastTxDuration = duration;

DcfManager::NotifyMaybeCcaBusyStartNow (Time duration)
{
  NS_LOG_FUNCTION (this << duration);
  NS_LOG_DEBUG ("busy start for " << duration);
  UpdateBackoff ();
  m_lastBusyStart = Simulator::Now ();
  m_lastBusyDuration = duration;

      state->NotifyChannelSwitching ();
    }

  NS_LOG_DEBUG ("switching start for " << duration);
  m_lastSwitchingStart = Simulator::Now ();
  m_lastSwitchingDuration = duration;


DcfManager::NotifyNavResetNow (Time duration)
{
  NS_LOG_FUNCTION (this << duration);
  NS_LOG_DEBUG ("nav reset for=" << duration);
  UpdateBackoff ();
  m_lastNavStart = Simulator::Now ();
  m_lastNavDuration = duration;

{
  NS_LOG_FUNCTION (this << duration);
  NS_ASSERT (m_lastNavStart <= Simulator::Now ());
  NS_LOG_DEBUG ("nav start for=" << duration);
  UpdateBackoff ();
  Time newNavEnd = Simulator::Now () + duration;
  Time lastNavEnd = m_lastNavStart + m_lastNavDuration;

Return to bug 2491