Attachment #3037 for bug #2870

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

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

Lines 46-53 void	Link Here

BlockAckAgreement::SetBufferSize (uint16_t bufferSize)

BlockAckAgreement::SetBufferSize (uint16_t bufferSize)

  NS_LOG_FUNCTION (this << bufferSize);

  NS_LOG_FUNCTION (this << bufferSize);

  NS_ASSERT (bufferSize <= 1024);

  NS_ASSERT (bufferSize > 0 && bufferSize <= 1024);

  NS_ASSERT (bufferSize % 16 == 0);

  m_bufferSize = bufferSize;

  m_bufferSize = bufferSize;




  return (m_agreements.find (std::make_pair (recipient, tid)) != m_agreements.end ());
}

uint16_t
BlockAckManager::GetAgreementBufferSize (Mac48Address recipient, uint8_t tid) const
{
  NS_LOG_FUNCTION (this << recipient << static_cast<uint16_t> (tid));
  NS_ASSERT (ExistsAgreement (recipient, tid));
  uint16_t bufferSize = m_agreements.find (std::make_pair (recipient, tid))->second.first.GetBufferSize ();
  return bufferSize;
}

void
BlockAckManager::SetMaxBufferSize (uint16_t maxBufferSize)
{
  NS_LOG_FUNCTION (this << maxBufferSize);
  NS_ASSERT (maxBufferSize > 0 && maxBufferSize < 1024);
  m_maxBufferSize = maxBufferSize;
}

uint16_t
BlockAckManager::GetMaxBufferSize (void) const
{
  return m_maxBufferSize;
}

