Attachment #461 for bug #555

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




{
public:
  DcfStateTest (DcfManagerTest *test, uint32_t i);
  void QueueTx (uint64_t txTime, uint64_t expectedGrantTime, uint32_t nBackoffSlots);
private:
  friend class DcfManagerTest;
  virtual void DoNotifyAccessGranted (void);
  virtual void DoNotifyInternalCollision (void);
  virtual void DoNotifyCollision (void);

  struct ExpectedGrant {
    uint64_t m_txTime;
    uint64_t m_expectedGrantTime;
    uint32_t m_nBackoffSlots;
  };
  typedef std::list<struct ExpectedGrant> ExpectedGrants;

  struct ExpectedCollision {
    uint64_t at;
    uint32_t nSlots;

  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 nBackoffSlots, uint32_t from);
  void AddAccessRequestWithAckTimeout (uint64_t at, uint64_t txTime, uint64_t expectedGrantTime,
                                       uint32_t nBackoffSlots, 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 nBackoffSlots, uint32_t ackDelay, uint32_t from);
  void DoAccessRequest (uint64_t txTime, uint64_t expectedGrantTime, uint32_t nBackoffSlots, DcfStateTest *state);
  
  typedef std::vector<DcfStateTest *> DcfStates;


  : m_test (test), m_i(i)
{}
void 
DcfStateTest::QueueTx (uint64_t txTime, uint64_t expectedGrantTime, uint32_t nBackoffSlots)
{
  struct ExpectedGrant grant;
  grant.m_txTime = txTime;
  grant.m_expectedGrantTime = expectedGrantTime;
  grant.m_nBackoffSlots = nBackoffSlots;
  m_expectedGrants.push_back (grant);
}
void 
DcfStateTest::DoNotifyAccessGranted (void)

  DcfStateTest *state = m_dcfStates[i];
  bool result = true;
  NS_TEST_ASSERT (!state->m_expectedGrants.empty ());
  struct DcfStateTest::ExpectedGrant expected = state->m_expectedGrants.front ();
  state->m_expectedGrants.pop_front ();
  NS_TEST_ASSERT_EQUAL (Simulator::Now (), MicroSeconds (expected.m_expectedGrantTime));
  m_dcfManager->NotifyTxStartNow (MicroSeconds (expected.m_txTime));
  state->StartBackoffNow (expected.m_nBackoffSlots);
  m_dcfManager->NotifyAckTimeoutStartNow (MicroSeconds (m_ackTimeoutValue + expected.m_txTime));
  if (!result)
    {
      m_result = result;

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


  //
  StartTest (1, 3, 10);
  AddDcfState (1);
  AddAccessRequest (1, 1, 4, 1, 0);
  AddAccessRequest (10, 2, 10, 0, 0);
  EndTest ();

  // The test below mainly intends to test the case where the medium

  AddDcfState (1);
  AddRxOkEvt (20, 40);
  AddRxOkEvt (80, 20);
  AddAccessRequest (30, 2, 118, 4, 0);
  ExpectCollision (30, 4, 0); // backoff: 4 slots
  EndTest ();


  StartTest (4, 6 , 10);
  AddDcfState (1);
  AddRxOkEvt (20, 40);
  AddAccessRequest (30, 2, 70, 0, 0);
  ExpectCollision (30, 0, 0); // backoff: 0 slots
  EndTest ();

  // Test case where two packets are queued at DcaTxop, the first send starts
  // immediately and the second is also immediately indicated but has to wait
  // for its backoff.
  //
  //  20          60     66      70   80
  //   | tx        | sifs | aifs  | tx |
  //   |20: request access for both packets
  StartTest (4, 6 , 10);
  AddDcfState (1);
  AddAccessRequest (20, 40, 20, 0, 0);
  AddAccessRequest (20, 10, 70, 0, 0);
  EndTest ();

  // Test case where two packets are queued at DcaTxop, the first send starts
  // immediately and the second is also immediately indicated but has to wait
  // for its backoff.
  //
  //  20          60     66      70        78   88
  //   | tx        | sifs | aifs  | backoff | tx |
  //   |20: request access for both packets
  StartTest (4, 6 , 10);
  AddDcfState (1);
  AddAccessRequest (20, 40, 20, 2, 0);
  AddAccessRequest (20, 10, 78, 0, 0);
  EndTest ();

  // The test below is subject to some discussion because I am 
  // not sure I understand the intent of the spec here.
  // i.e., what happens if you make a request to get access

  StartTest (4, 6 , 10);
  AddDcfState (1);
  AddRxOkEvt (20, 40);
  AddAccessRequest (62, 2, 70, 0, 0);
  EndTest ();



  StartTest (4, 6, 10);
  AddDcfState (1);
  AddRxErrorEvt (20, 40);
  AddAccessRequest (30, 2, 96, 4, 0);
  ExpectCollision (30, 4, 0); // backoff: 4 slots  
  EndTest ();


  StartTest (4, 6, 10);
  AddDcfState (1);
  AddRxErrorEvt (20, 40);
  AddAccessRequest (30, 2, 101, 4, 0);
  ExpectCollision (30, 4, 0); // backoff: 4 slots  
  AddRxOkEvt (69, 6);
  EndTest ();

  AddDcfState (1); // high priority DCF
  AddDcfState (3); // low priority DCF
  AddRxOkEvt (20, 40);
  AddAccessRequest (30, 10, 78, 2, 0);
  ExpectCollision (30, 2, 0); // backoff: 2 slot

  AddAccessRequest (40, 2, 110, 0, 1);
  ExpectCollision (40, 0, 1); // backoff: 0 slot
  ExpectInternalCollision (78, 1, 1); // backoff: 1 slot
  EndTest ();

  StartTest (4, 6, 10);
  AddDcfState (2); // high priority DCF
  AddDcfState (0); // low priority DCF
  AddAccessRequestWithAckTimeout (20, 20, 20, 0, 0);
  AddAccessRequest (50, 10, 66, 0, 1);
  EndTest ();

  // Test of AckTimeout handling: 

  StartTest (4, 6, 10);
  AddDcfState (2); // high priority DCF
  AddDcfState (0); // low priority DCF
  AddAccessRequestWithSuccessfullAck (20, 20, 20, 2, 0, 0);
  AddAccessRequest (41, 10, 48, 0, 1);
  EndTest ();

  //Repeat the same but with one queue:

  //                              ^ request access
  StartTest (4, 6, 10);
  AddDcfState (2);
  AddAccessRequestWithSuccessfullAck (20, 20, 20, 2, 0, 0);
  AddAccessRequest (41, 10, 56, 0, 0);
  EndTest ();

  //Repeat the same when ack was delayed:

  //                      ^ request access
  StartTest (4, 6, 10);
  AddDcfState (2);
  AddAccessRequestWithSuccessfullAck (20, 20, 20, 2, 2, 0);
  AddAccessRequest (39, 10, 64, 0, 0);
  // this situation is not supposed to fire an internal or external collison.
  // ExpectCollision (39, 2, 0); // backoff: 2 slot
  EndTest ();

  //

  AddNavStart (60, 15);
  AddRxOkEvt (66, 5);
  AddNavStart (71, 0);
  AddAccessRequest (30, 10, 93, 0, 0);
  ExpectCollision (30, 2, 0); // backoff: 2 slot
  EndTest ();


  AddNavStart (60, 15);
  AddRxOkEvt (66, 5);
  AddNavReset (71, 2);
  AddAccessRequest (30, 10, 91, 0, 0);
  ExpectCollision (30, 2, 0); // backoff: 2 slot
  EndTest ();


  StartTest (4, 6, 10);
  AddDcfState (2);
  AddRxOkEvt (20, 40);
  AddAccessRequest (80, 10, 80, 0, 0);
  EndTest ();



  AddDcfState (2);
  AddRxOkEvt (20, 40);
  AddRxOkEvt (78, 8);
  AddAccessRequest (30, 50, 108, 0, 0);
  ExpectCollision (30, 3, 0); // backoff: 3 slots
  EndTest ();
 

  return m_result;
}

(-)a/src/devices/wifi/dcf-manager.cc (-2 / +12 lines)

Lines 42-47 namespace ns3 {	Link Here

DcfState::DcfState ()

DcfState::DcfState ()

  : m_backoffSlots (0),

  : m_backoffSlots (0),

    m_backoffStart (Seconds (0.0)),

    m_backoffStart (Seconds (0.0)),

    m_backoffElapsed (true),

    m_cwMin (0),

    m_cwMin (0),

    m_cwMax (0),

    m_cwMax (0),

    m_cw (0),

    m_cw (0),

Lines 101-106 DcfState::UpdateBackoffSlotsNow (uint32_	Link Here

101

  m_backoffSlots -= nSlots;

102

  m_backoffSlots -= nSlots;

102

  m_backoffStart = backoffUpdateBound;

103

  m_backoffStart = backoffUpdateBound;

103

  MY_DEBUG ("update slots="<<nSlots<<" slots, backoff="<<m_backoffSlots);

104

  MY_DEBUG ("update slots="<<nSlots<<" slots, backoff="<<m_backoffSlots);

105

  if (m_backoffSlots == 0)

106

107

      m_backoffElapsed = true;

108

104

109

105

110

106

void

111

void

Lines 110-115 DcfState::StartBackoffNow (uint32_t nSlo	Link Here

110

  MY_DEBUG ("start backoff="<<nSlots<<" slots");

115

  MY_DEBUG ("start backoff="<<nSlots<<" slots");

111

  m_backoffSlots = nSlots;

116

  m_backoffSlots = nSlots;

112

  m_backoffStart = Simulator::Now ();

117

  m_backoffStart = Simulator::Now ();

118

  m_backoffElapsed = false;

113

119

114

120

115

uint32_t

121

uint32_t

Lines 127-132 DcfState::GetBackoffStart (void) const	Link Here

127

133

128

  return m_backoffStart;

134

  return m_backoffStart;

129

135

136

bool

137

DcfState::IsBackoffElapsed (void) const

138

139

  return m_backoffElapsed;

140

130

bool

141

bool

131

DcfState::IsAccessRequested (void) const

142

DcfState::IsAccessRequested (void) const

132

143

Lines 352-359 DcfManager::RequestAccess (DcfState *sta	Link Here

352

   * If there is a collision, generate a backoff

363

   * If there is a collision, generate a backoff

353

   * by notifying the collision to the user.

364

   * by notifying the collision to the user.

354

*/

365

*/

355

  if (state->GetBackoffSlots () == 0 &&

366

  if (state->IsBackoffElapsed() && IsBusy ())

356

      IsBusy ())

357

367

358

      MY_DEBUG ("medium is busy: collision");

368

      MY_DEBUG ("medium is busy: collision");

359

      /* someone else has accessed the medium.

369

      /* someone else has accessed the medium.

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

Lines 80-85 public:	Link Here

*/

*/

  void StartBackoffNow (uint32_t nSlots);

  void StartBackoffNow (uint32_t nSlots);

/**

/**

   * Returns true if the backoff procedure elapsed.

*/

  bool IsBackoffElapsed (void) const;

/**

   * \returns the current value of the CW variable. The initial value is

   * \returns the current value of the CW variable. The initial value is

   * minCW.

   * minCW.

*/

*/

Lines 137-142 private:	Link Here

137

  // time at which a backoff was started or the time at which

141

  // time at which a backoff was started or the time at which

138

  // the backoff counter was last updated.

142

  // the backoff counter was last updated.

139

  Time m_backoffStart;

143

  Time m_backoffStart;

144

  bool m_backoffElapsed;

140

  uint32_t m_cwMin;

145

  uint32_t m_cwMin;

141

  uint32_t m_cwMax;

146

  uint32_t m_cwMax;

142

  uint32_t m_cw;

147

  uint32_t m_cw;

Return to bug 555