Attachment #2402 for bug #2385

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




}

void
RateChange (uint64_t newVal, Mac48Address peer)
{
  NS_LOG_DEBUG ("Change to " << newVal << " for station " << peer);
  g_intervalRate = newVal;
}


  serverDevice = wifi.Install (wifiPhy, wifiMac, serverNode);
  clientDevice = wifi.Install (wifiPhy, wifiMac, clientNode);

  Config::ConnectWithoutContext ("/NodeList/0/DeviceList/*/$ns3::WifiNetDevice/RemoteStationManager/$ns3::IdealWifiManager/RateChange", MakeCallback(&RateChange)); 
  // Configure the mobility.
  MobilityHelper mobility;
 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();




struct IdealWifiRemoteStation : public WifiRemoteStation
{
  double m_lastSnrObserved;  //!< SNR of most recently reported packet sent to the remote station
  double m_lastSnrUsed;    //!< SNR most recently used to select a rate
  uint64_t m_lastRate;       //!< last data rate used towards the station
  double m_nss;              //!< nss most recently used towards the station
  WifiMode m_lastMode;       //!< Mode most recently used to the remote station
};


                   DoubleValue (1e-5),
                   MakeDoubleAccessor (&IdealWifiManager::m_ber),
                   MakeDoubleChecker<double> ())
    .AddTraceSource ("RateChange",
                     "The transmission rate has changed",
                     MakeTraceSourceAccessor (&IdealWifiManager::m_rateChange),
                     "ns3::IdealWifiManager::RateChangeTracedCallback")
  ;
  return tid;
}

IdealWifiManager::IdealWifiManager ()
 : m_currentRate (0)
{
}


                    " 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));
        }
    }
}

  NS_LOG_FUNCTION (this);
  IdealWifiRemoteStation *station = new IdealWifiRemoteStation ();
  station->m_lastSnrObserved = 0.0;
  station->m_lastSnrUsed = -100.0;
  station->m_lastRate = 0;
  station->m_lastMode = GetDefaultMode ();
  station->m_nss = 1;
  return station;

{
}

// This check is encapsulated in case any more sophisticated checks
// for applicability of cached data are added in the future
bool
IdealWifiManager::UseCachedDataTxVector (WifiRemoteStation *st) const
{
  NS_LOG_FUNCTION (this << st);
  IdealWifiRemoteStation *station = (IdealWifiRemoteStation *)st;
  if (station->m_lastSnrObserved == station->m_lastSnrUsed)
    {
      return true;
    }
  return false;
}

void
IdealWifiManager::UpdateCachedDataTxVector (WifiRemoteStation *st, WifiMode mode, uint8_t nss)
{
  NS_LOG_FUNCTION (this << st);
  IdealWifiRemoteStation *station = (IdealWifiRemoteStation *)st;
  NS_LOG_DEBUG ("Mode found; updating cached values for station to " <<  mode.GetUniqueName () << " snr " << station->m_lastSnrObserved);
  station->m_lastSnrUsed = station->m_lastSnrObserved;
  station->m_lastMode = mode;
  station->m_nss = nss;
  uint64_t dataRate = mode.GetDataRate (GetChannelWidth (station), GetPhy ()->GetGuardInterval (), nss);
  if (station->m_lastRate != dataRate)
    {
      NS_LOG_DEBUG ("Updated datarate: " << dataRate << " to station " << station->m_state->m_address);
      station->m_lastRate = dataRate;
      m_rateChange (dataRate, station->m_state->m_address);
    }
}

