Attachment #2349 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,

(-)a/src/wifi/model/wifi-mode.cc (-17 / +93 lines)

Lines 73-81	Link Here

uint64_t

uint64_t

WifiMode::GetPhyRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const

WifiMode::GetPhyRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const

  //TODO: nss > 4 not supported yet

  NS_ASSERT (nss <= 4);

  uint32_t dataRate, phyRate;

  uint32_t dataRate, phyRate;

  dataRate = GetDataRate (channelWidth, isShortGuardInterval, nss);

  dataRate = GetDataRate (channelWidth, isShortGuardInterval, nss);

  switch (GetCodeRate (nss))

  switch (GetCodeRate ())

    case WIFI_CODE_RATE_5_6:

    case WIFI_CODE_RATE_5_6:

      phyRate = dataRate * 6 / 5;

      phyRate = dataRate * 6 / 5;

Lines 106-120	Link Here

106

uint64_t

108

uint64_t

107

WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const

109

WifiMode::GetDataRate (uint32_t channelWidth, bool isShortGuardInterval, uint8_t nss) const

108

110

111

  //TODO: nss > 4 not supported yet

112

  NS_ASSERT (nss <= 4);

109

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

113

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

110

  uint64_t dataRate = 0;

114

  uint64_t dataRate = 0;

111

  if (item->modClass == WIFI_MOD_CLASS_DSSS)

115

  if (item->modClass == WIFI_MOD_CLASS_DSSS)

112

116

113

      dataRate = (11000000 / 11) * log2 (GetConstellationSize (nss));

117

      dataRate = (11000000 / 11) * log2 (GetConstellationSize ());

114

118

115

  else if (item->modClass == WIFI_MOD_CLASS_HR_DSSS)

119

  else if (item->modClass == WIFI_MOD_CLASS_HR_DSSS)

116

120

117

      dataRate = (11000000 / 8) * log2 (GetConstellationSize (nss));

121

      dataRate = (11000000 / 8) * log2 (GetConstellationSize ());

118

122

119

  else if (item->modClass == WIFI_MOD_CLASS_OFDM || item->modClass == WIFI_MOD_CLASS_ERP_OFDM)

123

  else if (item->modClass == WIFI_MOD_CLASS_OFDM || item->modClass == WIFI_MOD_CLASS_ERP_OFDM)

120

124

Lines 136-142	Link Here

136

140

137

141

138

      double codingRate;

142

      double codingRate;

139

      switch (GetCodeRate (nss))

143

      switch (GetCodeRate ())

140

144

141

        case WIFI_CODE_RATE_3_4:

145

        case WIFI_CODE_RATE_3_4:

142

          codingRate = (3.0 / 4.0);

146

          codingRate = (3.0 / 4.0);

Lines 153-159	Link Here

153

          break;

157

          break;

154

158

155

159

156

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize (nss));

160

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize ());

157

161

158

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

162

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

159

163

Lines 198-204	Link Here

198

202

199

203

200

      double codingRate;

204

      double codingRate;

201

      switch (GetCodeRate (nss))

205

      switch (GetCodeRate ())

202

206

203

        case WIFI_CODE_RATE_5_6:

207

        case WIFI_CODE_RATE_5_6:

204

          codingRate = (5.0 / 6.0);

208

          codingRate = (5.0 / 6.0);

Lines 218-224	Link Here

218

          break;

222

          break;

219

223

220

224

221

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize (nss));

225

      uint32_t numberOfBitsPerSubcarrier = log2 (GetConstellationSize ());

222

226

223

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

227

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

224

228

Lines 237-248	Link Here

237

241

238

242

239

enum WifiCodeRate

243

enum WifiCodeRate

240

WifiMode::GetCodeRate (uint8_t nss) const

244

WifiMode::GetCodeRate (void) const

241

245

242

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

246

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

243

  if (item->modClass == WIFI_MOD_CLASS_HT)

247

  if (item->modClass == WIFI_MOD_CLASS_HT)

244

248

245

      NS_ASSERT (nss <= 4);

246

      switch (item->mcsValue % 8)

249

      switch (item->mcsValue % 8)

247

250

248

        case 0:

251

        case 0:

Lines 263-269	Link Here

263

266

264

  else if (item->modClass == WIFI_MOD_CLASS_VHT)

267

  else if (item->modClass == WIFI_MOD_CLASS_VHT)

265

268

266

      NS_ASSERT (nss <= 8);

