Attachment #3137 for bug #2950

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




                      WifiModeList htMcsList = GetHtDeviceMcsList ();
                      for (uint8_t i = 0; i < MAX_HT_GROUP_RATES; i++)
                        {
                          uint16_t deviceIndex = i + (m_minstrelGroups[groupId].streams - 1) * 8;
                          WifiMode mode =  htMcsList[deviceIndex];
                          AddFirstMpduTxTime (groupId, mode, CalculateFirstMpduTxDuration (GetPhy (), streams, sgi, chWidth, mode));
                          AddMpduTxTime (groupId, mode, CalculateMpduTxDuration (GetPhy (), streams, sgi, chWidth, mode));

MinstrelHtWifiManager::DoReportRxOk (WifiRemoteStation *st, double rxSnr, WifiMode txMode)
{
  NS_LOG_FUNCTION (this << st);
  NS_LOG_DEBUG ("DoReportRxOk m_txrate=" << ((MinstrelHtWifiRemoteStation *)st)->m_txrate);
}

void

    {
      return;
    }
  NS_LOG_DEBUG ("DoReportRtsFailed m_txrate = " << station->m_txrate);
  station->m_shortRetry++;
}


      return;
    }

  NS_LOG_DEBUG ("DoReportDataFailed " << station << "\t rate " << station->m_txrate << "\tlongRetry \t" << station->m_longRetry);

  if (!station->m_isHt)
    {

      return;
    }

  NS_LOG_DEBUG ("DoReportDataOk m_txrate = " << station->m_txrate << ", attempt = " << station->m_minstrelTable[station->m_txrate].numRateAttempt << ", success = " << station->m_minstrelTable[station->m_txrate].numRateSuccess << " (before update).");

  if (!station->m_isHt)
    {


      m_legacyManager->UpdatePacketCounters (station);

      NS_LOG_DEBUG ("DoReportDataOk m_txrate = " << station->m_txrate << ", attempt = " << station->m_minstrelTable[station->m_txrate].numRateAttempt << ", success = " << station->m_minstrelTable[station->m_txrate].numRateSuccess << " (after update).");

      UpdateRetry (station);
      m_legacyManager->UpdateStats (station);


      UpdatePacketCounters (station, 1, 0);

      NS_LOG_DEBUG ("DoReportDataOk m_txrate = " << station->m_txrate << ", attempt = " << station->m_minstrelTable[station->m_txrate].numRateAttempt << ", success = " << station->m_minstrelTable[station->m_txrate].numRateSuccess << " (after update).");

      station->m_isSampling = false;
      station->m_sampleDeferred = false;

        }
    }

  NS_LOG_DEBUG ("Next rate to use TxRate = " << station->m_txrate  );
}

void

      return;
    }

  NS_LOG_DEBUG ("DoReportFinalDataFailed - TxRate=" << station->m_txrate);

  if (!station->m_isHt)
    {

          station->m_txrate = FindRate (station);
        }
    }
  NS_LOG_DEBUG ("Next rate to use TxRate = " << station->m_txrate);
}

void

      NS_ASSERT_MSG (false,"A-MPDU Tx Status called but no HT or VHT supported.");
    }

  NS_LOG_DEBUG ("DoReportAmpduTxStatus. TxRate=" << station->m_txrate << " SuccMpdus= " <<
                +nSuccessfulMpdus << " FailedMpdus= " << +nFailedMpdus);

  station->m_ampduPacketCount++;

        {
          station->m_txrate = FindRate (station);
        }
      NS_LOG_DEBUG ("Next rate to use TxRate = " << station->m_txrate);
    }
}


          NS_ASSERT_MSG (false,"Max retries reached and m_longRetry not cleared properly. longRetry= " << station->m_longRetry);
        }
    }
  NS_LOG_DEBUG ("Next rate to use TxRate = " << station->m_txrate);
}

