Attachment #3208 for bug #3010

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

(-)a/RELEASE_NOTES (+1 lines)

Lines 80-85 New user-visible features	Link Here

  This trace is fired whenever a new path loss value is calculated. It exports pointers

  This trace is fired whenever a new path loss value is calculated. It exports pointers

  to the mobility model of the transmitter and the receiver, Tx antenna gain, Rx antenna gain,

  to the mobility model of the transmitter and the receiver, Tx antenna gain, Rx antenna gain,

  propagation gain and the pathloss value.

  propagation gain and the pathloss value.

- (wifi) It is now possible to transmit A-MPDUs containing up to 256 MPDUs (802.11ax only)

Bugs fixed

Bugs fixed

----------

----------

(-)a/src/network/utils/queue.cc (-1 / +1 lines)

Lines 37-43 QueueBase::GetTypeId (void)	Link Here

    .SetGroupName ("Network")

    .SetGroupName ("Network")

    .AddAttribute ("MaxSize",

    .AddAttribute ("MaxSize",

                   "The max queue size",

                   "The max queue size",

                   QueueSizeValue (QueueSize ("100p")),

                   QueueSizeValue (QueueSize ("300p")),

                   MakeQueueSizeAccessor (&QueueBase::SetMaxSize,

                   MakeQueueSizeAccessor (&QueueBase::SetMaxSize,

                                          &QueueBase::GetMaxSize),

                                          &QueueBase::GetMaxSize),

                   MakeQueueSizeChecker ())

                   MakeQueueSizeChecker ())

(-)a/src/wifi/doc/source/wifi-user.rst (+7 lines)

Lines 790-795 attributes for 802.11ax devices.	Link Here

790

 Ptr<HeConfiguration> heConfiguration = wnd->GetHeConfiguration ();

790

 Ptr<HeConfiguration> heConfiguration = wnd->GetHeConfiguration ();

791

 heConfiguration->SetGuardInterval (NanoSeconds (1600));

791

 heConfiguration->SetGuardInterval (NanoSeconds (1600));

792

793

 802.11ax allows extended compressed Block ACKs containing a 256-bits bitmap, making possible transmissions of A-MPDUs containing up to 256 MPDUs,

794

 depending on the negotiated buffer size. In order to configure the buffer size of an 802.11ax device, the following line of code could be used::

795

796

 heConfiguration->SetMpduBufferSize (256);

797

798

 For transmitting large MPDUs, it might also be needed to increase the maximum aggregation size (see above).

799

793

Mobility configuration

800

Mobility configuration

794

======================

801

======================

795

802

(-)a/src/wifi/model/ampdu-tag.cc (-1 lines)

Lines 51-57 AmpduTag::AmpduTag ()	Link Here

void

void

AmpduTag::SetRemainingNbOfMpdus (uint8_t nbofmpdus)

AmpduTag::SetRemainingNbOfMpdus (uint8_t nbofmpdus)

  NS_ASSERT (nbofmpdus <= 64);

  m_nbOfMpdus = nbofmpdus;

  m_nbOfMpdus = nbofmpdus;




NS_LOG_COMPONENT_DEFINE ("BlockAckAgreement");

BlockAckAgreement::BlockAckAgreement (Mac48Address peer, uint8_t tid)
  : m_peer (peer),
    m_amsduSupported (0),
    m_blockAckPolicy (1),
    m_tid (tid),
    m_htSupported (0),
    m_inactivityEvent ()
{
  NS_LOG_FUNCTION (this << peer << +tid);
  m_tid = tid;
  m_peer = peer;
}

BlockAckAgreement::~BlockAckAgreement ()

BlockAckAgreement::SetBufferSize (uint16_t bufferSize)
{
  NS_LOG_FUNCTION (this << bufferSize);
  NS_ASSERT (bufferSize <= 256);
  NS_ASSERT (bufferSize % 16 == 0);
  m_bufferSize = bufferSize;
}

uint8_t
BlockAckAgreement::GetTid (void) const
{
  NS_LOG_FUNCTION (this);
  return m_tid;
}


uint16_t
BlockAckAgreement::GetBufferSize (void) const
{
  NS_LOG_FUNCTION (this);
  return m_bufferSize;
}

uint16_t
BlockAckAgreement::GetTimeout (void) const
{
  NS_LOG_FUNCTION (this);
  return m_timeout;
}

uint16_t
BlockAckAgreement::GetStartingSequence (void) const
{
  NS_LOG_FUNCTION (this);
  return m_startingSeq;
}

uint16_t
BlockAckAgreement::GetStartingSequenceControl (void) const
{
  NS_LOG_FUNCTION (this);
  uint16_t seqControl = (m_startingSeq << 4) & 0xfff0;
  return seqControl;
}

bool
BlockAckAgreement::IsImmediateBlockAck (void) const
{
  NS_LOG_FUNCTION (this);
  return (m_blockAckPolicy == 1);
}

bool
BlockAckAgreement::IsAmsduSupported (void) const
{
  NS_LOG_FUNCTION (this);
  return (m_amsduSupported == 1) ? true : false;
}


bool
BlockAckAgreement::IsHtSupported (void) const
{
  NS_LOG_FUNCTION (this);
  return (m_htSupported == 1) ? true : false;
}


(-)a/src/wifi/model/block-ack-cache.cc (-2 / +2 lines)

Lines 36-42 BlockAckCache::Init (uint16_t winStart, uint16_t winSize)	Link Here

  NS_LOG_FUNCTION (this << winStart << winSize);

  NS_LOG_FUNCTION (this << winStart << winSize);

  m_winStart = winStart;

  m_winStart = winStart;

  m_winSize = winSize <= 64 ? winSize : 64;

  m_winSize = winSize;

  m_winEnd = (m_winStart + m_winSize - 1) % 4096;

  m_winEnd = (m_winStart + m_winSize - 1) % 4096;

  memset (m_bitmap, 0, sizeof (m_bitmap));

  memset (m_bitmap, 0, sizeof (m_bitmap));

Lines 119-125 BlockAckCache::FillBlockAckBitmap (CtrlBAckResponseHeader *blockAckHeader)	Link Here

119

120

      NS_FATAL_ERROR ("Basic block ack is only partially implemented.");

120

      NS_FATAL_ERROR ("Basic block ack is only partially implemented.");

121

122

  else if (blockAckHeader->IsCompressed ())

122

  else if (blockAckHeader->IsCompressed () || blockAckHeader->IsExtendedCompressed ())

123

124

      uint16_t i = blockAckHeader->GetStartingSequence ();

124

      uint16_t i = blockAckHeader->GetStartingSequence ();

125

      uint16_t end = (i + m_winSize - 1) % 4096;

125

      uint16_t end = (i + m_winSize - 1) % 4096;




  agreement.SetStartingSequence (reqHdr->GetStartingSequence ());
  /* For now we assume that originator doesn't use this field. Use of this field
     is mandatory only for recipient */
  agreement.SetBufferSize (reqHdr->GetBufferSize());
  agreement.SetWinEnd ((agreement.GetStartingSequence () + agreement.GetBufferSize () - 1) % 4096);
  agreement.SetTimeout (reqHdr->GetTimeout ());
  agreement.SetAmsduSupport (reqHdr->IsAmsduSupported ());

                    }
                }
            }
          else if (blockAck->IsCompressed () || blockAck->IsExtendedCompressed ())
            {
              for (PacketQueueI queueIt = it->second.second.begin (); queueIt != queueEnd; )
                {

      agreement.CompleteExchange ();

      CtrlBAckRequestHeader reqHdr;
      reqHdr.SetType (m_blockAckType);
      reqHdr.SetTidInfo (agreement.GetTid ());
      reqHdr.SetStartingSequence (agreement.GetStartingSequence ());

          reqHdr.SetStartingSequence (agreement.GetStartingSequence ());
        }
      else if (m_blockAckType == MULTI_TID_BLOCK_ACK)
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        }
      else
        {
          NS_FATAL_ERROR ("Invalid block ack type.");
        }
      Ptr<Packet> bar = Create<Packet> ();
      bar->AddHeader (reqHdr);
      return bar;

    }
}

uint16_t
BlockAckManager::GetRecipientBufferSize (Mac48Address recipient, uint8_t tid) const
{
  uint16_t size = 0;
  AgreementsCI it = m_agreements.find (std::make_pair (recipient, tid));
  if (it != m_agreements.end ())
    {
      size = it->second.first.GetBufferSize ();
    }
  return size;
}

} //namespace ns3

(-)a/src/wifi/model/block-ack-manager.h (+9 lines)

Lines 361-366 public:	Link Here

361

   * \returns true if BAR retransmission needed

361

   * \returns true if BAR retransmission needed

362

*/

362

*/

363

  bool NeedBarRetransmission (uint8_t tid, uint16_t seqNumber, Mac48Address recipient);

363

  bool NeedBarRetransmission (uint8_t tid, uint16_t seqNumber, Mac48Address recipient);

364

/**

365

   * This function returns the buffer size negociated with the recipient.

366

367

   * \param tid Traffic ID

368

   * \param recipient MAC address

369

370

   * \returns the buffer size negociated with the recipient

371

*/

372

  uint16_t GetRecipientBufferSize (Mac48Address recipient, uint8_t tid) const;

364

373

365