bool
BlockAckManager::ExistsAgreementInState (Mac48Address recipient, uint8_t tid,
                                         OriginatorBlockAckAgreement::State state) const

  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 (m_maxBufferSize < 64 ? m_maxBufferSize : 64);
  agreement.SetWinEnd ((agreement.GetStartingSequence () + agreement.GetBufferSize () - 1) % 4096);
  agreement.SetTimeout (reqHdr->GetTimeout ());
  agreement.SetAmsduSupport (reqHdr->IsAmsduSupported ());

  if (it != m_agreements.end ())
    {
      OriginatorBlockAckAgreement& agreement = it->second.first;
      uint16_t bufferSize = respHdr->GetBufferSize () + 1;
      agreement.SetBufferSize (bufferSize < m_maxBufferSize ? bufferSize : m_maxBufferSize);
      agreement.SetTimeout (respHdr->GetTimeout ());
      agreement.SetAmsduSupport (respHdr->IsAmsduSupported ());
      if (respHdr->IsImmediateBlockAck ())




   */
  void UpdateAgreement (const MgtAddBaResponseHeader *respHdr, Mac48Address recipient);
  /**
   * \param recipient Address of peer station involved in block ack mechanism.
   * \param tid Traffic ID.
   *
   * \return the buffer size negotiated for this peer and for the given TID
   *
   * Returns the negotiated buffer size of an existing block ack agreement
   * with station addressed by <i>recipient</i> for tid <i>tid</i>.
   */
  uint16_t GetAgreementBufferSize (Mac48Address recipient, uint8_t tid) const;
  /**
   * \param maxBufferSize Maximum buffer size for the underlying device
   *
   * Sets the maximum buffer size supported by the device. Will be enforced when negotiating
   * block ack agreements.
   */
  void SetMaxBufferSize (uint16_t maxBufferSize);
  /**
   * \return the maximum buffer size for the underlying device
   *
   * This method returns the maximum buffer size supported by the device.
   */
  uint16_t GetMaxBufferSize (void) const;
  /**
   * \param packet Packet to store.
   * \param hdr 802.11 header for packet.
   * \param tStamp time stamp for packet

  std::list<PacketQueueI> m_retryPackets;
  std::list<Bar> m_bars; ///< list of BARs

  uint8_t m_blockAckThreshold; ///< block ack threshold
  BlockAckType m_blockAckType; ///< block ack type
  Time m_maxDelay; ///< maximum delay
  Ptr<MacTxMiddle> m_txMiddle; ///< the MacTxMiddle
  Mac48Address m_address; ///< address

  TxOk m_txOkCallback; ///< transmit ok callback
  TxFailed m_txFailedCallback; ///< transmit failed callback
  Ptr<WifiRemoteStationManager> m_stationManager; ///< the station manager
  uint16_t m_maxBufferSize;     ///< maximum buffer size supported by the device
};

} //namespace ns3




}

bool
EdcaTxopN::GetEstablishedBaAgreementExists (Mac48Address address, uint8_t tid) const
{
  return m_baManager->ExistsAgreementInState (address, tid, OriginatorBlockAckAgreement::ESTABLISHED);
}

uint16_t
EdcaTxopN::GetAgreementBufferSize (Mac48Address recipient, uint8_t tid) const
{
  NS_LOG_FUNCTION (this << recipient << static_cast<uint16_t> (tid));
  NS_ASSERT (GetEstablishedBaAgreementExists (recipient, tid));
  uint16_t bufferSize = m_baManager->GetAgreementBufferSize (recipient, tid);
  return bufferSize;
}

Ptr<BlockAckManager>
EdcaTxopN::GetBlockAckManager (void) const
{
  return m_baManager;
}

void

          uint8_t tid = GetTid (m_currentPacket, m_currentHdr);
          m_low->FlushAggregateQueue (tid);

          if (GetEstablishedBaAgreementExists (m_currentHdr.GetAddr1 (), tid))
            {
              NS_LOG_DEBUG ("Transmit Block Ack Request");
              CtrlBAckRequestHeader reqHdr;

        {
          uint8_t tid = GetTid (m_currentPacket, m_currentHdr);

          if (GetEstablishedBaAgreementExists (m_currentHdr.GetAddr1 (), tid))
            {
              //send Block ACK Request in order to shift WinStart at the receiver
              NS_LOG_DEBUG ("Transmit Block Ack Request");

      || GetAmpduExist (m_currentHdr.GetAddr1 ())
      || (m_stationManager->HasHtSupported ()
          && m_currentHdr.IsQosData ()
          && GetEstablishedBaAgreementExists (m_currentHdr.GetAddr1 (), GetTid (m_currentPacket, m_currentHdr))
          && GetMpduAggregator ()->GetMaxAmpduSize () >= m_currentPacket->GetSize ()))
    {
      //MSDU is not fragmented when it is transmitted using an HT-immediate or

      reqHdr.SetDelayedBlockAck ();
    }
  reqHdr.SetTid (tid);
  /* Send the device's max buffer size field in the ADDBA request frame to facilitate analysis through sniffers.
   * Note that this information is only advisory since it's up to the recipient to choose how many packets
   * it can receive under block ack.
   */
  reqHdr.SetBufferSize (m_baManager->GetMaxBufferSize () - 1);
  reqHdr.SetTimeout (timeout);
  reqHdr.SetStartingSequence (startSeq);





   *
   * \return true if a block ack agreement exists, false otherwise.
   *
   * Checks if an established block ack agreement exists with station addressed by
   * <i>recipient</i> for tid <i>tid</i>.
   */
  bool GetEstablishedBaAgreementExists (Mac48Address address, uint8_t tid) const;
  /**
   * \param recipient Address of peer station involved in block ack mechanism.
   * \param tid traffic ID.
   *
   * \return the buffer size negotiated for this peer and for the given TID
   *
   * Returns the negotiated buffer size of an existing block ack agreement
   * with station addressed by <i>recipient</i> for tid <i>tid</i>.
   */
  uint16_t GetAgreementBufferSize (Mac48Address recipient, uint8_t tid) const;
  /**
   * \return a smart pointer to BlockAckManager
   *
   * Accessor for the Block ACK manager
   */
  Ptr<BlockAckManager> GetBlockAckManager (void) const;
  /**
   * \param recipient address of peer station involved in block ack mechanism.
   * \param tid Ttraffic ID of transmitted packet.





      if (!hdr.GetAddr1 ().IsBroadcast () && edcaIt->second->GetMpduAggregator () != 0)
        {
          //Have to make sure that their exist an established block Ack agreement before sending an AMPDU (BlockAck Manager)
          if (edcaIt->second->GetEstablishedBaAgreementExists (hdr.GetAddr1 (), tid))
            {
              /* here is performed mpdu aggregation */
              /* MSDU aggregation happened in edca if the user asked for it so m_currentPacket may contains a normal packet or a A-MSDU*/

                  currentSequenceNumber = peekedHdr.GetSequenceNumber ();
                }

              while (IsInWindow (currentSequenceNumber, startingSequenceNumber, edcaIt->second->GetAgreementBufferSize (peekedHdr.GetAddr1 (), tid))
                  && !StopMpduAggregation (peekedPacket, peekedHdr, currentAggregatedPacket, blockAckSize))
                {
                  //for now always send AMPDU with normal ACK
                  if (retry == false)

                          //find what will the sequence number be so that we don't send more than 64 packets apart
                          currentSequenceNumber = edcaIt->second->PeekNextSequenceNumberFor (&peekedHdr);

                          if (edcaIt->second->GetMsduAggregator () != 0
                              && IsInWindow (currentSequenceNumber, startingSequenceNumber, edcaIt->second->GetAgreementBufferSize (peekedHdr.GetAddr1 (), tid)))
                            {
                              tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);
                              if (tempPacket != 0) //MSDU aggregation

                {
                  InsertInTxQueue (packet, peekedHdr, tstamp, tid);
                }
              if (edcaIt->second->GetEstablishedBaAgreementExists (hdr.GetAddr1 (), tid))
                {
                  edcaIt->second->CompleteAmpduTransfer (peekedHdr.GetAddr1 (), tid);
                }

(-)a/src/wifi/model/regular-wifi-mac.cc (-7 / +25 lines)

Lines 1047-1059 RegularWifiMac::SendAddBaResponse (const MgtAddBaRequestHeader *reqHdr,	Link Here

1047

      respHdr.SetDelayedBlockAck ();

1047

      respHdr.SetDelayedBlockAck ();

1048

1049

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

1049

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

1050

  //For now there's not no control about limit of reception. We

1050

  //Since only compressed bitmap is used for block acks, enforce limitation

1051

  //assume that receiver has no limit on reception. However we assume

1051

  //of 64. The footpage note in section 7.3.1.14 in IEEE802.11e (or equivalently

1052

  //that a receiver sets a bufferSize in order to satisfy next

1052

  //the one in 9.4.1.14 in IEEE802.11-2016) specifies that a buffer space is used

1053

  //equation: (bufferSize + 1) % 16 = 0 So if a recipient is able to

1053

  //irrespective of whether a small MSDU fragment or a full-size A-MSDU is considered).

1054

  //buffer a packet, it should be also able to buffer all possible

1054

  //In addition, since the buffer size in the ADDBA request is only advisory

1055

  //packet's fragments. See section 7.3.1.14 in IEEE802.11e for more details.

1055

  //it'll not be used here. However, the device's max buffer size has to be enforced.

1056

  respHdr.SetBufferSize (1023);

1056

  uint16_t maxBufferSize = m_edca[QosUtilsMapTidToAc (respHdr.GetTid ())]->GetBlockAckManager ()->GetMaxBufferSize ();

1057

  uint16_t negotiatedBufferSize = maxBufferSize < 64 ? maxBufferSize : 64;

1058

  respHdr.SetBufferSize (negotiatedBufferSize - 1);

1057

  respHdr.SetTimeout (reqHdr->GetTimeout ());

1059

  respHdr.SetTimeout (reqHdr->GetTimeout ());

1058

1060

1059

  WifiActionHeader actionHdr;

1061

  WifiActionHeader actionHdr;

Lines 1257-1262 RegularWifiMac::GetTypeId (void)	Link Here

1257

                   PointerValue (),

1259

                   PointerValue (),

1258

                   MakePointerAccessor (&RegularWifiMac::GetBKQueue),

1260

                   MakePointerAccessor (&RegularWifiMac::GetBKQueue),

1259

                   MakePointerChecker<EdcaTxopN> ())

1261

                   MakePointerChecker<EdcaTxopN> ())