void

    }
  else
    {
      NS_LOG_DEBUG ("DoGetDataMode m_txrate= " << station->m_txrate);

      uint8_t rateId = GetRateId (station->m_txrate);
      uint8_t groupId = GetGroupId (station->m_txrate);

    }
  else
    {
      NS_LOG_DEBUG ("DoGetRtsMode m_txrate=" << station->m_txrate);

      /* RTS is sent in a non-HT frame. RTS with HT is not supported yet in NS3.
       * When supported, decision of using HT has to follow rules in Section 9.7.6 from 802.11-2012.

  return true;
}

uint16_t
MinstrelHtWifiManager::GetNextSample (MinstrelHtWifiRemoteStation *station)
{
  NS_LOG_FUNCTION (this << station);

  uint8_t index = station->m_groupsTable[sampleGroup].m_index;
  uint8_t col = station->m_groupsTable[sampleGroup].m_col;
  uint8_t sampleIndex = station->m_sampleTable[index][col];
  uint16_t rateIndex = GetIndex (sampleGroup, sampleIndex);
  NS_LOG_DEBUG ("Next Sample is " << rateIndex);
  SetNextSample (station); //Calculate the next sample rate.
  return rateIndex;
}

  NS_LOG_DEBUG ("New sample set: group= " << +sampleGroup << " index= " << +station->m_sampleTable[index][col]);
}

uint16_t
MinstrelHtWifiManager::FindRate (MinstrelHtWifiRemoteStation *station)
{
  NS_LOG_FUNCTION (this << station);

      //SAMPLING
      NS_LOG_DEBUG ("Obtaining a sampling rate");
      /// Now go through the table and find an index rate.
      uint16_t sampleIdx = GetNextSample (station);
      NS_LOG_DEBUG ("Sampling rate = " << sampleIdx);

      //Evaluate if the sampling rate selected should be used.
      uint8_t sampleGroupId = GetGroupId (sampleIdx);

           */
          HtRateInfo sampleRateInfo = station->m_groupsTable[sampleGroupId].m_ratesTable[sampleRateId];

          NS_LOG_DEBUG ("Use sample rate? MaxTpRate= " << station->m_maxTpRate << " CurrentRate= " << station->m_txrate <<
                        " SampleRate= " << sampleIdx << " SampleProb= " << sampleRateInfo.ewmaProb);

          if (sampleIdx != station->m_maxTpRate && sampleIdx != station->m_maxTpRate2
              && sampleIdx != station->m_maxProbRate && sampleRateInfo.ewmaProb <= 95)

                  /// set the rate that we're currently sampling
                  station->m_sampleRate = sampleIdx;

                  NS_LOG_DEBUG ("FindRate " << "sampleRate=" << sampleIdx);
                  station->m_sampleTries--;
                  return sampleIdx;
                }

                      /// set the rate that we're currently sampling
                      station->m_sampleRate = sampleIdx;

                      NS_LOG_DEBUG ("FindRate " << "sampleRate=" << sampleIdx);
                      station->m_sampleTries--;
                      return sampleIdx;
                    }


  ///	Continue using the best rate.

  NS_LOG_DEBUG ("FindRate " << "maxTpRrate=" << station->m_maxTpRate);
  return station->m_maxTpRate;
}
void

  CalculateRetransmits (station, station->m_maxTpRate2);
  CalculateRetransmits (station, station->m_maxProbRate);

  NS_LOG_DEBUG ("max tp=" << station->m_maxTpRate << "\nmax tp2=" <<  station->m_maxTpRate2 << "\nmax prob=" << station->m_maxProbRate);
  if (m_printStats)
    {
      PrintTable (station);

}