bool
IdealWifiManager::DoGetDataTxVectorVht (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  IdealWifiRemoteStation *station = (IdealWifiRemoteStation *)st;
  WifiMode mode;
  uint8_t nss = 1;
  WifiTxVector txVector;
  // channel width and guard interval are not variable within here
  txVector.SetChannelWidth (GetPhy ()->GetChannelWidth ());
  txVector.SetShortGuardInterval (GetPhy ()->GetGuardInterval ());

  // Search within the supported rate set for the mode corresponding
  // to the highest rate with an SNR threshold smaller than the last
  // SNR reported from the remote station
  WifiMode maxMode = GetDefaultMode ();
  uint8_t maxNss = 1;
  uint64_t maxDataRate = 0;
  
  bool found = false;
  for (uint32_t i = 0; i < GetNMcsSupported (station); i++)
    {
      mode = GetMcsSupported (station, i);
      if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT)
        {
          continue;
        }
      txVector.SetMode (mode);
      // For each VHT mode, we must consider multiple spatial streams
      for (uint8_t j = 1; j <= GetPhy ()->GetSupportedTxSpatialStreams (); j++)
        {
          txVector.SetNss (j);
          if (WifiPhy::IsValidTxVector (txVector) == false || IsSupportedTxVector (txVector) == false)
             {
               NS_LOG_DEBUG ("Skipping mode " << mode.GetUniqueName () <<
                             " nss " << (uint16_t) j << " width " << 
                             txVector.GetChannelWidth());
               continue;       
             }
          // Mode is a candidate
          double threshold = GetSnrThreshold (txVector);
          NS_LOG_DEBUG ("Testing mode = " << mode.GetUniqueName () <<
                        " threshold " << threshold  << 
                        " last snr observed " <<
                        station->m_lastSnrObserved << " cached " <<
                        station->m_lastSnrUsed);
          uint64_t candidateRate = mode.GetDataRate (GetPhy ()->GetChannelWidth (), GetPhy ()->GetGuardInterval (), nss);
          // Prefer a mode if its data rate exceeds previous candidate
          if (candidateRate > maxDataRate && threshold < station->m_lastSnrObserved) 
            {
              NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () <<
                            " threshold " << threshold <<
                            " last snr observed " <<
                            station->m_lastSnrObserved);
              maxMode = mode;
              maxNss = nss;
              maxDataRate = candidateRate;
              found = true;
            }
        }
    }
  if (found)
    {
      UpdateCachedDataTxVector (st, maxMode, maxNss);
    }
  return found;
}

bool
IdealWifiManager::DoGetDataTxVectorHt (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  IdealWifiRemoteStation *station = (IdealWifiRemoteStation *)st;
  WifiMode mode;
  uint8_t nss = 1;
  WifiTxVector txVector;
  // channel width and guard interval are not variable within here
  txVector.SetChannelWidth (GetPhy ()->GetChannelWidth ());
  txVector.SetShortGuardInterval (GetPhy ()->GetGuardInterval ());

  // Search within the supported rate set for the mode corresponding
  // to the highest rate with an SNR threshold smaller than the last
  // SNR reported from the remote station
  WifiMode maxMode = GetDefaultMode ();
  uint8_t maxNss = 1;
  uint64_t maxDataRate = 0;
  
  bool found = false;
  for (uint32_t i = 0; i < GetNMcsSupported (station); i++)
    {
      mode = GetMcsSupported (station, i);
      if (mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
        {
          continue;
        }
      txVector.SetMode (mode);
      // For each HT mode, we can derive the nss from the MCS number
      nss = (mode.GetMcsValue () / 8) + 1;
      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;       
         }
      // Mode is a candidate
      double threshold = GetSnrThreshold (txVector);
      NS_LOG_DEBUG ("Testing mode = " << mode.GetUniqueName () <<
                    " threshold " << threshold  << " last snr observed " <<
                    station->m_lastSnrObserved << " cached " <<
                    station->m_lastSnrUsed);
      uint64_t candidateRate = mode.GetDataRate (GetPhy ()->GetChannelWidth (), GetPhy ()->GetGuardInterval (), nss);
      // Prefer a mode if its data rate exceeds previous candidate
      if (candidateRate > maxDataRate && threshold < station->m_lastSnrObserved) 
        {
          NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () <<
                        " threshold " << threshold  << " last snr observed " <<
                        station->m_lastSnrObserved);
          maxMode = mode;
          maxNss = nss;
          maxDataRate = candidateRate;
          found = true;
        }
    }
  if (found)
    {
      UpdateCachedDataTxVector (st, maxMode, maxNss);
    }
  return found;
}

