Attachment #1642 for bug #1726

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

(-)a/src/wifi/model/minstrel-wifi-manager.cc (-82 / +85 lines)

Lines 74-79	Link Here

  uint32_t m_txrate;  ///< current transmit rate

  uint32_t m_txrate;  ///< current transmit rate

  bool m_initialized;  ///< for initializing tables

  bool m_initialized;  ///< for initializing tables

  MinstrelRate m_minstrelTable;  ///< minstrel table

  SampleRate m_sampleTable;  ///< sample table

};

};

NS_OBJECT_ENSURE_REGISTERED (MinstrelWifiManager);

NS_OBJECT_ENSURE_REGISTERED (MinstrelWifiManager);

Lines 206-213	Link Here

206

      // to make sure that the set of supported rates has been initialized

209

      // to make sure that the set of supported rates has been initialized

207

      // before we perform our own initialization.

210

      // before we perform our own initialization.

208

      m_nsupported = GetNSupported (station);

211

      m_nsupported = GetNSupported (station);

209

      m_minstrelTable = MinstrelRate (m_nsupported);

212

      station->m_minstrelTable = MinstrelRate (m_nsupported);

210

      m_sampleTable = SampleRate (m_nsupported, std::vector<uint32_t> (m_sampleCol));

213

      station->m_sampleTable = SampleRate (m_nsupported, std::vector<uint32_t> (m_sampleCol));

211

      InitSampleTable (station);

214

      InitSampleTable (station);

212

      RateInit (station);

215

      RateInit (station);

213

      station->m_initialized = true;

216

      station->m_initialized = true;

Lines 278-307	Link Here

278

  if (!station->m_isSampling)

281

  if (!station->m_isSampling)

279

282

280

      /// use best throughput rate

283

      /// use best throughput rate

281

      if (station->m_longRetry < m_minstrelTable[station->m_txrate].adjustedRetryCount)

284

      if (station->m_longRetry < station->m_minstrelTable[station->m_txrate].adjustedRetryCount)

282

285

283

          ;  ///<  there's still a few retries left

286

          ;  ///<  there's still a few retries left

284

287

285

288

286

      /// use second best throughput rate

289

      /// use second best throughput rate

287

      else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount +

290

      else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

288

                                        m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

291

                                        station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

289

292

290

          station->m_txrate = station->m_maxTpRate2;

293

          station->m_txrate = station->m_maxTpRate2;

291

294

292

295

293

      /// use best probability rate

296

      /// use best probability rate

294

      else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount +

297

      else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

295

                                        m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount +

298

                                        station->m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount +

296

                                        m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

299

                                        station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

297

300

298

          station->m_txrate = station->m_maxProbRate;

301

          station->m_txrate = station->m_maxProbRate;

299

302

300

303

301

      /// use lowest base rate

304

      /// use lowest base rate

302

      else if (station->m_longRetry > (m_minstrelTable[station->m_txrate].adjustedRetryCount +

305

      else if (station->m_longRetry > (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

303

                                       m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount +

306

                                       station->m_minstrelTable[station->m_maxTpRate2].adjustedRetryCount +

304

                                       m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

307

                                       station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

305

308

306

          station->m_txrate = 0;

309

          station->m_txrate = 0;

307

310

Lines 314-343	Link Here

314

      if (station->m_sampleRateSlower)

317

      if (station->m_sampleRateSlower)

315

318

316

          /// use best throughput rate

319

          /// use best throughput rate

317

          if (station->m_longRetry < m_minstrelTable[station->m_txrate].adjustedRetryCount)

320

          if (station->m_longRetry < station->m_minstrelTable[station->m_txrate].adjustedRetryCount)

318

321

319

              ; ///<  there are a few retries left

322

              ; ///<  there are a few retries left

320

323

321

324

322

          ///	use random rate

325

          ///	use random rate

323

          else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount +

326

          else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

324

                                            m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

327

                                            station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

325

328

326

              station->m_txrate = station->m_sampleRate;

329

              station->m_txrate = station->m_sampleRate;

327

330

328

331

329

          /// use max probability rate

332

          /// use max probability rate

330

          else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount +

333

          else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

331

                                            m_minstrelTable[station->m_sampleRate].adjustedRetryCount +

334

                                            station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount +

332

                                            m_minstrelTable[station->m_maxTpRate].adjustedRetryCount ))

335

                                            station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount ))

333

336

334

              station->m_txrate = station->m_maxProbRate;

337

              station->m_txrate = station->m_maxProbRate;