/**

374

/**

366

   * typedef for a callback to invoke when a

375

   * typedef for a callback to invoke when a

(-)a/src/wifi/model/block-ack-type.h (-1 / +2 lines)

Lines 31-37 enum BlockAckType	Link Here

  BASIC_BLOCK_ACK,

  BASIC_BLOCK_ACK,

  COMPRESSED_BLOCK_ACK,

  COMPRESSED_BLOCK_ACK,

  MULTI_TID_BLOCK_ACK

  EXTENDED_COMPRESSED_BLOCK_ACK,

  MULTI_TID_BLOCK_ACK,

};

};

} //namespace ns3

} //namespace ns3





CtrlBAckRequestHeader::CtrlBAckRequestHeader ()
  : m_barAckPolicy (false),
    m_baType (BASIC_BLOCK_ACK)
    m_compressed (false)
{
}


{
  uint32_t size = 0;
  size += 2; //Bar control
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        size += 2;
        break;
      case MULTI_TID_BLOCK_ACK:
        size += (2 + 2) * (m_tidInfo + 1);
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return size;
}

{
  Buffer::Iterator i = start;
  i.WriteHtolsbU16 (GetBarControl ());
  switch (m_baType)
    {
      i.WriteHtolsbU16 (GetStartingSequenceControl ());
    }
  else if (m_compressed)
    {
      NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
    }
  else
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        i.WriteHtolsbU16 (GetStartingSequenceControl ());
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
}


{
  Buffer::Iterator i = start;
  SetBarControl (i.ReadLsbtohU16 ());
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        SetStartingSequenceControl (i.ReadLsbtohU16 ());
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i.GetDistanceFrom (start);
}

CtrlBAckRequestHeader::GetBarControl (void) const
{
  uint16_t res = 0;
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        break;
      case COMPRESSED_BLOCK_ACK:
        res |= (0x02 << 1);
        break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        res |= (0x01 << 1);
        break;
      case MULTI_TID_BLOCK_ACK:
        res |= (0x03 << 1);
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  res |= (m_tidInfo << 12) & (0xf << 12);
  return res;

CtrlBAckRequestHeader::SetBarControl (uint16_t bar)
{
  m_barAckPolicy = ((bar & 0x01) == 1) ? true : false;
  if (((bar >> 1) & 0x0f) == 0x03)
    {
      m_baType = MULTI_TID_BLOCK_ACK;
    }
  else if (((bar >> 1) & 0x0f) == 0x01)
    {
      m_baType = EXTENDED_COMPRESSED_BLOCK_ACK;
    }
  else if (((bar >> 1) & 0x0f) == 0x02)
    {
      m_baType = COMPRESSED_BLOCK_ACK;
    }
  else
    {
      m_baType = BASIC_BLOCK_ACK;
    }
  m_tidInfo = (bar >> 12) & 0x0f;
}


void
CtrlBAckRequestHeader::SetType (BlockAckType type)
{
  m_baType = type;
}

BlockAckType
CtrlBAckRequestHeader::GetType (void) const
{
  return m_baType;
      m_multiTid = false;
      m_compressed = true;
      break;
    case MULTI_TID_BLOCK_ACK:
      m_multiTid = true;
      m_compressed = true;
      break;
    default:
      NS_FATAL_ERROR ("Invalid variant type");
      break;
    }
}

void

bool
CtrlBAckRequestHeader::IsBasic (void) const
{
  return (m_baType == BASIC_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckRequestHeader::IsCompressed (void) const
{
  return (m_baType == COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckRequestHeader::IsExtendedCompressed (void) const
{
  return (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckRequestHeader::IsMultiTid (void) const
{
  return (m_baType == MULTI_TID_BLOCK_ACK) ? true : false;
}




CtrlBAckResponseHeader::CtrlBAckResponseHeader ()
  : m_baAckPolicy (false),
    m_baType (BASIC_BLOCK_ACK)
    m_compressed (false)
{
  memset (&bitmap, 0, sizeof (bitmap));
}

{
  uint32_t size = 0;
  size += 2; //Bar control
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        size += (2 + 128);
        break;
      case COMPRESSED_BLOCK_ACK:
        size += (2 + 8);
        break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        size += (2 + 32);
        break;
      case MULTI_TID_BLOCK_ACK:
        size += (2 + 2 + 8) * (m_tidInfo + 1); //Multi-tid block ack
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
      else
        {
          NS_FATAL_ERROR ("Reserved configuration.");
        }
    }
  return size;
}

{
  Buffer::Iterator i = start;
  i.WriteHtolsbU16 (GetBaControl ());
  switch (m_baType)
    {
      i.WriteHtolsbU16 (GetStartingSequenceControl ());
      i = SerializeBitmap (i);
    }
  else if (m_compressed)
    {
      NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
    }
  else
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        i.WriteHtolsbU16 (GetStartingSequenceControl ());
        i = SerializeBitmap (i);
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
}


{
  Buffer::Iterator i = start;
  SetBaControl (i.ReadLsbtohU16 ());
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        SetStartingSequenceControl (i.ReadLsbtohU16 ());
        i = DeserializeBitmap (i);
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i.GetDistanceFrom (start);
}

void
CtrlBAckResponseHeader::SetType (BlockAckType type)
{
  m_baType = type;
}

BlockAckType
CtrlBAckResponseHeader::GetType (void) const
{
  return m_baType;
      m_multiTid = false;
      m_compressed = true;
      break;
    case MULTI_TID_BLOCK_ACK:
      m_multiTid = true;
      m_compressed = true;
      break;
    default:
      NS_FATAL_ERROR ("Invalid variant type");
      break;
    }
}

void

bool
CtrlBAckResponseHeader::IsBasic (void) const
{
  return (m_baType == BASIC_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckResponseHeader::IsCompressed (void) const
{
  return (m_baType == COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckResponseHeader::IsExtendedCompressed (void) const
{
  return (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK) ? true : false;
}

bool
CtrlBAckResponseHeader::IsMultiTid (void) const
{
  return (m_baType == MULTI_TID_BLOCK_ACK) ? true : false;
}

uint16_t

    {
      res |= 0x1;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        break;
      case COMPRESSED_BLOCK_ACK:
        res |= (0x02 << 1);
        break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        res |= (0x01 << 1);
        break;
      case MULTI_TID_BLOCK_ACK:
        res |= (0x03 << 1);
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  res |= (m_tidInfo << 12) & (0xf << 12);
  return res;

CtrlBAckResponseHeader::SetBaControl (uint16_t ba)
{
  m_baAckPolicy = ((ba & 0x01) == 1) ? true : false;
  if (((ba >> 1) & 0x0f) == 0x03)
    {
      m_baType = MULTI_TID_BLOCK_ACK;
    }
  else if (((ba >> 1) & 0x0f) == 0x01)
    {
      m_baType = EXTENDED_COMPRESSED_BLOCK_ACK;
    }
  else if (((ba >> 1) & 0x0f) == 0x02)
    {
      m_baType = COMPRESSED_BLOCK_ACK;
    }
  else
    {
      m_baType = BASIC_BLOCK_ACK;
    }
  m_tidInfo = (ba >> 12) & 0x0f;
}


CtrlBAckResponseHeader::SerializeBitmap (Buffer::Iterator start) const
{
  Buffer::Iterator i = start;
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          for (uint8_t j = 0; j < 64; j++)
            {
              i.WriteHtolsbU16 (bitmap.m_bitmap[j]);
            }
          break;
      case COMPRESSED_BLOCK_ACK:
        {
          i.WriteHtolsbU64 (bitmap.m_compressedBitmap);
          break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[0]);
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[1]);
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[2]);
          i.WriteHtolsbU64 (bitmap.m_extendedCompressedBitmap[3]);
          break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i;
}

CtrlBAckResponseHeader::DeserializeBitmap (Buffer::Iterator start)
{
  Buffer::Iterator i = start;
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          for (uint8_t j = 0; j < 64; j++)
            {
              bitmap.m_bitmap[j] = i.ReadLsbtohU16 ();
            }
          break;
      case COMPRESSED_BLOCK_ACK:
        {
          bitmap.m_compressedBitmap = i.ReadLsbtohU64 ();
          break;
      case EXTENDED_COMPRESSED_BLOCK_ACK:
          bitmap.m_extendedCompressedBitmap[0] = i.ReadLsbtohU64 ();
          bitmap.m_extendedCompressedBitmap[1] = i.ReadLsbtohU64 ();
          bitmap.m_extendedCompressedBitmap[2] = i.ReadLsbtohU64 ();
          bitmap.m_extendedCompressedBitmap[3] = i.ReadLsbtohU64 ();
          break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
    }
  return i;
}

    {
      return;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          /* To set correctly basic block ack bitmap we need fragment number too.
             So if it's not specified, we consider packet not fragmented. */
          bitmap.m_bitmap[IndexInBitmap (seq)] |= 0x0001;
          break;
        }
      case COMPRESSED_BLOCK_ACK:
        {
          bitmap.m_compressedBitmap |= (uint64_t (0x0000000000000001) << IndexInBitmap (seq));
          break;
        }
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        {
          uint16_t index = IndexInBitmap (seq);
          bitmap.m_extendedCompressedBitmap[index/64] |= (uint64_t (0x0000000000000001) << index);
          break;
        }
      case MULTI_TID_BLOCK_ACK:
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
          break;
        }
      default:
        {
          NS_FATAL_ERROR ("Invalid BA type");
          break;
        }
    }
}

    {
      return;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        bitmap.m_bitmap[IndexInBitmap (seq)] |= (0x0001 << frag);
        break;
      case COMPRESSED_BLOCK_ACK:
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        /* We can ignore this...compressed block ack doesn't support
           acknowledgement of single fragments */
        break;
      case MULTI_TID_BLOCK_ACK:
        NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        break;
      default:
        NS_FATAL_ERROR ("Invalid BA type");
        break;
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
        }
      else
        {
          NS_FATAL_ERROR ("Reserved configuration.");
        }
    }
}


    {
      return false;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          /*It's impossible to say if an entire packet was correctly received. */
          return false;
        }
      case COMPRESSED_BLOCK_ACK:
        {
          /* Although this could make no sense, if packet with sequence number
             equal to <i>seq</i> was correctly received, also all of its fragments
             were correctly received. */
          uint64_t mask = uint64_t (0x0000000000000001);
          return (((bitmap.m_compressedBitmap >> IndexInBitmap (seq)) & mask) == 1) ? true : false;
        }
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        {
          uint64_t mask = uint64_t (0x0000000000000001);
          uint16_t index = IndexInBitmap (seq);
          return (((bitmap.m_extendedCompressedBitmap[index/64] >> index) & mask) == 1) ? true : false;
        }
      case MULTI_TID_BLOCK_ACK:
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
          break;
        }
      default:
        {
          NS_FATAL_ERROR ("Invalid BA type");
          break;
        }
    }
  return false;

    {
      return false;
    }
  switch (m_baType)
    {
      case BASIC_BLOCK_ACK:
        {
          return ((bitmap.m_bitmap[IndexInBitmap (seq)] & (0x0001 << frag)) != 0x0000) ? true : false;
        }
      case COMPRESSED_BLOCK_ACK:
        {
          /* Although this could make no sense, if packet with sequence number
             equal to <i>seq</i> was correctly received, also all of its fragments

          uint64_t mask = uint64_t (0x0000000000000001);
          return (((bitmap.m_compressedBitmap >> IndexInBitmap (seq)) & mask) == 1) ? true : false;
        }
      case EXTENDED_COMPRESSED_BLOCK_ACK:
        {
          uint64_t mask = uint64_t (0x0000000000000001);
          uint16_t index = IndexInBitmap (seq);
          return (((bitmap.m_extendedCompressedBitmap[index/64] >> index) & mask) == 1) ? true : false;
        }
      case MULTI_TID_BLOCK_ACK:
        {
          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");
          break;
        }
      default:
        {
          NS_FATAL_ERROR ("Invalid BA type");
          break;
        }
    }
  return false;

    {
      index = 4096 - m_startingSeq + seq;
    }
  if (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK)
    {
      NS_ASSERT (index <= 255);
    }
  else
    {
      NS_ASSERT (index <= 63);
    }
  return index;
}

bool
CtrlBAckResponseHeader::IsInBitmap (uint16_t seq) const
{
  if (m_baType == EXTENDED_COMPRESSED_BLOCK_ACK)
    {
      return (seq - m_startingSeq + 4096) % 4096 < 256;
    }
  else
    {
      return (seq - m_startingSeq + 4096) % 4096 < 64;
    }
}

const uint16_t*

  return bitmap.m_compressedBitmap;
}

const uint64_t*
CtrlBAckResponseHeader::GetExtendedCompressedBitmap (void) const
{
  return bitmap.m_extendedCompressedBitmap;
}

void
CtrlBAckResponseHeader::ResetBitmap (void)
{

(-)a/src/wifi/model/ctrl-headers.h (-16 / +46 lines)

Lines 88-93 public:	Link Here

*/

*/

  bool MustSendHtImmediateAck (void) const;

  bool MustSendHtImmediateAck (void) const;

/**

/**

   * Return the block ACK type ID.

   * \return type

*/

  BlockAckType GetType (void) const;

/**

   * Return the Traffic ID (TID).

   * Return the Traffic ID (TID).

   * \return TID

   * \return TID

Lines 116-121 public:	Link Here

116

*/

122

*/

117

  bool IsCompressed (void) const;

123

  bool IsCompressed (void) const;

118

/**

124

/**

125

   * Check if the current BA policy is extended compressed block ACK.

126

127

   * \return true if the current BA policy is extended compressed block ACK,

128

   *         false otherwise

129

*/

130

  bool IsExtendedCompressed (void) const;

131

/**

119

   * Check if the current ACK policy has multiple TID.

132

   * Check if the current ACK policy has multiple TID.

120

133

121

   * \return true if the current ACK policy has multiple TID,

134

   * \return true if the current ACK policy has multiple TID,

Lines 158-167 private:	Link Here

158

   * For now only non HT immediate block ack is implemented so this field

171

   * For now only non HT immediate block ack is implemented so this field

159

   * is here only for a future implementation of HT delayed variant.

172

   * is here only for a future implementation of HT delayed variant.

160

*/

173

*/

161

  bool m_barAckPolicy; ///< bar ack policy

174

  bool m_barAckPolicy;    ///< bar ack policy

162

  bool m_multiTid; ///< multi TID

175

  BlockAckType m_baType;  ///< BA type

163

  bool m_compressed; ///< compressed

176

  uint16_t m_tidInfo;     ///< TID info

164

  uint16_t m_tidInfo; ///< TID info

165

  uint16_t m_startingSeq; ///< starting seq

177

  uint16_t m_startingSeq; ///< starting seq

166

};

178

};

