ns-3.24: comparison src/wifi/model/mac-low.cc

equal deleted inserted replaced

-:adba3fdac443
+:af3a3d5dcc21
 {
 }
 MacLowDcfListener::~MacLowDcfListener ()
 {
 }
 MacLowAggregationCapableTransmissionListener::MacLowAggregationCapableTransmissionListener ()
 {
 }
 MacLowAggregationCapableTransmissionListener::~MacLowAggregationCapableTransmissionListener ()
 {
 }
 void MacLowAggregationCapableTransmissionListener::SetAmpdu (bool ampdu)
 {
 }
 void MacLowAggregationCapableTransmissionListener::CompleteTransfer(Mac48Address address, uint8_t tid)
 {
 m_sendCtsEvent.Cancel ();
 m_sendAckEvent.Cancel ();
 m_sendDataEvent.Cancel ();
 m_waitSifsEvent.Cancel ();
 m_endTxNoAckEvent.Cancel ();
 m_waitRifsEvent.Cancel();
 m_phy = 0;
 m_stationManager = 0;
 if (m_phyMacLowListener != 0)
 {
 	  delete m_phyMacLowListener;
 m_phy = phy;
 m_phy->SetReceiveOkCallback (MakeCallback (&MacLow::DeaggregateAmpduAndReceive, this));
 m_phy->SetReceiveErrorCallback (MakeCallback (&MacLow::ReceiveError, this));
 SetupPhyMacLowListener (phy);
 }
 Ptr<WifiPhy>
 MacLow::GetPhy (void) const
 {
 return m_phy;
 }
 void
 MacLow::ResetPhy (void)
 {
 m_phy->SetReceiveOkCallback (MakeNullCallback<void,Ptr<Packet>, double, WifiTxVector, enum WifiPreamble>  ());
 m_phy->SetReceiveErrorCallback (MakeNullCallback<void,Ptr<const Packet>, double> ());
 RemovePhyMacLowListener (m_phy);
 m_phy = 0;
 }
 void
 MacLow::SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> manager)
 {
 m_stationManager = manager;
 }
 void
 MacLow::SetAddress (Mac48Address ad)
 {
 m_self = ad;
 }
 void
 MacLow::SetAckTimeout (Time ackTimeout)
 {
 m_ackTimeout = ackTimeout;
 }
 void
 MacLow::SetBasicBlockAckTimeout (Time blockAckTimeout)
 {
 m_basicBlockAckTimeout = blockAckTimeout;
 }
 void
 MacLow::SetCompressedBlockAckTimeout (Time blockAckTimeout)
 {
 m_compressedBlockAckTimeout = blockAckTimeout;
 }
 void
 MacLow::SetCtsToSelfSupported (bool enable)
 {
 m_ctsToSelfSupported = enable;
 }
 bool
 MacLow::GetCtsToSelfSupported () const
 {
 return m_ctsToSelfSupported;
 }
 void
 MacLow::SetCtsTimeout (Time ctsTimeout)
 {
 m_ctsTimeout = ctsTimeout;
 }
 void
 MacLow::SetSifs (Time sifs)
 {
 m_sifs = sifs;
 }
 void
 MacLow::SetSlotTime (Time slotTime)
 {
 m_slotTime = slotTime;
 }
 void
 MacLow::SetPifs (Time pifs)
 {
 m_pifs = pifs;
 }
 void
 MacLow::SetRifs (Time rifs)
 {
 m_rifs = rifs;
 }
 void
 MacLow::SetBssid (Mac48Address bssid)
 {
 m_bssid = bssid;
 }
 void
 MacLow::SetPromisc (void)
 {
 m_promisc = true;
 }
 Mac48Address
 MacLow::GetAddress (void) const
 {
 return m_self;
 }
 Time
 MacLow::GetAckTimeout (void) const
 {
 return m_ackTimeout;
 }
 Time
 MacLow::GetBasicBlockAckTimeout () const
 {
 return m_basicBlockAckTimeout;
 }
 Time
 MacLow::GetCompressedBlockAckTimeout () const
 {
 return m_compressedBlockAckTimeout;
 }
 Time
 MacLow::GetCtsTimeout (void) const
 {
 return m_ctsTimeout;
 }
 Time
 MacLow::GetSifs (void) const
 {
 return m_sifs;
 }
 Time
 MacLow::GetRifs (void) const
 {
 return m_rifs;
 }
 Time
 MacLow::GetSlotTime (void) const
 {
 return m_slotTime;
 }
 Time
 MacLow::GetPifs (void) const
 {
 return m_pifs;
 }
 Mac48Address
 MacLow::GetBssid (void) const
 {
 return m_bssid;
 }
 bool
 MacLow::IsPromisc (void) const
 {
 return m_promisc;
 }
 void