335

338

336

339

337

          /// use lowest base rate

340

          /// use lowest base rate

338

          else if (station->m_longRetry > (m_minstrelTable[station->m_txrate].adjustedRetryCount +

341

          else if (station->m_longRetry > (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

339

                                           m_minstrelTable[station->m_sampleRate].adjustedRetryCount +

342

                                           station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount +

340

                                           m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

343

                                           station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount))

341

344

342

              station->m_txrate = 0;

345

              station->m_txrate = 0;

343

346

Lines 347-376	Link Here

347

      else

350

      else

348

351

349

          /// use random rate

352

          /// use random rate

350

          if (station->m_longRetry < m_minstrelTable[station->m_txrate].adjustedRetryCount)

353

          if (station->m_longRetry < station->m_minstrelTable[station->m_txrate].adjustedRetryCount)

351

354

352

              ;    ///< keep using it

355

              ;    ///< keep using it

353

356

354

357

355

          /// use the best rate

358

          /// use the best rate

356

          else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount +

359

          else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

357

                                            m_minstrelTable[station->m_sampleRate].adjustedRetryCount))

360

                                            station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount))

358

361

359

              station->m_txrate = station->m_maxTpRate;

362

              station->m_txrate = station->m_maxTpRate;

360

363

361

364

362

          /// use the best probability rate

365

          /// use the best probability rate

363

          else if (station->m_longRetry <= (m_minstrelTable[station->m_txrate].adjustedRetryCount +

366

          else if (station->m_longRetry <= (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

364

                                            m_minstrelTable[station->m_maxTpRate].adjustedRetryCount +

367

                                            station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount +

365

                                            m_minstrelTable[station->m_sampleRate].adjustedRetryCount))

368

                                            station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount))

366

369

367

              station->m_txrate = station->m_maxProbRate;

370

              station->m_txrate = station->m_maxProbRate;

368

371

369

372

370

          /// use the lowest base rate

373

          /// use the lowest base rate

371

          else if (station->m_longRetry > (m_minstrelTable[station->m_txrate].adjustedRetryCount +

374

          else if (station->m_longRetry > (station->m_minstrelTable[station->m_txrate].adjustedRetryCount +

372

                                           m_minstrelTable[station->m_maxTpRate].adjustedRetryCount +

375

                                           station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount +

373

                                           m_minstrelTable[station->m_sampleRate].adjustedRetryCount))

376

                                           station->m_minstrelTable[station->m_sampleRate].adjustedRetryCount))

374

377

375

              station->m_txrate = 0;

378

              station->m_txrate = 0;

376

379

Lines 393-404	Link Here

393

      return;

396

      return;

394

397

395

398

396

  m_minstrelTable[station->m_txrate].numRateSuccess++;

399

  station->m_minstrelTable[station->m_txrate].numRateSuccess++;

397

  m_minstrelTable[station->m_txrate].numRateAttempt++;

400

  station->m_minstrelTable[station->m_txrate].numRateAttempt++;

398

401

399

  UpdateRetry (station);

402

  UpdateRetry (station);

400

403

401

  m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry;

404

  station->m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry;

402

  station->m_packetCount++;

405

  station->m_packetCount++;

403

406

404

  if (m_nsupported >= 1)

407

  if (m_nsupported >= 1)

Lines 418-424	Link Here

418

421

419

  UpdateRetry (station);

422

  UpdateRetry (station);

420

423

421

  m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry;

424

  station->m_minstrelTable[station->m_txrate].numRateAttempt += station->m_retry;

422

  station->m_err++;

425

  station->m_err++;

423

426

424

  if (m_nsupported >= 1)

427

  if (m_nsupported >= 1)

Lines 469-475	Link Here

469

MinstrelWifiManager::GetNextSample (MinstrelWifiRemoteStation *station)

472

MinstrelWifiManager::GetNextSample (MinstrelWifiRemoteStation *station)

470

473

471

  uint32_t bitrate;

474

  uint32_t bitrate;

472

  bitrate = m_sampleTable[station->m_index][station->m_col];

475

  bitrate = station->m_sampleTable[station->m_index][station->m_col];

473

  station->m_index++;

476

  station->m_index++;

474

477

475

  /// bookeeping for m_index and m_col variables

478

  /// bookeeping for m_index and m_col variables

Lines 550-556	Link Here

550

553

551

          /// is this rate slower than the current best rate

554

          /// is this rate slower than the current best rate

552

          station->m_sampleRateSlower =

