Attachment #2288 for bug #2305

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




  NS_LOG_FUNCTION (this);
}

BlockAckManager::Item::Item (Ptr<const Packet> packet, const WifiMacHeader &hdr, Time tStamp, uint32_t nRetries)
  : packet (packet),
    hdr (hdr),
    timestamp (tStamp),
    nRetries (nRetries)
{
  NS_LOG_FUNCTION (this << packet << hdr << tStamp << nRetries);
}

Bar::Bar ()

}

void
BlockAckManager::StorePacket (Ptr<const Packet> packet, const WifiMacHeader &hdr, Time tStamp, uint32_t nRetries)
{
  NS_LOG_FUNCTION (this << packet << hdr << tStamp);
  NS_ASSERT (hdr.IsQosData ());

  uint8_t tid = hdr.GetQosTid ();
  Mac48Address recipient = hdr.GetAddr1 ();

  Item item (packet, hdr, tStamp, nRetries);
  AgreementsI it = m_agreements.find (std::make_pair (recipient, tid));
  NS_ASSERT (it != m_agreements.end ());
  PacketQueueI queueIt = it->second.second.begin ();

          packet = (*it)->packet->Copy ();
          hdr = (*it)->hdr;
          hdr.SetRetry ();
          NS_LOG_INFO ("Retry packet seq = " << hdr.GetSequenceNumber () << " nRetries = " << (*it)->nRetries);
          if (hdr.IsQosData ())
            {
              tid = hdr.GetQosTid ();



Ptr<const Packet>
BlockAckManager::PeekNextPacket (WifiMacHeader &hdr, Mac48Address recipient, uint8_t tid, Time *tstamp, uint32_t *nRetries)
{
  NS_LOG_FUNCTION (this);
  Ptr<const Packet> packet = 0;

          hdr = (*it)->hdr;
          hdr.SetRetry ();
          *tstamp = (*it)->timestamp;
          *nRetries = (*it)->nRetries;
          NS_LOG_INFO ("Retry packet seq = " << hdr.GetSequenceNumber () << " nRetries = " << (*it)->nRetries);
          Mac48Address recipient = hdr.GetAddr1 ();
          if (!agreement->second.first.IsHtSupported ()
              && (ExistsAgreementInState (recipient, tid, OriginatorBlockAckAgreement::ESTABLISHED)

                          (*it).second.first.SetStartingSequence (sequenceFirstLost);
                        }

                      if (!AlreadyExists ((*queueIt).hdr.GetSequenceNumber (), recipient, tid))
                        {
                          InsertInRetryQueue (queueIt);
                        }

                        {
                          m_txFailedCallback ((*queueIt).hdr);
                        }
                      if (!AlreadyExists ((*queueIt).hdr.GetSequenceNumber (), recipient, tid))
                        {
                          if ((*queueIt).nRetries >= m_stationManager->GetMaxSlrc ())
                            {
                              NS_LOG_INFO ("Remove packet with seq = " << (*queueIt).hdr.GetSequenceNumber ());
                              (*it).second.first.SetStartingSequence ((*queueIt).hdr.GetSequenceNumber ());
                              queueIt = it->second.second.erase (queueIt);
                            }
                          else
                            {
                              InsertInRetryQueue (queueIt);
                              queueIt++;
                            }
                        }
                      queueIt++;
                    }
                }
            }

BlockAckManager::InsertInRetryQueue (PacketQueueI item)
{
  NS_LOG_INFO ("Adding to retry queue " << (*item).hdr.GetSequenceNumber ());
  (*item).nRetries++;
  if (m_retryPackets.size () == 0)
    {
      m_retryPackets.push_back (item);




   * \param packet Packet to store.
   * \param hdr 802.11 header for packet.
   * \param tStamp time stamp for packet
   * \param nRetries number of retries for packet
   *
   * Stores <i>packet</i> for a possible future retransmission. Retransmission occurs
   * if the packet, in a block ack frame, is indicated by recipient as not received.
   */
  void StorePacket (Ptr<const Packet> packet, const WifiMacHeader &hdr, Time tStamp, uint32_t nRetries);
  /**
   * \param hdr 802.11 header of returned packet (if exists).
   *

  /*
   * Peek in retransmit queue and get the next packet without removing it from the queue
   */
  Ptr<const Packet> PeekNextPacket (WifiMacHeader &hdr, Mac48Address recipient, uint8_t tid, Time *timestamp, uint32_t *nRetries);
  /**
   * This function returns true if the lifetime of the packets a BAR refers to didn't expire yet else it returns false.
   * If it return false then the BAR will be discarded (i.e. will not be re-transmitted)

    Item ();
    Item (Ptr<const Packet> packet,
          const WifiMacHeader &hdr,
          Time tStamp,
          uint32_t nRetries);
    Ptr<const Packet> packet;
    WifiMacHeader hdr;
    Time timestamp;
    uint32_t nRetries;
  };
  /**
   * \param item




  {
    return m_txop->SetAmpduExist (ampdu);
  }
  virtual void CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp, uint32_t nRetries)
  {
    m_txop->CompleteMpduTx (packet, hdr, tstamp, nRetries);
  }
  virtual uint16_t GetNextSequenceNumberfor (WifiMacHeader *hdr)
  {

  {
    return m_txop->PeekNextSequenceNumberfor (hdr);
  }
  virtual Ptr<const Packet> PeekNextPacketInBaQueue (WifiMacHeader &header, Mac48Address recipient, uint8_t tid, Time *timestamp, uint32_t *nRetries)
  {
    return m_txop->PeekNextRetransmitPacket (header, recipient, tid, timestamp, nRetries);
  }
  virtual void RemoveFromBaQueue (uint8_t tid, Mac48Address recipient, uint16_t seqnumber)
  {

}

Ptr<const Packet>
EdcaTxopN::PeekNextRetransmitPacket (WifiMacHeader &header,Mac48Address recipient, uint8_t tid, Time *timestamp, uint32_t *nRetries)
{
  return m_baManager->PeekNextPacket (header,recipient,tid, timestamp, nRetries);
}

void

    {
      m_txOkCallback (m_currentHdr);
    }
  if (NeedBarRetransmission ())
    {
      if (!GetAmpduExist ())
        {
          //should i report this to station addressed by ADDR1?
          NS_LOG_DEBUG ("Retransmit block ack request");
          m_currentHdr.SetRetry ();
        }
      else
        {
          //standard says when loosing a BlockAck originator may send a BAR page 139
          NS_LOG_DEBUG ("Transmit Block Ack Request");
          CtrlBAckRequestHeader reqHdr;
          reqHdr.SetType (COMPRESSED_BLOCK_ACK);
          uint8_t tid = 0;
          if (m_currentHdr.IsQosData ())
            {
              tid = m_currentHdr.GetQosTid ();
              reqHdr.SetStartingSequence (m_currentHdr.GetSequenceNumber ());
            }
          else if (m_currentHdr.IsBlockAckReq ())
            {
              CtrlBAckRequestHeader baReqHdr;
              m_currentPacket->PeekHeader (baReqHdr);
              tid = baReqHdr.GetTidInfo ();
              reqHdr.SetStartingSequence (baReqHdr.GetStartingSequence ());
            }
          else if (m_currentHdr.IsBlockAck ())
            {
              CtrlBAckResponseHeader baRespHdr;
              m_currentPacket->PeekHeader (baRespHdr);
              tid = baRespHdr.GetTidInfo ();
              reqHdr.SetStartingSequence (m_currentHdr.GetSequenceNumber ());
            }
          reqHdr.SetTidInfo (tid);
          reqHdr.SetHtImmediateAck (true);
          Ptr<Packet> bar = Create<Packet> ();
          bar->AddHeader (reqHdr);
          Bar request (bar, m_currentHdr.GetAddr1 (), tid, reqHdr.MustSendHtImmediateAck ());
          m_currentBar = request;
          WifiMacHeader hdr;
          hdr.SetType (WIFI_MAC_CTL_BACKREQ);
          hdr.SetAddr1 (request.recipient);
          hdr.SetAddr2 (m_low->GetAddress ());
          hdr.SetAddr3 (m_low->GetBssid ());
          hdr.SetDsNotTo ();
          hdr.SetDsNotFrom ();
          hdr.SetNoRetry ();
          hdr.SetNoMoreFragments ();

          m_currentPacket = request.bar;
          m_currentHdr = hdr;
        }
      m_dcf->UpdateFailedCw ();
    }
  else
    {
      //to reset the dcf.
      m_currentPacket = 0;
      m_dcf->ResetCw ();
    }
  m_dcf->StartBackoffNow (m_rng->GetNext (0, m_dcf->GetCw ()));
  RestartAccessIfNeeded ();
}

    {
      if (!m_currentHdr.IsRetry ())
        {
          m_baManager->StorePacket (m_currentPacket, m_currentHdr, m_currentPacketTimestamp, 0);
        }
      m_baManager->NotifyMpduTransmission (m_currentHdr.GetAddr1 (), m_currentHdr.GetQosTid (),
                                           m_txMiddle->GetNextSeqNumberByTidAndAddress (m_currentHdr.GetQosTid (),

}

void
EdcaTxopN::CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp, uint32_t nRetries)
{
  NS_ASSERT (hdr.IsQosData ());
  m_baManager->StorePacket (packet, hdr, tstamp, nRetries);
  m_baManager->NotifyMpduTransmission (hdr.GetAddr1 (), hdr.GetQosTid (),
                                       m_txMiddle->GetNextSeqNumberByTidAndAddress (hdr.GetQosTid (),
                                                                                    hdr.GetAddr1 ()), WifiMacHeader::NORMAL_ACK);

(-)a/src/wifi/model/edca-txop-n.h (-2 / +2 lines)

Lines 407-413	Link Here

407

408

  void SetBlockAckInactivityTimeout (uint16_t timeout);

408

  void SetBlockAckInactivityTimeout (uint16_t timeout);

409

  void SendDelbaFrame (Mac48Address addr, uint8_t tid, bool byOriginator);

409

  void SendDelbaFrame (Mac48Address addr, uint8_t tid, bool byOriginator);

410

  void CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp);

410

  void CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp, uint32_t nRetries);

411

  bool GetAmpduExist (void);

411

  bool GetAmpduExist (void);

412

  void SetAmpduExist (bool ampdu);

412

  void SetAmpduExist (bool ampdu);

413

Lines 434-440	Link Here

434

/*

434

/*

435

   * Peek in retransmit queue and get the next packet without removing it from the queue

435

   * Peek in retransmit queue and get the next packet without removing it from the queue

436

*/

436

*/

437

  Ptr<const Packet> PeekNextRetransmitPacket (WifiMacHeader &header, Mac48Address recipient, uint8_t tid, Time *timestamp);

437

  Ptr<const Packet> PeekNextRetransmitPacket (WifiMacHeader &header, Mac48Address recipient, uint8_t tid, Time *timestamp, uint32_t *nRetries);

438

/**

438

/**

439

   * The packet we sent was successfully received by the receiver

439

   * The packet we sent was successfully received by the receiver

440




{
}
void
MacLowAggregationCapableTransmissionListener::CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp, uint32_t nRetries)
{
}
uint16_t

  return 0;
}
Ptr<const Packet>
MacLowAggregationCapableTransmissionListener::PeekNextPacketInBaQueue (WifiMacHeader &header, Mac48Address recipient, uint8_t tid, Time *timestamp, uint32_t *nRetries)
{
  return 0;
}

          AcIndex ac = QosUtilsMapTidToAc (tid);
          std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac);

          listenerIt->second->CompleteMpduTx (m_txPackets.at (i).packet, m_txPackets.at (i).hdr, m_txPackets.at (i).timestamp, m_txPackets.at (i).nRetries);
        }
      m_txPackets.clear ();
    }

  if (hdr.IsQosData () || hdr.IsBlockAck ()|| hdr.IsBlockAckReq ())
    {
      Time tstamp;
      uint32_t nRetries;
      uint8_t tid = GetTid (packet, hdr);
      Ptr<WifiMacQueue> queue;
      AcIndex ac = QosUtilsMapTidToAc (tid);

              aggregated = false;
              bool retry = false;
              //looks for other packets to the same destination with the same Tid need to extend that to include MSDUs
              Ptr<const Packet> peekedPacket = listenerIt->second->PeekNextPacketInBaQueue (peekedHdr, peekedHdr.GetAddr1 (), tid, &tstamp, &nRetries);
              if (peekedPacket == 0)
                {
                  peekedPacket = queue->PeekByTidAndAddress (&peekedHdr, tid,

                      peekedHdr.SetFragmentNumber (0);
                      peekedHdr.SetNoMoreFragments ();
                      peekedHdr.SetNoRetry ();
                      nRetries = 0;
                    }
                  if (qosPolicy == 0)
                    {

                        {
                          if (!m_txParams.MustSendRts ())
                            {
                              listenerIt->second->CompleteMpduTx (packet, hdr, tstamp, nRetries);
                            }
                          else
                            {
                              InsertInTxQueue (packet, hdr, tstamp, nRetries);
                            }
                        }
                      NS_LOG_DEBUG ("Adding packet with Sequence number " << peekedHdr.GetSequenceNumber () << " to A-MPDU, packet size = " << newPacket->GetSize () << ", A-MPDU size = " << currentAggregatedPacket->GetSize ());

                      m_sentMpdus++;
                      if (!m_txParams.MustSendRts ())
                        {
                          listenerIt->second->CompleteMpduTx (peekedPacket, peekedHdr, tstamp, nRetries);
                        }
                      else
                        {
                          InsertInTxQueue (peekedPacket, peekedHdr, tstamp, nRetries);
                        }
                      if (retry)
                        {

                    }
                  if (retry == true)
                    {
                      peekedPacket = listenerIt->second->PeekNextPacketInBaQueue (peekedHdr, hdr.GetAddr1 (), tid, &tstamp, &nRetries);
                      if (peekedPacket == 0)
                        {
                          //I reached the first packet that I added to this A-MPDU

}

void
MacLow::InsertInTxQueue (Ptr<const Packet> packet, const WifiMacHeader &hdr, Time tStamp, uint32_t nRetries)
{
  Item item;

  item.packet = packet;
  item.hdr = hdr;
  item.timestamp = tStamp;
  item.nRetries = nRetries;

  m_txPackets.push_back (item);
}




   * for a blockack containing the sequence number of this MPDU).
   * It also calls NotifyMpdu transmission that updates the status of OriginatorBlockAckAgreement.
   */
  virtual void CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp, uint32_t nRetries);
  /**
   * Return the next sequence number for the given header.
   *

  /*
   * Peek in retransmit queue and get the next packet without removing it from the queue
   */
  virtual Ptr<const Packet> PeekNextPacketInBaQueue (WifiMacHeader &header, Mac48Address recipient, uint8_t tid, Time *timestamp, uint32_t *nRetries);
  /**
   * Remove a packet after you peek in the retransmit queue and get it
   */

   * Insert in a temporary queue.
   * It is only used with a RTS/CTS exchange for an A-MPDU transmission.
   */
  void InsertInTxQueue (Ptr<const Packet> packet, const WifiMacHeader &hdr, Time tStamp, uint32_t nRetries);
  /**
   * Perform MSDU aggregation for a given MPDU in an A-MPDU
   *

    Ptr<const Packet> packet;
    WifiMacHeader hdr;
    Time timestamp;
    uint32_t nRetries;
  } Item;

  /**

Return to bug 2305