Attachment #1990 for bug #2075

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




      if (GetAmpduExist())
        {
          m_low->FlushAggregateQueue ();
          
          NS_LOG_DEBUG ("Transmit Block Ack Request");
          CtrlBAckRequestHeader reqHdr;
          reqHdr.SetType (COMPRESSED_BLOCK_ACK);
          uint8_t tid = m_currentHdr.GetQosTid ();
          reqHdr.SetStartingSequence (m_txMiddle->PeekNextSequenceNumberfor (&m_currentHdr));
          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;
        }
      else
        {
          m_currentPacket = 0;
        }
      // to reset the dcf.
      m_currentPacket = 0;
      m_dcf->ResetCw ();
    }
  else




      m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                      rxSnr, txMode, tag.Get ());
        
      FlushAggregateQueue();
      bool gotAck = false;
      if (m_txParams.MustWaitNormalAck ()
          && m_normalAckTimeoutEvent.IsRunning ())

      m_listener->GotBlockAck (&blockAck, hdr.GetAddr2 (),txMode);
      m_sentMpdus = 0;
      m_ampdu = false;
      FlushAggregateQueue();
    }
  else if (hdr.IsBlockAckReq () && hdr.GetAddr1 () == m_self)
    {

  m_listener = 0;
  m_sentMpdus = 0;
  m_ampdu = false;
  FlushAggregateQueue();
  listener->MissedAck ();
}
void

  m_listener = 0;
  m_sentMpdus = 0;
  m_ampdu = false;
  FlushAggregateQueue();
  listener->MissedBlockAck ();
}
void

  NS_ASSERT (m_currentPacket != 0);
  WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr);
  
  if (m_aggregateQueue->GetSize () != 0)
  {
    for(int i = 0; i < m_txPackets.size(); i++)
    {
      uint8_t tid = GetTid (m_txPackets.at(i).packet, m_txPackets.at(i).hdr);
      AcIndex ac = QosUtilsMapTidToAc (tid);
      std::map<AcIndex, MacLowBlockAckEventListener*>::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.clear ();
  }
  
  WifiPreamble preamble;       
  if (m_phy->GetGreenfield() && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
     //In the future has to make sure that receiver has greenfield enabled

                      m_aggregateQueue->Enqueue (aggPacket, peekedHdr);
                      if (i == 1 && hdr.IsQosData ())
                      {
                        if (!m_txParams.MustSendRts ())
                        {
                          listenerIt->second->CompleteMpduTx (packet, hdr, tstamp);
                        }
                        else
                        {
                          InsertInTxQueue (packet, hdr, tstamp);
                        }
                      }
                      NS_LOG_DEBUG ("Adding packet with Sequence number " << peekedHdr.GetSequenceNumber()<<" to A-MPDU");
                      i++;
                      isAmpdu = true;
                      m_sentMpdus++;
                      if (!m_txParams.MustSendRts ())
                      {
                        listenerIt->second->CompleteMpduTx (peekedPacket, peekedHdr, tstamp);
                      }
                      else
                      {
                        InsertInTxQueue (peekedPacket, peekedHdr, tstamp);
                      }
                      if (retry)
                          listenerIt->second->RemoveFromBaQueue(tid, hdr.GetAddr1 (), peekedHdr.GetSequenceNumber ());
                      else

{
  NS_LOG_DEBUG("Flush aggregate queue");
  m_aggregateQueue->Flush ();
  m_txPackets.clear ();
}

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

  m_txPackets.push_back (item);
}

} // namespace ns3

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

Lines 1242-1251	Link Here

1242

1243

*/

1243

*/

1244

  bool IsAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr);

1244

  bool IsAmpdu (Ptr<const Packet> packet, const WifiMacHeader hdr);

1245

/**

1246

   * Insert in a temporary queue.

1247

   * It is only used with a RTS/CTS exchange for an A-MPDU transmission.

1248

*/

1249

  void InsertInTxQueue (Ptr<const Packet> packet, const WifiMacHeader &hdr, Time tStamp);

1245

1250

1246

  Ptr<WifiPhy> m_phy; //!< Pointer to WifiPhy (actually send/receives frames)

1251

  Ptr<WifiPhy> m_phy; //!< Pointer to WifiPhy (actually send/receives frames)

1247

  Ptr<WifiRemoteStationManager> m_stationManager; //!< Pointer to WifiRemoteStationManager (rate control)

1252

  Ptr<WifiRemoteStationManager> m_stationManager; //!< Pointer to WifiRemoteStationManager (rate control)

1248

  MacLowRxCallback m_rxCallback; //!< Callback to pass packet up

1253

  MacLowRxCallback m_rxCallback; //!< Callback to pass packet up

1254

1255

/**

1256

   * A struct for packet, Wifi header, and timestamp.

1257

*/

1258

  typedef struct

1259

1260

    Ptr<const Packet> packet;

1261

    WifiMacHeader hdr;

1262

    Time timestamp;

1263

  } Item;

1264

1249

/**

1265

/**

1250

   * typedef for an iterator for a list of MacLowDcfListener.

1266

   * typedef for an iterator for a list of MacLowDcfListener.

1251

*/

1267

*/

Lines 1320-1325	Link Here

1320

  Ptr<WifiMacQueue> m_aggregateQueue; //!< Queue used for MPDU aggregation

1336

  Ptr<WifiMacQueue> m_aggregateQueue; //!< Queue used for MPDU aggregation

1321

  WifiMode m_currentMode;             //!< mode used for the current packet transmission

1337

  WifiMode m_currentMode;             //!< mode used for the current packet transmission

1322

  bool m_receivedAtLeastOneMpdu;      //!< Flag whether an MPDU has already been successfully received while receiving an A-MPDU

1338

  bool m_receivedAtLeastOneMpdu;      //!< Flag whether an MPDU has already been successfully received while receiving an A-MPDU

1339

  std::vector<Item> m_txPackets;      //!< Contain temporary items to be sent with the next A-MPDU transmission, once RTS/CTS exchange has succeeded. It is not used in other cases.

1323

};

1340

};

1324

1341

1325

} // namespace ns3

1342

} // namespace ns3

Return to bug 2075