1262

    .AddAttribute ("MaxBlockAckBufferSize",

1263

                   "Maximum Block ACK buffer size that this device can support."

1264

                   "Will be configured in all BlockAckManagers of all EdcaTxopN instances.",

1265

                   UintegerValue (64),

1266

                   MakeUintegerAccessor (&RegularWifiMac::SetMaxBlockAckBufferSize),

1267

                   MakeUintegerChecker<uint16_t> (1, 1024))

1260

    .AddTraceSource ("TxOkHeader",

1268

    .AddTraceSource ("TxOkHeader",

1261

                     "The header of successfully transmitted packet.",

1269

                     "The header of successfully transmitted packet.",

1262

                     MakeTraceSourceAccessor (&RegularWifiMac::m_txOkCallback),

1270

                     MakeTraceSourceAccessor (&RegularWifiMac::m_txOkCallback),

Lines 1327-1332 RegularWifiMac::ConfigureContentionWindow (uint32_t cwMin, uint32_t cwMax)	Link Here

1327

1335

1328

1336

1329

void

1337

void

1338

RegularWifiMac::SetMaxBlockAckBufferSize (uint16_t maxBufferSize)

1339

1340

  NS_LOG_FUNCTION (this << maxBufferSize);

1341

  for (EdcaQueues::const_iterator i = m_edca.begin (); i != m_edca.end (); ++i)

1342

1343

      i->second->GetBlockAckManager ()->SetMaxBufferSize (maxBufferSize);

1344

1345

1346

1347

void

1330

RegularWifiMac::TxOk (const WifiMacHeader &hdr)

1348

RegularWifiMac::TxOk (const WifiMacHeader &hdr)

1331

1349

1332

  NS_LOG_FUNCTION (this << hdr);

1350

  NS_LOG_FUNCTION (this << hdr);

(-)a/src/wifi/model/regular-wifi-mac.h (+7 lines)

Lines 697-702 private:	Link Here

697

  void EnableAggregation (void);

697

  void EnableAggregation (void);

698

  /// Disable aggregation function

698

  /// Disable aggregation function

699

  void DisableAggregation (void);

699

  void DisableAggregation (void);

700

/**

701

   * Set the maximum Block ACK buffer size that this device can support.

702

   * Will be configured in all BlockAckManagers of all EdcaTxopN instances.

703

704

   * \param maxBufferSize the maximum Block ACK buffer size.

705

*/

706

  void SetMaxBlockAckBufferSize (uint16_t maxBufferSize);

700

707

701

  uint32_t m_voMaxAmsduSize; ///< maximum A-MSDU size for AC_VO

708

  uint32_t m_voMaxAmsduSize; ///< maximum A-MSDU size for AC_VO

702

  uint32_t m_viMaxAmsduSize; ///< maximum A-MSDU size for AC_VI

709

  uint32_t m_viMaxAmsduSize; ///< maximum A-MSDU size for AC_VI

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

Lines 101-106 AmpduAggregationTest::DoRun (void)	Link Here

101

  m_txMiddle = Create<MacTxMiddle> ();

101

  m_txMiddle = Create<MacTxMiddle> ();

102

  m_edca->SetTxMiddle (m_txMiddle);

102

  m_edca->SetTxMiddle (m_txMiddle);

103

  m_edca->CompleteConfig ();

103

  m_edca->CompleteConfig ();

104

  m_edca->m_baManager->SetMaxBufferSize (64);

104

105

/*

106

/*

106

   * Configure MPDU aggregation.

107

   * Configure MPDU aggregation.

Lines 137-142 AmpduAggregationTest::DoRun (void)	Link Here

137

  reqHdr.SetTimeout (0);

138

  reqHdr.SetTimeout (0);

138

  reqHdr.SetStartingSequence (0);

139

  reqHdr.SetStartingSequence (0);

139

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

140

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

141

  m_edca->m_baManager->NotifyAgreementEstablished (hdr.GetAddr1 (), 0, 0); //to force to established state

140

142

141

  //-----------------------------------------------------------------------------------------------------

143

  //-----------------------------------------------------------------------------------------------------

142

144

Return to bug 2870