167

179

Lines 228-233 public:	Link Here

228

*/

240

*/

229

  bool MustSendHtImmediateAck (void) const;

241

  bool MustSendHtImmediateAck (void) const;

230

/**

242

/**

243

   * Return the block ACK type ID.

244

245

   * \return type

246

*/

247

  BlockAckType GetType (void) const;

248

/**

231

   * Return the Traffic ID (TID).

249

   * Return the Traffic ID (TID).

232

250

233

   * \return TID

251

   * \return TID

Lines 240-264 public:	Link Here

240

*/

258

*/

241

  uint16_t GetStartingSequence (void) const;

259

  uint16_t GetStartingSequence (void) const;

242

/**

260

/**

243

   * Check if the current ACK policy is basic

261

   * Check if the current BA policy is basic block ACK.

244

   * (i.e. not multiple TID and not compressed ACK).

245

262

246

   * \return true if the current ACK policy is basic,

263

   * \return true if the current BA policy is basic block ACK,

247

   *         false otherwise

264

   *         false otherwise

248

*/

265

*/

249

  bool IsBasic (void) const;

266

  bool IsBasic (void) const;

250

/**

267

/**

251

   * Check if the current ACK policy is compressed ACK

268

   * Check if the current BA policy is compressed block ACK.

252

   * and not multiple TID.

253

269

254

   * \return true if the current ACK policy is compressed ACK,

270

   * \return true if the current BA policy is compressed block ACK,

255

   *         false otherwise

271

   *         false otherwise

256

*/

272

*/

257

  bool IsCompressed (void) const;

273

  bool IsCompressed (void) const;

258

/**

274

/**

259

   * Check if the current ACK policy has multiple TID.

275

   * Check if the current BA policy is extended compressed block ACK.

260

276

261

   * \return true if the current ACK policy has multiple TID,

277

   * \return true if the current BA policy is extended compressed block ACK,

278

   *         false otherwise

279

*/

280

  bool IsExtendedCompressed (void) const;

281

/**

282

   * Check if the current BA policy is multi-TID block ACK.

283

284

   * \return true if the current BA policy is multi-TID block ACK,

262

   *         false otherwise

285

   *         false otherwise

263

*/

286

*/

264

  bool IsMultiTid (void) const;

287

  bool IsMultiTid (void) const;

Lines 317-322 public:	Link Here

317

340

318

   * \return the bitmap from the block ACK response header

341

   * \return the bitmap from the block ACK response header

319

*/

342

*/

343

320

  const uint16_t* GetBitmap (void) const;

344

  const uint16_t* GetBitmap (void) const;

321

/**

345

/**

322

   * Return the compressed bitmap from the block ACK response header.

346

   * Return the compressed bitmap from the block ACK response header.

Lines 324-329 public:	Link Here

324

   * \return the compressed bitmap from the block ACK response header

348

   * \return the compressed bitmap from the block ACK response header

325

*/

349

*/

326

  uint64_t GetCompressedBitmap (void) const;

350

  uint64_t GetCompressedBitmap (void) const;

351

/**

352

   * Return the extended compressed bitmap from the block ACK response header.

353

354

   * \return the extended compressed bitmap from the block ACK response header

355

*/

356

  const uint64_t* GetExtendedCompressedBitmap (void) const;

327

357

328

/**

358

/**

329

   * Reset the bitmap to 0.

359

   * Reset the bitmap to 0.

Lines 391-406 private:	Link Here

391

   * For now only non HT immediate block ack is implemented so this field

421

   * For now only non HT immediate block ack is implemented so this field

392

   * is here only for a future implementation of HT delayed variant.

422

   * is here only for a future implementation of HT delayed variant.

393

*/

423

*/

394

  bool m_baAckPolicy; ///< BA ack policy

424

  bool m_baAckPolicy;     ///< BA ack policy

395

  bool m_multiTid; ///< multi TID

425

  BlockAckType m_baType;  ///< BA type

396

  bool m_compressed; ///< compressed

426

  uint16_t m_tidInfo;     ///< TID info

397

  uint16_t m_tidInfo; ///< TID info

398

  uint16_t m_startingSeq; ///< starting seq

427

  uint16_t m_startingSeq; ///< starting seq

399

428

400

  union