bool
IdealWifiManager::DoGetDataTxVectorLegacy (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  IdealWifiRemoteStation *station = (IdealWifiRemoteStation *)st;
  WifiMode mode;
  uint8_t nss = 1;
  WifiTxVector txVector;
  // channel width and guard interval are not variable within here
  txVector.SetChannelWidth (GetPhy ()->GetChannelWidth ());
  txVector.SetShortGuardInterval (GetPhy ()->GetGuardInterval ());

  // Search within the supported rate set for the mode corresponding
  // to the highest rate with an SNR threshold smaller than the last
  // SNR reported from the remote station
  WifiMode maxMode = GetDefaultMode ();
  uint8_t maxNss = 1;
  uint64_t maxDataRate = 0;

  bool found = false;
  for (uint32_t i = 0; i < GetNSupported (station); i++)
    {
      mode = GetSupported (station, i);
      txVector.SetMode (mode);
      txVector.SetNss (nss);
      txVector.SetChannelWidth (GetChannelWidthForMode (mode));
      double threshold = GetSnrThreshold (txVector);
      NS_LOG_DEBUG ("mode = " << mode.GetUniqueName () <<
                    " threshold " << threshold  <<
                    " last snr observed " <<
                    station->m_lastSnrObserved);
      uint64_t candidateRate = mode.GetDataRate (GetPhy ()->GetChannelWidth (), GetPhy ()->GetGuardInterval (), nss);
      // Prefer a mode if its data rate exceeds previous candidate
      if (candidateRate > maxDataRate && threshold < station->m_lastSnrObserved) 
        {
          NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () <<
                        " threshold " << threshold  << " last snr observed " <<
                        station->m_lastSnrObserved);
          maxMode = mode;
          maxNss = nss;
          maxDataRate = candidateRate;
          found = true;
        }
    }
  if (found)
    {
      UpdateCachedDataTxVector (st, maxMode, maxNss);
    }
  return found;
}

