Attachment #771 for bug #826

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




 ****************************************************************/

DcfManager::DcfManager ()
  : m_lastAckTimeoutEnd (0),
    m_lastCtsTimeoutEnd (0),
    m_lastNavStart (0),
    m_lastNavDuration (0),
    m_lastRxStart (0),
    m_lastRxDuration (0),
    m_lastRxReceivedOk (true),
    m_lastRxEnd (0),
    m_lastTxStart (0),
    m_lastTxDuration (0),
    m_lastBusyStart (0),
    m_lastBusyDuration (0),
    m_lastSwitchingStart (0), 
    m_lastSwitchingDuration (0), 
    m_rxing (false),
    m_slotTimeUs (0),
    m_sifs (Seconds (0.0)),

  Time retval = Max (k, l);
  return retval;
}
uint64_t
DcfManager::Maximum (uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, uint64_t g) const
{
  uint64_t h = a > b ? a : b;
  uint64_t i = c > d ? c: d;
  uint64_t j = e > f ? e : f;
  uint64_t k = h > i ? h : i;
  uint64_t l = j > g ? j : g;
  return (k > l ? k : l);
}

bool 
DcfManager::IsBusy (void) const
{
  // PHY busy
  uint64_t now = Simulator::Now ().GetNanoSeconds ();
  if (m_rxing) 
    {
      return true;
    }
  uint64_t lastTxEnd = m_lastTxStart + m_lastTxDuration;
  if (lastTxEnd > now) 
    {
      return true;
    }
  // NAV busy
  uint64_t lastNavEnd = m_lastNavStart + m_lastNavDuration;
  if (lastNavEnd > now)
    {
      return true;
    }

Time
DcfManager::GetAccessGrantStart (void) const
{
  uint64_t rxAccessStart;
  uint64_t sifsNanoSeconds = m_sifs.GetNanoSeconds ();
  if (!m_rxing) 
    {
      rxAccessStart = m_lastRxEnd + sifsNanoSeconds;
      if (!m_lastRxReceivedOk)
        {
          rxAccessStart += m_eifsNoDifs.GetNanoSeconds ();
        }
    } 
  else 
    {
      rxAccessStart = m_lastRxStart + m_lastRxDuration + m_sifs.GetNanoSeconds ();
    }
  uint64_t busyAccessStart = m_lastBusyStart + m_lastBusyDuration + sifsNanoSeconds;
  uint64_t txAccessStart = m_lastTxStart + m_lastTxDuration + sifsNanoSeconds;
  uint64_t navAccessStart = m_lastNavStart + m_lastNavDuration + sifsNanoSeconds;
  uint64_t ackTimeoutAccessStart = m_lastAckTimeoutEnd + sifsNanoSeconds;
  uint64_t ctsTimeoutAccessStart = m_lastCtsTimeoutEnd + sifsNanoSeconds;
  uint64_t switchingAccessStart = m_lastSwitchingStart + m_lastSwitchingDuration + sifsNanoSeconds; 
  uint64_t accessGrantedStart = Maximum (rxAccessStart, 
                                          busyAccessStart,
                                          txAccessStart, 
                                          navAccessStart,
                                          ackTimeoutAccessStart,
                                          ctsTimeoutAccessStart,
                                          switchingAccessStart 
                                          );
  NS_LOG_INFO ("access grant start=" << accessGrantedStart <<
               ", rx access start=" << rxAccessStart <<
               ", busy access start=" << busyAccessStart <<
               ", tx access start=" << txAccessStart <<
               ", nav access start=" << navAccessStart);
  return NanoSeconds (accessGrantedStart);
}

Time

{
  MY_DEBUG ("rx start for="<<duration);
  UpdateBackoff ();
  m_lastRxStart = Simulator::Now ().GetNanoSeconds ();
  m_lastRxDuration = duration.GetNanoSeconds ();
  m_rxing = true;
}
void 
DcfManager::NotifyRxEndOkNow (void)
{
  MY_DEBUG ("rx end ok");
  m_lastRxEnd = Simulator::Now ().GetNanoSeconds ();
  m_lastRxReceivedOk = true;
  m_rxing = false;
}

DcfManager::NotifyRxEndErrorNow (void)
{
  MY_DEBUG ("rx end error");
  m_lastRxEnd = Simulator::Now ().GetNanoSeconds ();
  m_lastRxReceivedOk = false;
  m_rxing = false;
}

      //this may be caused only if PHY has started to receive a packet
      //inside SIFS, so, we check that lastRxStart was maximum a SIFS
      //ago
      NS_ASSERT (Simulator::Now () - NanoSeconds (m_lastRxStart) <= m_sifs);
      m_lastRxEnd = Simulator::Now ().GetNanoSeconds ();
      m_lastRxDuration = m_lastRxEnd - m_lastRxStart;
      m_lastRxReceivedOk = true;
      m_rxing = false;
    }
  MY_DEBUG ("tx start for "<<duration);
  UpdateBackoff ();
  m_lastTxStart = Simulator::Now ().GetNanoSeconds ();
  m_lastTxDuration = duration.GetNanoSeconds ();
}
void 
DcfManager::NotifyMaybeCcaBusyStartNow (Time duration)
{
  MY_DEBUG ("busy start for "<<duration);
  UpdateBackoff ();
  m_lastBusyStart = Simulator::Now ().GetNanoSeconds ();
  m_lastBusyDuration = duration.GetNanoSeconds ();
}