555

          station->m_sampleRateSlower =

553

            (m_minstrelTable[idx].perfectTxTime > m_minstrelTable[station->m_maxTpRate].perfectTxTime);

556

            (station->m_minstrelTable[idx].perfectTxTime > station->m_minstrelTable[station->m_maxTpRate].perfectTxTime);

554

557

555

          /// using the best rate instead

558

          /// using the best rate instead

556

          if (station->m_sampleRateSlower)

559

          if (station->m_sampleRateSlower)

Lines 596-602	Link Here

596

599

597

600

598

      /// calculate the perfect tx time for this rate

601

      /// calculate the perfect tx time for this rate

599

      txTime = m_minstrelTable[i].perfectTxTime;

602

      txTime = station->m_minstrelTable[i].perfectTxTime;

600

603

601

      /// just for initialization

604

      /// just for initialization

602

      if (txTime.GetMicroSeconds () == 0)

605

      if (txTime.GetMicroSeconds () == 0)

Lines 605-665	Link Here

605

608

606

609

607

      NS_LOG_DEBUG ("m_txrate=" << station->m_txrate <<

610

      NS_LOG_DEBUG ("m_txrate=" << station->m_txrate <<

608

                    "\t attempt=" << m_minstrelTable[i].numRateAttempt <<

611

                    "\t attempt=" << station->m_minstrelTable[i].numRateAttempt <<

609

                    "\t success=" << m_minstrelTable[i].numRateSuccess);

612

                    "\t success=" << station->m_minstrelTable[i].numRateSuccess);

610

613

611

      /// if we've attempted something

614

      /// if we've attempted something

612

      if (m_minstrelTable[i].numRateAttempt)

615

      if (station->m_minstrelTable[i].numRateAttempt)

613

616

614

/**

617

/**

615

           * calculate the probability of success

618

           * calculate the probability of success

616

           * assume probability scales from 0 to 18000

619

           * assume probability scales from 0 to 18000

617

*/

620

*/

618

          tempProb = (m_minstrelTable[i].numRateSuccess * 18000) / m_minstrelTable[i].numRateAttempt;

621

          tempProb = (station->m_minstrelTable[i].numRateSuccess * 18000) / station->m_minstrelTable[i].numRateAttempt;

619

622

620

          /// bookeeping

623

          /// bookeeping

621

          m_minstrelTable[i].successHist += m_minstrelTable[i].numRateSuccess;

624

          station->m_minstrelTable[i].successHist += station->m_minstrelTable[i].numRateSuccess;

622

          m_minstrelTable[i].attemptHist += m_minstrelTable[i].numRateAttempt;

625

          station->m_minstrelTable[i].attemptHist += station->m_minstrelTable[i].numRateAttempt;

623

          m_minstrelTable[i].prob = tempProb;

626

          station->m_minstrelTable[i].prob = tempProb;

624

627

625

          /// ewma probability (cast for gcc 3.4 compatibility)

628

          /// ewma probability (cast for gcc 3.4 compatibility)

626

          tempProb = static_cast<uint32_t> (((tempProb * (100 - m_ewmaLevel)) + (m_minstrelTable[i].ewmaProb * m_ewmaLevel) ) / 100);

629

          tempProb = static_cast<uint32_t> (((tempProb * (100 - m_ewmaLevel)) + (station->m_minstrelTable[i].ewmaProb * m_ewmaLevel) ) / 100);

627

630

628

          m_minstrelTable[i].ewmaProb = tempProb;

631

          station->m_minstrelTable[i].ewmaProb = tempProb;

629

632

630

          /// calculating throughput

633

          /// calculating throughput

631

          m_minstrelTable[i].throughput = tempProb * (1000000 / txTime.GetMicroSeconds ());

634

          station->m_minstrelTable[i].throughput = tempProb * (1000000 / txTime.GetMicroSeconds ());

632

635

633

636

634

637

635

      /// bookeeping

638

      /// bookeeping

636

      m_minstrelTable[i].prevNumRateAttempt = m_minstrelTable[i].numRateAttempt;

639

      station->m_minstrelTable[i].prevNumRateAttempt = station->m_minstrelTable[i].numRateAttempt;

637

      m_minstrelTable[i].prevNumRateSuccess = m_minstrelTable[i].numRateSuccess;

640

      station->m_minstrelTable[i].prevNumRateSuccess = station->m_minstrelTable[i].numRateSuccess;

638

      m_minstrelTable[i].numRateSuccess = 0;

641

      station->m_minstrelTable[i].numRateSuccess = 0;