429

  union

401

430

402

    uint16_t m_bitmap[64]; ///< the block ack bitmap

431

    uint16_t m_bitmap[64]; ///< the block ack bitmap

403

    uint64_t m_compressedBitmap; ///< the compressed block ack bitmap

432

    uint64_t m_compressedBitmap; ///< the compressed block ack bitmap

433

    uint64_t m_extendedCompressedBitmap[4]; ///< the extended compressed block ack bitmap

404

  } bitmap; ///< bitmap union type

434

  } bitmap; ///< bitmap union type

405

};

435

};

406

436

(-)a/src/wifi/model/he-configuration.cc (-1 / +21 lines)

Lines 46-55 HeConfiguration::GetTypeId (void)	Link Here

                   MakeTimeAccessor (&HeConfiguration::GetGuardInterval,

                   MakeTimeAccessor (&HeConfiguration::GetGuardInterval,

                                     &HeConfiguration::SetGuardInterval),

                                     &HeConfiguration::SetGuardInterval),

                   MakeTimeChecker (NanoSeconds (800), NanoSeconds (3200)))

                   MakeTimeChecker (NanoSeconds (800), NanoSeconds (3200)))

    .AddAttribute ("BssColor", "BSS color",

    .AddAttribute ("BssColor",

                   "The BSS color",

                   UintegerValue (0),

                   UintegerValue (0),

                   MakeUintegerAccessor (&HeConfiguration::m_bssColor),

                   MakeUintegerAccessor (&HeConfiguration::m_bssColor),

                   MakeUintegerChecker<uint8_t> ())

                   MakeUintegerChecker<uint8_t> ())

    .AddAttribute ("MpduBufferSize",

                   "The MPDU buffer size for receiving A-MPDUs",

                   UintegerValue (64),

                   MakeUintegerAccessor (&HeConfiguration::GetMpduBufferSize,

                                         &HeConfiguration::SetMpduBufferSize),

                   MakeUintegerChecker<uint16_t> (64, 256))

    return tid;

    return tid;

Lines 68-71 HeConfiguration::GetGuardInterval (void) const	Link Here

  return m_guardInterval;

  return m_guardInterval;

void

HeConfiguration::SetMpduBufferSize (uint16_t size)

  NS_LOG_FUNCTION (this << size);

  m_mpduBufferSize = size;

uint16_t

HeConfiguration::GetMpduBufferSize (void) const

  return m_mpduBufferSize;

} //namespace ns3

} //namespace ns3




   * \return the supported HE guard interval
   */
  Time GetGuardInterval (void) const;
  /**
   * \param size the MPDU buffer size to receive A-MPDUs
   */
  void SetMpduBufferSize (uint16_t size);
  /**
   * \return the MPDU buffer size to receive A-MPDUs
   */
  uint16_t GetMpduBufferSize (void) const;


private:
  Time m_guardInterval;      //!< Supported HE guard interval
  uint8_t m_bssColor;        //!< BSS color
  uint16_t m_mpduBufferSize; //!< MPDU buffer size
};

} //namespace ns3

(-)a/src/wifi/model/mac-low-transmission-parameters.cc (+15 lines)

Lines 56-61 MacLowTransmissionParameters::EnableCompressedBlockAck (void)	Link Here

void

void

MacLowTransmissionParameters::EnableExtendedCompressedBlockAck (void)

  m_waitAck = EXTENDED_BLOCK_ACK_COMPRESSED;

void

MacLowTransmissionParameters::EnableMultiTidBlockAck (void)

MacLowTransmissionParameters::EnableMultiTidBlockAck (void)

  m_waitAck = BLOCK_ACK_MULTI_TID;

  m_waitAck = BLOCK_ACK_MULTI_TID;

Lines 104-109 MacLowTransmissionParameters::MustWaitCompressedBlockAck (void) const	Link Here

104

110

105

111

106

bool

112

bool

113

MacLowTransmissionParameters::MustWaitExtendedCompressedBlockAck (void) const

114

115

  return (m_waitAck == EXTENDED_BLOCK_ACK_COMPRESSED) ? true : false;

116

117

118

bool

107

MacLowTransmissionParameters::MustWaitMultiTidBlockAck (void) const

119

MacLowTransmissionParameters::MustWaitMultiTidBlockAck (void) const

108

120

109

  return (m_waitAck == BLOCK_ACK_MULTI_TID) ? true : false;

121

  return (m_waitAck == BLOCK_ACK_MULTI_TID) ? true : false;

