Attachment #2741 for bug #2615

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

(-)a/src/wifi/model/dca-txop.cc (+4 lines)

Lines 131-136	Link Here

131

132

    return false;

132

    return false;

133

134

  virtual Time GetTxopLimit (void)

135

136

    return NanoSeconds (0);

137

134

138

135

private:

139

private:

136

  DcaTxop *m_txop;

140

  DcaTxop *m_txop;




#include "ns3/log.h"
#include "ns3/pointer.h"
#include "edca-txop-n.h"
#include "mac-low.h"
#include "dcf-manager.h"
#include "mac-tx-middle.h"
#include "wifi-mac-trailer.h"

  {
    return m_txop->HasTxop ();
  }
  virtual Time GetTxopLimit (void)
  {
    return m_txop->GetTxopLimit ();
  }
  virtual Ptr<WifiMacQueue> GetQueue (void)
  {
    return m_txop->GetEdcaQueue ();

    m_typeOfStation (STA),
    m_blockAckType (COMPRESSED_BLOCK_ACK),
    m_startTxop (Seconds (0)),
    m_isAccessRequestedForRts (false),
    m_currentIsFragmented (false)
{
  NS_LOG_FUNCTION (this);
  m_transmissionListener = new EdcaTxopN::TransmissionListener (this);

uint32_t
EdcaTxopN::GetMinCw (void) const
{
  NS_LOG_FUNCTION (this);
  return m_dcf->GetCwMin ();
}

uint32_t
EdcaTxopN::GetMaxCw (void) const
{
  NS_LOG_FUNCTION (this);
  return m_dcf->GetCwMax ();
}

uint32_t
EdcaTxopN::GetAifsn (void) const
{
  NS_LOG_FUNCTION (this);
  return m_dcf->GetAifsn ();
}

Time
EdcaTxopN::GetTxopLimit (void) const
{
  NS_LOG_FUNCTION (this);
  return m_dcf->GetTxopLimit ();
}


{
  NS_LOG_FUNCTION (this);
  m_isAccessRequestedForRts = false;
  m_startTxop = Simulator::Now ();
  if (m_currentPacket == 0)
    {
      if (m_queue->IsEmpty () && !m_baManager->HasPackets ())

            }
        }
    }
  m_currentParams.DisableOverrideDurationId ();
  params.DisableOverrideDurationId ();
  if (m_currentHdr.GetAddr1 ().IsGroup ())
    {
      m_currentParams.DisableRts ();
      m_currentParams.DisableAck ();
      m_currentParams.DisableNextData ();
      m_low->StartTransmission (m_currentPacket,
                                &m_currentHdr,
                                m_currentParams,
                                m_transmissionListener);

      NS_LOG_DEBUG ("tx broadcast");

    {
      if (m_currentHdr.IsQosData () && m_currentHdr.IsQosBlockAck ())
        {
          m_currentParams.DisableAck ();
        }
      else
        {
          m_currentParams.EnableAck ();
        }
      if (((m_currentHdr.IsQosData () && !m_currentHdr.IsQosAmsdu ())
          || (m_currentHdr.IsData () && !m_currentHdr.IsQosData ()))

          && NeedFragmentation ())
        {
          //With COMPRESSED_BLOCK_ACK fragmentation must be avoided.
          m_currentIsFragmented = true;
          m_currentParams.DisableRts ();
          WifiMacHeader hdr;
          Ptr<Packet> fragment = GetFragmentPacket (&hdr);
          if (IsLastFragment ())
            {
              NS_LOG_DEBUG ("fragmenting last fragment size=" << fragment->GetSize ());
              m_currentParams.DisableNextData ();
            }
          else
            {
              NS_LOG_DEBUG ("fragmenting size=" << fragment->GetSize ());
              m_currentParams.EnableNextData (GetNextFragmentSize ());
            }
          m_low->StartTransmission (fragment, &hdr, m_currentParams,
                                    m_transmissionListener);
        }
      else
        {
          m_currentIsFragmented = false;
          WifiMacHeader peekedHdr;
          Time tstamp;
          if (m_currentHdr.IsQosData ()

                  NS_LOG_DEBUG ("tx unicast A-MSDU");
                }
            }
          m_currentParams.DisableNextData ();
          m_startTxop = Simulator::Now ();
          m_low->StartTransmission (m_currentPacket, &m_currentHdr,
                                    m_currentParams, m_transmissionListener);
          if (!GetAmpduExist (m_currentHdr.GetAddr1 ()))
            {
              CompleteTx ();

void
EdcaTxopN::Queue (Ptr<const Packet> packet, const WifiMacHeader &hdr)
{
  //NS_LOG_FUNCTION (this << packet << &hdr);
  m_stationManager->PrepareForQueue (hdr.GetAddr1 (), &hdr, packet);
  m_queue->Enqueue (packet, hdr);
  StartAccessIfNeeded ();

EdcaTxopN::GotAck (double snr, WifiMode txMode)
{
  NS_LOG_FUNCTION (this << snr << txMode);
  if (!m_currentIsFragmented
      || !m_currentParams.HasNextPacket ()
      || m_currentHdr.IsQosAmsdu ())
    {
      NS_LOG_DEBUG ("got ack. tx done.");

  else
    {
      NS_LOG_DEBUG ("got ack. tx not done, size=" << m_currentPacket->GetSize ());
      if (!HasTxop ())
        {
          if (m_currentHdr.IsQosData () && GetTxopLimit () > NanoSeconds (0))
            {
              m_txopTrace (m_startTxop, Simulator::Now () - m_startTxop);
              m_cwTrace = m_dcf->GetCw ();
              m_backoffTrace = m_rng->GetNext (0, m_dcf->GetCw ());
              m_dcf->StartBackoffNow (m_backoffTrace);
              m_fragmentNumber++;
              RestartAccessIfNeeded ();
            }
        }
    }
}


void
EdcaTxopN::StartAccessIfNeeded (void)
{
  //NS_LOG_FUNCTION (this);
  if (m_currentPacket == 0
      && (!m_queue->IsEmpty () || m_baManager->HasPackets ())
      && !m_dcf->IsAccessRequested ())

  NextFragment ();
  WifiMacHeader hdr;
  Ptr<Packet> fragment = GetFragmentPacket (&hdr);
  m_currentParams.EnableAck ();
  m_currentParams.DisableRts ();
  m_currentParams.DisableOverrideDurationId ();
  params.DisableOverrideDurationId ();
  if (IsLastFragment ())
    {
      m_currentParams.DisableNextData ();
    }
  else
    {
      m_currentParams.EnableNextData (GetNextFragmentSize ());
    }
  GetLow ()->StartTransmission (fragment, &hdr, m_currentParams, m_transmissionListener);
}

void

        }
      return;
    }
  m_currentParams.DisableOverrideDurationId ();
  m_currentParams.DisableNextData ();
  params.DisableNextData ();
  if (m_currentHdr.IsQosData () && m_currentHdr.IsQosBlockAck ())
    {
      m_currentParams.DisableAck ();
    }
  else
    {
      m_currentParams.EnableAck ();
    }
  if (txopLimit >= GetLow ()->CalculateOverallTxTime (peekedPacket, &hdr, m_currentParams))
    {
      NS_LOG_DEBUG ("start next packet");
      m_currentPacket = m_queue->DequeueByTidAndAddress (&hdr,

      m_currentHdr.SetNoRetry ();
      m_fragmentNumber = 0;
      VerifyBlockAck ();
      GetLow ()->StartTransmission (m_currentPacket, &m_currentHdr, m_currentParams, m_transmissionListener);
      if (!GetAmpduExist (m_currentHdr.GetAddr1 ()))
        {
          CompleteTx ();

  NS_LOG_FUNCTION (this);
  WifiMacHeader hdr;
  Time tstamp;
  if (!m_currentHdr.IsQosData () || GetTxopLimit () == NanoSeconds (0))
    {
      return false;
    }

      return false;
    }

  MacLowTransmissionParameters params = m_currentParams;
  params.DisableOverrideDurationId ();
  if (m_currentHdr.IsQosData () && m_currentHdr.IsQosBlockAck ())
    {
      params.DisableAck ();

      //HT-delayed Block Ack agreement or when it is carried in an A-MPDU.
      return false;
    }
  bool needTxopFragmentation = false;
  if (GetTxopLimit () > NanoSeconds (0) && m_currentHdr.IsData ())
    {
      needTxopFragmentation = (GetLow ()->CalculateOverallTxTime (m_currentPacket, &m_currentHdr, m_currentParams) > GetTxopLimit ());
    }
  return (needTxopFragmentation || m_stationManager->NeedFragmentation (m_currentHdr.GetAddr1 (), &m_currentHdr, m_currentPacket));
}

bool
EdcaTxopN::IsTxopFragmentation () const
{
  NS_LOG_FUNCTION (this);
  if (GetTxopLimit () == NanoSeconds (0))
    {
      return false;
    }
  if (!m_stationManager->NeedFragmentation (m_currentHdr.GetAddr1 (), &m_currentHdr, m_currentPacket)
      || (GetTxopFragmentSize () < m_stationManager->GetFragmentSize (m_currentHdr.GetAddr1 (), &m_currentHdr,m_currentPacket, 0)))
    {
      return true;
    }
  return false;
}

uint32_t
EdcaTxopN::GetTxopFragmentSize () const
{
  NS_LOG_FUNCTION (this);
  Time txopDuration = GetTxopLimit ();
  if (txopDuration == NanoSeconds (0))
    {
      return 0;
    }
  uint32_t maxSize = m_currentPacket->GetSize ();
  uint32_t minSize = 0;
  uint32_t size;
  bool found = false;
  while (!found)
    {
      size = (minSize + ((maxSize - minSize) / 2));
      if (GetLow ()->CalculateOverallTxFragmentTime (m_currentPacket, &m_currentHdr, m_currentParams, size) > txopDuration)
        {
          maxSize = size;
        }
      else
        {
          minSize = size;
        }
      if (GetLow ()->CalculateOverallTxFragmentTime (m_currentPacket, &m_currentHdr, m_currentParams, size) <= txopDuration
          && GetLow ()->CalculateOverallTxFragmentTime (m_currentPacket, &m_currentHdr, m_currentParams, size + 1) > txopDuration)
        {
          found = true;
        }
    }
  NS_ASSERT (size != 0);
  return size;
}

uint32_t
EdcaTxopN::GetNTxopFragment () const
{
  NS_LOG_FUNCTION (this);
  uint32_t fragmentSize = GetTxopFragmentSize ();
  uint32_t nFragments = (m_currentPacket->GetSize () / fragmentSize);
  if ((m_currentPacket->GetSize () % fragmentSize) > 0)
    {
      nFragments++;
    }
  NS_LOG_DEBUG ("GetNTxopFragment returning " << nFragments);
  return nFragments;
}

uint32_t
EdcaTxopN::GetTxopFragmentOffset (uint32_t fragmentNumber) const
{
  NS_LOG_FUNCTION (this << fragmentNumber);
  if (fragmentNumber == 0)
    {
      return 0;
    }
  uint32_t offset;
  uint32_t fragmentSize = GetTxopFragmentSize ();
  uint32_t nFragments = (m_currentPacket->GetSize () / fragmentSize);
 if ((m_currentPacket->GetSize () % fragmentSize) > 0)
    {
      nFragments++;
    }
  if (fragmentNumber < nFragments)
    {
      offset = (fragmentNumber * fragmentSize);
    }
  else
    {
      NS_ASSERT (false);
    }
  NS_LOG_DEBUG ("GetTxopFragmentOffset returning " << offset);
  return offset;
}

uint32_t
EdcaTxopN::GetNextTxopFragmentSize (uint32_t fragmentNumber) const
{
  NS_LOG_FUNCTION (this << fragmentNumber);
  uint32_t fragmentSize = GetTxopFragmentSize ();
  uint32_t nFragments = GetNTxopFragment ();
  if (fragmentNumber >= nFragments)
    {
      NS_LOG_DEBUG ("GetNextTxopFragmentSize returning 0");
      return 0;
    }
  if (fragmentNumber == nFragments - 1)
    {
      fragmentSize = (m_currentPacket->GetSize () - ((nFragments - 1) * fragmentSize));
    }
  NS_LOG_DEBUG ("GetNextTxopFragmentSize returning " << fragmentSize);
  return fragmentSize;
}

uint32_t
EdcaTxopN::GetFragmentSize (void) const
{
  NS_LOG_FUNCTION (this);
  uint32_t size;
  if (IsTxopFragmentation ())
    {
      size = GetNextTxopFragmentSize (m_fragmentNumber);
    }
  else
    {
      size = m_stationManager->GetFragmentSize (m_currentHdr.GetAddr1 (), &m_currentHdr,m_currentPacket, m_fragmentNumber);
    }
  return size;
}

uint32_t
EdcaTxopN::GetNextFragmentSize (void) const
{
  NS_LOG_FUNCTION (this);
  uint32_t size;
  if (IsTxopFragmentation ())
    {
      size = GetNextTxopFragmentSize (m_fragmentNumber + 1);
    }
  else
    {
      size = m_stationManager->GetFragmentSize (m_currentHdr.GetAddr1 (), &m_currentHdr,m_currentPacket, m_fragmentNumber + 1);
    }
  return size;
}

uint32_t
EdcaTxopN::GetFragmentOffset (void) const
{
  NS_LOG_FUNCTION (this);
  uint32_t offset;
  if (IsTxopFragmentation ())
    {
      offset = GetTxopFragmentOffset (m_fragmentNumber);
    }
  else
    {
      offset = m_stationManager->GetFragmentOffset (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                                    m_currentPacket, m_fragmentNumber);
    }
  return offset;
}


bool
EdcaTxopN::IsLastFragment (void) const
{
  NS_LOG_FUNCTION (this);
  bool isLastFragment;
  if (IsTxopFragmentation ())
    {
      isLastFragment = (m_fragmentNumber == GetNTxopFragment () - 1);
    }
  else
    {
      isLastFragment = m_stationManager->IsLastFragment (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                                         m_currentPacket, m_fragmentNumber);
    }
  return isLastFragment;
}

Ptr<Packet>




#include "ns3/traced-value.h"
#include "dcf.h"
#include "block-ack-manager.h"
#include "mac-low.h"

class AmpduAggregationTest;


   */
  bool NeedFragmentation (void) const;
  /**
   * Check if the current packet is fragmented because of an exceeded TXOP duration.
   *
   * \return true if the current packet is fragmented because of an exceeded TXOP duration,
   *         false otherwise
   */
  bool IsTxopFragmentation () const;
  /**
   * Calculate the size of the current TXOP fragment.
   *
   * \return the size of the current TXOP fragment
   */
  uint32_t GetTxopFragmentSize () const;
  /**
   * Calculate the number of TXOP fragments needed for the transmission of the current packet.
   *
   * \return the number of TXOP fragments needed for the transmission of the current packet
   */
  uint32_t GetNTxopFragment () const;
  /**
   * Calculate the size of the next TXOP fragment.
   *
   * \param fragmentNumber number of the next fragment
   */
  uint32_t GetNextTxopFragmentSize (uint32_t fragmentNumber) const;
  /**
   * Calculate the offset for the fragment.
   *
   * \param fragmentNumber number of the fragment
   */
  uint32_t GetTxopFragmentOffset (uint32_t fragmentNumber) const;
  /**
   * Calculate the size of the next fragment.
   *
   * \return the size of the next fragment

  Ptr<const Packet> m_currentPacket;

  WifiMacHeader m_currentHdr;
  MacLowTransmissionParameters m_currentParams;
  Ptr<MsduAggregator> m_msduAggregator;
  Ptr<MpduAggregator> m_mpduAggregator;
  TypeOfStation m_typeOfStation;

  Bar m_currentBar;
  Time m_startTxop;
  bool m_isAccessRequestedForRts;
  bool m_currentIsFragmented;
  TracedValue<uint32_t> m_backoffTrace;
  TracedValue<uint32_t> m_cwTrace;
  TracedCallback<Time, Time> m_txopTrace;

(-)a/src/wifi/model/mac-low.cc (-5 / +35 lines)

Lines 985-994	Link Here

985

      NS_LOG_DEBUG ("receive ack from=" << m_currentHdr.GetAddr1 ());

985

      NS_LOG_DEBUG ("receive ack from=" << m_currentHdr.GetAddr1 ());

986

      SnrTag tag;

986

      SnrTag tag;

987

      packet->RemovePacketTag (tag);

987

      packet->RemovePacketTag (tag);

988

      m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,

988

      //When fragmentation is used, only update manager when the last fragment is acknowledged

989

                                    rxSnr, txVector.GetMode ());

989

      if (!m_txParams.HasNextPacket ())

990

      m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr,

990

991

                                      rxSnr, txVector.GetMode (), tag.Get ());

991

          m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,

992

                                        rxSnr, txVector.GetMode ());

993

          m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr,

994

                                          rxSnr, txVector.GetMode (), tag.Get ());

995

992

      bool gotAck = false;

996

      bool gotAck = false;

993

      if (m_txParams.MustWaitNormalAck ()

997

      if (m_txParams.MustWaitNormalAck ()

994

          && m_normalAckTimeoutEvent.IsRunning ())

998

          && m_normalAckTimeoutEvent.IsRunning ())

Lines 1008-1014	Link Here

1008

1012

1009

          m_listener->GotAck (rxSnr, txVector.GetMode ());

1013

          m_listener->GotAck (rxSnr, txVector.GetMode ());

1010

1014

1011

      if (m_txParams.HasNextPacket ())

1015

      if (m_txParams.HasNextPacket () && (!m_currentHdr.IsQosData () || m_listener->GetTxopLimit () == NanoSeconds (0) || m_listener->HasTxop ()))

1012

1016

1013

          m_waitSifsEvent = Simulator::Schedule (GetSifs (),

1017

          m_waitSifsEvent = Simulator::Schedule (GetSifs (),

1014

                                                 &MacLow::WaitSifsAfterEndTxFragment, this);

1018

                                                 &MacLow::WaitSifsAfterEndTxFragment, this);

Lines 1398-1403	Link Here

1398

1402

1399

1403

1400

Time

1404

Time

1405

MacLow::CalculateOverallTxFragmentTime (Ptr<const Packet> packet,

1406

                                        const WifiMacHeader* hdr,

1407

                                        const MacLowTransmissionParameters& params,

1408

                                        uint32_t fragmentSize) const

1409

1410

  Time txTime = Seconds (0);

1411

  if (params.MustSendRts ())

1412

1413

      WifiTxVector rtsTxVector = GetRtsTxVector (packet, hdr);

1414

      txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, m_phy->GetFrequency ());

1415

      txTime += GetCtsDuration (hdr->GetAddr1 (), rtsTxVector);

1416

      txTime += Time (GetSifs () * 2);

1417

1418

  WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);

1419

  Ptr<const Packet> fragment = Create<Packet> (fragmentSize);

1420

  uint32_t dataSize = GetSize (fragment, hdr);

1421

  txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, m_phy->GetFrequency ());

1422

  txTime += GetSifs ();

1423

  if (params.MustWaitAck ())

1424

1425

      txTime += GetAckDuration (hdr->GetAddr1 (), dataTxVector);

1426

1427

  return txTime;

1428

1429

1430

Time

1401

MacLow::CalculateTransmissionTime (Ptr<const Packet> packet,

1431

MacLow::CalculateTransmissionTime (Ptr<const Packet> packet,

1402

                                   const WifiMacHeader* hdr,

1432

                                   const WifiMacHeader* hdr,

1403

                                   const MacLowTransmissionParameters& params) const

1433

                                   const MacLowTransmissionParameters& params) const

(-)a/src/wifi/model/mac-low.h (+9 lines)

Lines 133-138	Link Here

133

   * Returns whether it has TXOP granted for the next MPDU

133

   * Returns whether it has TXOP granted for the next MPDU

134

*/

134

*/

135

  virtual bool HasTxop (void) = 0;

135

  virtual bool HasTxop (void) = 0;

136

/**

137

   * Returns the TXOP limit duration

138

*/

139

  virtual Time GetTxopLimit (void) = 0;

136

};

140

};

137

141

138

142

Lines 697-702	Link Here

697

  Time CalculateOverallTxTime (Ptr<const Packet> packet,

701

  Time CalculateOverallTxTime (Ptr<const Packet> packet,

698

                               const WifiMacHeader* hdr,

702

                               const WifiMacHeader* hdr,

699

                               const MacLowTransmissionParameters &params) const;

703

                               const MacLowTransmissionParameters &params) const;

704

705

  Time CalculateOverallTxFragmentTime (Ptr<const Packet> packet,

706

                                       const WifiMacHeader* hdr,

707

                                       const MacLowTransmissionParameters& params,

708

                                       uint32_t fragmentSize) const;

700

709

701

/**

710

/**

702

   * \param packet packet to send

711

   * \param packet packet to send

Return to bug 2615