267

      switch (item->mcsValue)

269

      switch (item->mcsValue)

268

270

269

        case 0:

271

        case 0:

Lines 291-303	Link Here

291

293

292

294

293

uint16_t

295

uint16_t

294

WifiMode::GetConstellationSize (uint8_t nss) const

296

WifiMode::GetConstellationSize (void) const

295

297

296

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

298

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

297

  if (item->modClass == WIFI_MOD_CLASS_HT)

299

  if (item->modClass == WIFI_MOD_CLASS_HT)

298

300

299

      NS_ASSERT (nss <= 4);

300

      NS_ASSERT ((item->mcsValue - (8 * (nss - 1))) >= 0 || (item->mcsValue - (8 * (nss - 1))) <= 7);

301

      switch (item->mcsValue % 8)

301

      switch (item->mcsValue % 8)

302

303

        case 0:

303

        case 0:

Lines 318-324	Link Here

318

319

  else if (item->modClass == WIFI_MOD_CLASS_VHT)

319

  else if (item->modClass == WIFI_MOD_CLASS_VHT)

320

321

      NS_ASSERT (nss <= 8);

322

      switch (item->mcsValue)

321

      switch (item->mcsValue)

323

322

324

        case 0:

323

        case 0:

Lines 391-404	Link Here

391

390

392

391

393

uint64_t

392

uint64_t

394

WifiMode::GetNonHtReferenceRate (uint8_t nss) const

393

WifiMode::GetNonHtReferenceRate (void) const

395

394

396

  uint64_t dataRate;

395

  uint64_t dataRate;

397

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

396

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

398

  if (item->modClass == WIFI_MOD_CLASS_HT || item->modClass == WIFI_MOD_CLASS_VHT)

397

  if (item->modClass == WIFI_MOD_CLASS_HT || item->modClass == WIFI_MOD_CLASS_VHT)

399

398

400

      WifiCodeRate codeRate = GetCodeRate(nss);

399

      WifiCodeRate codeRate = GetCodeRate();

401

      switch(GetConstellationSize(nss))

400

      switch(GetConstellationSize())

402

401

403

        case 2:

402

        case 2:

404

          if (codeRate == WIFI_CODE_RATE_1_2)

403

          if (codeRate == WIFI_CODE_RATE_1_2)

Lines 449-454	Link Here

449

  return dataRate;

448

  return dataRate;

450

449

451

450

451

bool

452

WifiMode::IsHigherCodeRate (WifiMode mode) const

453

454

  WifiCodeRate codeRate = mode.GetCodeRate ();

455

  switch (GetCodeRate ())

456

457

    case WIFI_CODE_RATE_1_2:

458

      return false; //This is the smallest code rate.

459

    case WIFI_CODE_RATE_2_3:

460

      return (codeRate == WIFI_CODE_RATE_1_2);

461

    case WIFI_CODE_RATE_3_4:

462

      return (codeRate == WIFI_CODE_RATE_1_2 || codeRate == WIFI_CODE_RATE_2_3);

463

    case WIFI_CODE_RATE_5_6:

464

      return (codeRate == WIFI_CODE_RATE_1_2 || codeRate == WIFI_CODE_RATE_2_3 || codeRate == WIFI_CODE_RATE_3_4);

465

    default:

466

      NS_FATAL_ERROR ("Wifi Code Rate not defined");

467

      return false;

468

469

470

471

bool

472

WifiMode::IsHigherDataRate (WifiMode mode) const

473

474

  struct WifiModeFactory::WifiModeItem *item = WifiModeFactory::GetFactory ()->Get (m_uid);

475

  switch(item->modClass)

476

477

    case WIFI_MOD_CLASS_DSSS:

478

      if (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)

479

480

          return (GetConstellationSize () > mode.GetConstellationSize ());

481

482

      else

483

484

          return false;

485

486

    case WIFI_MOD_CLASS_HR_DSSS:

487

      if (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)

488

489

          return true;

490

491

      else

492

493

          return (GetConstellationSize () > mode.GetConstellationSize ());

494

495

    case WIFI_MOD_CLASS_ERP_OFDM:

496

    case WIFI_MOD_CLASS_OFDM:

497

    case WIFI_MOD_CLASS_HT:

498

    case WIFI_MOD_CLASS_VHT:

499

      if (mode.GetModulationClass () == WIFI_MOD_CLASS_DSSS)

500

501

          return true;

502

503

      else if (mode.GetModulationClass () == WIFI_MOD_CLASS_HR_DSSS)