Lines 148-153 std::ostream &operator << (std::ostream &os, const MacLowTransmissionParameters	Link Here

148

    case MacLowTransmissionParameters::BLOCK_ACK_COMPRESSED:

160

    case MacLowTransmissionParameters::BLOCK_ACK_COMPRESSED:

149

      os << "compressed-block-ack";

161

      os << "compressed-block-ack";

150

      break;

162

      break;

163

    case MacLowTransmissionParameters::EXTENDED_BLOCK_ACK_COMPRESSED:

164

      os << "extended-compressed-block-ack";

165

      break;

151

    case MacLowTransmissionParameters::BLOCK_ACK_MULTI_TID:

166

    case MacLowTransmissionParameters::BLOCK_ACK_MULTI_TID:

152

      os << "multi-tid-block-ack";

167

      os << "multi-tid-block-ack";

153

      break;

168

      break;

(-)a/src/wifi/model/mac-low-transmission-parameters.h (+11 lines)

Lines 55-60 public:	Link Here

*/

*/

  void EnableCompressedBlockAck (void);

  void EnableCompressedBlockAck (void);

/**

/**

   * Wait COMPRESSEDBLOCKACKTimeout for an Extended Compressed Block Ack Response frame.

*/

  void EnableExtendedCompressedBlockAck (void);

/**

   * NOT IMPLEMENTED FOR NOW

   * NOT IMPLEMENTED FOR NOW

*/

*/

  void EnableMultiTidBlockAck (void);

  void EnableMultiTidBlockAck (void);

Lines 108-113 public:	Link Here

108

*/

112

*/

109

  bool MustWaitCompressedBlockAck (void) const;

113

  bool MustWaitCompressedBlockAck (void) const;

110

/**

114

/**

115

   * \returns true if extended compressed block ack mechanism is used, false otherwise.

116

117

   * \sa EnableExtendedCompressedBlockAck

118

*/

119

  bool MustWaitExtendedCompressedBlockAck (void) const;

120

/**

111

   * \returns true if multi-tid block ack mechanism is used, false otherwise.

121

   * \returns true if multi-tid block ack mechanism is used, false otherwise.

112

122

113

   * \sa EnableMultiTidBlockAck

123

   * \sa EnableMultiTidBlockAck

Lines 137-142 private:	Link Here

137

    ACK_NORMAL,

147

    ACK_NORMAL,

138

    BLOCK_ACK_BASIC,

148

    BLOCK_ACK_BASIC,

139

    BLOCK_ACK_COMPRESSED,

149

    BLOCK_ACK_COMPRESSED,

150

    EXTENDED_BLOCK_ACK_COMPRESSED,

140

    BLOCK_ACK_MULTI_TID

151

    BLOCK_ACK_MULTI_TID

141

  } m_waitAck; //!< wait ack

152

  } m_waitAck; //!< wait ack

142

  bool m_sendRts; //!< send an RTS?

153

  bool m_sendRts; //!< send an RTS?

(-)a/src/wifi/model/mac-low.cc (-39 / +88 lines)

Lines 534-540 MacLow::StartTransmission (Ptr<const Packet> packet,	Link Here

534

      //In that case, we transmit the same A-MPDU as previously.

534

      //In that case, we transmit the same A-MPDU as previously.

535

      uint32_t sentMpdus = m_aggregateQueue[GetTid (packet, *hdr)]->GetNPackets ();

535

      uint32_t sentMpdus = m_aggregateQueue[GetTid (packet, *hdr)]->GetNPackets ();

536

      m_ampdu = true;

536

      m_ampdu = true;

537

      if (sentMpdus > 1)

537

      if (sentMpdus > 64)

538

539

          m_txParams.EnableExtendedCompressedBlockAck ();

540

541

      else if (sentMpdus > 1)

538

542

539

          m_txParams.EnableCompressedBlockAck ();

543

          m_txParams.EnableCompressedBlockAck ();

540

544

Lines 565-571 MacLow::StartTransmission (Ptr<const Packet> packet,	Link Here

565

569

566

          AmpduTag ampdu;

570

          AmpduTag ampdu;

567

          m_currentPacket->PeekPacketTag (ampdu);

571

          m_currentPacket->PeekPacketTag (ampdu);

568

          if (ampdu.GetRemainingNbOfMpdus () > 0)

572

          if (ampdu.GetRemainingNbOfMpdus () > 63)

573

574

              m_txParams.EnableExtendedCompressedBlockAck ();

575

576

          else if (ampdu.GetRemainingNbOfMpdus () > 0)

569

577

570

              m_txParams.EnableCompressedBlockAck ();

578

              m_txParams.EnableCompressedBlockAck ();

571

579

Lines 815-821 MacLow::ReceiveOk (Ptr<Packet> packet, double rxSnr, WifiTxVector txVector, bool	Link Here

815

823

816

824

817

  else if (hdr.IsBlockAck () && hdr.GetAddr1 () == m_self

825

  else if (hdr.IsBlockAck () && hdr.GetAddr1 () == m_self

818

           && (m_txParams.MustWaitBasicBlockAck () || m_txParams.MustWaitCompressedBlockAck ())

826

           && (m_txParams.MustWaitBasicBlockAck () || m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

819

           && m_blockAckTimeoutEvent.IsRunning ())

827

           && m_blockAckTimeoutEvent.IsRunning ())

820

828

821

      NS_LOG_DEBUG ("got block ack from " << hdr.GetAddr2 ());

829

      NS_LOG_DEBUG ("got block ack from " << hdr.GetAddr2 ());

Lines 1573-1582 MacLow::SendRtsForPacket (void)	Link Here

1573

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1581

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1574

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1582

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1575

1583

1576

  else if (m_txParams.MustWaitCompressedBlockAck ())

1584

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1577

1585

1578

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1586

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1579

      duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1587

        if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1588

1589

            duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1590

1591

        else

1592

1593

            duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1594

1580

1595

1581

  else if (m_txParams.MustWaitNormalAck ())

1596

  else if (m_txParams.MustWaitNormalAck ())

1582

1597

Lines 1626-1632 MacLow::StartDataTxTimers (WifiTxVector dataTxVector)	Link Here

1626

      NotifyAckTimeoutStartNow (timerDelay);

1641

      NotifyAckTimeoutStartNow (timerDelay);

1627

      m_blockAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::BlockAckTimeout, this);

1642

      m_blockAckTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::BlockAckTimeout, this);

1628

1643

1629

  else if (m_txParams.MustWaitCompressedBlockAck ())

1644

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1630

1645

1631

      Time timerDelay = txDuration + GetCompressedBlockAckTimeout ();

1646

      Time timerDelay = txDuration + GetCompressedBlockAckTimeout ();

1632

      NS_ASSERT (m_blockAckTimeoutEvent.IsExpired ());

1647

      NS_ASSERT (m_blockAckTimeoutEvent.IsExpired ());

Lines 1683-1693 MacLow::SendDataPacket (void)	Link Here

1683

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1698

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1684

          duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1699

          duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1685

1700

1686

      else if (m_txParams.MustWaitCompressedBlockAck ())

1701

      else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1687

1702

1688

          duration += GetSifs ();

1703

          duration += GetSifs ();

1689

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1704

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1690

          duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1705

          if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1706

1707

              duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1708

1709

          else

1710

1711

              duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1712

1691

1713

1692

      else if (m_txParams.MustWaitNormalAck ())

1714

      else if (m_txParams.MustWaitNormalAck ())

1693

1715

Lines 1807-1817 MacLow::SendCtsToSelf (void)	Link Here

1807

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1829

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1808

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1830

      duration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1809

1831

1810

  else if (m_txParams.MustWaitCompressedBlockAck ())

1832

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1811

1833

1812

      duration += GetSifs ();

1834

      duration += GetSifs ();

1813

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1835

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1814

      duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1836

      if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1837

1838

          duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1839

1840

      else

1841

1842

          duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1843

1815

1844

1816

  else if (m_txParams.MustWaitNormalAck ())

1845

  else if (m_txParams.MustWaitNormalAck ())

1817

1846

Lines 1823-1833 MacLow::SendCtsToSelf (void)	Link Here

1823

      duration += GetSifs ();

1852

      duration += GetSifs ();

1824

      duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),

1853

      duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),

1825

                                              m_currentTxVector, m_phy->GetFrequency ());

1854

                                              m_currentTxVector, m_phy->GetFrequency ());

1826

      if (m_txParams.MustWaitCompressedBlockAck ())

1855

      if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1827

1856

1828

          duration += GetSifs ();

1857

          duration += GetSifs ();

1829

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1858

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1830

          duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1859

          if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1860

1861

              duration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1862

1863

          else

1864

1865

              duration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1866

1831

1867

1832

      else if (m_txParams.MustWaitNormalAck ())

1868

      else if (m_txParams.MustWaitNormalAck ())

1833

1869

Lines 1916-1926 MacLow::SendDataAfterCts (Time duration)	Link Here

1916

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1952

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1917

      newDuration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1953

      newDuration += GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

1918

1954

1919

  else if (m_txParams.MustWaitCompressedBlockAck ())

1955

  else if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1920

1956

1921

      newDuration += GetSifs ();

1957

      newDuration += GetSifs ();

1922

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1958

      WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1923

      newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1959

      if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1960

1961

          newDuration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1962

1963

      else

1964

1965

          newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1966

1924

1967

1925

  else if (m_txParams.MustWaitNormalAck ())

1968

  else if (m_txParams.MustWaitNormalAck ())

1926

1969

Lines 1938-1948 MacLow::SendDataAfterCts (Time duration)	Link Here

1938

          newDuration += GetSifs ();

1981

          newDuration += GetSifs ();

1939

1982

1940

      newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), m_currentTxVector, m_phy->GetFrequency ());

1983

      newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), m_currentTxVector, m_phy->GetFrequency ());

1941

      if (m_txParams.MustWaitCompressedBlockAck ())

1984

      if (m_txParams.MustWaitCompressedBlockAck () || m_txParams.MustWaitExtendedCompressedBlockAck ())

1942

1985

1943

          newDuration += GetSifs ();

1986

          newDuration += GetSifs ();

1944

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1987

          WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), m_currentTxVector.GetMode ());

1945

          newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1988

          if (m_txParams.MustWaitExtendedCompressedBlockAck ())

1989

1990

              newDuration += GetBlockAckDuration (blockAckReqTxVector, EXTENDED_COMPRESSED_BLOCK_ACK);

1991

1992

          else

1993

1994

              newDuration += GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

1995

1946

1996

1947

      else if (m_txParams.MustWaitNormalAck ())

1997

      else if (m_txParams.MustWaitNormalAck ())

1948

1998

Lines 2282-2299 MacLow::SendBlockAckResponse (const CtrlBAckResponseHeader* blockAck, Mac48Addre	Link Here

2282

2332

2283

      m_txParams.DisableAck ();

2333

      m_txParams.DisableAck ();

2284

      duration -= GetSifs ();

2334

      duration -= GetSifs ();

2285

      if (blockAck->IsBasic ())

2335

      duration -= GetBlockAckDuration (blockAckReqTxVector, blockAck->GetType ());

2286

2287

          duration -= GetBlockAckDuration (blockAckReqTxVector, BASIC_BLOCK_ACK);

2288

2289

      else if (blockAck->IsCompressed ())

2290

2291

          duration -= GetBlockAckDuration (blockAckReqTxVector, COMPRESSED_BLOCK_ACK);

2292

2293

      else if (blockAck->IsMultiTid ())

2294

2295

          NS_FATAL_ERROR ("Multi-tid block ack is not supported.");

2296

2297

2336

2298

  else

2337

  else

2299

2338

Lines 2321-2327 MacLow::SendBlockAckResponse (const CtrlBAckResponseHeader* blockAck, Mac48Addre	Link Here

2321

2360

2322

2361

2323

void

2362

void

2324

MacLow::SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time duration, WifiTxVector blockAckReqTxVector, double rxSnr)

2363

MacLow::SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time duration, WifiTxVector blockAckReqTxVector, double rxSnr, uint8_t nMpdus)

2325

2364

2326

  NS_LOG_FUNCTION (this);

2365

  NS_LOG_FUNCTION (this);

2327

  if (!m_phy->IsStateTx () && !m_phy->IsStateRx ())

2366

  if (!m_phy->IsStateTx () && !m_phy->IsStateRx ())

Lines 2338-2344 MacLow::SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time durat	Link Here

2338

      blockAck.SetStartingSequence (seqNumber);

2377

      blockAck.SetStartingSequence (seqNumber);

2339

      blockAck.SetTidInfo (tid);

2378

      blockAck.SetTidInfo (tid);

2340

      immediate = (*it).second.first.IsImmediateBlockAck ();

2379

      immediate = (*it).second.first.IsImmediateBlockAck ();

2341

      blockAck.SetType (COMPRESSED_BLOCK_ACK);

2380

      if (nMpdus > 64)

2381

2382

          blockAck.SetType (EXTENDED_COMPRESSED_BLOCK_ACK);

2383

2384

      else

2385

2386

          blockAck.SetType (COMPRESSED_BLOCK_ACK);

2387

2342

      NS_LOG_DEBUG ("Got Implicit block Ack Req with seq " << seqNumber);

2388

      NS_LOG_DEBUG ("Got Implicit block Ack Req with seq " << seqNumber);

2343

      (*i).second.FillBlockAckBitmap (&blockAck);

2389

      (*i).second.FillBlockAckBitmap (&blockAck);

2344

2390

Lines 2375-2380 MacLow::SendBlockAckAfterBlockAckRequest (const CtrlBAckRequestHeader reqHdr, Ma	Link Here

2375

2421

2376

              blockAck.SetType (COMPRESSED_BLOCK_ACK);

2422

              blockAck.SetType (COMPRESSED_BLOCK_ACK);

2377

2423

2424

          else if (reqHdr.IsExtendedCompressed ())

2425

2426

              blockAck.SetType (EXTENDED_COMPRESSED_BLOCK_ACK);

2427

2378

          BlockAckCachesI i = m_bAckCaches.find (std::make_pair (originator, tid));

2428

          BlockAckCachesI i = m_bAckCaches.find (std::make_pair (originator, tid));

2379

          NS_ASSERT (i != m_bAckCaches.end ());

2429

          NS_ASSERT (i != m_bAckCaches.end ());

2380

          (*i).second.FillBlockAckBitmap (&blockAck);

2430

          (*i).second.FillBlockAckBitmap (&blockAck);

Lines 2470-2477 MacLow::DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr,	Link Here

2470

                                                    firsthdr.GetQosTid (),

2520

                                                    firsthdr.GetQosTid (),

2471

                                                    firsthdr.GetAddr2 (),

2521

                                                    firsthdr.GetAddr2 (),

2472

                                                    firsthdr.GetDuration (),

2522

                                                    firsthdr.GetDuration (),

2473

                                                    txVector,

2523

                                                    txVector, rxSnr,

2474

                                                    rxSnr);

2524

                                                    ampdu.GetRemainingNbOfMpdus () + 1);

2475

2525

2476

2526

2477

          if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ())

2527

          if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ())

Lines 2594-2600 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2594

2644

2595

      if (!hdr.GetAddr1 ().IsBroadcast () && edcaIt->second->GetMpduAggregator () != 0)

2645

      if (!hdr.GetAddr1 ().IsBroadcast () && edcaIt->second->GetMpduAggregator () != 0)

2596

2646

2597

          //Have to make sure that their exist a block Ack agreement before sending an AMPDU (BlockAck Manager)

2647

          //Have to make sure that their exist a block Ack agreement before sending an A-MPDU

2598

          if (edcaIt->second->GetBaAgreementExists (hdr.GetAddr1 (), tid))

2648

          if (edcaIt->second->GetBaAgreementExists (hdr.GetAddr1 (), tid))

2599

2649

2600

              /* here is performed mpdu aggregation */

2650

              /* here is performed mpdu aggregation */

Lines 2606-2612 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2606

              uint8_t qosPolicy = 0;

2656

              uint8_t qosPolicy = 0;

2607

              uint8_t blockAckSize = 0;

2657

              uint8_t blockAckSize = 0;

2608

              bool aggregated = false;

2658

              bool aggregated = false;

2609

              uint8_t i = 0;

2659

              uint16_t i = 0;

2610

              aggPacket = newPacket->Copy ();

2660

              aggPacket = newPacket->Copy ();

2611

2661

2612

              if (!hdr.IsBlockAckReq ())

2662

              if (!hdr.IsBlockAckReq ())

Lines 2668-2674 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2668

                  currentSequenceNumber = peekedHdr.GetSequenceNumber ();

2718

                  currentSequenceNumber = peekedHdr.GetSequenceNumber ();

2669

2719

2670

2720

2671

              while (IsInWindow (currentSequenceNumber, startingSequenceNumber, 64) && !StopMpduAggregation (peekedPacket, peekedHdr, currentAggregatedPacket, blockAckSize))

2721

              uint16_t maxMpdus = edcaIt->second->GetBaBufferSize (hdr.GetAddr1 (), tid);

2722

              while (IsInWindow (currentSequenceNumber, startingSequenceNumber, maxMpdus) && !StopMpduAggregation (peekedPacket, peekedHdr, currentAggregatedPacket, blockAckSize))

2672

2723

2673

                  //for now always send AMPDU with normal ACK

2724

                  //for now always send AMPDU with normal ACK

2674

                  if (retry == false)

2725

                  if (retry == false)

Lines 2747-2753 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2747

                              peekedPacket = item->GetPacket ();

2798

                              peekedPacket = item->GetPacket ();

2748

                              peekedHdr = item->GetHeader ();

2799

                              peekedHdr = item->GetHeader ();

2749

                              tstamp = item->GetTimeStamp ();

2800

                              tstamp = item->GetTimeStamp ();

2750

                              //find what will the sequence number be so that we don't send more than 64 packets apart

2751

                              currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2801

                              currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2752

2802

2753

                              if (edcaIt->second->GetMsduAggregator () != 0)

2803

                              if (edcaIt->second->GetMsduAggregator () != 0)

Lines 2774-2783 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2774

                          peekedPacket = item->GetPacket ();

2824

                          peekedPacket = item->GetPacket ();

2775

                          peekedHdr = item->GetHeader ();

2825

                          peekedHdr = item->GetHeader ();

2776

                          tstamp = item->GetTimeStamp ();

2826

                          tstamp = item->GetTimeStamp ();

2777

                          //find what will the sequence number be so that we don't send more than 64 packets apart

2778

                          currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2827

                          currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

2779

2828

2780

                          if (edcaIt->second->GetMsduAggregator () != 0 && IsInWindow (currentSequenceNumber, startingSequenceNumber, 64))

2829

                          if (edcaIt->second->GetMsduAggregator () != 0 && IsInWindow (currentSequenceNumber, startingSequenceNumber, maxMpdus))

2781

2830

2782

                              tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);