-MacLow::SetRxCallback (Callback<void,Ptr<Packet>,const WifiMacHeader *> callback)
+MacLow::SetRxCallback (Callback<void, Ptr<Packet>, const WifiMacHeader *> callback)
 {
 m_rxCallback = callback;
 }
 void
 MacLow::RegisterDcfListener (MacLowDcfListener *listener)
 {
 m_dcfListeners.push_back (listener);
 }
 *   - ctsTimeout
 *   - sendDataAfterCTS
 * expired. This means that one of these timers is still
 * running. They are all cancelled below anyway by the
 * call to CancelAllEvents (because of at least one
-* of these two timer) which will trigger a call to the
+* of these two timers) which will trigger a call to the
 * previous listener's cancel method.
 *
 * This typically happens because the high-priority
 * QapScheduler has taken access to the channel from
 * one of the Edca of the QAP.
 */
 m_currentHdr = *hdr;
 CancelAllEvents ();
 m_listener = listener;
 m_txParams = params;
-//NS_ASSERT (m_phy->IsStateIdle ());
 if(m_aggregateQueue->GetSize () == 0)
 {
 m_currentPacket = packet->Copy ();
 m_ampdu = IsAmpdu (m_currentPacket, m_currentHdr);
 }
 /* When this method completes, we have taken ownership of the medium. */
 NS_ASSERT (m_phy->IsStateTx ());
 }
 bool
 MacLow::NeedCtsToSelf (void)
 {
 WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr);
 return m_stationManager->NeedCtsToSelf (dataTxVector);
 }
 void
 MacLow::ReceiveError (Ptr<const Packet> packet, double rxSnr)
 {
 NS_LOG_FUNCTION (this << packet << rxSnr);
 NS_LOG_DEBUG ("rx failed ");
 Ptr<Packet> pkt = packet->Copy();
 bool isInAmpdu = pkt->RemovePacketTag(ampdu);
 if(isInAmpdu && m_receivedAtLeastOneMpdu && (ampdu.GetNoOfMpdus() == 1))
 {
-MpduAggregator::DeaggregatedMpdus packets =  MpduAggregator::Deaggregate (pkt);
+MpduAggregator::DeaggregatedMpdus packets = MpduAggregator::Deaggregate (pkt);
 MpduAggregator::DeaggregatedMpdusCI n = packets.begin ();
 WifiMacHeader hdr;
 (*n).first->PeekHeader(hdr);
 if(hdr.IsQosData())
 {
 NS_LOG_DEBUG ("last a-mpdu subframe detected/sendImmediateBlockAck from=" << hdr.GetAddr2 ());
 m_sendAckEvent = Simulator::Schedule (GetSifs (),
 &MacLow::SendBlockAckAfterAmpdu, this,
-hdr.GetQosTid(),
+hdr.GetQosTid (),
 hdr.GetAddr2 (),
 hdr.GetDuration (),
 m_currentTxVector);
 }
 else if (hdr.IsBlockAckReq())
 {
-	  NS_LOG_DEBUG("last a-mpdu subframe is BAR");
+	      NS_LOG_DEBUG("last a-mpdu subframe is BAR");
 	}
 m_receivedAtLeastOneMpdu = false;
 }
 else if (m_txParams.MustWaitFastAck ())
 {
 NS_ASSERT (m_fastAckFailedTimeoutEvent.IsExpired ());
 * idle. If the NAV at the STA receiving the RTS indicates the medium is not idle,
 * that STA shall not respond to the RTS frame.
 */
 if (ampduSubframe)
 {
 NS_FATAL_ERROR ("Received RTS as part of an A-MPDU");
 }
 else
 {
 if (isPrevNavZero
 && hdr.GetAddr1 () == m_self)
 {
 if (ampduSubframe)
 {
 NS_FATAL_ERROR ("Received CTS as part of an A-MPDU");
 }
 NS_LOG_DEBUG ("receive cts from=" << m_currentHdr.GetAddr1 ());
 SnrTag tag;
 packet->RemovePacketTag (tag);
 m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
 rxSnr, txVector.GetMode ());
 m_stationManager->ReportRtsOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
 m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
 rxSnr, txVector.GetMode ());
 m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
 rxSnr, txVector.GetMode (), tag.Get ());
-FlushAggregateQueue();
+FlushAggregateQueue ();
 bool gotAck = false;
 if (m_txParams.MustWaitNormalAck ()
 && m_normalAckTimeoutEvent.IsRunning ())
 {
 m_normalAckTimeoutEvent.Cancel ();
 NotifyAckTimeoutResetNow ();
 m_blockAckTimeoutEvent.Cancel ();
 NotifyAckTimeoutResetNow ();
 m_listener->GotBlockAck (&blockAck, hdr.GetAddr2 (), txVector.GetMode ());
 m_sentMpdus = 0;
 m_ampdu = false;
-FlushAggregateQueue();
+FlushAggregateQueue ();
 }
 else if (hdr.IsBlockAckReq () && hdr.GetAddr1 () == m_self)
 {
 CtrlBAckRequestHeader blockAckReq;
 packet->RemoveHeader (blockAckReq);
 NS_LOG_DEBUG ("rx unicast/noAck from=" << hdr.GetAddr2 ());
 }
 }
 else if (hdr.IsData () || hdr.IsMgt ())
 {
-if (hdr.IsMgt() && ampduSubframe)
+if (hdr.IsMgt () && ampduSubframe)
 {
 NS_FATAL_ERROR ("Received management packet as part of an A-MPDU");
 }
 else
 {
 tid = hdr.GetQosTid ();
 else if (hdr.IsBlockAckReq ())
 {
 CtrlBAckRequestHeader baReqHdr;
 packet->PeekHeader (baReqHdr);
-tid = baReqHdr.GetTidInfo();
+tid = baReqHdr.GetTidInfo ();
 }
 else if (hdr.IsBlockAck ())
 {
 CtrlBAckResponseHeader baRespHdr;
 packet->PeekHeader (baRespHdr);
 {
 WifiMacHeader ack;
 ack.SetType (WIFI_MAC_CTL_ACK);
 return ack.GetSize () + 4;
 }
 uint32_t
 MacLow::GetBlockAckSize (enum BlockAckType type) const
 {
 WifiMacHeader hdr;
 hdr.SetType (WIFI_MAC_CTL_BACKRESP);
 //Not implemented
 NS_ASSERT (false);
 }
 return hdr.GetSize () + blockAck.GetSerializedSize () + 4;
 }
 uint32_t
 MacLow::GetRtsSize (void) const
 {
 WifiMacHeader rts;
 rts.SetType (WIFI_MAC_CTL_RTS);
 return rts.GetSize () + 4;
 }
 Time
 MacLow::GetAckDuration (Mac48Address to, WifiTxVector dataTxVector) const
 {
 WifiTxVector ackTxVector = GetAckTxVectorForData (to, dataTxVector.GetMode ());
 return GetAckDuration (ackTxVector);
 }
 Time
 MacLow::GetAckDuration (WifiTxVector ackTxVector) const
 {
 NS_ASSERT (ackTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); // ACK should always use non-HT PPDU (HT PPDU cases not supported yet)
 return m_phy->CalculateTxDuration (GetAckSize (), ackTxVector, WIFI_PREAMBLE_LONG, m_phy->GetFrequency(), 0, 0);
 }
 Time
 MacLow::GetBlockAckDuration (Mac48Address to, WifiTxVector blockAckReqTxVector, enum BlockAckType type) const
 {
 /*
 * For immediate Basic BlockAck we should transmit the frame with the same WifiMode
 * as the BlockAckReq.
 */
 WifiPreamble preamble;
 if (blockAckReqTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT && type == BASIC_BLOCK_ACK)
-preamble= WIFI_PREAMBLE_HT_MF;
+preamble = WIFI_PREAMBLE_HT_MF;
 else
-preamble=WIFI_PREAMBLE_LONG;
+preamble = WIFI_PREAMBLE_LONG;
-return m_phy->CalculateTxDuration (GetBlockAckSize (type), blockAckReqTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+return m_phy->CalculateTxDuration (GetBlockAckSize (type), blockAckReqTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 }
 Time
 MacLow::GetCtsDuration (Mac48Address to, WifiTxVector rtsTxVector) const
 {
 WifiTxVector ctsTxVector = GetCtsTxVectorForRts (to, rtsTxVector.GetMode ());
 return GetCtsDuration (ctsTxVector);
 Time
 MacLow::GetCtsDuration (WifiTxVector ctsTxVector) const
 {
 NS_ASSERT (ctsTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); // CTS should always use non-HT PPDU (HT PPDU cases not supported yet)
-return m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, WIFI_PREAMBLE_LONG, m_phy->GetFrequency(), 0, 0);
+return m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, WIFI_PREAMBLE_LONG, m_phy->GetFrequency (), 0, 0);
 }
 uint32_t
 MacLow::GetCtsSize (void) const
 {
 WifiMacHeader cts;
 cts.SetType (WIFI_MAC_CTL_CTS);
 return cts.GetSize () + 4;
 }
 uint32_t
 MacLow::GetSize (Ptr<const Packet> packet, const WifiMacHeader *hdr) const
 {
 uint32_t size;
 WifiMacTrailer fcs;
 MacLow::GetRtsTxVector (Ptr<const Packet> packet, const WifiMacHeader *hdr) const
 {
 Mac48Address to = hdr->GetAddr1 ();
 return m_stationManager->GetRtsTxVector (to, hdr, packet);
 }
 WifiTxVector
 MacLow::GetDataTxVector (Ptr<const Packet> packet, const WifiMacHeader *hdr) const
 {
 Mac48Address to = hdr->GetAddr1 ();
 WifiMacTrailer fcs;
 uint32_t size =  packet->GetSize ()+ hdr->GetSize () + fcs.GetSerializedSize ();
 //size is not used in anything!! will not worry about aggregation
 return m_stationManager->GetDataTxVector (to, hdr, packet, size);
 }
 WifiTxVector
 MacLow::GetCtsTxVector (Mac48Address to, WifiMode rtsTxMode) const
 {
 return m_stationManager->GetCtsTxVector (to, rtsTxMode);
 }
 WifiTxVector
 MacLow::GetAckTxVector (Mac48Address to, WifiMode dataTxMode) const
 {
 return m_stationManager->GetAckTxVector (to, dataTxMode);
 }
 WifiTxVector
 MacLow::GetBlockAckTxVector (Mac48Address to, WifiMode dataTxMode) const
 {
 return m_stationManager->GetBlockAckTxVector (to, dataTxMode);
 }
 WifiTxVector
 MacLow::GetCtsTxVectorForRts (Mac48Address to, WifiMode rtsTxMode) const
 {
 return GetCtsTxVector (to, rtsTxMode);
 }
 WifiTxVector
 MacLow::GetAckTxVectorForData (Mac48Address to, WifiMode dataTxMode) const
 {
 return GetAckTxVector (to, dataTxMode);
 }
 Time
 MacLow::CalculateOverallTxTime (Ptr<const Packet> packet,
 const WifiMacHeader* hdr,
 const MacLowTransmissionParameters& params) const
 else
 {
 //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet)
 preamble = WIFI_PREAMBLE_LONG;
 }
-txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 txTime += GetCtsDuration (hdr->GetAddr1 (), rtsTxVector);
 txTime += Time (GetSifs () * 2);
 }
 WifiTxVector dataTxVector = GetDataTxVector (packet, hdr);
 if (m_phy->GetGreenfield () && m_stationManager->GetGreenfieldSupported (m_currentHdr.GetAddr1 ()))
 preamble = WIFI_PREAMBLE_HT_GF;
-else if (dataTxVector.GetMode().GetModulationClass () == WIFI_MOD_CLASS_HT)
+else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
 preamble = WIFI_PREAMBLE_HT_MF;
 else
 preamble = WIFI_PREAMBLE_LONG;
 uint32_t dataSize = GetSize (packet, hdr);
-txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 if (params.MustWaitAck ())
 {
 txTime += GetSifs ();
 txTime += GetAckDuration (hdr->GetAddr1 (), dataTxVector);
 }
 else if (dataTxVector.GetMode().GetModulationClass () == WIFI_MOD_CLASS_HT)
 preamble = WIFI_PREAMBLE_HT_MF;
 else
 preamble = WIFI_PREAMBLE_LONG;
 txTime += GetSifs ();
-txTime += m_phy->CalculateTxDuration (params.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+txTime += m_phy->CalculateTxDuration (params.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 }
 return txTime;
 }
 void
 */
 WifiMacHeader cts;
 cts.SetType (WIFI_MAC_CTL_CTS);
 WifiTxVector txVector=GetRtsTxVector (packet, &hdr);
 Time navCounterResetCtsMissedDelay =
-m_phy->CalculateTxDuration (cts.GetSerializedSize (), txVector, preamble, m_phy->GetFrequency(), 0, 0) +
+m_phy->CalculateTxDuration (cts.GetSerializedSize (), txVector, preamble, m_phy->GetFrequency (), 0, 0) +
 Time (2 * GetSifs ()) + Time (2 * GetSlotTime ());
 m_navCounterResetCtsMissed = Simulator::Schedule (navCounterResetCtsMissedDelay,
 &MacLow::NavCounterResetCtsMissed, this,
 Simulator::Now ());
 }
 (*i)->NavReset (duration);
 }
 m_lastNavStart = Simulator::Now ();
 m_lastNavStart = duration;
 }
 bool
 MacLow::DoNavStartNow (Time duration)
 {
 for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++)
 {
 m_lastNavDuration = duration;
 return true;
 }
 return false;
 }
 void
 MacLow::NotifyAckTimeoutStartNow (Time duration)
 {
 for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++)
 {
 (*i)->AckTimeoutStart (duration);
 }
 }
 void
 MacLow::NotifyAckTimeoutResetNow ()
 {
 for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++)
 {
 (*i)->AckTimeoutReset ();
 }
 }
 void
 MacLow::NotifyCtsTimeoutStartNow (Time duration)
 {
 for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++)
 {
 (*i)->CtsTimeoutStart (duration);
 }
 }
 void
 MacLow::NotifyCtsTimeoutResetNow ()
 {
 for (DcfListenersCI i = m_dcfListeners.begin (); i != m_dcfListeners.end (); i++)
 {
 {
 Ptr<Packet> newPacket;
 Ptr <const Packet> dequeuedPacket;
 WifiMacHeader newHdr;
 WifiMacTrailer fcs;
 uint32_t queueSize = m_aggregateQueue->GetSize ();
 bool last = false;
 uint8_t packetType = 0;
 //Add packet tag
 AmpduTag ampdutag;
 ampdutag.SetAmpdu (true);
 else
 {
 Simulator::Schedule (delay, &MacLow::SendPacket, this, newPacket, txVector, preamble, packetType);
 }
 if(queueSize > 1)
-delay = delay + m_phy->CalculateTxDuration (GetSize (newPacket, &newHdr), txVector, preamble, m_phy->GetFrequency(), packetType, 0);
+delay = delay + m_phy->CalculateTxDuration (GetSize (newPacket, &newHdr), txVector, preamble, m_phy->GetFrequency (), packetType, 0);
 preamble = WIFI_PREAMBLE_NONE;
 }
 }
 }
 m_listener = 0;
 m_sentMpdus = 0;
 m_ampdu = false;
 listener->MissedCts ();
 }
 void
 MacLow::NormalAckTimeout (void)
 {
 NS_LOG_FUNCTION (this);
 NS_LOG_DEBUG ("normal ack timeout");
 m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 MacLowTransmissionListener *listener = m_listener;
 m_listener = 0;
 m_sentMpdus = 0;
 m_ampdu = false;
-FlushAggregateQueue();
+FlushAggregateQueue ();
 listener->MissedAck ();
 }
 void
 MacLow::FastAckTimeout (void)
 {
 NS_LOG_FUNCTION (this);
 m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 else
 {
 NS_LOG_DEBUG ("fast Ack ok");
 }
 }
 void
 MacLow::BlockAckTimeout (void)
 {
 NS_LOG_FUNCTION (this);
 NS_LOG_DEBUG ("block ack timeout");
 m_sentMpdus = 0;
 m_ampdu = false;
 FlushAggregateQueue();
 listener->MissedBlockAck ();
 }
 void
 MacLow::SuperFastAckTimeout ()
 {
 NS_LOG_FUNCTION (this);
 m_stationManager->ReportDataFailed (m_currentHdr.GetAddr1 (), &m_currentHdr);
 WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr);
 duration += GetSifs ();
 duration += GetCtsDuration (m_currentHdr.GetAddr1 (), rtsTxVector);
 duration += GetSifs ();
 duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr),
-dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 duration += GetSifs ();
 if (m_txParams.MustWaitBasicBlockAck ())
 {
-WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2(), dataTxVector.GetMode  ());
+WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ());
 duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, BASIC_BLOCK_ACK);
 }
 else if (m_txParams.MustWaitCompressedBlockAck ())
 {
-WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2(), dataTxVector.GetMode  ());
+WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ());
 duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
 }
 else if (m_txParams.MustWaitAck ())
 {
 duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector);
 }
 if (m_txParams.HasNextPacket ())
 {
 duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
-dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 if (m_txParams.MustWaitAck ())
 {
 duration += GetSifs ();
 duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector);
 }
 }
 }
 rts.SetDuration (duration);
-Time txDuration = m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+Time txDuration = m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 Time timerDelay = txDuration + GetCtsTimeout ();
 NS_ASSERT (m_ctsTimeoutEvent.IsExpired ());
 NotifyCtsTimeoutStartNow (timerDelay);
 m_ctsTimeoutEvent = Simulator::Schedule (timerDelay, &MacLow::CtsTimeout, this);
 else if (dataTxVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT)
 preamble = WIFI_PREAMBLE_HT_MF;
 else
 preamble = WIFI_PREAMBLE_LONG;
-Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 if (m_txParams.MustWaitNormalAck ())
 {
 Time timerDelay = txDuration + GetAckTimeout ();
 NS_ASSERT (m_normalAckTimeoutEvent.IsExpired ());
 NotifyAckTimeoutStartNow (timerDelay);
 }
 if (m_txParams.HasNextPacket ())
 {
 duration += GetSifs ();
 duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
-dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 if (m_txParams.MustWaitAck ())
 {
 duration += GetSifs ();
 duration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector);
 }
 else
 {
 WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr);
 duration += GetSifs ();
 duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket,&m_currentHdr),
-dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 if (m_txParams.MustWaitBasicBlockAck ())
 {
 duration += GetSifs ();
 WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ());
 }
 if (m_txParams.HasNextPacket ())
 {
 duration += GetSifs ();
 duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
-dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 if (m_txParams.MustWaitCompressedBlockAck ())
 {
 duration += GetSifs ();
 WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ());
 duration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
 WifiMacTrailer fcs;
 packet->AddTrailer (fcs);
 ForwardDown (packet, &cts, ctsTxVector,preamble);
-Time txDuration = m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+Time txDuration = m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 txDuration += GetSifs ();
 NS_ASSERT (m_sendDataEvent.IsExpired ());
 m_sendDataEvent = Simulator::Schedule (txDuration,
 &MacLow::SendDataAfterCts, this,
 {
 for (std::vector<Item>::size_type 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, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt= m_edcaListeners.find(ac);
+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.clear ();
 }
 newDuration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector);
 }
 if (m_txParams.HasNextPacket ())
 {
 newDuration += GetSifs ();
-newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 if (m_txParams.MustWaitCompressedBlockAck ())
 {
 newDuration += GetSifs ();
 WifiTxVector blockAckReqTxVector = GetBlockAckTxVector (m_currentHdr.GetAddr2 (), dataTxVector.GetMode ());
 newDuration += GetBlockAckDuration (m_currentHdr.GetAddr1 (), blockAckReqTxVector, COMPRESSED_BLOCK_ACK);
 newDuration += GetSifs ();
 newDuration += GetAckDuration (m_currentHdr.GetAddr1 (), dataTxVector);
 }
 }
-Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr),dataTxVector, preamble, m_phy->GetFrequency(), 0, 0);
+Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency (), 0, 0);
 duration -= txDuration;
 duration -= GetSifs ();
 duration = std::max (duration, newDuration);
 NS_ASSERT (duration >= MicroSeconds (0));
 m_currentPacket->AddHeader (m_currentHdr);
 WifiMacTrailer fcs;
 m_currentPacket->AddTrailer (fcs);
 }