504

505

          return (mode.GetConstellationSize () > GetConstellationSize ());

506

507

      else

508

509

          if (GetConstellationSize () > mode.GetConstellationSize ())

510

511

              return true;

512

513

          else if (GetConstellationSize () == mode.GetConstellationSize ())

514

515

              return IsHigherCodeRate (mode);

516

517

          else

518

519

              return false;

520

521

522

    default:

523

      NS_FATAL_ERROR ("Modulation class not defined");

524

      return false;

525

526

527

452

WifiMode::WifiMode ()

528

WifiMode::WifiMode ()

453

  : m_uid (0)

529

  : m_uid (0)

454

530




   */
  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 this WifiMode has a
   * a code rate strictly higher than mode.
   */
  bool IsHigherCodeRate (WifiMode mode) const;
  /**
   * \returns true if this WifiMode has a
   * a rate strictly higher than mode.
   */
  bool IsHigherDataRate (WifiMode mode) const;

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




  return isLast;
}

bool
WifiRemoteStationManager::IsAllowedControlAnswerModulationClass (enum WifiModulationClass modClassReq, enum WifiModulationClass modClassAnswer) const
{
  switch (modClassReq)
    {
    case WIFI_MOD_CLASS_DSSS:
      return (modClassAnswer == WIFI_MOD_CLASS_DSSS);
    case WIFI_MOD_CLASS_HR_DSSS:
      return (modClassAnswer == WIFI_MOD_CLASS_DSSS || modClassAnswer == WIFI_MOD_CLASS_HR_DSSS);
    case WIFI_MOD_CLASS_ERP_OFDM:
      return (modClassAnswer == WIFI_MOD_CLASS_DSSS || modClassAnswer == WIFI_MOD_CLASS_HR_DSSS || modClassAnswer == WIFI_MOD_CLASS_ERP_OFDM);
    case WIFI_MOD_CLASS_OFDM:
      return (modClassAnswer == WIFI_MOD_CLASS_OFDM);
    case WIFI_MOD_CLASS_HT:
    case WIFI_MOD_CLASS_VHT:
      return true;
    default:
      NS_FATAL_ERROR ("Modulation class not defined");
      return false;
    }
}

WifiMode
WifiRemoteStationManager::GetControlAnswerMode (Mac48Address address, WifiMode reqMode)
{

  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++)
    {
      if ((!found || i->IsHigherDataRate (mode))
          && (!i->IsHigherDataRate (reqMode))
          && (IsAllowedControlAnswerModulationClass (reqMode.GetModulationClass (), i->GetModulationClass ())))
          && ((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->IsHigherDataRate (mode))
                  && (!i->IsHigherDataRate (reqMode))
                  && (i->GetModulationClass () == reqMode.GetModulationClass ()))
                {
                  mode = *i;
                  //We've found a potentially-suitable transmit rate, but we

   * \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);

      /* If the rate:
       *
       *  - is a mandatory rate for the PHY, and

       * ...then it's our best choice so far.
       */
      if (thismode.IsMandatory ()
          && (!found || thismode.IsHigherDataRate (mode))
          && (!thismode.IsHigherDataRate (reqMode))
          && (IsAllowedControlAnswerModulationClass (reqMode.GetModulationClass (), thismode.GetModulationClass ())))
          && ((thismode.GetModulationClass () == reqMode.GetModulationClass ())
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)
              || (reqMode.GetModulationClass () == WIFI_MOD_CLASS_HT)))

        {
          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 || thismode.IsHigherDataRate (mode))
              && (!thismode.IsHigherCodeRate(reqMode))
              && (thismode.GetModulationClass () == reqMode.GetModulationClass ()))
            {
              mode = thismode;
              //As above; we've found a potentially-suitable transmit




   */
  WifiRemoteStation* Lookup (Mac48Address address, const WifiMacHeader *header) const;

  /**
   * Return whether the modulation class of the selected mode for the 
   * control answer frame is allowed.
   *
   * \param modClassReq modulation class of the request frame
   * \param modClassAnswer modulation class of the answer frame
   *
   * \return true if the modulation class of the selected mode for the 
   * control answer frame is allowed, false otherwise
   */
  bool IsAllowedControlAnswerModulationClass (enum WifiModulationClass modClassReq, enum WifiModulationClass modClassAnswer) const;

  WifiMode GetControlAnswerMode (Mac48Address address, WifiMode reqMode);

  /**




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