Attachment #2348 for bug #2338

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

(-)a/src/wifi/model/minstrel-ht-wifi-manager.cc (-2 / +1 lines)

Lines 976-983	Link Here

976

      uint32_t mcsIndex = station->m_groupsTable[groupId].m_ratesTable[rateId].mcsIndex;

976

      uint32_t mcsIndex = station->m_groupsTable[groupId].m_ratesTable[rateId].mcsIndex;

977

978

      WifiMode lastRate = GetMcsSupported (station, mcsIndex);

978

      WifiMode lastRate = GetMcsSupported (station, mcsIndex);

979

      uint8_t streams = m_minstrelGroups[groupId].streams;

979

      uint64_t lastDataRate = lastRate.GetNonHtReferenceRate ();

980

      uint64_t lastDataRate = lastRate.GetNonHtReferenceRate (streams);

981

      uint32_t nBasicRates = GetNBasicModes ();

980

      uint32_t nBasicRates = GetNBasicModes ();

982

981

983

      WifiMode rtsRate;

982

      WifiMode rtsRate;




NistErrorRateModel::GetChunkSuccessRate (WifiMode mode, WifiTxVector txVector, double snr, uint32_t nbits) const
{
  NS_LOG_FUNCTION (this << mode << txVector.GetMode () << snr << nbits);
  uint8_t nss = txVector.GetNss ();
  if (mode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_HT
      || mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      if (mode.GetConstellationSize () == 2)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_1_2)
            {
              return GetFecBpskBer (snr,
                                    nbits,

                                    3); //b value
            }
        }
      else if (mode.GetConstellationSize () == 4)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_1_2)
            {
              return GetFecQpskBer (snr,
                                    nbits,

                                    3); //b value
            }
        }
      else if (mode.GetConstellationSize () == 16)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_1_2)
            {
              return GetFec16QamBer (snr,
                                     nbits,

                                     3); //b value
            }
        }
      else if (mode.GetConstellationSize () == 64)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_2_3)
            {
              return GetFec64QamBer (snr,
                                     nbits,
                                     2); //b value
            }
          else if (mode.GetCodeRate () == WIFI_CODE_RATE_5_6)
            {
              return GetFec64QamBer (snr,
                                     nbits,

                                     3); //b value
            }
        }
      else if (mode.GetConstellationSize () == 256)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_5_6)
            {
              return GetFec256QamBer (snr,
                                      nbits,




uint64_t
WifiMode::GetPhyRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const
{
  NS_ASSERT (nss <= 4);
  uint32_t dataRate, phyRate;
  dataRate = GetDataRate (channelWidth, isShortGuardInterval, nss);
  switch (GetCodeRate ())
    {
    case WIFI_CODE_RATE_5_6:
      phyRate = dataRate * 6 / 5;

uint64_t
WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const
{
  NS_ASSERT (nss <= 4);
  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  uint64_t dataRate = 0;
  if (item->modClass == WIFI_MOD_CLASS_DSSS)
    {
      dataRate = (11000000 / 11) * log2 (GetConstellationSize ());
    }
  else if (item->modClass == WIFI_MOD_CLASS_HR_DSSS)
    {
      dataRate = (11000000 / 8) * log2 (GetConstellationSize ());
    }
  else if (item->modClass == WIFI_MOD_CLASS_OFDM || item->modClass == WIFI_MOD_CLASS_ERP_OFDM)
    {

        }

      double codingRate;
      switch (GetCodeRate ())
        {
        case WIFI_CODE_RATE_3_4:
          codingRate = (3.0 / 4.0);

          break;
        }

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize ());

      dataRate = lrint (ceil (symbolRate * usableSubCarriers * numberOfBitsPerSubcarrier * codingRate));
    }

        }

      double codingRate;
      switch (GetCodeRate ())
        {
        case WIFI_CODE_RATE_5_6:
          codingRate = (5.0 / 6.0);

          break;
        }

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize ());

      dataRate = lrint (ceil (symbolRate * usableSubCarriers * numberOfBitsPerSubcarrier * codingRate));
    }

}