void
MinstrelHtWifiManager::SetBestProbabilityRate (MinstrelHtWifiRemoteStation *station, uint16_t index)
{
  GroupInfo *group;
  HtRateInfo rate;

 * MCS groups.
 */
void
MinstrelHtWifiManager::SetBestStationThRates (MinstrelHtWifiRemoteStation *station, uint16_t index)
{
  uint8_t groupId, rateId;
  double th, prob;

}

void
MinstrelHtWifiManager::CalculateRetransmits (MinstrelHtWifiRemoteStation *station, uint16_t index)
{
  NS_LOG_FUNCTION (this << station << index);
  uint8_t groupId = GetGroupId (index);
  uint8_t rateId = GetRateId (index);
  if (!station->m_groupsTable[groupId].m_ratesTable[rateId].retryUpdated)

  //for off-setting to make rates fall between 0 and nModes
  uint8_t numSampleRates = m_numRates;

  uint16_t newIndex;
  for (uint8_t col = 0; col < m_nSampleCol; col++)
    {
      for (uint8_t i = 0; i < numSampleRates; i++ )

              of << "VHT" << group.chWidth << "   " << giMode << "GI  " << (int)group.streams << "   ";
            }

          uint16_t maxTpRate = station->m_maxTpRate;
          uint16_t maxTpRate2 = station->m_maxTpRate2;
          uint16_t maxProbRate = station->m_maxProbRate;

          uint16_t idx = GetIndex (groupId, i);
          if (idx == maxTpRate)
            {
              of << 'A';

        }
    }
}
uint16_t
MinstrelHtWifiManager::GetIndex (uint8_t groupId, uint8_t rateId)
{
  NS_LOG_FUNCTION (this << +groupId << +rateId);
  uint16_t index;
  index = groupId * m_numRates + rateId;
  return index;
}

uint8_t
MinstrelHtWifiManager::GetRateId (uint16_t index)
{
  NS_LOG_FUNCTION (this << index);
  uint8_t id;
  id = index % m_numRates;
  return id;
}

uint8_t
MinstrelHtWifiManager::GetGroupId (uint16_t index)
{
  NS_LOG_FUNCTION (this << index);
  return index / m_numRates;
}


  return MAX_HT_STREAM_GROUPS * MAX_SUPPORTED_STREAMS + MAX_SUPPORTED_STREAMS * 2 * (chWidth == 160 ? 3 : chWidth == 80 ? 2 : chWidth == 40 ? 1 : 0) + MAX_SUPPORTED_STREAMS * sgi + txstreams - 1;
}

uint16_t
MinstrelHtWifiManager::GetLowestIndex (MinstrelHtWifiRemoteStation *station)
{
  NS_LOG_FUNCTION (this << station);

  return GetIndex (groupId, rateId);
}

uint16_t
MinstrelHtWifiManager::GetLowestIndex (MinstrelHtWifiRemoteStation *station, uint8_t groupId)
{
  NS_LOG_FUNCTION (this << station << +groupId);

  uint8_t rateId = 0;
  while (rateId < m_numRates && !station->m_groupsTable[groupId].m_ratesTable[rateId].supported)




  uint8_t m_col;                  //!< Sample table column.
  uint8_t m_index;                //!< Sample table index.
  bool m_supported;               //!< If the rates of this group are supported by the station.
  uint16_t m_maxTpRate;           //!< The max throughput rate of this group.
  uint16_t m_maxTpRate2;          //!< The second max throughput rate of this group.
  uint16_t m_maxProbRate;         //!< The highest success probability rate of this group.
  HtMinstrelRate m_ratesTable;    //!< Information about rates of this group.
};


typedef std::vector<struct GroupInfo> McsGroupData;

/**
 * Data structure for a Sample Rate table.
 * A vector of a vector uint8_t.
 */
typedef std::vector<std::vector<uint8_t> > HtSampleRate;

