Mercurial Mercurial > ns-3.24 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/devices/wifi/dca-txop.cc
changeset 6068 a2127017ecb4
parent 6065 0f012e7d9128
parent 5999 ee04189aec1b
child 6080 41ee42654550
equal deleted inserted replaced
6067:ccbdc2b19ea5 6068:a2127017ecb4 
    34 #include "wifi-mac.h"
 
    34 #include "wifi-mac.h"
 
    35 #include "random-stream.h"
 
    35 #include "random-stream.h"
 
    36 
    36 
    37 NS_LOG_COMPONENT_DEFINE ("DcaTxop");
 
    37 NS_LOG_COMPONENT_DEFINE ("DcaTxop");
 
    38 
    38 
    39 #define MY_DEBUG(x) \
 
    39 #undef NS_LOG_APPEND_CONTEXT
 
    40   NS_LOG_DEBUG (m_low->GetAddress () << " " << x)
 
    40 #define NS_LOG_APPEND_CONTEXT if (m_low != 0) {std::clog << "[mac=" << m_low->GetAddress () << "] ";}
 
    41 
       
    42 
    41 
    43 namespace ns3 {
 
    42 namespace ns3 {
 
    44 
    43 
    45 class DcaTxop::Dcf : public DcfState
 
    44 class DcaTxop::Dcf : public DcfState
 
    46 {
 
    45 {
 
   261 {
 
   260 {
 
   262   return m_low;
 
   261   return m_low;
 
   263 }
 
   262 }
 
   264 
   263 
   265 bool
 
   264 bool
 
   266 DcaTxop::NeedRts (void)
 
   265 DcaTxop::NeedRts (Ptr<const Packet> packet, const WifiMacHeader *header)
 
   267 {
 
   266 {
 
   268   return m_stationManager->NeedRts (m_currentHdr.GetAddr1 (), &m_currentHdr,
 
   267   return m_stationManager->NeedRts (header->GetAddr1 (), header,
 
   269                                     m_currentPacket);
 
   268                                     packet);
 
   270 }
 
   269 }
 
   271 
   270 
   272 bool
 
   271 bool
 
   273 DcaTxop::NeedRtsRetransmission (void)
 
   272 DcaTxop::NeedRtsRetransmission (void)
 
   274 {
 
   273 {
 
   353   NS_LOG_FUNCTION (this);
 
   352   NS_LOG_FUNCTION (this);
 
   354   if (m_currentPacket == 0) 
   353   if (m_currentPacket == 0) 
   355     {
 
   354     {
 
   356       if (m_queue->IsEmpty ()) 
   355       if (m_queue->IsEmpty ()) 
   357         {
 
   356         {
 
   358           MY_DEBUG ("queue empty");
 
   357           NS_LOG_DEBUG ("queue empty");
 
   359           return;
 
   358           return;
 
   360         }
 
   359         }
 
   361       m_currentPacket = m_queue->Dequeue (&m_currentHdr);
 
   360       m_currentPacket = m_queue->Dequeue (&m_currentHdr);
 
   362       NS_ASSERT (m_currentPacket != 0);
 
   361       NS_ASSERT (m_currentPacket != 0);
 
   363       uint16_t sequence = m_txMiddle->GetNextSequenceNumberfor (&m_currentHdr);
 
   362       uint16_t sequence = m_txMiddle->GetNextSequenceNumberfor (&m_currentHdr);
 
   364       m_currentHdr.SetSequenceNumber (sequence);
 
   363       m_currentHdr.SetSequenceNumber (sequence);
 
   365       m_currentHdr.SetFragmentNumber (0);
 
   364       m_currentHdr.SetFragmentNumber (0);
 
   366       m_currentHdr.SetNoMoreFragments ();
 
   365       m_currentHdr.SetNoMoreFragments ();
 
   367       m_currentHdr.SetNoRetry ();
 
   366       m_currentHdr.SetNoRetry ();
 
   368       m_fragmentNumber = 0;
 
   367       m_fragmentNumber = 0;
 
   369       MY_DEBUG ("dequeued size="<<m_currentPacket->GetSize ()<<
 
   368       NS_LOG_DEBUG ("dequeued size="<<m_currentPacket->GetSize ()<<
 
   370                     ", to="<<m_currentHdr.GetAddr1 ()<<
 
   369                     ", to="<<m_currentHdr.GetAddr1 ()<<
 
   371                     ", seq="<<m_currentHdr.GetSequenceControl ()); 
   370                     ", seq="<<m_currentHdr.GetSequenceControl ()); 
   372     }
 
   371     }
 
   373   MacLowTransmissionParameters params;
 
   372   MacLowTransmissionParameters params;
 
   374   params.DisableOverrideDurationId ();
 
   373   params.DisableOverrideDurationId ();
 
   383                                  m_transmissionListener);
 
   382                                  m_transmissionListener);
 
   384       m_currentPacket = 0;
 
   383       m_currentPacket = 0;
 
   385       m_dcf->ResetCw ();
 
   384       m_dcf->ResetCw ();
 
   386       m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   385       m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   387       StartAccessIfNeeded ();
 
   386       StartAccessIfNeeded ();
 
   388       MY_DEBUG ("tx broadcast");
 
   387       NS_LOG_DEBUG ("tx broadcast");
 
   389     } 
   388     } 
   390   else 
   389   else 
   391     {
 
   390     {
 
   392       params.EnableAck ();
 
   391       params.EnableAck ();
 
   393       
   392       
   394       if (NeedFragmentation ()) 
   393       if (NeedFragmentation ()) 
   395         {
 
   394         {
 
   396           params.DisableRts ();
 
       
   397           WifiMacHeader hdr;
 
   395           WifiMacHeader hdr;
 
   398           Ptr<Packet> fragment = GetFragmentPacket (&hdr);
 
   396           Ptr<Packet> fragment = GetFragmentPacket (&hdr);
 
       
   397           if (NeedRts (fragment, &hdr))
 
       
   398             {
 
       
   399               params.EnableRts ();
 
       
   400             }
 
       
   401           else
 
       
   402             {
 
       
   403               params.DisableRts ();
 
       
   404             }
 
   399           if (IsLastFragment ()) 
   405           if (IsLastFragment ()) 
   400             {
 
   406             {
 
   401               MY_DEBUG ("fragmenting last fragment size="<<fragment->GetSize ());
 
   407               NS_LOG_DEBUG ("fragmenting last fragment size="<<fragment->GetSize ());
 
   402               params.DisableNextData ();
 
   408               params.DisableNextData ();
 
   403             } 
   409             } 
   404           else 
   410           else 
   405             {
 
   411             {
 
   406               MY_DEBUG ("fragmenting size="<<fragment->GetSize ());
 
   412               NS_LOG_DEBUG ("fragmenting size="<<fragment->GetSize ());
 
   407               params.EnableNextData (GetNextFragmentSize ());
 
   413               params.EnableNextData (GetNextFragmentSize ());
 
   408             }
 
   414             }
 
   409           Low ()->StartTransmission (fragment, &hdr, params, 
   415           Low ()->StartTransmission (fragment, &hdr, params, 
   410                                      m_transmissionListener);
 
   416                                      m_transmissionListener);
 
   411         } 
   417         } 
   412       else 
   418       else 
   413         {
 
   419         {
 
   414           if (NeedRts ()) 
   420           if (NeedRts (m_currentPacket, &m_currentHdr)) 
   415             {
 
   421             {
 
   416               params.EnableRts ();
 
   422               params.EnableRts ();
 
   417               MY_DEBUG ("tx unicast rts");
 
   423               NS_LOG_DEBUG ("tx unicast rts");
 
   418             } 
   424             } 
   419           else 
   425           else 
   420             {
 
   426             {
 
   421               params.DisableRts ();
 
   427               params.DisableRts ();
 
   422               MY_DEBUG ("tx unicast");
 
   428               NS_LOG_DEBUG ("tx unicast");
 
   423             }
 
   429             }
 
   424           params.DisableNextData ();
 
   430           params.DisableNextData ();
 
   425           Low ()->StartTransmission (m_currentPacket, &m_currentHdr,
 
   431           Low ()->StartTransmission (m_currentPacket, &m_currentHdr,
 
   426                                      params, m_transmissionListener);
 
   432                                      params, m_transmissionListener);
 
   427         }
 
   433         }
 
   436 }
 
   442 }
 
   437 void 
   443 void 
   438 DcaTxop::NotifyCollision (void)
 
   444 DcaTxop::NotifyCollision (void)
 
   439 {
 
   445 {
 
   440   NS_LOG_FUNCTION (this);
 
   446   NS_LOG_FUNCTION (this);
 
   441   MY_DEBUG ("collision");
 
   447   NS_LOG_DEBUG ("collision");
 
   442   m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   448   m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   443   RestartAccessIfNeeded ();
 
   449   RestartAccessIfNeeded ();
 
   444 }
 
   450 }
 
   445 
   451 
   446 void 
   452 void 
   452 
   458 
   453 void 
   459 void 
   454 DcaTxop::GotCts (double snr, WifiMode txMode)
 
   460 DcaTxop::GotCts (double snr, WifiMode txMode)
 
   455 {
 
   461 {
 
   456   NS_LOG_FUNCTION (this << snr << txMode);
 
   462   NS_LOG_FUNCTION (this << snr << txMode);
 
   457   MY_DEBUG ("got cts");
 
   463   NS_LOG_DEBUG ("got cts");
 
   458 }
 
   464 }
 
   459 void 
   465 void 
   460 DcaTxop::MissedCts (void)
 
   466 DcaTxop::MissedCts (void)
 
   461 {
 
   467 {
 
   462   NS_LOG_FUNCTION (this);
 
   468   NS_LOG_FUNCTION (this);
 
   463   MY_DEBUG ("missed cts");
 
   469   NS_LOG_DEBUG ("missed cts");
 
   464   if (!NeedRtsRetransmission ())
 
   470   if (!NeedRtsRetransmission ())
 
   465     {
 
   471     {
 
   466       MY_DEBUG ("Cts Fail");
 
   472       NS_LOG_DEBUG ("Cts Fail");
 
   467       m_stationManager->ReportFinalRtsFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 
   473       m_stationManager->ReportFinalRtsFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 
   468       if (!m_txFailedCallback.IsNull ()) 
   474       if (!m_txFailedCallback.IsNull ()) 
   469         {
 
   475         {
 
   470           m_txFailedCallback (m_currentHdr);
 
   476           m_txFailedCallback (m_currentHdr);
 
   471         }
 
   477         }
 
   485 {
 
   491 {
 
   486   NS_LOG_FUNCTION (this << snr << txMode);
 
   492   NS_LOG_FUNCTION (this << snr << txMode);
 
   487   if (!NeedFragmentation () ||
 
   493   if (!NeedFragmentation () ||
 
   488       IsLastFragment ()) 
   494       IsLastFragment ()) 
   489     {
 
   495     {
 
   490       MY_DEBUG ("got ack. tx done.");
 
   496       NS_LOG_DEBUG ("got ack. tx done.");
 
   491       if (!m_txOkCallback.IsNull ()) 
   497       if (!m_txOkCallback.IsNull ()) 
   492         {
 
   498         {
 
   493           m_txOkCallback (m_currentHdr);
 
   499           m_txOkCallback (m_currentHdr);
 
   494         }
 
   500         }
 
   495 
   501 
   501       m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   507       m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   502       RestartAccessIfNeeded ();
 
   508       RestartAccessIfNeeded ();
 
   503     } 
   509     } 
   504   else 
   510   else 
   505     {
 
   511     {
 
   506       MY_DEBUG ("got ack. tx not done, size="<<m_currentPacket->GetSize ());
 
   512       NS_LOG_DEBUG ("got ack. tx not done, size="<<m_currentPacket->GetSize ());
 
   507     }
 
   513     }
 
   508 }
 
   514 }
 
   509 void 
   515 void 
   510 DcaTxop::MissedAck (void)
 
   516 DcaTxop::MissedAck (void)
 
   511 {
 
   517 {
 
   512   NS_LOG_FUNCTION (this);
 
   518   NS_LOG_FUNCTION (this);
 
   513   MY_DEBUG ("missed ack");
 
   519   NS_LOG_DEBUG ("missed ack");
 
   514   if (!NeedDataRetransmission ()) 
   520   if (!NeedDataRetransmission ()) 
   515     {
 
   521     {
 
   516       MY_DEBUG ("Ack Fail");
 
   522       NS_LOG_DEBUG ("Ack Fail");
 
   517       m_stationManager->ReportFinalDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 
   523       m_stationManager->ReportFinalDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 
   518       if (!m_txFailedCallback.IsNull ()) 
   524       if (!m_txFailedCallback.IsNull ()) 
   519         {
 
   525         {
 
   520           m_txFailedCallback (m_currentHdr);
 
   526           m_txFailedCallback (m_currentHdr);
 
   521         }
 
   527         }
 
   523       m_currentPacket = 0;
 
   529       m_currentPacket = 0;
 
   524       m_dcf->ResetCw ();
 
   530       m_dcf->ResetCw ();
 
   525     } 
   531     } 
   526   else 
   532   else 
   527     {
 
   533     {
 
   528       MY_DEBUG ("Retransmit");
 
   534       NS_LOG_DEBUG ("Retransmit");
 
   529       m_currentHdr.SetRetry ();
 
   535       m_currentHdr.SetRetry ();
 
   530       m_dcf->UpdateFailedCw ();
 
   536       m_dcf->UpdateFailedCw ();
 
   531     }
 
   537     }
 
   532   m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   538   m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
 
   533   RestartAccessIfNeeded ();
 
   539   RestartAccessIfNeeded ();
 
   534 }
 
   540 }
 
   535 void 
   541 void 
   536 DcaTxop::StartNext (void)
 
   542 DcaTxop::StartNext (void)
 
   537 {
 
   543 {
 
   538   NS_LOG_FUNCTION (this);
 
   544   NS_LOG_FUNCTION (this);
 
   539   MY_DEBUG ("start next packet fragment");
 
   545   NS_LOG_DEBUG ("start next packet fragment");
 
   540   /* this callback is used only for fragments. */
 
   546   /* this callback is used only for fragments. */
 
   541   NextFragment ();
 
   547   NextFragment ();
 
   542   WifiMacHeader hdr;
 
   548   WifiMacHeader hdr;
 
   543   Ptr<Packet> fragment = GetFragmentPacket (&hdr);
 
   549   Ptr<Packet> fragment = GetFragmentPacket (&hdr);
 
   544   MacLowTransmissionParameters params;
 
   550   MacLowTransmissionParameters params;
 
   558 
   564 
   559 void
 
   565 void
 
   560 DcaTxop::Cancel (void)
 
   566 DcaTxop::Cancel (void)
 
   561 {
 
   567 {
 
   562   NS_LOG_FUNCTION (this);
 
   568   NS_LOG_FUNCTION (this);
 
   563   MY_DEBUG ("transmission cancelled");
 
   569   NS_LOG_DEBUG ("transmission cancelled");
 
   564   /**
 
   570   /**
 
   565    * This happens in only one case: in an AP, you have two DcaTxop:
 
   571    * This happens in only one case: in an AP, you have two DcaTxop:
 
   566    *   - one is used exclusively for beacons and has a high priority.
 
   572    *   - one is used exclusively for beacons and has a high priority.
 
   567    *   - the other is used for everything else and has a normal
 
   573    *   - the other is used for everything else and has a normal
 
   568    *     priority.
 
   574    *     priority.
ns-3.24