2831

                              tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);

2783

                              if (tempPacket != 0) //MSDU aggregation

2832

                              if (tempPacket != 0) //MSDU aggregation

Lines 2818-2824 MacLow::AggregateToAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr)	Link Here

2818

                  newPacket = currentAggregatedPacket;

2867

                  newPacket = currentAggregatedPacket;

2819

                  newPacket->AddPacketTag (ampdutag);

2868

                  newPacket->AddPacketTag (ampdutag);

2820

2869

2821

                  NS_LOG_DEBUG ("tx unicast A-MPDU");

2870

                  NS_LOG_DEBUG ("tx unicast A-MPDU containing " << +i << " MPDUs");

2822

                  edcaIt->second->SetAmpduExist (hdr.GetAddr1 (), true);

2871

                  edcaIt->second->SetAmpduExist (hdr.GetAddr1 (), true);

2823

2872

2824

              else

2873

              else

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

Lines 37-42	Link Here

class TwoLevelAggregationTest;

class TwoLevelAggregationTest;

class AmpduAggregationTest;

class AmpduAggregationTest;

class HeAggregationTest;

namespace ns3 {

namespace ns3 {

Lines 60-67 class MacLow : public Object	Link Here

public:

public:

  /// Allow test cases to access private members

  /// Allow test cases to access private members

  friend class ::TwoLevelAggregationTest;

  friend class ::TwoLevelAggregationTest;

  /// Allow test cases to access private members

  friend class ::AmpduAggregationTest;

  friend class ::AmpduAggregationTest;

  friend class ::HeAggregationTest;

/**

/**

   * typedef for a callback for MacLowRx

   * typedef for a callback for MacLowRx

*/

*/

Lines 403-419 public:	Link Here

403

*/

405

*/

404

  void DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector);

406

  void DeaggregateAmpduAndReceive (Ptr<Packet> aggregatedPacket, double rxSnr, WifiTxVector txVector);

405

/**

407

/**

406

   * \param peekedPacket the packet to be aggregated

407

   * \param peekedHdr the WifiMacHeader for the packet.

408

   * \param aggregatedPacket the current A-MPDU

409

   * \param blockAckSize the size of a piggybacked block ack request

410

   * \return false if the given packet can be added to an A-MPDU, true otherwise

411

412

   * This function decides if a given packet can be added to an A-MPDU or not

413

414

*/

415

  bool StopMpduAggregation (Ptr<const Packet> peekedPacket, WifiMacHeader peekedHdr, Ptr<Packet> aggregatedPacket, uint8_t blockAckSize) const;

416

/**

417

408

418

   * This function is called to flush the aggregate queue, which is used for A-MPDU

409

   * This function is called to flush the aggregate queue, which is used for A-MPDU

419

   * \param tid the Traffic ID

410

   * \param tid the Traffic ID

Lines 477-482 private:	Link Here

477

*/

468

*/

478

  void SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype);

469

  void SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, MpduType mpdutype);

479

/**

470

/**

471

   * \param peekedPacket the packet to be aggregated

472

   * \param peekedHdr the WifiMacHeader for the packet.

473

   * \param aggregatedPacket the current A-MPDU

474

   * \param blockAckSize the size of a piggybacked block ack request

475

   * \return false if the given packet can be added to an A-MPDU, true otherwise

476

477

   * This function decides if a given packet can be added to an A-MPDU or not

478

479

*/

480

  bool StopMpduAggregation (Ptr<const Packet> peekedPacket, WifiMacHeader peekedHdr, Ptr<Packet> aggregatedPacket, uint8_t blockAckSize) const;

481

/**

480

   * Return a TXVECTOR for the RTS frame given the destination.

482

   * Return a TXVECTOR for the RTS frame given the destination.

481

   * The function consults WifiRemoteStationManager, which controls the rate

483

   * The function consults WifiRemoteStationManager, which controls the rate

482

   * to different destinations.

484

   * to different destinations.

Lines 788-796 private:	Link Here

788

   * \param duration the remaining NAV duration

790

   * \param duration the remaining NAV duration

789

   * \param blockAckReqTxVector the transmit vector

791

   * \param blockAckReqTxVector the transmit vector

790

   * \param rxSnr the receive SNR

792

   * \param rxSnr the receive SNR

793

   * \param nMpdus the number of received MPDUs

791

*/

794

*/

792

  void SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator,

795

  void SendBlockAckAfterAmpdu (uint8_t tid, Mac48Address originator, Time duration,

793

                               Time duration, WifiTxVector blockAckReqTxVector, double rxSnr);

796

                               WifiTxVector blockAckReqTxVector, double rxSnr, uint8_t nMpdus);

794