/**
 * Constants for maximum values.
 */


   * \param station the wifi remote station
   * \returns the next sample
   */
  uint16_t GetNextSample (MinstrelHtWifiRemoteStation *station);

  /**
   * Set the next sample from Sample Table.

   * \param station the minstrel HT wifi remote station
   * \returns the rate
   */
  uint16_t FindRate (MinstrelHtWifiRemoteStation *station);

  /**
   * Updating the Minstrel Table every 1/10 seconds.

   * \param station the minstrel HT wifi remote station
   * \param index the index
   */
  void SetBestStationThRates (MinstrelHtWifiRemoteStation *station, uint16_t index);

  /**
   * Set index rate as maxProbRate if it is better than current value.

   * \param station the minstrel HT wifi remote station
   * \param index the index
   */
  void SetBestProbabilityRate (MinstrelHtWifiRemoteStation *station, uint16_t index);

  /**
   * Calculate the number of retransmissions to set for the index rate.

   * \param station the minstrel HT wifi remote station
   * \param index the index
   */
  void CalculateRetransmits (MinstrelHtWifiRemoteStation *station, uint16_t index);

  /**
   * Calculate the number of retransmissions to set for the (groupId, rateId) rate.

   * Print group statistics.
   *
   * \param station the minstrel HT wifi remote station
   * \param groupId the group ID
   * \param of the output file stream
   */
  void StatsDump (MinstrelHtWifiRemoteStation *station, uint8_t groupId, std::ofstream &of);

  /**
   * Check for initializations.

   * \param index the index
   * \returns the rate ID
   */
  uint8_t GetRateId (uint16_t index);

  /**
   * Return the groupId from the global index.

   * \param index the index
   * \returns the group ID
   */
  uint8_t GetGroupId (uint16_t index);

  /**
   * Returns the global index corresponding to the groupId and rateId.

   * \param rateId the rate ID
   * \returns the index
   */
  uint16_t GetIndex (uint8_t groupId, uint8_t rateId);

  /**
   * Returns the groupId of a HT MCS with the given number of streams, if using sgi and the channel width used.

   * \param station the minstrel HT wifi remote station
   * \returns the lowest global index
   */
  uint16_t GetLowestIndex (MinstrelHtWifiRemoteStation *station);

  /**
   * Returns the lowest global index of the rates supported by in the group.

   * \param groupId the group ID
   * \returns the lowest global index
   */
  uint16_t GetLowestIndex (MinstrelHtWifiRemoteStation *station, uint8_t groupId);

  /**
   * Returns a list of only the VHT MCS supported by the device.

   */
  WifiModeList GetHtDeviceMcsList (void) const;

  Time m_updateStats;        //!< How frequent do we calculate the stats (1/10 seconds).
  uint8_t m_lookAroundRate;  //!< The % to try other rates than our current rate.
  uint8_t m_ewmaLevel;       //!< Exponential weighted moving average level (or coefficient).
  uint8_t m_nSampleCol;      //!< Number of sample columns.
  uint32_t m_frameLength;    //!< Frame length used for calculate modes TxTime.
  uint8_t m_numGroups;       //!< Number of groups Minstrel should consider.
  uint8_t m_numRates;        //!< Number of rates per group Minstrel should consider.
  bool m_useVhtOnly;         //!< If only VHT MCS should be used, instead of HT and VHT.
  bool m_printStats;         //!< If statistics table should be printed.

  bool m_useVhtOnly;           //!< If only VHT MCS should be used, instead of HT and VHT.

  bool m_printStats;           //!< If statistics table should be printed.

  MinstrelMcsGroups m_minstrelGroups;                 //!< Global array for groups information.

  Ptr<MinstrelWifiManager> m_legacyManager;           //!< Pointer to an instance of MinstrelWifiManager. Used when 802.11n/ac not supported.


  Ptr<UniformRandomVariable> m_uniformRandomVariable; //!< Provides uniform random variables.

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




  //for normal rate, we're not currently sampling random rates
  if (!station->m_isSampling)
    {
      NS_LOG_DEBUG ("Failed with normal rate: current=" << station->m_txrate << ", sample=" << station->m_sampleRate << ", maxTp=" << station->m_maxTpRate << ", maxTp2=" << station->m_maxTpRate2 << ", maxProb=" << station->m_maxProbRate);
      //use best throughput rate
      if (station->m_longRetry < station->m_minstrelTable[station->m_maxTpRate].adjustedRetryCount)
        {

  //for look-around rate, we're currently sampling random rates
  else
    {
      NS_LOG_DEBUG ("Failed with look around rate: current=" << station->m_txrate << ", sample=" << station->m_sampleRate << ", maxTp=" << station->m_maxTpRate << ", maxTp2=" << station->m_maxTpRate2 << ", maxProb=" << station->m_maxProbRate);
      //current sampling rate is slower than the current best rate
      if (station->m_sampleDeferred)
        {

MinstrelWifiManager::GetRtsTxVector (MinstrelWifiRemoteStation *station)
{
  NS_LOG_FUNCTION (this << station);
  NS_LOG_DEBUG ("DoGetRtsMode m_txrate=" << station->m_txrate);
  uint16_t channelWidth = GetChannelWidth (station);
  if (channelWidth > 20 && channelWidth != 22)
    {

    }
}

uint16_t
MinstrelWifiManager::FindRate (MinstrelWifiRemoteStation *station)
{
  NS_LOG_FUNCTION (this << station);

      return 0;
    }

  uint16_t idx = 0;
  NS_LOG_DEBUG ("Total: " << station->m_totalPacketsCount << "  Sample: " << station->m_samplePacketsCount << "  Deferred: " << station->m_numSamplesDeferred);

  int delta = (station->m_totalPacketsCount * m_lookAroundRate / 100) - (station->m_samplePacketsCount + station->m_numSamplesDeferred / 2);

      //now go through the table and find an index rate
      idx = GetNextSample (station);

      NS_LOG_DEBUG ("Sample rate = " << idx << "(" << GetSupported (station, idx) << ")");

      //error check
      if (idx >= station->m_nModes)

      //using the best rate instead
      if (station->m_sampleDeferred)
        {
          NS_LOG_DEBUG ("The next look around rate is slower than the maximum throughput rate, continue with the maximum throughput rate: " << station->m_maxTpRate << "(" << GetSupported (station, station->m_maxTpRate) << ")");
          idx = station->m_maxTpRate;
        }
    }
  //continue using the best rate
  else
    {
      NS_LOG_DEBUG ("Continue using the maximum throughput rate: " << station->m_maxTpRate << "(" << GetSupported (station, station->m_maxTpRate) << ")");
      idx = station->m_maxTpRate;
    }

  NS_LOG_DEBUG ("Rate = " << idx << "(" << GetSupported (station, idx) << ")");

  return idx;
}

  NS_LOG_FUNCTION (this);
  station->m_nextStatsUpdate = Simulator::Now () + m_updateStats;
  NS_LOG_DEBUG ("Next update at " << station->m_nextStatsUpdate);
  NS_LOG_DEBUG ("Currently using rate: " << station->m_txrate << " (" << GetSupported (station, station->m_txrate) << ")");

  Time txTime;
  uint32_t tempProb;

          txTime = Seconds (1);
        }

      NS_LOG_DEBUG (+i << " " << GetSupported (station, i) <<
                    "\t" << station->m_minstrelTable[i].numRateAttempt <<
                    "\t" << station->m_minstrelTable[i].numRateSuccess);



  NS_LOG_DEBUG ("max throughput=" << +index_max_tp << "(" << GetSupported (station, index_max_tp) <<
                ")\tsecond max throughput=" << +index_max_tp2 << "(" << GetSupported (station, index_max_tp2) <<
                ")\tmax prob=" << +index_max_prob << "(" << GetSupported (station, index_max_prob) << ")");
  if (m_printStats)
    {
      PrintTable (station);

MinstrelWifiManager::DoReportRxOk (WifiRemoteStation *st, double rxSnr, WifiMode txMode)
{
  NS_LOG_FUNCTION (this << st << rxSnr << txMode);
  NS_LOG_DEBUG ("DoReportRxOk m_txrate=" << ((MinstrelWifiRemoteStation *)st)->m_txrate);
}

void

{
  NS_LOG_FUNCTION (this << st);
  MinstrelWifiRemoteStation *station = (MinstrelWifiRemoteStation *)st;
  NS_LOG_DEBUG ("DoReportRtsFailed m_txrate=" << station->m_txrate);
  station->m_shortRetry++;
}


{
  NS_LOG_FUNCTION (this << st);
  MinstrelWifiRemoteStation *station = (MinstrelWifiRemoteStation *)st;
  NS_LOG_DEBUG ("DoReportDataFailed " << station << "\t rate " << station->m_txrate << "\tlongRetry \t" << station->m_longRetry);
  CheckInit (station);
  if (!station->m_initialized)
    {

      return;
    }

  NS_LOG_DEBUG ("DoReportDataOk m_txrate = " << station->m_txrate << ", attempt = " << station->m_minstrelTable[station->m_txrate].numRateAttempt << ", success = " << station->m_minstrelTable[station->m_txrate].numRateSuccess << " (before update).");

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

  UpdatePacketCounters (station);

  NS_LOG_DEBUG ("DoReportDataOk m_txrate = " << station->m_txrate << ", attempt = " << station->m_minstrelTable[station->m_txrate].numRateAttempt << ", success = " << station->m_minstrelTable[station->m_txrate].numRateSuccess << " (after update).");

  UpdateRetry (station);
  UpdateStats (station);

    {
      station->m_txrate = FindRate (station);
    }
  NS_LOG_DEBUG ("Next rate to use TxRate = " << station->m_txrate);
}

void

    {
      station->m_txrate = FindRate (station);
    }
  NS_LOG_DEBUG ("Next rate to use TxRate = " << station->m_txrate);
}

void

  return true;
}