639

      m_minstrelTable[i].numRateAttempt = 0;

642

      station->m_minstrelTable[i].numRateAttempt = 0;

640

643

641

      /// Sample less often below 10% and  above 95% of success

644

      /// Sample less often below 10% and  above 95% of success

642

      if ((m_minstrelTable[i].ewmaProb > 17100) || (m_minstrelTable[i].ewmaProb < 1800))

645

      if ((station->m_minstrelTable[i].ewmaProb > 17100) || (station->m_minstrelTable[i].ewmaProb < 1800))

643

646

644

/**

647

/**

645

           * retry count denotes the number of retries permitted for each rate

648

           * retry count denotes the number of retries permitted for each rate

646

           * # retry_count/2

649

           * # retry_count/2

647

*/

650

*/

648

          m_minstrelTable[i].adjustedRetryCount = m_minstrelTable[i].retryCount >> 1;

651

          station->m_minstrelTable[i].adjustedRetryCount = station->m_minstrelTable[i].retryCount >> 1;

649

          if (m_minstrelTable[i].adjustedRetryCount > 2)

652

          if (station->m_minstrelTable[i].adjustedRetryCount > 2)

650

653

651

              m_minstrelTable[i].adjustedRetryCount = 2;

654

              station->m_minstrelTable[i].adjustedRetryCount = 2;

652

655

653

656

654

      else

657

      else

655

658

656

          m_minstrelTable[i].adjustedRetryCount = m_minstrelTable[i].retryCount;

659

          station->m_minstrelTable[i].adjustedRetryCount = station->m_minstrelTable[i].retryCount;

657

660

658

661

659

      /// if it's 0 allow one retry limit

662

      /// if it's 0 allow one retry limit

660

      if (m_minstrelTable[i].adjustedRetryCount == 0)

663

      if (station->m_minstrelTable[i].adjustedRetryCount == 0)

661

664

662

          m_minstrelTable[i].adjustedRetryCount = 1;

665

          station->m_minstrelTable[i].adjustedRetryCount = 1;

663

666

664

667

665

668

Lines 669-687	Link Here

669

  /// go find max throughput, second maximum throughput, high probability succ

672

  /// go find max throughput, second maximum throughput, high probability succ

670

  for (uint32_t i = 0; i < m_nsupported; i++)

673

  for (uint32_t i = 0; i < m_nsupported; i++)

671

674

672

      NS_LOG_DEBUG ("throughput" << m_minstrelTable[i].throughput <<

675

      NS_LOG_DEBUG ("throughput" << station->m_minstrelTable[i].throughput <<

673

                    "\n ewma" << m_minstrelTable[i].ewmaProb);

676

                    "\n ewma" << station->m_minstrelTable[i].ewmaProb);

674

677

675

      if (max_tp < m_minstrelTable[i].throughput)

678

      if (max_tp < station->m_minstrelTable[i].throughput)

676

679

677

          index_max_tp = i;

680

          index_max_tp = i;

678

          max_tp = m_minstrelTable[i].throughput;

681

          max_tp = station->m_minstrelTable[i].throughput;

679

682

680

683

681

      if (max_prob < m_minstrelTable[i].ewmaProb)

684

      if (max_prob < station->m_minstrelTable[i].ewmaProb)

682

685

683

          index_max_prob = i;

686

          index_max_prob = i;

684

          max_prob = m_minstrelTable[i].ewmaProb;

687

          max_prob = station->m_minstrelTable[i].ewmaProb;

685

688

686

689

687

690

Lines 690-699	Link Here

690

  /// find the second highest max

693

  /// find the second highest max

691

  for (uint32_t i = 0; i < m_nsupported; i++)

694

  for (uint32_t i = 0; i < m_nsupported; i++)

692

695

693

      if ((i != index_max_tp) && (max_tp < m_minstrelTable[i].throughput))

696

      if ((i != index_max_tp) && (max_tp < station->m_minstrelTable[i].throughput))

694

697

695

          index_max_tp2 = i;

698

          index_max_tp2 = i;

696

          max_tp = m_minstrelTable[i].throughput;

699

          max_tp = station->m_minstrelTable[i].throughput;

697

700

698

701

699

702

Lines 710-716	Link Here

710

  NS_LOG_DEBUG ("max tp=" << index_max_tp << "\nmax tp2=" << index_max_tp2 << "\nmax prob=" << index_max_prob);

713

  NS_LOG_DEBUG ("max tp=" << index_max_tp << "\nmax tp2=" << index_max_tp2 << "\nmax prob=" << index_max_prob);