/**

797

/**

795

   * This method creates block ack frame with header equals to <i>blockAck</i> and start its transmission.

798

   * This method creates block ack frame with header equals to <i>blockAck</i> and start its transmission.

796

799




}

void
MpduAggregator::SetMaxAmpduSize (uint32_t maxSize)
{
  m_maxAmpduLength = maxSize;
}

uint32_t
MpduAggregator::GetMaxAmpduSize (void) const
{
  return m_maxAmpduLength;




   *
   * \param maxSize the maximum A-MPDU size in bytes.
   */
  void SetMaxAmpduSize (uint32_t maxSize);
  /**
   * Returns the maximum A-MPDU size in bytes.
   * Value 0 means that MPDU aggregation is disabled.
   *
   * \return the maximum A-MPDU size in bytes.
   */
  uint32_t GetMaxAmpduSize (void) const;

  /**
   * \param packet Packet we have to insert into <i>aggregatedPacket</i>.

   */
  uint8_t CalculatePadding (Ptr<const Packet> packet) const;

  uint32_t m_maxAmpduLength; //!< Maximum length in bytes of A-MPDUs
};

}  //namespace ns3

(-)a/src/wifi/model/originator-block-ack-agreement.cc (-2 / +1 lines)

Lines 76-83 OriginatorBlockAckAgreement::NotifyMpduTransmission (uint16_t nextSeqNumber)	Link Here

  NS_ASSERT (m_sentMpdus < m_bufferSize);

  NS_ASSERT (m_sentMpdus < m_bufferSize);

  m_sentMpdus++;

  m_sentMpdus++;

  uint16_t delta = (nextSeqNumber - m_startingSeq + 4096) % 4096;

  uint16_t delta = (nextSeqNumber - m_startingSeq + 4096) % 4096;

  uint16_t min = m_bufferSize < 64 ? m_bufferSize : 64;

  if (delta >= m_bufferSize || m_sentMpdus == m_bufferSize)

  if (delta >= min || m_sentMpdus == m_bufferSize)

      m_needBlockAckReq = true;

      m_needBlockAckReq = true;

(-)a/src/wifi/model/qos-txop.cc (+6 lines)

Lines 117-122 QosTxop::CompleteAmpduTransfer (Mac48Address recipient, uint8_t tid)	Link Here

117

  m_baManager->CompleteAmpduExchange (recipient, tid);

117

  m_baManager->CompleteAmpduExchange (recipient, tid);

118

119

120

uint16_t

121

QosTxop::GetBaBufferSize (Mac48Address address, uint8_t tid) const

122

123

  return m_baManager->GetRecipientBufferSize (address, tid);

124

125

120

void

126

void

121

QosTxop::SetWifiRemoteStationManager (const Ptr<WifiRemoteStationManager> remoteManager)

127

QosTxop::SetWifiRemoteStationManager (const Ptr<WifiRemoteStationManager> remoteManager)

122

128




#include "qos-utils.h"

class AmpduAggregationTest;
class HeAggregationTest;

namespace ns3 {


public:
  /// Allow test cases to access private members
  friend class ::AmpduAggregationTest;
  friend class ::HeAggregationTest;

  std::map<Mac48Address, bool> m_aMpduEnabled; //!< list containing flags whether A-MPDU is enabled for a given destination address


   * of an A-MPDU with ImmediateBlockAck policy (i.e. no BAR is scheduled).
   */
  void CompleteAmpduTransfer (Mac48Address recipient, uint8_t tid);
  /**
   * \param address recipient address of the peer station
   * \param tid traffic ID.
   *
   * \return the negociated buffer size during ADDBA handshake.
   *
   * Returns the negociated buffer size during ADDBA handshake with station addressed by
   * <i>recipient</i> for tid <i>tid</i>.
   */
  uint16_t GetBaBufferSize (Mac48Address address, uint8_t tid) const;

  /* dcf notifications forwarded here */
  /**




}

void
RegularWifiMac::SetVoMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  m_voMaxAmpduSize = size;

}

void
RegularWifiMac::SetViMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  m_viMaxAmpduSize = size;

}

void
RegularWifiMac::SetBeMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  m_beMaxAmpduSize = size;

}

void
RegularWifiMac::SetBkMaxAmpduSize (uint32_t size)
{
  NS_LOG_FUNCTION (this << size);
  m_bkMaxAmpduSize = size;

      respHdr.SetDelayedBlockAck ();
    }
  respHdr.SetTid (reqHdr->GetTid ());

  Ptr<WifiNetDevice> device = DynamicCast<WifiNetDevice> (GetDevice ());
  Ptr<HeConfiguration> heConfiguration = device->GetHeConfiguration ();
  if (heConfiguration && heConfiguration->GetMpduBufferSize () > 64)
    {
      respHdr.SetBufferSize (255);
    }
  else
    {
      respHdr.SetBufferSize (63);
    }
  respHdr.SetTimeout (reqHdr->GetTimeout ());

  WifiActionHeader actionHdr;

                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetVoMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("VI_MaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_VI access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (65535),
                   MakeUintegerAccessor (&RegularWifiMac::SetViMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("BE_MaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BE access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (65535),
                   MakeUintegerAccessor (&RegularWifiMac::SetBeMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("BK_MaxAmpduSize",
                   "Maximum length in bytes of an A-MPDU for AC_BK access class."
                   "Value 0 means A-MPDU is disabled for that AC.",
                   UintegerValue (0),
                   MakeUintegerAccessor (&RegularWifiMac::SetBkMaxAmpduSize),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("VO_BlockAckThreshold",
                   "If number of packets in VO queue reaches this value, "
                   "block ack mechanism is used. If this value is 0, block ack is never used."




   *
   * \param size the maximum A-MPDU size for AC_VO.
   */
  void SetVoMaxAmpduSize (uint32_t size);
  /**
   * Set the maximum A-MPDU size for AC_VI.
   *
   * \param size the maximum A-MPDU size for AC_VI.
   */
  void SetViMaxAmpduSize (uint32_t size);
  /**
   * Set the maximum A-MPDU size for AC_BE.
   *
   * \param size the maximum A-MPDU size for AC_BE.
   */
  void SetBeMaxAmpduSize (uint32_t size);
  /**
   * Set the maximum A-MPDU size for AC_BK.
   *
   * \param size the maximum A-MPDU size for AC_BK.
   */
  void SetBkMaxAmpduSize (uint32_t size);

  /**
   * Set the Block ACK threshold for AC_VO.

  uint16_t m_beMaxAmsduSize; ///< maximum A-MSDU size for AC_BE
  uint16_t m_bkMaxAmsduSize; ///< maximum A-MSDU size for AC_BK

  uint32_t m_voMaxAmpduSize; ///< maximum A-MPDU size for AC_VO
  uint32_t m_viMaxAmpduSize; ///< maximum A-MPDU size for AC_VI
  uint32_t m_beMaxAmpduSize; ///< maximum A-MPDU size for AC_BE
  uint32_t m_bkMaxAmpduSize; ///< maximum A-MPDU size for AC_BK

  TracedCallback<const WifiMacHeader &> m_txOkCallback; ///< transmit OK callback
  TracedCallback<const WifiMacHeader &> m_txErrCallback; ///< transmit error callback

(-)a/src/wifi/model/sta-wifi-mac.h (-1 / +3 lines)

Lines 28-33	Link Here

class TwoLevelAggregationTest;

class TwoLevelAggregationTest;

class AmpduAggregationTest;

class AmpduAggregationTest;

class HeAggregationTest;

namespace ns3  {

namespace ns3  {

Lines 109-115 public:	Link Here

109

  friend class ::TwoLevelAggregationTest;

110

  friend class ::TwoLevelAggregationTest;

110

  /// Allow test cases to access private members

111

  /// Allow test cases to access private members

111

  friend class ::AmpduAggregationTest;

112

  friend class ::AmpduAggregationTest;

112

113

  /// Allow test cases to access private members

114

  friend class ::HeAggregationTest;

113

/**

115

/**

114

   * \brief Get the type ID.

116

   * \brief Get the type ID.

115

   * \return the object TypeId

117

   * \return the object TypeId




  WifiMacHeader hdr;
  hdr.SetType (WIFI_MAC_CTL_BACKRESP);
  CtrlBAckResponseHeader blockAck;
  blockAck.SetType (type);
    {
      blockAck.SetType (BASIC_BLOCK_ACK);
    }
  else if (type == COMPRESSED_BLOCK_ACK)
    {
      blockAck.SetType (COMPRESSED_BLOCK_ACK);
    }
  else if (type == MULTI_TID_BLOCK_ACK)
    {
      //Not implemented
      NS_ASSERT (false);
    }
  return hdr.GetSize () + blockAck.GetSerializedSize () + 4;
}


(-)a/src/wifi/model/wifi-utils.h (-1 / +1 lines)

Lines 120-126 uint32_t GetCtsSize (void);	Link Here

120

/**

120

/**

121

 * \param seq MPDU sequence number

121

 * \param seq MPDU sequence number

122

 * \param winstart sequence number window start

122

 * \param winstart sequence number window start

123

 * \param winsize the size of the sequence number window (currently default is 64)

123

 * \param winsize the size of the sequence number window

124

 * \returns true if in the window

124

 * \returns true if in the window

125

126

 * This method checks if the MPDU's sequence number is inside the scoreboard boundaries or not

126

 * This method checks if the MPDU's sequence number is inside the scoreboard boundaries or not

(-)a/src/wifi/test/wifi-aggregation-test.cc (-1 / +155 lines)

Lines 30-35	Link Here

#include "ns3/mpdu-aggregator.h"

#include "ns3/mpdu-aggregator.h"

#include "ns3/wifi-net-device.h"

#include "ns3/wifi-net-device.h"

#include "ns3/ht-configuration.h"

#include "ns3/ht-configuration.h"

#include "ns3/vht-configuration.h"

#include "ns3/he-configuration.h"

using namespace ns3;

using namespace ns3;

Lines 124-130 AmpduAggregationTest::DoRun (void)	Link Here

124

  MgtAddBaRequestHeader reqHdr;

126

  MgtAddBaRequestHeader reqHdr;

125

  reqHdr.SetImmediateBlockAck ();

127

  reqHdr.SetImmediateBlockAck ();

126

  reqHdr.SetTid (0);

128

  reqHdr.SetTid (0);

127

  reqHdr.SetBufferSize (0);

129

  reqHdr.SetBufferSize (64);

128

  reqHdr.SetTimeout (0);

130

  reqHdr.SetTimeout (0);

129

  reqHdr.SetStartingSequence (0);

131

  reqHdr.SetStartingSequence (0);

130

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

132

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

Lines 388-393 TwoLevelAggregationTest::DoRun (void)	Link Here

388

 * \ingroup wifi-test

390

 * \ingroup wifi-test

389

 * \ingroup tests

391

 * \ingroup tests

390

392

393

 * \brief 802.11ax aggregation test which permits 64 or 256 MPDUs in A-MPDU according to the negociated buffer size.

394

*/

395

class HeAggregationTest : public TestCase

396

397

public:

398