uint16_t
MinstrelWifiManager::GetNextSample (MinstrelWifiRemoteStation *station)
{
  NS_LOG_FUNCTION (this << station);
  uint16_t bitrate;
  bitrate = station->m_sampleTable[station->m_index][station->m_col];
  station->m_index++;

  //bookkeeping for m_index and m_col variables

  //for off-setting to make rates fall between 0 and nModes
  uint8_t numSampleRates = station->m_nModes;

  uint16_t newIndex;
  for (uint8_t col = 0; col < m_sampleCol; col++)
    {
      for (uint8_t i = 0; i < numSampleRates; i++ )

  station->m_statsFile << "best   _______________rate________________    ________statistics________    ________last_______    ______sum-of________\n" <<
    "rate  [      name       idx airtime max_tp]  [avg(tp) avg(prob) sd(prob)]  [prob.|retry|suc|att]  [#success | #attempts]\n";

  uint16_t maxTpRate = station->m_maxTpRate;
  uint16_t maxTpRate2 = station->m_maxTpRate2;
  uint16_t maxProbRate = station->m_maxProbRate;

  for (uint8_t i = 0; i < station->m_nModes; i++)
    {




   */
  uint8_t m_col;                 ///< vector index
  uint8_t m_index;               ///< vector index
  uint16_t m_maxTpRate;          ///< the current throughput rate
  uint16_t m_maxTpRate2;         ///< second highest throughput rate
  uint16_t m_maxProbRate;        ///< rate with highest prob of success
  uint8_t m_nModes;              ///< number of modes supported
  int m_totalPacketsCount;       ///< total number of packets as of now
  int m_samplePacketsCount;      ///< how many packets we have sample so far
  int m_numSamplesDeferred;      ///< number samles deferred
  bool m_isSampling;             ///< a flag to indicate we are currently sampling
  uint16_t m_sampleRate;         ///< current sample rate
  bool m_sampleDeferred;         ///< a flag to indicate sample rate is on the second stage
  uint32_t m_shortRetry;         ///< short retries such as control packts
  uint32_t m_longRetry;          ///< long retries such as data packets
  uint32_t m_retry;              ///< total retries short + long
  uint16_t m_txrate;             ///< current transmit rate
  bool m_initialized;            ///< for initializing tables
  MinstrelRate m_minstrelTable;  ///< minstrel table
  SampleRate m_sampleTable;      ///< sample table

   * \param station the station object
   * \returns the rate
   */
  uint16_t FindRate (MinstrelWifiRemoteStation *station);

  /**
   * Get data transmit vector

   * \param station the station object
   * \returns the next sample
   */
  uint16_t GetNextSample (MinstrelWifiRemoteStation *station);

  /**
   * Estimate the time to transmit the given packet with the given number of retries.

Return to bug 2950