-ForwardDown (m_currentPacket, &m_currentHdr, dataTxVector,preamble);
+ForwardDown (m_currentPacket, &m_currentHdr, dataTxVector, preamble);
 m_currentPacket = 0;
 }
 void
 MacLow::WaitSifsAfterEndTx (void)
 }
 bool
 MacLow::IsInWindow (uint16_t seq, uint16_t winstart, uint16_t winsize)
 {
-return ((seq - winstart+ 4096) % 4096) < winsize;
+return ((seq - winstart + 4096) % 4096) < winsize;
 }
 bool
 MacLow::ReceiveMpdu (Ptr<Packet> packet, WifiMacHeader hdr)
 {
 if (!QosUtilsIsOldPacket ((*it).second.first.GetStartingSequence (), seqNumber))
 {
 StoreMpduIfNeeded (packet, hdr);
 if (!IsInWindow(hdr.GetSequenceNumber (), (*it).second.first.GetStartingSequence (), (*it).second.first.GetBufferSize ()))
 {
-uint16_t delta = (seqNumber - (*it).second.first.GetWinEnd()+ 4096) % 4096;
+uint16_t delta = (seqNumber - (*it).second.first.GetWinEnd() + 4096) % 4096;
 if (delta > 1)
 {
 (*it).second.first.SetWinEnd (seqNumber);
 int16_t winEnd = (*it).second.first.GetWinEnd ();
 int16_t bufferSize = (*it).second.first.GetBufferSize ();
 (*it).second.first.SetStartingSequence (sum);
 RxCompleteBufferedPacketsWithSmallerSequence ((*it).second.first.GetStartingSequence (), originator, tid);
 }
 }
 RxCompleteBufferedPacketsUntilFirstLost (originator, tid); //forwards up packets starting from winstart and set winstart to last +1
-(*it).second.first.SetWinEnd(((*it).second.first.GetStartingSequence()+(*it).second.first.GetBufferSize()-1)%4096);
+(*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence()+(*it).second.first.GetBufferSize() - 1) % 4096);
 }
 return true;
 }
 return false;
 }
 else
