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 1979 d535a38b7fc4
parent 1974 0d6b3bead74a
child 2001 00f8a2a9cd89
equal deleted inserted replaced
1978:cc905522d049 1979:d535a38b7fc4 
    17  *
 
    17  *
 
    18  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 
    18  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 
    19  */
 
    19  */
 
    20 
    20 
    21 #include "ns3/assert.h"
 
    21 #include "ns3/assert.h"
 
    22 
       
    23 #include "ns3/packet.h"
 
    22 #include "ns3/packet.h"
 
       
    23 #include "ns3/log.h"
 
    24 
    24 
    25 #include "dca-txop.h"
 
    25 #include "dca-txop.h"
 
    26 #include "dcf.h"
 
    26 #include "dcf.h"
 
    27 #include "mac-parameters.h"
 
    27 #include "mac-parameters.h"
 
    28 #include "mac-low.h"
 
    28 #include "mac-low.h"
 
    29 #include "wifi-mac-queue.h"
 
    29 #include "wifi-mac-queue.h"
 
    30 #include "mac-tx-middle.h"
 
    30 #include "mac-tx-middle.h"
 
    31 #include "wifi-phy.h"
 
    31 #include "wifi-phy.h"
 
    32 
    32 
    33 
    33 NS_LOG_COMPONENT_DEFINE ("DcaTxop");
 
    34 
    34 
    35 #define noDCA_TXOP_TRACE 1
 
       
    36 
       
    37 #ifdef DCA_TXOP_TRACE
 
       
    38 #include "ns3/simulator.h"
 
       
    39 #include <iostream>
 
       
    40 # define TRACE(x) \
 
       
    41   std::cout <<"DCA TXOP now="<<Simulator::NowUs ()<<"us "<<x<<std::endl;
 
       
    42 #else /* DCA_TXOP_TRACE */
 
       
    43 # define TRACE(x)
 
       
    44 #endif /* DCA_TXOP_TRACE */
 
       
    45 
    35 
    46 namespace ns3 {
 
    36 namespace ns3 {
 
    47 
    37 
    48 class DcaTxop::NavListener : public ns3::MacLowNavListener {
 
    38 class DcaTxop::NavListener : public ns3::MacLowNavListener {
 
    49 public:
 
    39 public:
 
   370 DcaTxop::AccessNeeded (void)
 
   360 DcaTxop::AccessNeeded (void)
 
   371 {
 
   361 {
 
   372   if (!m_queue->IsEmpty () ||
 
   362   if (!m_queue->IsEmpty () ||
 
   373       m_hasCurrent) 
   363       m_hasCurrent) 
   374     {
 
   364     {
 
   375       TRACE ("access needed here");
 
   365       NS_LOG_DEBUG ("access needed here");
 
   376       return true;
 
   366       return true;
 
   377     } 
   367     } 
   378   else 
   368   else 
   379     {
 
   369     {
 
   380       TRACE ("no access needed here");
 
   370       NS_LOG_DEBUG ("no access needed here");
 
   381       return false;
 
   371       return false;
 
   382     }
 
   372     }
 
   383 }
 
   373 }
 
   384 
   374 
   385 void
 
   375 void
 
   387 {
 
   377 {
 
   388   if (!m_hasCurrent) 
   378   if (!m_hasCurrent) 
   389     {
 
   379     {
 
   390       if (m_queue->IsEmpty ()) 
   380       if (m_queue->IsEmpty ()) 
   391         {
 
   381         {
 
   392           TRACE ("queue empty");
 
   382           NS_LOG_DEBUG ("queue empty");
 
   393           return;
 
   383           return;
 
   394         }
 
   384         }
 
   395       bool found;
 
   385       bool found;
 
   396       m_currentPacket = m_queue->Dequeue (&m_currentHdr, &found);
 
   386       m_currentPacket = m_queue->Dequeue (&m_currentHdr, &found);
 
   397       NS_ASSERT (found);
 
   387       NS_ASSERT (found);
 
   402       m_currentHdr.SetFragmentNumber (0);
 
   392       m_currentHdr.SetFragmentNumber (0);
 
   403       m_currentHdr.SetNoMoreFragments ();
 
   393       m_currentHdr.SetNoMoreFragments ();
 
   404       m_ssrc = 0;
 
   394       m_ssrc = 0;
 
   405       m_slrc = 0;
 
   395       m_slrc = 0;
 
   406       m_fragmentNumber = 0;
 
   396       m_fragmentNumber = 0;
 
   407       TRACE ("dequeued size="<<m_currentPacket.GetSize ()<<
 
   397       NS_LOG_DEBUG ("dequeued size="<<m_currentPacket.GetSize ()<<
 
   408              ", to="<<m_currentHdr.GetAddr1 ()<<
 
   398              ", to="<<m_currentHdr.GetAddr1 ()<<
 
   409              ", seq="<<m_currentHdr.GetSequenceControl ()); 
   399              ", seq="<<m_currentHdr.GetSequenceControl ()); 
   410     }
 
   400     }
 
   411   MacLowTransmissionParameters params;
 
   401   MacLowTransmissionParameters params;
 
   412   params.DisableOverrideDurationId ();
 
   402   params.DisableOverrideDurationId ();
 
   420                                  params,
 
   410                                  params,
 
   421                                  m_transmissionListener);
 
   411                                  m_transmissionListener);
 
   422       m_hasCurrent = false;
 
   412       m_hasCurrent = false;
 
   423       m_dcf->ResetCw ();
 
   413       m_dcf->ResetCw ();
 
   424       m_dcf->StartBackoff ();
 
   414       m_dcf->StartBackoff ();
 
   425       TRACE ("tx broadcast");
 
   415       NS_LOG_DEBUG ("tx broadcast");
 
   426     } 
   416     } 
   427   else 
   417   else 
   428     {
 
   418     {
 
   429       params.EnableAck ();
 
   419       params.EnableAck ();
 
   430       
   420       
   433           params.DisableRts ();
 
   423           params.DisableRts ();
 
   434           WifiMacHeader hdr;
 
   424           WifiMacHeader hdr;
 
   435           Packet fragment = GetFragmentPacket (&hdr);
 
   425           Packet fragment = GetFragmentPacket (&hdr);
 
   436           if (IsLastFragment ()) 
   426           if (IsLastFragment ()) 
   437             {
 
   427             {
 
   438               TRACE ("fragmenting last fragment size="<<fragment->GetSize ());
 
   428               NS_LOG_DEBUG ("fragmenting last fragment size="<<fragment.GetSize ());
 
   439               params.DisableNextData ();
 
   429               params.DisableNextData ();
 
   440             } 
   430             } 
   441           else 
   431           else 
   442             {
 
   432             {
 
   443               TRACE ("fragmenting size="<<fragment->GetSize ());
 
   433               NS_LOG_DEBUG ("fragmenting size="<<fragment.GetSize ());
 
   444               params.EnableNextData (GetNextFragmentSize ());
 
   434               params.EnableNextData (GetNextFragmentSize ());
 
   445             }
 
   435             }
 
   446           Low ()->StartTransmission (fragment, &hdr, params, 
   436           Low ()->StartTransmission (fragment, &hdr, params, 
   447                                      m_transmissionListener);
 
   437                                      m_transmissionListener);
 
   448         } 
   438         } 
   449       else 
   439       else 
   450         {
 
   440         {
 
   451           if (NeedRts ()) 
   441           if (NeedRts ()) 
   452             {
 
   442             {
 
   453               params.EnableRts ();
 
   443               params.EnableRts ();
 
   454               TRACE ("tx unicast rts");
 
   444               NS_LOG_DEBUG ("tx unicast rts");
 
   455             } 
   445             } 
   456           else 
   446           else 
   457             {
 
   447             {
 
   458               params.DisableRts ();
 
   448               params.DisableRts ();
 
   459               TRACE ("tx unicast");
 
   449               NS_LOG_DEBUG ("tx unicast");
 
   460             }
 
   450             }
 
   461           params.DisableNextData ();
 
   451           params.DisableNextData ();
 
   462           // We need to make a copy in case we need to 
   452           // We need to make a copy in case we need to 
   463           // retransmit the packet: the MacLow modifies the input
 
   453           // retransmit the packet: the MacLow modifies the input
 
   464           // Packet so, we would retransmit a modified packet
 
   454           // Packet so, we would retransmit a modified packet
 
   474 
   464 
   475 
   465 
   476 void 
   466 void 
   477 DcaTxop::GotCts (double snr, WifiMode txMode)
 
   467 DcaTxop::GotCts (double snr, WifiMode txMode)
 
   478 {
 
   468 {
 
   479   TRACE ("got cts");
 
   469   NS_LOG_DEBUG ("got cts");
 
   480   m_ssrc = 0;
 
   470   m_ssrc = 0;
 
   481 }
 
   471 }
 
   482 void 
   472 void 
   483 DcaTxop::MissedCts (void)
 
   473 DcaTxop::MissedCts (void)
 
   484 {
 
   474 {
 
   485   TRACE ("missed cts");
 
   475   NS_LOG_DEBUG ("missed cts");
 
   486   m_ssrc++;
 
   476   m_ssrc++;
 
   487   m_ctstimeoutTrace (m_ssrc);
 
   477   m_ctstimeoutTrace (m_ssrc);
 
   488   if (m_ssrc > Parameters ()->GetMaxSsrc ()) 
   478   if (m_ssrc > Parameters ()->GetMaxSsrc ()) 
   489     {
 
   479     {
 
   490       // to reset the dcf.
 
   480       // to reset the dcf.
 
   503 {
 
   493 {
 
   504   m_slrc = 0;
 
   494   m_slrc = 0;
 
   505   if (!NeedFragmentation () ||
 
   495   if (!NeedFragmentation () ||
 
   506       IsLastFragment ()) 
   496       IsLastFragment ()) 
   507     {
 
   497     {
 
   508       TRACE ("got ack. tx done.");
 
   498       NS_LOG_DEBUG ("got ack. tx done.");
 
   509       if (!m_txOkCallback.IsNull ()) 
   499       if (!m_txOkCallback.IsNull ()) 
   510         {
 
   500         {
 
   511           m_txOkCallback (m_currentHdr);
 
   501           m_txOkCallback (m_currentHdr);
 
   512         }
 
   502         }
 
   513 
   503 
   518       m_dcf->ResetCw ();
 
   508       m_dcf->ResetCw ();
 
   519       m_dcf->StartBackoff ();
 
   509       m_dcf->StartBackoff ();
 
   520     } 
   510     } 
   521   else 
   511   else 
   522     {
 
   512     {
 
   523       TRACE ("got ack. tx not done, size="<<m_currentPacket.GetSize ());
 
   513       NS_LOG_DEBUG ("got ack. tx not done, size="<<m_currentPacket.GetSize ());
 
   524     }
 
   514     }
 
   525 }
 
   515 }
 
   526 void 
   516 void 
   527 DcaTxop::MissedAck (void)
 
   517 DcaTxop::MissedAck (void)
 
   528 {
 
   518 {
 
   529   TRACE ("missed ack");
 
   519   NS_LOG_DEBUG ("missed ack");
 
   530   m_slrc++;
 
   520   m_slrc++;
 
   531   m_acktimeoutTrace (m_slrc);
 
   521   m_acktimeoutTrace (m_slrc);
 
   532   if (m_slrc > Parameters ()->GetMaxSlrc ()) 
   522   if (m_slrc > Parameters ()->GetMaxSlrc ()) 
   533     {
 
   523     {
 
   534       // to reset the dcf.    
   524       // to reset the dcf.    
   550   
   540   
   551 }
 
   541 }
 
   552 void 
   542 void 
   553 DcaTxop::StartNext (void)
 
   543 DcaTxop::StartNext (void)
 
   554 {
 
   544 {
 
   555   TRACE ("start next packet fragment");
 
   545   NS_LOG_DEBUG ("start next packet fragment");
 
   556   /* this callback is used only for fragments. */
 
   546   /* this callback is used only for fragments. */
 
   557   NextFragment ();
 
   547   NextFragment ();
 
   558   WifiMacHeader hdr;
 
   548   WifiMacHeader hdr;
 
   559   Packet fragment = GetFragmentPacket (&hdr);
 
   549   Packet fragment = GetFragmentPacket (&hdr);
 
   560   MacLowTransmissionParameters params;
 
   550   MacLowTransmissionParameters params;
ns-3.24