Attachment #455 for bug #556

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






private:
  void StartTest (uint64_t slotTime, uint64_t sifs, uint64_t eifsNoDifsNoSifs, uint32_t ackTimeoutValue = 20);
  void AddDcfState (uint32_t aifsn);
  void EndTest (void);
  void ExpectInternalCollision (uint64_t time, uint32_t from, uint32_t nSlots);

  void AddRxErrorEvt (uint64_t at, uint64_t duration);
  void AddNavReset (uint64_t at, uint64_t duration);
  void AddNavStart (uint64_t at, uint64_t duration);
  void AddAckTimeoutReset (uint64_t at);
  void AddAccessRequest (uint64_t at, uint64_t txTime, 
                         uint64_t expectedGrantTime, uint32_t from);
  void AddAccessRequestWithAckTimeout (uint64_t at, uint64_t txTime, 
                                  uint64_t expectedGrantTime, uint32_t from);
  ///\param ackDelay is delay of the ack after txEnd
  void AddAccessRequestWithSuccessfullAck (uint64_t at, uint64_t txTime, 
                                  uint64_t expectedGrantTime, uint32_t ackDelay, uint32_t from);
  void DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, DcfStateTest *state);
  
  typedef std::vector<DcfStateTest *> DcfStates;

  DcfManager *m_dcfManager;
  DcfStates m_dcfStates;
  uint32_t m_ackTimeoutValue;
  bool m_result;
};


  state->m_expectedGrants.pop_front ();
  NS_TEST_ASSERT_EQUAL (Simulator::Now (), MicroSeconds (expected.second));
  m_dcfManager->NotifyTxStartNow (MicroSeconds (expected.first));
  m_dcfManager->NotifyAckTimeoutStartNow (MicroSeconds (m_ackTimeoutValue + expected.first));
  if (!result)
    {
      m_result = result;

}

void
DcfManagerTest::StartTest (uint64_t slotTime, uint64_t sifs, uint64_t eifsNoDifsNoSifs, uint32_t ackTimeoutValue)
{
  m_dcfManager = new DcfManager ();
  m_dcfManager->SetSlot (MicroSeconds (slotTime));
  m_dcfManager->SetSifs (MicroSeconds (sifs));
  m_dcfManager->SetEifsNoDifs (MicroSeconds (eifsNoDifsNoSifs+sifs));
  m_ackTimeoutValue = ackTimeoutValue;
}