-return StoreMpduIfNeeded (packet,hdr);
+return StoreMpduIfNeeded (packet, hdr);
 }
 bool
 MacLow::StoreMpduIfNeeded (Ptr<Packet> packet, WifiMacHeader hdr)
 {
 {
 guard = (*it).second.second.begin ()->second.GetSequenceControl () & 0xfff0;
 }
 BufferedPacketI i = (*it).second.second.begin ();
 for (; i != (*it).second.second.end ()
-&& QosUtilsMapSeqControlToUniqueInteger ((*i).second.GetSequenceNumber (), endSequence) < mappedStart;)
+&& QosUtilsMapSeqControlToUniqueInteger ((*i).second.GetSequenceNumber (), endSequence) < mappedStart; )
 {
 if (guard == (*i).second.GetSequenceControl ())
 {
 if (!(*i).second.IsMoreFragments ())
 {
 }
 else
 {
 if (!QosUtilsIsOldPacket ((*it).second.first.GetStartingSequence(), reqHdr.GetStartingSequence ()))
 {
-(*it).second.first.SetStartingSequence(reqHdr.GetStartingSequence ());
+(*it).second.first.SetStartingSequence (reqHdr.GetStartingSequence ());
-(*it).second.first.SetWinEnd(((*it).second.first.GetStartingSequence()+(*it).second.first.GetBufferSize()-1) % 4096);
+(*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence()+(*it).second.first.GetBufferSize() - 1) % 4096);
 RxCompleteBufferedPacketsWithSmallerSequence (reqHdr.GetStartingSequence (), originator, tid);
 RxCompleteBufferedPacketsUntilFirstLost (originator, tid);
-(*it).second.first.SetWinEnd(((*it).second.first.GetStartingSequence()+(*it).second.first.GetBufferSize()-1) % 4096);
+(*it).second.first.SetWinEnd (((*it).second.first.GetStartingSequence()+(*it).second.first.GetBufferSize() - 1) % 4096);
 }
 }
 }
 else
 {
 {
 NS_ASSERT (agreement.m_inactivityEvent.IsRunning ());
 agreement.m_inactivityEvent.Cancel ();
 Time timeout = MicroSeconds (1024 * agreement.GetTimeout ());
 AcIndex ac = QosUtilsMapTidToAc (agreement.GetTid ());
-//std::map<AcIndex, MacLowTransmissionListener*>::iterator it = m_edcaListeners.find (ac);
-//NS_ASSERT (it != m_edcaListeners.end ());
 agreement.m_inactivityEvent = Simulator::Schedule (timeout,
 &MacLowAggregationCapableTransmissionListener::BlockAckInactivityTimeout,
 m_edcaListeners[ac],
 agreement.GetPeer (),
 agreement.GetTid ());
 bool normalAck = false;
 bool ampduSubframe = false;
 if (aggregatedPacket->RemovePacketTag(ampdu))
 {
 ampduSubframe = true;
-MpduAggregator::DeaggregatedMpdus packets =  MpduAggregator::Deaggregate (aggregatedPacket);
+MpduAggregator::DeaggregatedMpdus packets = MpduAggregator::Deaggregate (aggregatedPacket);
 MpduAggregator::DeaggregatedMpdusCI n = packets.begin ();
 WifiMacHeader firsthdr;
-(*n).first->PeekHeader(firsthdr);
+(*n).first->PeekHeader (firsthdr);
 NS_LOG_DEBUG ("duration/id=" << firsthdr.GetDuration ());
 NotifyNav ((*n).first, firsthdr, preamble);
 if (firsthdr.GetAddr1 () == m_self)
 {
 m_receivedAtLeastOneMpdu = true;
 if (firsthdr.IsAck () || firsthdr.IsBlockAck () || firsthdr.IsBlockAckReq ())
 ReceiveOk ((*n).first, rxSnr, txVector, preamble, ampduSubframe);
 else if (firsthdr.IsData () || firsthdr.IsQosData ())
 {
-NS_LOG_DEBUG ("Deaagregate packet with sequence=" << firsthdr.GetSequenceNumber ());
+NS_LOG_DEBUG ("Deaggregate packet with sequence=" << firsthdr.GetSequenceNumber ());
 ReceiveOk ((*n).first, rxSnr, txVector, preamble, ampduSubframe);
 if (firsthdr.IsQosAck ())
 {
 NS_LOG_DEBUG ("Normal Ack");
 normalAck = true;
 /* See section 11.5.3 in IEEE 802.11 for mean of this timer */
 ResetBlockAckInactivityTimerIfNeeded (it->second.first);
 NS_LOG_DEBUG ("rx A-MPDU/sendImmediateBlockAck from=" << firsthdr.GetAddr2 ());
 m_sendAckEvent = Simulator::Schedule (GetSifs (),
 &MacLow::SendBlockAckAfterAmpdu, this,
-firsthdr.GetQosTid(),
+firsthdr.GetQosTid (),
 firsthdr.GetAddr2 (),
 firsthdr.GetDuration (),
 txVector);
 }
 else
 if (peekedPacket == 0)
 return true;
 //An HT STA shall not transmit a PPDU that has a duration that is greater than aPPDUMaxTime (10 milliseconds)
-if(m_phy->CalculateTxDuration (aggregatedPacket->GetSize () + peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, dataTxVector, preamble, m_phy->GetFrequency(), 0, 0) > MilliSeconds(10))
+if(m_phy->CalculateTxDuration (aggregatedPacket->GetSize () + peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, dataTxVector, preamble, m_phy->GetFrequency (), 0, 0) > MilliSeconds(10))
 return true;
 if (!m_mpduAggregator->CanBeAggregated (peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, aggregatedPacket, size))
 return true;
 else
 {
 InsertInTxQueue (packet, hdr, tstamp);
 }
 }
-NS_LOG_DEBUG ("Adding packet with Sequence number " << peekedHdr.GetSequenceNumber()<<" to A-MPDU, packet size = " << newPacket->GetSize ()<< ", A-MPDU size = " << currentAggregatedPacket->GetSize ());
+NS_LOG_DEBUG ("Adding packet with Sequence number " << peekedHdr.GetSequenceNumber () <<" to A-MPDU, packet size = " << newPacket->GetSize ()<< ", A-MPDU size = " << currentAggregatedPacket->GetSize ());
 i++;
 isAmpdu = true;
 m_sentMpdus++;
 if (!m_txParams.MustSendRts ())
 {
 else
 {
 InsertInTxQueue (peekedPacket, peekedHdr, tstamp);
 }
 if (retry)
-listenerIt->second->RemoveFromBaQueue(tid, hdr.GetAddr1 (), peekedHdr.GetSequenceNumber ());
+listenerIt->second->RemoveFromBaQueue (tid, hdr.GetAddr1 (), peekedHdr.GetSequenceNumber ());
 else
 queue->Remove (peekedPacket);
 newPacket = 0;
 }
 else
 //find what will the sequence number be so that we don't send more than 64 packets apart
 currentSequenceNumber = listenerIt->second->PeekNextSequenceNumberfor (&peekedHdr);
 if (listenerIt->second->GetMsduAggregator () != 0)
 {
-tempPacket = PerformMsduAggregation(peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);
+tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);
 if (tempPacket != 0) //MSDU aggregation
 peekedPacket = tempPacket->Copy();
 }
 }
 }
 //find what will the sequence number be so that we don't send more than 64 packets apart
 currentSequenceNumber = listenerIt->second->PeekNextSequenceNumberfor (&peekedHdr);
 if (listenerIt->second->GetMsduAggregator () != 0 && IsInWindow (currentSequenceNumber, startingSequenceNumber, 64))
 {
-tempPacket = PerformMsduAggregation(peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);
+tempPacket = PerformMsduAggregation (peekedPacket, &peekedHdr, &tstamp, currentAggregatedPacket, blockAckSize);
 if (tempPacket != 0) //MSDU aggregation
 peekedPacket = tempPacket->Copy();
 }
 }
 }
 newPacket->AddTrailer (fcs);
 m_mpduAggregator->Aggregate (newPacket, currentAggregatedPacket);
 }
 if (qosPolicy==0)
 {
-listenerIt->second->CompleteTransfer(hdr.GetAddr1 (),tid);
+listenerIt->second->CompleteTransfer (hdr.GetAddr1 (), tid);
 }
 //Add packet tag
 AmpduTag ampdutag;
 ampdutag.SetAmpdu (true);
 ampdutag.SetNoOfMpdus(i);
 Ptr<Packet> currentAmsduPacket = Create<Packet> ();
 Ptr<Packet> tempPacket = Create<Packet> ();
 Ptr<WifiMacQueue> queue;
 AcIndex ac = QosUtilsMapTidToAc (GetTid (packet, *hdr));
-std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt= m_edcaListeners.find(ac);
+std::map<AcIndex, MacLowAggregationCapableTransmissionListener*>::const_iterator listenerIt = m_edcaListeners.find (ac);
 NS_ASSERT (listenerIt != m_edcaListeners.end ());
 queue = listenerIt->second->GetQueue();
 listenerIt->second->GetMsduAggregator ()->Aggregate (packet, currentAmsduPacket,
 listenerIt->second->GetSrcAddressForAggregation (*hdr),

changeset 11440	af3a3d5dcc21
parent 11432	d2656819dd54
child 11450	9f4ae69f12b7