WifiTxVector
IdealWifiManager::DoGetDataTxVector (WifiRemoteStation *st)
{
  NS_LOG_FUNCTION (this << st);
  IdealWifiRemoteStation *station = (IdealWifiRemoteStation *)st;
  
  if (UseCachedDataTxVector (st))
  //to ensure correct packet delivery.
  double maxThreshold = 0.0;
  WifiMode maxMode = GetDefaultMode ();
  std::vector<WifiTxVector> candidateTxVectors;
  WifiTxVector txVector;
  WifiMode mode;
  uint8_t nss = 1;
  txVector.SetChannelWidth (GetPhy ()->GetChannelWidth ());
  txVector.SetShortGuardInterval (GetPhy ()->GetGuardInterval ());
  if (station->m_lastSnrObserved == station->m_lastSnrCached)
    {
      NS_LOG_DEBUG ("Using cached WifiTxVector to station " << station->m_state->m_address);
      NS_LOG_DEBUG ("Returning cached mode: " << 
                    station->m_lastMode.GetUniqueName () << 
                    " channelWidth: " << GetChannelWidth (station) <<
                    " nss " << (uint16_t) station->m_nss << " dataRate: " << 
                    station->m_lastRate);
      return WifiTxVector (station->m_lastMode, GetDefaultTxPowerLevel (), 
                           GetLongRetryCount (station), false, station->m_nss, 
                           0, GetChannelWidth (station), 
                           GetAggregation (station), false);
    }
  bool found = false;
  if (HasVhtSupported () == true && GetVhtSupported (st))
    {
      NS_LOG_DEBUG ("Searching VHT modes to station " << station->m_state->m_address);
      found = DoGetDataTxVectorVht (st);
    }
  if (!found && HasHtSupported () == true && GetHtSupported (st))
    {
      NS_LOG_DEBUG ("Searching HT modes to station " << station->m_state->m_address);
      found = DoGetDataTxVectorHt (st);
    }
  if (!found)
    {
      NS_LOG_DEBUG ("Searching legacy modes to station " << station->m_state->m_address);
      found = DoGetDataTxVectorLegacy (st);
    }
  if (found)
    {
      return WifiTxVector (station->m_lastMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, station->m_nss, 0, GetChannelWidth (station), GetAggregation (station), false);
    }
  else
    {
      NS_LOG_DEBUG ("Suitable mode not found; returning default mode");
      return WifiTxVector (GetDefaultMode (), GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, 1, 0, GetChannelWidth (station), GetAggregation (station), false);
          for (uint32_t i = 0; i < GetNMcsSupported (station); i++)
            {
              mode = GetMcsSupported (station, i);
              txVector.SetMode (mode);
              if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                {
                  //derive NSS from the Mcs index
                  nss = (mode.GetMcsValue () / 8) + 1;
                }
              else
                {
                  nss = GetPhy ()->GetSupportedTxSpatialStreams ();
                }
              txVector.SetNss (nss);
              if (WifiPhy::IsValidTxVector (txVector) == false)
                 {
                   NS_LOG_DEBUG ("Skipping mode " << mode.GetUniqueName () <<
                                 " nss " << nss << " width " << 
                                 txVector.GetChannelWidth());
                   continue;       
                 }
              double threshold = GetSnrThreshold (txVector);
              // If the node and peer are both VHT capable, only search VHT modes 
              if (mode.GetModulationClass () == WIFI_MOD_CLASS_HT && HasVhtSupported () && GetVhtSupported (st))
                { 
                  continue;
                }
              // If the node and peer are not both VHT capable, only search HT modes 
              if (mode.GetModulationClass () == WIFI_MOD_CLASS_VHT && (!HasVhtSupported () || !GetVhtSupported (st)))
                { 
                  continue;
                }
              NS_LOG_DEBUG ("Testing mode = " << mode.GetUniqueName () <<
                            " threshold " << threshold  << " maxThreshold " <<
                            maxThreshold << " last snr observed " <<
                            station->m_lastSnrObserved << " cached " <<
                            station->m_lastSnrCached);
              if (threshold > maxThreshold && threshold < station->m_lastSnrObserved)
                {
                  NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () <<
                                " threshold " << threshold  <<
                                " last snr observed " <<
                                station->m_lastSnrObserved);
                  maxThreshold = threshold;
                  maxMode = mode;
                }
            }
        }
      else 
        {
          // Non-HT selection
          nss = 1;
          for (uint32_t i = 0; i < GetNSupported (station); i++)
            {
              mode = GetSupported (station, i);
              txVector.SetMode (mode);
              txVector.SetNss (nss);
              txVector.SetChannelWidth (GetChannelWidthForMode (mode));
              double threshold = GetSnrThreshold (txVector);
              NS_LOG_DEBUG ("mode = " << mode.GetUniqueName () <<
                            " threshold " << threshold  <<
                            " last snr observed " <<
                            station->m_lastSnrObserved);
              if (threshold > maxThreshold && threshold < station->m_lastSnrObserved)
                {
                  NS_LOG_DEBUG ("Candidate mode = " << mode.GetUniqueName () <<
                                " threshold " << threshold  <<
                                " last snr observed " <<
                                station->m_lastSnrObserved);
                  maxThreshold = threshold;
                  maxMode = mode;
                }
            }
        }
      NS_LOG_DEBUG ("Updating cached values for station to " <<  maxMode.GetUniqueName () << " snr " << station->m_lastSnrObserved);
      station->m_lastSnrCached = station->m_lastSnrObserved;
      station->m_lastMode = maxMode;
      station->m_nss = nss;
    }
  uint32_t channelWidth = GetChannelWidth (station);
  NS_LOG_DEBUG ("Found maxMode: " << maxMode << " channelWidth: " << channelWidth);
  if (m_currentRate != maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss))
    {
      NS_LOG_DEBUG ("New datarate: " << maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss));
      m_currentRate = maxMode.GetDataRate (channelWidth, GetPhy ()->GetGuardInterval (), nss);
    }
  return WifiTxVector (maxMode, GetDefaultTxPowerLevel (), GetLongRetryCount (station), false, nss, 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

(-)a/src/wifi/model/ideal-wifi-manager.h (-1 / +56 lines)

Lines 43-48	Link Here

 * and uses it to pick a transmission mode based on a set

 * and uses it to pick a transmission mode based on a set

 * of snr thresholds built from a target ber and transmission

 * of snr thresholds built from a target ber and transmission

 * mode-specific snr/ber curves.

 * mode-specific snr/ber curves.

 * This model does not presently account for WifiPhy configuration

 * changes that may occur during runtime (after object initialization time),

 * including changing the number of antennas, the guard interval, or the

 * channel width.

*/

*/

class IdealWifiManager : public WifiRemoteStationManager

class IdealWifiManager : public WifiRemoteStationManager

Lines 51-58	Link Here

  IdealWifiManager ();

  IdealWifiManager ();

  virtual ~IdealWifiManager ();

  virtual ~IdealWifiManager ();

  // Inherited from WifiRemoteStationManager

  virtual void SetupPhy (Ptr<WifiPhy> phy);

  virtual void SetupPhy (Ptr<WifiPhy> phy);

  typedef void (*RateChangeTracedCallback)(const uint64_t rate, const Mac48Address remoteAddress);

private:

private:

  //overriden from base class

  //overriden from base class

Lines 92-97	Link Here

  void AddSnrThreshold (WifiTxVector txVector, double snr);

  void AddSnrThreshold (WifiTxVector txVector, double snr);

100

/**

101

/**

102

   * Return true or false depending on whether the txVector is supported

103

   * for transmitting.  The list of supported modes stored in the

104

   * WifiPhy may be larger than the list of usable modes for sending data

105

   * because the number of transmit antennas and receive antennas may

106

   * be unequal.

107

108

   * Note that WifiPhy has a similar IsValidTxVector() that may be used

109

   * to check whether the standard allows the combination of channel width,

110

   * NSS, and MCS.

111

112

   * \param txVector the txVector to check

113

   * \return true if the station can transmit using this txVector

114

*/

115

  bool IsSupportedTxVector (const WifiTxVector txVector) const;

116

/**

   * Convenience function for selecting a channel width for legacy mode

117

   * Convenience function for selecting a channel width for legacy mode

   * \param non-(V)HT WifiMode

118

   * \param non-(V)HT WifiMode

   * \return the channel width (MHz) for the selected mode

119

   * \return the channel width (MHz) for the selected mode

Lines 99-104	Link Here

  uint32_t GetChannelWidthForMode (WifiMode mode) const;

121

  uint32_t GetChannelWidthForMode (WifiMode mode) const;

100

122

101

/**

123

/**

124

   * \param st Station under consideration

125

   * \return true if cached values may be reused

126

*/

127

  bool UseCachedDataTxVector (WifiRemoteStation* st) const;

128

/**

129

   * \param st Station under consideration

130

   * \mode WifiMode value to update the cached value to

131

   * \mode nss value to update the cached value to

132

*/

133

  void UpdateCachedDataTxVector (WifiRemoteStation* st, WifiMode mode, uint8_t nss);

134

135

/**

136

   * \param st Station under consideration

137

   * \return true if suitable VHT MCS is found

138

*/

139

  bool DoGetDataTxVectorVht (WifiRemoteStation* st);

140

141

/**

142

   * \param st Station under consideration

143

   * \return true if suitable HT MCS is found

144

*/

145

  bool DoGetDataTxVectorHt (WifiRemoteStation* st);

146

147

/**

148

   * \param st Station under consideration

149

   * \return true if suitable legacy mode is found

150

*/

151

  bool DoGetDataTxVectorLegacy (WifiRemoteStation* st);

152

153

/**

102

   * A vector of <snr, WifiTxVector> pair holding the minimum SNR for the

154

   * A vector of <snr, WifiTxVector> pair holding the minimum SNR for the

103

   * WifiTxVector

155

   * WifiTxVector

104

*/

156

*/

Lines 107-113	Link Here

107

  double m_ber;             //!< The maximum Bit Error Rate acceptable at any transmission mode

159

  double m_ber;             //!< The maximum Bit Error Rate acceptable at any transmission mode

108

  Thresholds m_thresholds;  //!< List of WifiTxVector and the minimum SNR pair

160

  Thresholds m_thresholds;  //!< List of WifiTxVector and the minimum SNR pair

109

161

110

  TracedValue<uint64_t> m_currentRate; //!< Trace rate changes

162

/**

163

   * The trace source fired when the transmission rate change.

164

*/

165

  TracedCallback<uint64_t, Mac48Address> m_rateChange;

111

};

166

};

112

167

113

} //namespace ns3

168

} //namespace ns3

Return to bug 2385