enum WifiCodeRate
WifiMode::GetCodeRate (void) const
{
  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  if (item->modClass == WIFI_MOD_CLASS_HT)
    {
      NS_ASSERT (nss <= 4);
      switch (item->mcsValue % 8)
        {
        case 0:

    }
  else if (item->modClass == WIFI_MOD_CLASS_VHT)
    {
      NS_ASSERT (nss <= 8);
      switch (item->mcsValue)
        {
        case 0:

}

uint16_t
WifiMode::GetConstellationSize (void) const
{
  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  if (item->modClass == WIFI_MOD_CLASS_HT)
    {
      NS_ASSERT (nss <= 4);
      NS_ASSERT ((item->mcsValue - (8 * (nss - 1))) >= 0 || (item->mcsValue - (8 * (nss - 1))) <= 7);
      switch (item->mcsValue % 8)
        {
        case 0:

    }
  else if (item->modClass == WIFI_MOD_CLASS_VHT)
    {
      NS_ASSERT (nss <= 8);
      switch (item->mcsValue)
        {
        case 0:

}

uint64_t
WifiMode::GetNonHtReferenceRate (void) const
{
  uint64_t dataRate;
  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);
  if (item->modClass == WIFI_MOD_CLASS_HT || item->modClass == WIFI_MOD_CLASS_VHT)
    {
      WifiCodeRate codeRate = GetCodeRate();
      switch(GetConstellationSize())
        {
        case 2:
          if (codeRate == WIFI_CODE_RATE_1_2)

  return dataRate;
}

bool
WifiMode::IsHigherCodeRate (WifiMode mode) const
{
  WifiCodeRate codeRate = mode.GetCodeRate ();
  switch (GetCodeRate ())
    {
    case WIFI_CODE_RATE_1_2:
      return false; //This is the smallest code rate.
    case WIFI_CODE_RATE_2_3:
      return (codeRate == WIFI_CODE_RATE_1_2);
    case WIFI_CODE_RATE_3_4:
      return (codeRate == WIFI_CODE_RATE_1_2 || codeRate == WIFI_CODE_RATE_2_3);
    case WIFI_CODE_RATE_5_6:
      return (codeRate == WIFI_CODE_RATE_1_2 || codeRate == WIFI_CODE_RATE_2_3 || codeRate == WIFI_CODE_RATE_3_4);
    default:
      NS_FATAL_ERROR ("Wifi Code Rate not defined");
      return false;
    }
}

WifiMode::WifiMode ()
  : m_uid (0)
{




   */
  uint64_t GetDataRate (WifiTxVector txVector) const;
  /**
   *
   * \param nss the considered number of streams
   *
   * \returns the coding rate of this transmission mode
   */
  enum WifiCodeRate GetCodeRate (void) const;
  /**
   *
   * \param nss the considered number of streams
   *
   * \returns the size of the modulation constellation.
   */
  uint16_t GetConstellationSize (void) const;
  /**
   * \returns the MCS value.
   */

   * use the modulation and coding rate of the HT MCS
   * and lookup in Table 9-5 of IEEE 802.11-2012.
   */
  uint64_t GetNonHtReferenceRate (void) const;
  /**
   * \returns true if mode corresponds to a WifiMode with
   * a code rate strictly higher than this WifiMode.
   */
  bool IsHigherCodeRate (WifiMode mode) const;

  /**
   * Create an invalid WifiMode. Calling any method on the




  NS_LOG_FUNCTION (this << address << reqMode);
  WifiMode mode = GetDefaultMode ();
  bool found = false;
  uint8_t nss = 1;  // Use one spatial stream for control response
  //First, search the BSS Basic Rate set
  for (WifiModeListIterator i = m_bssBasicRateSet.begin (); i != m_bssBasicRateSet.end (); i++)
    {
      bool isOfdm = true;
      if (reqMode.GetModulationClass () == WIFI_MOD_CLASS_DSSS || reqMode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS
          || i->GetModulationClass () == WIFI_MOD_CLASS_DSSS || i->GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS
          || mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS || mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS)
        {
          isOfdm = false;
        }
      if ((!found
            || (isOfdm && (i->IsHigherCodeRate (mode) || (mode.GetConstellationSize () < i->GetConstellationSize ())))
            || (!isOfdm && ((mode.GetConstellationSize () < i->GetConstellationSize ())
              || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && i->GetModulationClass () == WIFI_MOD_CLASS_DSSS)
              || (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && i->GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
              || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && i->GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
              || (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && i->GetModulationClass () == WIFI_MOD_CLASS_HT)
              || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && i->GetModulationClass () == WIFI_MOD_CLASS_HT))))
          && ((isOfdm && !i->IsHigherCodeRate (reqMode) && (i->GetConstellationSize () <= reqMode.GetConstellationSize ()))
            || (!isOfdm && (i->GetConstellationSize () <= reqMode.GetConstellationSize ())))
          && ((!isOfdm && ((i->GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM && reqMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
              || (i->GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)))
            || (isOfdm && ((i->GetModulationClass () == reqMode.GetModulationClass ())
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_VHT)))))

        {
          mode = *i;
          //We've found a potentially-suitable transmit rate, but we

          found = true;
        }
    }
  nss = 1;  // Continue the assumption that MIMO not used for control response
  if (HasHtSupported () || HasVhtSupported ())
    {
      if (!found)

          mode = GetDefaultMcs ();
          for (WifiModeListIterator i = m_bssBasicMcsSet.begin (); i != m_bssBasicMcsSet.end (); i++)
            {
              if ((!found || i->IsHigherCodeRate(mode))
                  && !i->IsHigherCodeRate(reqMode))
              //&& thismode.GetModulationClass () == reqMode.GetModulationClass ()) //TODO: check standard
                {
                  mode = *i;

   * \todo Note that we're ignoring the last sentence for now, because
   * there is not yet any manipulation here of PHY options.
   */
  nss = 1;  // Continue the assumption that MIMO not used for control response
  for (uint32_t idx = 0; idx < m_wifiPhy->GetNModes (); idx++)
    {
      WifiMode thismode = m_wifiPhy->GetMode (idx);
      bool isOfdm = true;
      if (reqMode.GetModulationClass () == WIFI_MOD_CLASS_DSSS || reqMode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS
          || thismode.GetModulationClass () == WIFI_MOD_CLASS_DSSS || thismode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS
          || mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS || mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS)
        {
          isOfdm = false;
        }
      /* If the rate:
       *
       *  - is a mandatory rate for the PHY, and

       * ...then it's our best choice so far.
       */
      if (thismode.IsMandatory ()
          && (!found
             || (isOfdm && (thismode.IsHigherCodeRate (mode) || (mode.GetConstellationSize () < thismode.GetConstellationSize ())))
             || (!isOfdm && ((mode.GetConstellationSize () < thismode.GetConstellationSize ())
                || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && thismode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)
                || (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && thismode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
                || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && thismode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
                || (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && thismode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                || (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && thismode.GetModulationClass () == WIFI_MOD_CLASS_HT))))
          && ((isOfdm && !thismode.IsHigherCodeRate (reqMode) && (thismode.GetConstellationSize () <= reqMode.GetConstellationSize ()))
             || (!isOfdm && (thismode.GetConstellationSize () <= reqMode.GetConstellationSize ())))
          && ((!isOfdm && ((thismode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM && reqMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                || (thismode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM && reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)))
             || (isOfdm && ((thismode.GetModulationClass () == reqMode.GetModulationClass ())
                || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
                || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_VHT)))))
        {
          mode = thismode;
          //As above; we've found a potentially-suitable transmit

          found = true;
        }
    }
  nss = 1;  // Continue the assumption that MIMO not used for control response
  if (HasHtSupported () || HasVhtSupported ())
    {
      for (uint32_t idx = 0; idx < m_wifiPhy->GetNMcs (); idx++)
        {
          WifiMode thismode = m_wifiPhy->GetMcs (idx);
          if (thismode.IsMandatory ()
              && (!found || !mode.IsHigherCodeRate(thismode))
              && !reqMode.IsHigherCodeRate(thismode))
              //&& thismode.GetModulationClass () == reqMode.GetModulationClass ()) //TODO: check standard
            {
              mode = thismode;




YansErrorRateModel::GetChunkSuccessRate (WifiMode mode, WifiTxVector txVector, double snr, uint32_t nbits) const
{
  NS_LOG_FUNCTION (this << mode << txVector.GetMode () << snr << nbits);
  uint8_t nss = txVector.GetNss ();
  if (mode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_OFDM
      || mode.GetModulationClass () == WIFI_MOD_CLASS_HT
      || mode.GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      if (mode.GetConstellationSize () == 2)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_1_2)
            {
              return GetFecBpskBer (snr,
                                    nbits,

                                    8); //adFree
            }
        }
      else if (mode.GetConstellationSize () == 4)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_1_2)
            {
              return GetFecQamBer (snr,
                                   nbits,

                                   31); //adFreePlusOne
            }
        }
      else if (mode.GetConstellationSize () == 16)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_1_2)
            {
              return GetFecQamBer (snr,
                                   nbits,

                                   31); //adFreePlusOne
            }
        }
      else if (mode.GetConstellationSize () == 64)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_2_3)
            {
              return GetFecQamBer (snr,
                                   nbits,

                                   1, //adFree
                                   16); //adFreePlusOne
            }
          if (mode.GetCodeRate () == WIFI_CODE_RATE_5_6)
            {
              //Table B.32  in Pâl Frenger et al., "Multi-rate Convolutional Codes".
              return GetFecQamBer (snr,

                                   31); //adFreePlusOne
            }
        }
      else if (mode.GetConstellationSize () == 256)
        {
          if (mode.GetCodeRate () == WIFI_CODE_RATE_5_6)
            {
              return GetFecQamBer (snr,
                                   nbits,

Return to bug 2338