Attachment #2397 for bug #2385

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




{
  double m_lastSnrObserved;  //!< SNR of most recently reported packet sent to the remote station
  double m_lastSnrCached;    //!< SNR most recently used to select a rate
  double m_nss;              //!< spatial stream recently used to remote station
  WifiMode m_lastMode;       //!< Mode most recently used to the remote station
};


                    " short GI " << GetPhy ()->GetGuardInterval ());
      AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber));
    }
  // Add all supported Ht and Vht MCSes 
  txVector.SetChannelWidth (GetPhy ()->GetChannelWidth ());
  if (HasVhtSupported () == true || HasHtSupported () == true )
    {

      for (uint32_t i = 0; i < nModes; i++)
        {
          mode = GetPhy ()->GetMcs (i);
          txVector.SetMode (mode);
          for (uint8_t j = 1; j <= GetPhy ()->GetSupportedTxSpatialStreams (); j++)
            {
              if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                {
                  //derive NSS from the Mcs index
                  nss = (mode.GetMcsValue () / 8) + 1;
                  if (nss != j)
                    {
                      continue;
                    }
                }
              else
                {
                  nss = j;
                }
              txVector.SetNss (nss);
              if (IsSupportedTxVector (txVector) && WifiPhy::IsValidTxVector (txVector))
                {
                  NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () <<
                                " channel width " << GetPhy ()->GetChannelWidth () <<
                                " nss " << (uint16_t) nss << 
                               " short GI " << GetPhy ()->GetGuardInterval ());
                  AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber));
                }
              else
                {
                  NS_LOG_DEBUG ("Skipping mode " << mode.GetUniqueName () << " as unsupported");
                }
            }
          else
            {
              nss = GetPhy ()->GetSupportedTxSpatialStreams ();
            }
          NS_LOG_DEBUG ("Initialize, adding mode = " << mode.GetUniqueName () <<
                        " channel width " << GetPhy ()->GetChannelWidth () <<
                        " nss " << (uint16_t) nss << 
                        " short GI " << GetPhy ()->GetGuardInterval ());
          NS_LOG_DEBUG ("In SetupPhy, adding mode = " << mode.GetUniqueName ());
          txVector.SetNss (nss);
          txVector.SetMode (mode);
          AddSnrThreshold (txVector, GetPhy ()->CalculateSnr (txVector, m_ber));
        }
    }
}

  //to ensure correct packet delivery.
  double maxThreshold = 0.0;
  WifiMode maxMode = GetDefaultMode ();
  uint8_t maxNss = 1;
  std::vector<WifiTxVector> candidateTxVectors;
  WifiTxVector txVector;
  WifiMode mode;

      // SNR has not changed, so skip the search and use the last
      // mode selected
      maxMode = station->m_lastMode;      
      maxNss = station->m_nss;
      NS_LOG_DEBUG ("Using cached mode = " << maxMode.GetUniqueName () <<
                    " last snr observed " << station->m_lastSnrObserved <<
                    " cached " << station->m_lastSnrCached);

                  nss = GetPhy ()->GetSupportedTxSpatialStreams ();
                }
              txVector.SetNss (nss);
              if (WifiPhy::IsValidTxVector (txVector) == false || IsSupportedTxVector (txVector) == false)
                 {
                   NS_LOG_DEBUG ("Skipping mode " << mode.GetUniqueName () <<
                                 " nss " << (uint16_t) nss << " width " << 
                                 txVector.GetChannelWidth());
                   continue;       
                 }

                                station->m_lastSnrObserved);
                  maxThreshold = threshold;
                  maxMode = mode;
                  maxNss = nss;
                }
            }
        }

                                station->m_lastSnrObserved);
                  maxThreshold = threshold;
                  maxMode = mode;
                  maxNss = nss;
                }
            }
        }
      NS_LOG_DEBUG ("Updating cached values for station to " <<  maxMode.GetUniqueName () << " snr " << station->m_lastSnrObserved << " nss " << uint16_t (maxNss));
      station->m_lastSnrCached = station->m_lastSnrObserved;
      station->m_lastMode = maxMode;
      station->m_nss = maxNss;
    }
  uint32_t channelWidth = GetChannelWidth (station);
  NS_LOG_DEBUG ("Found maxMode: " << maxMode << " channelWidth: " << channelWidth);
  if (m_currentRate != maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), maxNss))
    {
      NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), maxNss));
      m_currentRate = maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), maxNss);
    }
  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, maxNss, 0, channelWidth, GetAggregation (station), false);
}

WifiTxVector

  return true;
}

bool 
IdealWifiManager::IsSupportedTxVector (const WifiTxVector txVector) const
{
  if (txVector.GetNss () > GetPhy ()->GetSupportedTxSpatialStreams ())
    {
      return false;
    } 
  return true;
}

} //namespace ns3




  virtual bool IsLowLatency (void) const;

  /**
   * Return true or false depending on whether the txVector is supported 
   * for transmitting.  The list of supported modes stored in the 
   * WifiPhy may be larger than the list of usable modes for sending data 
   * because the number of transmit antennas and receive antennas may 
   * be unequal.
   *
   * Note that WifiPhy has a similar IsValidTxVector() that may be used
   * to check whether the standard allows the combination of channel width,
   * NSS, and MCS.
   *
   * \param txVector the txVector to check
   * \return true if the station can transmit using this txVector
   */
  bool IsSupportedTxVector (const WifiTxVector txVector) const;
  /**
   * Return the minimum SNR needed to successfully transmit
   * data with this WifiTxVector at the specified BER.
   *

Return to bug 2385