711

714

712

  /// reset it

715

  /// reset it

713

  RateInit (station);

716

  //RateInit (station);

714

717

715

718

716

void

719

void

Lines 720-737	Link Here

720

723

721

  for (uint32_t i = 0; i < m_nsupported; i++)

724

  for (uint32_t i = 0; i < m_nsupported; i++)

722

725

723

      m_minstrelTable[i].numRateAttempt = 0;

726

      station->m_minstrelTable[i].numRateAttempt = 0;

724

      m_minstrelTable[i].numRateSuccess = 0;

727

      station->m_minstrelTable[i].numRateSuccess = 0;

725

      m_minstrelTable[i].prob = 0;

728

      station->m_minstrelTable[i].prob = 0;

726

      m_minstrelTable[i].ewmaProb = 0;

729

      station->m_minstrelTable[i].ewmaProb = 0;

727

      m_minstrelTable[i].prevNumRateAttempt = 0;

730

      station->m_minstrelTable[i].prevNumRateAttempt = 0;

728

      m_minstrelTable[i].prevNumRateSuccess = 0;

731

      station->m_minstrelTable[i].prevNumRateSuccess = 0;

729

      m_minstrelTable[i].successHist = 0;

732

      station->m_minstrelTable[i].successHist = 0;

730

      m_minstrelTable[i].attemptHist = 0;

733

      station->m_minstrelTable[i].attemptHist = 0;

731

      m_minstrelTable[i].throughput = 0;

734

      station->m_minstrelTable[i].throughput = 0;

732

      m_minstrelTable[i].perfectTxTime = GetCalcTxTime (GetSupported (station, i));

735

      station->m_minstrelTable[i].perfectTxTime = GetCalcTxTime (GetSupported (station, i));

733

      m_minstrelTable[i].retryCount = 1;

736

      station->m_minstrelTable[i].retryCount = 1;

734

      m_minstrelTable[i].adjustedRetryCount = 1;

737

      station->m_minstrelTable[i].adjustedRetryCount = 1;

735

738

736

739

737

740

Lines 759-769	Link Here

759

          newIndex = (i + uv) % numSampleRates;

762

          newIndex = (i + uv) % numSampleRates;

760

763

761

          /// this loop is used for filling in other uninitilized places

764

          /// this loop is used for filling in other uninitilized places

762

          while (m_sampleTable[newIndex][col] != 0)

765

          while (station->m_sampleTable[newIndex][col] != 0)

763

766

764

              newIndex = (newIndex + 1) % m_nsupported;

767

              newIndex = (newIndex + 1) % m_nsupported;

765

768

766

          m_sampleTable[newIndex][col] = i;

769

          station->m_sampleTable[newIndex][col] = i;

767

770

768

771

769

772

Lines 779-785	Link Here

779

782

780

      for (uint32_t j = 0; j < m_sampleCol; j++)

783

      for (uint32_t j = 0; j < m_sampleCol; j++)

781

784

782

          std::cout << m_sampleTable[i][j] << "\t";

785

          std::cout << station->m_sampleTable[i][j] << "\t";

783

786

784

      std::cout << std::endl;

787

      std::cout << std::endl;

785

788

Lines 792-798	Link Here

792

795

793

  for (uint32_t i = 0; i < m_nsupported; i++)

796

  for (uint32_t i = 0; i < m_nsupported; i++)

794

797

795

      std::cout << "index(" << i << ") = " << m_minstrelTable[i].perfectTxTime << "\n";

798

      std::cout << "index(" << i << ") = " << station->m_minstrelTable[i].perfectTxTime << "\n";

796

799

797

800

798

801

(-)a/src/wifi/model/minstrel-wifi-manager.h (-3 lines)

Lines 153-161	Link Here

153

154

155

  typedef std::vector<std::pair<Time,WifiMode> > TxTime;

155

  typedef std::vector<std::pair<Time,WifiMode> > TxTime;

156

  MinstrelRate m_minstrelTable;  ///< minstrel table

157

  SampleRate m_sampleTable;  ///< sample table

158

159

156

160

  TxTime m_calcTxTime;  ///< to hold all the calculated TxTime for all modes

157

  TxTime m_calcTxTime;  ///< to hold all the calculated TxTime for all modes

161

  Time m_updateStats;  ///< how frequent do we calculate the stats(1/10 seconds)

158

  Time m_updateStats;  ///< how frequent do we calculate the stats(1/10 seconds)

Return to bug 1726