  HeAggregationTest ();

399

400

private:

401

  void DoRun (void);

402

  void DoRunSubTest (uint16_t bufferSize);

403

  Ptr<WifiNetDevice> m_device; ///<WifiNetDevice

404

  Ptr<StaWifiMac> m_mac; ///< Mac

405

  Ptr<YansWifiPhy> m_phy; ///< Phy

406

  Ptr<WifiRemoteStationManager> m_manager; ///< remote station manager

407

  ObjectFactory m_factory; ///< factory

408

};

409

410

HeAggregationTest::HeAggregationTest ()

411

  : TestCase ("Check the correctness of 802.11ax aggregation operations")

412

413

414

415

void

416

HeAggregationTest::DoRunSubTest (uint16_t bufferSize)

417

418

/*

419

   * Create device and attach configurations.

420

*/

421

  m_device = CreateObject<WifiNetDevice> ();

422

  Ptr<HtConfiguration> htConfiguration = CreateObject<HtConfiguration> ();

423

  m_device->SetHtConfiguration (htConfiguration);

424

  Ptr<VhtConfiguration> vhtConfiguration = CreateObject<VhtConfiguration> ();

425

  m_device->SetVhtConfiguration (vhtConfiguration);

426

  Ptr<HeConfiguration> heConfiguration = CreateObject<HeConfiguration> ();

427

  m_device->SetHeConfiguration (heConfiguration);

428

429

/*

430

   * Create and configure phy layer.

431

*/

432

  m_phy = CreateObject<YansWifiPhy> ();

433

  m_phy->SetDevice (m_device);

434

  m_phy->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);

435

  m_device->SetPhy (m_phy);

436

437

/*

438

   * Create and configure manager.

439

*/

440

  m_factory = ObjectFactory ();

441

  m_factory.SetTypeId ("ns3::ConstantRateWifiManager");

442

  m_factory.Set ("DataMode", StringValue ("HeMcs11"));

443

  m_manager = m_factory.Create<WifiRemoteStationManager> ();

444

  m_manager->SetupPhy (m_phy);

445

  m_device->SetRemoteStationManager (m_manager);

446

447

/*

448

   * Create and configure mac layer.

449

*/

450

  m_mac = CreateObject<StaWifiMac> ();

451

  m_mac->SetDevice (m_device);

452

  m_mac->SetWifiPhy (m_phy);

453

  m_mac->SetWifiRemoteStationManager (m_manager);

454

  m_mac->SetAddress (Mac48Address ("00:00:00:00:00:01"));

455

  m_mac->ConfigureStandard (WIFI_PHY_STANDARD_80211ax_5GHZ);

456

  m_device->SetMac (m_mac);

457

458

/*

459

   * Configure MPDU aggregation.

460

*/

461

  m_mac->GetBEQueue ()->GetMpduAggregator ()->SetMaxAmpduSize (4194304); //Maximum size allowed by 802.11ax

462

463

/*

464

   * Create a dummy packet of 100 bytes and fill mac header fields.

465

*/

466

  Ptr<const Packet> pkt = Create<Packet> (100);

467

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

468

  WifiMacHeader hdr;

469

  hdr.SetAddr1 (Mac48Address ("00:00:00:00:00:02"));

470

  hdr.SetAddr2 (Mac48Address ("00:00:00:00:00:01"));

471

  hdr.SetType (WIFI_MAC_QOSDATA);

472

  hdr.SetQosTid (0);

473

  uint16_t sequence = m_mac->m_txMiddle->GetNextSequenceNumberFor (&hdr);

474

  hdr.SetSequenceNumber (sequence);

475

  hdr.SetFragmentNumber (0);

476

  hdr.SetNoMoreFragments ();

477

  hdr.SetNoRetry ();

478

479

/*

480

   * Establish agreement.

481

*/

482

  MgtAddBaRequestHeader reqHdr;

483

  reqHdr.SetImmediateBlockAck ();

484

  reqHdr.SetTid (0);

485

  reqHdr.SetBufferSize (bufferSize);

486

  reqHdr.SetTimeout (0);

487

  reqHdr.SetStartingSequence (0);

488

  m_mac->GetBEQueue ()->m_baManager->CreateAgreement (&reqHdr, hdr.GetAddr1 ());

489

490

/*

491

   * Prepare MacLow for transmission

492

*/

493

  m_mac->GetBEQueue ()->GetLow ()->m_currentHdr = hdr;

494

  m_mac->GetBEQueue ()->GetLow ()->m_currentPacket = pkt->Copy ();

495

  m_mac->GetBEQueue ()->GetLow ()->m_currentTxVector = m_mac->GetBEQueue ()->GetLow ()->GetDataTxVector (m_mac->GetBEQueue ()->GetLow ()->m_currentPacket, &m_mac->GetBEQueue ()->GetLow ()->m_currentHdr);

496

497

/*

498

   * Test behavior when 300 packets are ready for transmission but negociated buffer size is 64

499

*/

500

  for (uint16_t i = 0; i < 300; i++)

501

502

      Ptr<const Packet> pkt = Create<Packet> (100);

503

      WifiMacHeader hdr;

504

505

      hdr.SetAddr1 (Mac48Address ("00:00:00:00:00:02"));

506

      hdr.SetAddr2 (Mac48Address ("00:00:00:00:00:01"));

507

      hdr.SetType (WIFI_MAC_QOSDATA);

508

      hdr.SetQosTid (0);

509

510

      m_mac->GetBEQueue ()->GetWifiMacQueue ()->Enqueue (Create<WifiMacQueueItem> (pkt, hdr));

511

512

513

  bool isAmpdu = m_mac->GetBEQueue ()->GetLow ()->IsAmpdu (pkt, hdr);

514

  NS_TEST_EXPECT_MSG_EQ (isAmpdu, true, "MPDU aggregation failed");

515

  uint32_t aggregationQueueSize = m_mac->GetBEQueue ()->GetLow ()->m_aggregateQueue[0]->GetNPackets ();

516

  NS_TEST_EXPECT_MSG_EQ (aggregationQueueSize, bufferSize, "aggregation queue should countain " << bufferSize << " MPDUs");

517

  uint16_t expectedRemainingPacketsInQueue = 300 - bufferSize + 1;

518

  NS_TEST_EXPECT_MSG_EQ (m_mac->GetBEQueue ()->GetWifiMacQueue ()->GetNPackets (), expectedRemainingPacketsInQueue, "queue should contain 300 - "<< bufferSize - 1 << " = "<< expectedRemainingPacketsInQueue << " packets");

519

520

  Simulator::Destroy ();

521

522

  m_manager->Dispose ();

523

  m_manager = 0;

524

525

  m_device->Dispose ();

526

  m_device = 0;

527

528

  htConfiguration = 0;

529

  vhtConfiguration = 0;

530

  heConfiguration = 0;

531

532

533

void

534

HeAggregationTest::DoRun ()

535

536

  DoRunSubTest (64);

537

  DoRunSubTest (256);

538

539

540

/**

541

 * \ingroup wifi-test

542

 * \ingroup tests

543

391

 * \brief Wifi Aggregation Test Suite

544

 * \brief Wifi Aggregation Test Suite

392

*/

545

*/

393

class WifiAggregationTestSuite : public TestSuite

546

class WifiAggregationTestSuite : public TestSuite

Lines 401-406 WifiAggregationTestSuite::WifiAggregationTestSuite ()	Link Here

401

554

402

  AddTestCase (new AmpduAggregationTest, TestCase::QUICK);

555

  AddTestCase (new AmpduAggregationTest, TestCase::QUICK);

403

  AddTestCase (new TwoLevelAggregationTest, TestCase::QUICK);

556

  AddTestCase (new TwoLevelAggregationTest, TestCase::QUICK);

557

  AddTestCase (new HeAggregationTest, TestCase::QUICK);

404

558

405

559

406

static WifiAggregationTestSuite g_wifiAggregationTestSuite; ///< the test suite

560

static WifiAggregationTestSuite g_wifiAggregationTestSuite; ///< the test suite

Return to bug 3010