void 
DcfManager::NotifySwitchingStartNow (Time duration)
{
  uint64_t now = Simulator::Now ().GetNanoSeconds ();
  NS_ASSERT (m_lastTxStart + m_lastTxDuration <= now);
  NS_ASSERT (m_lastSwitchingStart + m_lastSwitchingDuration <= now);

  if (m_rxing)
    {
      // channel switching during packet reception
      m_lastRxEnd = Simulator::Now ().GetNanoSeconds ();
      m_lastRxDuration = m_lastRxEnd - m_lastRxStart;
      m_lastRxReceivedOk = true;
      m_rxing = false;

      uint32_t remainingSlots = state->GetBackoffSlots ();
      if (remainingSlots > 0) 
        {
          state->UpdateBackoffSlotsNow (remainingSlots, NanoSeconds(now));
          NS_ASSERT(state->GetBackoffSlots()==0);
        }
      state->ResetCw();

    } 
 
  MY_DEBUG ("switching start for "<<duration);
  m_lastSwitchingStart = Simulator::Now ().GetNanoSeconds ();
  m_lastSwitchingDuration = duration.GetNanoSeconds ();

}


{
  MY_DEBUG ("nav reset for="<<duration);
  UpdateBackoff ();
  m_lastNavStart = Simulator::Now ().GetNanoSeconds ();
  m_lastNavDuration = duration.GetNanoSeconds ();
  UpdateBackoff ();
  /**
   * If the nav reset indicates an end-of-nav which is earlier

void 
DcfManager::NotifyNavStartNow (Time duration)
{
  NS_ASSERT (NanoSeconds (m_lastNavStart) < Simulator::Now ());
  MY_DEBUG ("nav start for="<<duration);
  UpdateBackoff ();
  uint64_t newNavEnd = (Simulator::Now () + duration).GetNanoSeconds ();
  uint64_t lastNavEnd = m_lastNavStart + m_lastNavDuration;
  if (newNavEnd > lastNavEnd)
    {
      m_lastNavStart = Simulator::Now ().GetNanoSeconds ();
      m_lastNavDuration = duration.GetNanoSeconds ();
    }
}
void
DcfManager::NotifyAckTimeoutStartNow (Time duration)
{
  NS_ASSERT(NanoSeconds(m_lastAckTimeoutEnd) < Simulator::Now ());
  m_lastAckTimeoutEnd = (Simulator::Now () + duration).GetNanoSeconds ();
}
void
DcfManager::NotifyAckTimeoutResetNow ()
{
  m_lastAckTimeoutEnd = Simulator::Now ().GetNanoSeconds ();
  DoRestartAccessTimeoutIfNeeded ();
}
void
DcfManager::NotifyCtsTimeoutStartNow (Time duration)
{
  m_lastCtsTimeoutEnd = (Simulator::Now () + duration).GetNanoSeconds ();
}
void
DcfManager::NotifyCtsTimeoutResetNow ()
{
  m_lastCtsTimeoutEnd = Simulator::Now ().GetNanoSeconds ();
  DoRestartAccessTimeoutIfNeeded ();
}
} // namespace ns3




  Time MostRecent (Time a, Time b, Time c, Time d) const;
  Time MostRecent (Time a, Time b, Time c, Time d, Time e, Time f) const;
  Time MostRecent (Time a, Time b, Time c, Time d, Time e, Time f, Time g) const; 
  uint64_t Maximum (uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, uint64_t g) const;
  /**
   * Access will never be granted to the medium _before_
   * the time returned by this method.

  typedef std::vector<DcfState *> States;

  States m_states;
  uint64_t m_lastAckTimeoutEnd;
  uint64_t m_lastCtsTimeoutEnd;
  uint64_t m_lastNavStart;
  uint64_t m_lastNavDuration;
  uint64_t m_lastRxStart;
  uint64_t m_lastRxDuration;
  bool m_lastRxReceivedOk;
  uint64_t m_lastRxEnd;
  uint64_t m_lastTxStart;
  uint64_t m_lastTxDuration;
  uint64_t m_lastBusyStart;
  uint64_t m_lastBusyDuration;
  uint64_t m_lastSwitchingStart; 
  uint64_t m_lastSwitchingDuration; 
  bool m_rxing;
  bool m_sleeping;
  Time m_eifsNoDifs;

Return to bug 826