void

                       MicroSeconds (duration));
}
void 
DcfManagerTest::AddAckTimeoutReset (uint64_t at)
{
  Simulator::Schedule (MicroSeconds (at) - Now (), 
                       &DcfManager::NotifyAckTimeoutResetNow, m_dcfManager);
}
void 
DcfManagerTest::AddAccessRequest (uint64_t at, uint64_t txTime, 
                                  uint64_t expectedGrantTime, uint32_t from)
{
  AddAccessRequestWithSuccessfullAck (at, txTime, expectedGrantTime, 0, from);
}
void 
DcfManagerTest::AddAccessRequestWithAckTimeout (uint64_t at, uint64_t txTime, 
                                  uint64_t expectedGrantTime, uint32_t from)
{
  Simulator::Schedule (MicroSeconds (at) - Now (), 
                       &DcfManagerTest::DoAccessRequest, this,
                       txTime, expectedGrantTime, m_dcfStates[from]);
}
void 
DcfManagerTest::AddAccessRequestWithSuccessfullAck (uint64_t at, uint64_t txTime, 
                                  uint64_t expectedGrantTime, uint32_t ackDelay, uint32_t from)
{
  NS_ASSERT(ackDelay < m_ackTimeoutValue);
  Simulator::Schedule (MicroSeconds (at) - Now (), 
                       &DcfManagerTest::DoAccessRequest, this,
                       txTime, expectedGrantTime, m_dcfStates[from]);
  AddAckTimeoutReset (expectedGrantTime + txTime + ackDelay);
}
void
DcfManagerTest::DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, DcfStateTest *state)
{

  //   |    rx     | sifs | aifsn | bslot0  | bslot1  |   | rx   | sifs  |  aifsn | bslot2 | bslot3 | tx  |
  //        |
  //       30 request access. backoff slots: 4
  StartTest (4, 6, 10);
  AddDcfState (1);
  AddRxOkEvt (20, 40);
  AddRxOkEvt (80, 20);

  ExpectCollision (40, 0, 1); // backoff: 0 slot
  ExpectInternalCollision (78, 1, 1); // backoff: 1 slot
  EndTest ();
  
  // Test of AckTimeout handling: First queue requests access and ack procedure fails,
  // inside the ack timeout second queue with higher priority requests access.
  //
  //            20           40      50     60  66      76
  // DCF0 - low  |     tx     | ack timeout |sifs|       |
  // DCF1 - high |                    |     |sifs|  tx   |
  //                                  ^ request access
  StartTest (4, 6, 10);
  AddDcfState (2); // high priority DCF
  AddDcfState (0); // low priority DCF
  AddAccessRequestWithAckTimeout (20, 20, 20, 0);
  AddAccessRequest (50, 10, 66, 1);
  EndTest ();

  // Test of AckTimeout handling: 
  //
  // First queue requests access and ack is 2 us delayed (got ack interval at the picture),
  // inside this interval second queue with higher priority requests access.
  //
  //            20           40  41   42    48      58
  // DCF0 - low  |     tx     |got ack |sifs|       |
  // DCF1 - high |                |    |sifs|  tx   |
  //                              ^ request access
  StartTest (4, 6, 10);
  AddDcfState (2); // high priority DCF
  AddDcfState (0); // low priority DCF
  AddAccessRequestWithSuccessfullAck (20, 20, 20, 2, 0);
  AddAccessRequest (41, 10, 48, 1);
  EndTest ();

  //Repeat the same but with one queue:
  //            20           40  41   42    48      58
  // DCF0 - low  |     tx     |got ack |sifs|       |
  //                              ^ request access
  StartTest (4, 6, 10);
  AddDcfState (2);
  AddAccessRequestWithSuccessfullAck (20, 20, 20, 2, 0);
  AddAccessRequest (41, 10, 56, 0);
  EndTest ();

  //Repeat the same when ack was delayed:
  //and request the next access before previous tx end:
  //            20       39  40       42              64      74
  // DCF0 - low  |     tx     |got ack |sifs + 4 * slot|       |
  //                      ^ request access
  StartTest (4, 6, 10);
  AddDcfState (2);
  AddAccessRequestWithSuccessfullAck (20, 20, 20, 2, 0);
  AddAccessRequest (39, 10, 64, 0);
  ExpectCollision (39, 2, 0); // backoff: 2 slot
  EndTest ();

  //
  // test simple NAV count. This scenario modelizes a simple DATA+ACK handshake

  AddAccessRequest (30, 10, 93, 0);
  ExpectCollision (30, 2, 0); // backoff: 2 slot
  EndTest ();


  //
  // test more complex NAV handling by a CF-poll. This scenario modelizes a 




 *         Listener for Nav events. Forwards to DcfManager
 ***************************************************************/

class LowDcfListener : public ns3::MacLowDcfListener {
public:
  LowDcfListener (ns3::DcfManager *dcf)
    : m_dcf (dcf) {}
  virtual ~LowDcfListener () {}
  virtual void NavStart (Time duration) {
    m_dcf->NotifyNavStartNow (duration);
  }
  virtual void NavReset (Time duration) {
    m_dcf->NotifyNavResetNow (duration);
  }
  virtual void AckTimeoutStart (Time duration) {
    m_dcf->NotifyAckTimeoutStartNow (duration);
  }
  virtual void AckTimeoutReset () {
    m_dcf->NotifyAckTimeoutResetNow ();
  }
  virtual void CtsTimeoutStart (Time duration) {
    m_dcf->NotifyCtsTimeoutStartNow (duration);
  }
  virtual void CtsTimeoutReset () {
    m_dcf->NotifyCtsTimeoutResetNow ();
  }
private:
  ns3::DcfManager *m_dcf;

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

DcfManager::DcfManager ()
  : m_lastAckTimeoutEnd (MicroSeconds (0)),
    m_lastCtsTimeoutEnd (MicroSeconds (0)),
    m_lastNavStart (MicroSeconds (0)),
    m_lastNavDuration (MicroSeconds (0)),
    m_lastRxStart (MicroSeconds (0)),
    m_lastRxDuration (MicroSeconds (0)),

void 
DcfManager::SetupLowListener (Ptr<MacLow> low)
{
  m_lowListener = new LowDcfListener (this);
  low->RegisterDcfListener (m_lowListener);
}

void 

  Time retval = Max (e, f);
  return retval;
}
Time
DcfManager::MostRecent (Time a, Time b, Time c, Time d, Time e, Time f) const
{
  Time g = Max (a, b);
  Time h = Max (c, d);
  Time i = Max (e, f);
  Time k = Max (g, h);
  Time retval = Max (k, i);
  return retval;
}

bool 
DcfManager::IsBusy (void) const

    {
      DcfState *state = *i;
      if (state->IsAccessRequested () && 
          GetBackoffEndFor (state).GetTimeStep() <= Simulator::Now ().GetTimeStep ())
        {
          /**
           * This is the first dcf we find with an expired backoff and which

  Time busyAccessStart = m_lastBusyStart + m_lastBusyDuration + m_sifs;
  Time txAccessStart = m_lastTxStart + m_lastTxDuration + m_sifs;
  Time navAccessStart = m_lastNavStart + m_lastNavDuration + m_sifs;
  Time ackTimeoutAccessStart = m_lastAckTimeoutEnd + m_sifs;
  Time ctsTimeoutAccessStart = m_lastCtsTimeoutEnd + m_sifs;
  Time accessGrantedStart = MostRecent (rxAccessStart, 
                                        busyAccessStart,
                                        txAccessStart, 
                                        navAccessStart,
                                        ackTimeoutAccessStart,
                                        ctsTimeoutAccessStart
                                        );
  NS_LOG_INFO ("access grant start=" << accessGrantedStart <<
               ", rx access start=" << rxAccessStart <<
               ", busy access start=" << busyAccessStart <<

      if (state->IsAccessRequested ())
        {
          Time tmp = GetBackoffEndFor (state);
          if (tmp.GetTimeStep () > Simulator::Now ().GetTimeStep ())
            {
              accessTimeoutNeeded = true;
              expectedBackoffEnd = std::min (expectedBackoffEnd, tmp);

      m_lastNavDuration = duration;
    }
}
void
DcfManager::NotifyAckTimeoutStartNow (Time duration)
{
  NS_ASSERT(m_lastAckTimeoutEnd < Simulator::Now ());
  m_lastAckTimeoutEnd = Simulator::Now () + duration;
}
void
DcfManager::NotifyAckTimeoutResetNow ()
{
  m_lastAckTimeoutEnd = Simulator::Now ();
  DoRestartAccessTimeoutIfNeeded ();
}
void
DcfManager::NotifyCtsTimeoutStartNow (Time duration)
{
  m_lastCtsTimeoutEnd = Simulator::Now () + duration;
}
void
DcfManager::NotifyCtsTimeoutResetNow ()
{
  m_lastCtsTimeoutEnd = Simulator::Now ();
  DoRestartAccessTimeoutIfNeeded ();
}
} // namespace ns3

(-)a/src/devices/wifi/dcf-manager.h (-2 / +9 lines)

Lines 238-249	Link Here

238

   * Called at end of rx

238

   * Called at end of rx

239

*/

239

*/

240

  void NotifyNavStartNow (Time duration);

240

  void NotifyNavStartNow (Time duration);

241

  void NotifyAckTimeoutStartNow (Time duration);

242

  void NotifyAckTimeoutResetNow ();

243

  void NotifyCtsTimeoutStartNow (Time duration);

244

  void NotifyCtsTimeoutResetNow ();

245

  void NotifyAckTimeoutEnd (Time duration);

242

private:

246

private:

243

  void UpdateBackoff (void);

247

  void UpdateBackoff (void);

244

  Time MostRecent (Time a, Time b) const;

248

  Time MostRecent (Time a, Time b) const;

245

  Time MostRecent (Time a, Time b, Time c) const;

249

  Time MostRecent (Time a, Time b, Time c) const;

246

  Time MostRecent (Time a, Time b, Time c, Time d) const;

250

  Time MostRecent (Time a, Time b, Time c, Time d) const;

251

  Time MostRecent (Time a, Time b, Time c, Time d, Time e, Time f) const;

247

/**

252

/**

248

   * Access will never be granted to the medium _before_

253

   * Access will never be granted to the medium _before_

249

   * the time returned by this method.

254

   * the time returned by this method.

Lines 262-267	Link Here

262

  typedef std::vector<DcfState *> States;

267

  typedef std::vector<DcfState *> States;

263

268

264

  States m_states;

269

  States m_states;

270

  Time m_lastAckTimeoutEnd;

271

  Time m_lastCtsTimeoutEnd;

265

  Time m_lastNavStart;

272

  Time m_lastNavStart;

266

  Time m_lastNavDuration;

273

  Time m_lastNavDuration;

267

  Time m_lastRxStart;

274

  Time m_lastRxStart;

Lines 279-285	Link Here

279

  Time m_slotTime;

286

  Time m_slotTime;

280

  Time m_sifs;

287

  Time m_sifs;

281

  class PhyListener *m_phyListener;

288

  class PhyListener *m_phyListener;

282

  class LowNavListener *m_lowListener;

289

  class LowDcfListener *m_lowListener;

283

};

290

};

284

291

285

} // namespace ns3

292

} // namespace ns3




{}
MacLowTransmissionListener::~MacLowTransmissionListener ()
{}
MacLowDcfListener::MacLowDcfListener ()
{}
MacLowDcfListener::~MacLowDcfListener ()
{}

MacLowTransmissionParameters::MacLowTransmissionParameters ()

  m_rxCallback = callback;
}
void 
MacLow::RegisterDcfListener (MacLowDcfListener *listener)
{
  m_dcfListeners.push_back (listener);
}



      station->ReportRtsOk (rxSnr, txMode, tag.Get ());
      
      m_ctsTimeoutEvent.Cancel ();
      NotifyCtsTimeoutResetNow ();
      m_listener->GotCts (rxSnr, txMode);
      NS_ASSERT (m_sendDataEvent.IsExpired ());
      m_sendDataEvent = Simulator::Schedule (GetSifs (), 

          m_normalAckTimeoutEvent.IsRunning ()) 
        {
          m_normalAckTimeoutEvent.Cancel ();
          NotifyAckTimeoutResetNow ();
          gotAck = true;
        }
      if (m_txParams.MustWaitFastAck () &&
          m_fastAckTimeoutEvent.IsRunning ()) 
        {
          m_fastAckTimeoutEvent.Cancel ();
          NotifyAckTimeoutResetNow ();
          gotAck = true;
        }
      if (gotAck) 

void
MacLow::DoNavResetNow (Time duration)
{
  for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) 
    {
      (*i)->NavReset (duration);
    }

bool
MacLow::DoNavStartNow (Time duration)
{
  for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) 
    {
      (*i)->NavStart (duration);
    }

      return true;
    }
  return false;
}
void
MacLow::NotifyAckTimeoutStartNow (Time duration)
{
  for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) 
    {
      (*i)->AckTimeoutStart (duration);
    }
}
void
MacLow::NotifyAckTimeoutResetNow ()
{
  for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) 
    {
      (*i)->AckTimeoutReset ();
    }
}
void
MacLow::NotifyCtsTimeoutStartNow (Time duration)
{
  for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) 
    {
      (*i)->CtsTimeoutStart (duration);
    }
}
void
MacLow::NotifyCtsTimeoutResetNow ()
{
  for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++) 
    {
      (*i)->CtsTimeoutReset ();
    }
}

void

  Time timerDelay = txDuration + GetCtsTimeout ();

  NS_ASSERT (m_ctsTimeoutEvent.IsExpired ());
  NotifyCtsTimeoutStartNow (timerDelay);
  m_ctsTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::CtsTimeout, this);

  Ptr<Packet> packet = Create<Packet> ();

    {
      Time timerDelay = txDuration + GetAckTimeout ();
      NS_ASSERT (m_normalAckTimeoutEvent.IsExpired ());
      NotifyAckTimeoutStartNow (timerDelay);
      m_normalAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::NormalAckTimeout, this);
    } 
  else if (m_txParams.MustWaitFastAck ()) 
    {
      Time timerDelay = txDuration + GetPifs ();
      NS_ASSERT (m_fastAckTimeoutEvent.IsExpired ());
      NotifyAckTimeoutStartNow (timerDelay);
      m_fastAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::FastAckTimeout, this);
    } 
  else if (m_txParams.MustWaitSuperFastAck ()) 
    {
      Time timerDelay = txDuration + GetPifs ();
      NS_ASSERT (m_superFastAckTimeoutEvent.IsExpired ());
      NotifyAckTimeoutStartNow (timerDelay);
      m_superFastAckTimeoutEvent = Simulator::Schedule (timerDelay, 
                                                        &MacLow::SuperFastAckTimeout, this);
    } 

(-)a/src/devices/wifi/mac-low.h (-7 / +15 lines)

Lines 100-109	Link Here

100

 * and calls to its methods are forwards to the corresponding

100

 * and calls to its methods are forwards to the corresponding

101

 * ns3::Dcf methods.

101

 * ns3::Dcf methods.

102

*/

102

*/

103

class MacLowNavListener {

103

class MacLowDcfListener {

104

public:

104

public:

105

  MacLowNavListener ();

105

  MacLowDcfListener ();

106

  virtual ~MacLowNavListener ();

106

  virtual ~MacLowDcfListener ();

107

/**

107

/**

108

   * \param duration duration of NAV timer

108

   * \param duration duration of NAV timer

109

*/

109

*/

Lines 112-117	Link Here

112

   * \param duration duration of NAV timer

112

   * \param duration duration of NAV timer

113

*/

113

*/

114

  virtual void NavReset (Time duration) = 0;

114

  virtual void NavReset (Time duration) = 0;

115

  virtual void AckTimeoutStart (Time duration) = 0;

116

  virtual void AckTimeoutReset () = 0;

117

  virtual void CtsTimeoutStart (Time duration) = 0;

118

  virtual void CtsTimeoutReset () = 0;

115

};

119

};

116

120

117

/**

121

/**

Lines 306-312	Link Here

306

   * \param listener listen to NAV events for every incoming

310

   * \param listener listen to NAV events for every incoming

307

   *        and outgoing packet.

311

   *        and outgoing packet.

308

*/

312

*/

309

  void RegisterNavListener (MacLowNavListener *listener);

313

  void RegisterDcfListener (MacLowDcfListener *listener);

310

314

311

/**

315

/**

312

   * \param packet to send (does not include the 802.11 MAC header and checksum)

316

   * \param packet to send (does not include the 802.11 MAC header and checksum)

Lines 375-380	Link Here

375

  void DoNavResetNow (Time duration);

379

  void DoNavResetNow (Time duration);

376

  bool DoNavStartNow (Time duration);

380

  bool DoNavStartNow (Time duration);

377

  bool IsNavZero (void) const;

381

  bool IsNavZero (void) const;

382

  void NotifyAckTimeoutStartNow (Time duration);

383

  void NotifyAckTimeoutResetNow ();

384

  void NotifyCtsTimeoutStartNow (Time duration);

385

  void NotifyCtsTimeoutResetNow ();

378

  void MaybeCancelPrevious (void);

386

  void MaybeCancelPrevious (void);

379

387

380

  void NavCounterResetCtsMissed (Time rtsEndRxTime);

388

  void NavCounterResetCtsMissed (Time rtsEndRxTime);

Lines 397-405	Link Here

397

  Ptr<WifiPhy> m_phy;

405

  Ptr<WifiPhy> m_phy;

398

  Ptr<WifiRemoteStationManager> m_stationManager;

406

  Ptr<WifiRemoteStationManager> m_stationManager;

399

  MacLowRxCallback m_rxCallback;

407

  MacLowRxCallback m_rxCallback;

400

  typedef std::vector<MacLowNavListener *>::const_iterator NavListenersCI;

408

  typedef std::vector<MacLowDcfListener *>::const_iterator DcfListenersCI;

401

  typedef std::vector<MacLowNavListener *> NavListeners;

409

  typedef std::vector<MacLowDcfListener *> DcfListeners;

402

  NavListeners m_navListeners;

410

  DcfListeners m_dcfListeners;

403

411

404

  EventId m_normalAckTimeoutEvent;

412

  EventId m_normalAckTimeoutEvent;

405

  EventId m_fastAckTimeoutEvent;

413

  EventId m_fastAckTimeoutEvent;

Return to bug 556