A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
rrpaa-wifi-manager.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2017 Universidad de la República - Uruguay
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Matías Richart <mrichart@fing.edu.uy>
18 */
19
20#include "rrpaa-wifi-manager.h"
21
22#include "ns3/boolean.h"
23#include "ns3/data-rate.h"
24#include "ns3/double.h"
25#include "ns3/log.h"
26#include "ns3/packet.h"
27#include "ns3/simulator.h"
28#include "ns3/uinteger.h"
29#include "ns3/wifi-mac.h"
30#include "ns3/wifi-phy.h"
31
32NS_LOG_COMPONENT_DEFINE("RrpaaWifiManager");
33
34namespace ns3
35{
36
44{
53 uint8_t m_nRate;
55 uint8_t m_rateIndex;
57 uint8_t m_powerLevel;
60};
61
63
66{
67 static TypeId tid =
68 TypeId("ns3::RrpaaWifiManager")
70 .SetGroupName("Wifi")
71 .AddConstructor<RrpaaWifiManager>()
72 .AddAttribute(
73 "Basic",
74 "If true the RRPAA-BASIC algorithm will be used, otherwise the RRPAA will be used.",
75 BooleanValue(true),
78 .AddAttribute("Timeout",
79 "Timeout for the RRPAA-BASIC loss estimation block.",
83 .AddAttribute("FrameLength",
84 "The Data frame length (in bytes) used for calculating mode TxTime.",
85 UintegerValue(1420),
87 MakeUintegerChecker<uint32_t>())
88 .AddAttribute("AckFrameLength",
89 "The Ack frame length (in bytes) used for calculating mode TxTime.",
90 UintegerValue(14),
92 MakeUintegerChecker<uint32_t>())
93 .AddAttribute("Alpha",
94 "Constant for calculating the MTL threshold.",
95 DoubleValue(1.25),
97 MakeDoubleChecker<double>(1))
98 .AddAttribute("Beta",
99 "Constant for calculating the ORI threshold.",
100 DoubleValue(2),
102 MakeDoubleChecker<double>(1))
103 .AddAttribute("Tau",
104 "Constant for calculating the EWND size.",
105 DoubleValue(0.015),
107 MakeDoubleChecker<double>(0))
108 .AddAttribute("Gamma",
109 "Constant for Probabilistic Decision Table decrements.",
110 DoubleValue(2),
112 MakeDoubleChecker<double>(1))
113 .AddAttribute("Delta",
114 "Constant for Probabilistic Decision Table increments.",
115 DoubleValue(1.0905),
117 MakeDoubleChecker<double>(1))
118 .AddTraceSource("RateChange",
119 "The transmission rate has change.",
121 "ns3::WifiRemoteStationManager::RateChangeTracedCallback")
122 .AddTraceSource("PowerChange",
123 "The transmission power has change.",
125 "ns3::WifiRemoteStationManager::PowerChangeTracedCallback");
126 return tid;
127}
128
130{
131 NS_LOG_FUNCTION(this);
132 m_uniformRandomVariable = CreateObject<UniformRandomVariable>();
133}
134
136{
137 NS_LOG_FUNCTION(this);
138}
139
140int64_t
142{
143 NS_LOG_FUNCTION(this << stream);
145 return 1;
146}
147
148void
150{
151 NS_LOG_FUNCTION(this << phy);
152 m_sifs = phy->GetSifs();
153 m_difs = m_sifs + 2 * phy->GetSlot();
154 m_nPowerLevels = phy->GetNTxPower();
156 m_minPowerLevel = 0;
157 for (const auto& mode : phy->GetModeList())
158 {
159 WifiTxVector txVector;
160 txVector.SetMode(mode);
162 /* Calculate the TX Time of the Data and the corresponding Ack */
163 Time dataTxTime = phy->CalculateTxDuration(m_frameLength, txVector, phy->GetPhyBand());
164 Time ackTxTime = phy->CalculateTxDuration(m_ackLength, txVector, phy->GetPhyBand());
165 NS_LOG_DEBUG("Calculating TX times: Mode= " << mode << " DataTxTime= " << dataTxTime
166 << " AckTxTime= " << ackTxTime);
167 AddCalcTxTime(mode, dataTxTime + ackTxTime);
168 }
170}
171
172void
174{
175 NS_LOG_FUNCTION(this << mac);
177}
178
179void
181{
182 NS_LOG_FUNCTION(this);
183 if (GetHtSupported())
184 {
185 NS_FATAL_ERROR("WifiRemoteStationManager selected does not support HT rates");
186 }
187 if (GetVhtSupported())
188 {
189 NS_FATAL_ERROR("WifiRemoteStationManager selected does not support VHT rates");
190 }
191 if (GetHeSupported())
192 {
193 NS_FATAL_ERROR("WifiRemoteStationManager selected does not support HE rates");
194 }
195}
196
197Time
199{
200 NS_LOG_FUNCTION(this << mode);
201 for (auto i = m_calcTxTime.begin(); i != m_calcTxTime.end(); i++)
202 {
203 if (mode == i->second)
204 {
205 return i->first;
206 }
207 }
208 NS_ASSERT(false);
209 return Seconds(0);
210}
211
212void
214{
215 NS_LOG_FUNCTION(this << mode << t);
216 m_calcTxTime.emplace_back(t, mode);
217}
218
221{
222 NS_LOG_FUNCTION(this << station << mode);
223 WifiRrpaaThresholds threshold;
224 for (auto i = station->m_thresholds.begin(); i != station->m_thresholds.end(); i++)
225 {
226 if (mode == i->second)
227 {
228 return i->first;
229 }
230 }
231 NS_ABORT_MSG("No thresholds for mode " << mode << " found");
232 return threshold; // Silence compiler warning
233}
234
237{
238 NS_LOG_FUNCTION(this);
239 auto station = new RrpaaWifiRemoteStation();
240 station->m_adaptiveRtsWnd = 0;
241 station->m_rtsCounter = 0;
242 station->m_adaptiveRtsOn = false;
243 station->m_lastFrameFail = false;
244 station->m_initialized = false;
245 return station;
246}
247
248void
250{
251 NS_LOG_FUNCTION(this << station);
252 if (!station->m_initialized)
253 {
254 // Note: we appear to be doing late initialization of the table
255 // to make sure that the set of supported rates has been initialized
256 // before we perform our own initialization.
257 station->m_nRate = GetNSupported(station);
258 // Initialize at minimal rate and maximal power.
259 station->m_prevRateIndex = 0;
260 station->m_rateIndex = 0;
262 station->m_powerLevel = m_maxPowerLevel;
263 WifiMode mode = GetSupported(station, 0);
264 uint16_t channelWidth = GetChannelWidth(station);
265 DataRate rate(mode.GetDataRate(channelWidth));
266 double power = GetPhy()->GetPowerDbm(station->m_powerLevel);
267 m_rateChange(rate, rate, station->m_state->m_address);
268 m_powerChange(power, power, station->m_state->m_address);
269
270 station->m_pdTable =
271 RrpaaProbabilitiesTable(station->m_nRate, std::vector<double>(m_nPowerLevels));
272 NS_LOG_DEBUG("Initializing pdTable");
273 for (uint8_t i = 0; i < station->m_nRate; i++)
274 {
275 for (uint8_t j = 0; j < m_nPowerLevels; j++)
276 {
277 station->m_pdTable[i][j] = 1;
278 }
279 }
280
281 station->m_initialized = true;
282
283 station->m_thresholds = RrpaaThresholdsTable(station->m_nRate);
284 InitThresholds(station);
285 ResetCountersBasic(station);
286 }
287}
288
289void
291{
292 NS_LOG_FUNCTION(this << station);
293 double nextCritical = 0;
294 double nextMtl = 0;
295 double mtl = 0;
296 double ori = 0;
297 for (uint8_t i = 0; i < station->m_nRate; i++)
298 {
299 WifiMode mode = GetSupported(station, i);
300 Time totalTxTime = GetCalcTxTime(mode) + m_sifs + m_difs;
301 if (i == station->m_nRate - 1)
302 {
303 ori = 0;
304 }
305 else
306 {
307 WifiMode nextMode = GetSupported(station, i + 1);
308 Time nextTotalTxTime = GetCalcTxTime(nextMode) + m_sifs + m_difs;
309 nextCritical = 1 - (nextTotalTxTime.GetSeconds() / totalTxTime.GetSeconds());
310 nextMtl = m_alpha * nextCritical;
311 ori = nextMtl / m_beta;
312 }
313 if (i == 0)
314 {
315 mtl = nextMtl;
316 }
318 th.m_ewnd = static_cast<uint32_t>(ceil(m_tau / totalTxTime.GetSeconds()));
319 th.m_ori = ori;
320 th.m_mtl = mtl;
321 station->m_thresholds.emplace_back(th, mode);
322 mtl = nextMtl;
323 NS_LOG_DEBUG(mode << " " << th.m_ewnd << " " << th.m_mtl << " " << th.m_ori);
324 }
325}
326
327void
329{
330 NS_LOG_FUNCTION(this << station);
331 station->m_nFailed = 0;
332 station->m_counter = GetThresholds(station, station->m_rateIndex).m_ewnd;
333 station->m_lastReset = Simulator::Now();
334}
335
336void
338{
339 NS_LOG_FUNCTION(this << st);
340}
341
342void
344{
345 NS_LOG_FUNCTION(this << st);
346 auto station = static_cast<RrpaaWifiRemoteStation*>(st);
347 CheckInit(station);
348 station->m_lastFrameFail = true;
349 CheckTimeout(station);
350 station->m_counter--;
351 station->m_nFailed++;
352 RunBasicAlgorithm(station);
353}
354
355void
357{
358 NS_LOG_FUNCTION(this << st << rxSnr << txMode);
359}
360
361void
363 double ctsSnr,
364 WifiMode ctsMode,
365 double rtsSnr)
366{
367 NS_LOG_FUNCTION(this << st << ctsSnr << ctsMode << rtsSnr);
368}
369
370void
372 double ackSnr,
373 WifiMode ackMode,
374 double dataSnr,
375 uint16_t dataChannelWidth,
376 uint8_t dataNss)
377{
378 NS_LOG_FUNCTION(this << st << ackSnr << ackMode << dataSnr << dataChannelWidth << +dataNss);
379 auto station = static_cast<RrpaaWifiRemoteStation*>(st);
380 CheckInit(station);
381 station->m_lastFrameFail = false;
382 CheckTimeout(station);
383 station->m_counter--;
384 RunBasicAlgorithm(station);
385}
386
387void
389{
390 NS_LOG_FUNCTION(this << st);
391}
392
393void
395{
396 NS_LOG_FUNCTION(this << st);
397}
398
401{
402 NS_LOG_FUNCTION(this << st << allowedWidth);
403 auto station = static_cast<RrpaaWifiRemoteStation*>(st);
404 uint16_t channelWidth = GetChannelWidth(station);
405 if (channelWidth > 20 && channelWidth != 22)
406 {
407 channelWidth = 20;
408 }
409 CheckInit(station);
410 WifiMode mode = GetSupported(station, station->m_rateIndex);
411 DataRate rate(mode.GetDataRate(channelWidth));
412 DataRate prevRate(GetSupported(station, station->m_prevRateIndex).GetDataRate(channelWidth));
413 double power = GetPhy()->GetPowerDbm(station->m_powerLevel);
414 double prevPower = GetPhy()->GetPowerDbm(station->m_prevPowerLevel);
415 if (station->m_prevRateIndex != station->m_rateIndex)
416 {
417 m_rateChange(prevRate, rate, station->m_state->m_address);
418 station->m_prevRateIndex = station->m_rateIndex;
419 }
420 if (station->m_prevPowerLevel != station->m_powerLevel)
421 {
422 m_powerChange(prevPower, power, station->m_state->m_address);
423 station->m_prevPowerLevel = station->m_powerLevel;
424 }
425 return WifiTxVector(
426 mode,
427 station->m_powerLevel,
429 800,
430 1,
431 1,
432 0,
433 channelWidth,
434 GetAggregation(station));
435}
436
439{
440 NS_LOG_FUNCTION(this << st);
441 auto station = static_cast<RrpaaWifiRemoteStation*>(st);
442 uint16_t channelWidth = GetChannelWidth(station);
443 if (channelWidth > 20 && channelWidth != 22)
444 {
445 channelWidth = 20;
446 }
447 WifiMode mode;
449 {
450 mode = GetSupported(station, 0);
451 }
452 else
453 {
454 mode = GetNonErpSupported(station, 0);
455 }
456 return WifiTxVector(
457 mode,
460 800,
461 1,
462 1,
463 0,
464 channelWidth,
465 GetAggregation(station));
466}
467
468bool
470{
471 NS_LOG_FUNCTION(this << st << size << normally);
472 auto station = static_cast<RrpaaWifiRemoteStation*>(st);
473 CheckInit(station);
474 if (m_basic)
475 {
476 return normally;
477 }
479 return station->m_adaptiveRtsOn;
480}
481
482void
484{
485 NS_LOG_FUNCTION(this << station);
486 Time d = Simulator::Now() - station->m_lastReset;
487 if (station->m_counter == 0 || d > m_timeout)
488 {
489 ResetCountersBasic(station);
490 }
491}
492
493void
495{
496 NS_LOG_FUNCTION(this << station);
497 WifiRrpaaThresholds thresholds = GetThresholds(station, station->m_rateIndex);
498 double bploss = (static_cast<double>(station->m_nFailed) / thresholds.m_ewnd);
499 double wploss =
500 (static_cast<double>(station->m_counter + station->m_nFailed) / thresholds.m_ewnd);
501 NS_LOG_DEBUG("Best loss prob= " << bploss);
502 NS_LOG_DEBUG("Worst loss prob= " << wploss);
503 if (bploss >= thresholds.m_mtl)
504 {
505 if (station->m_powerLevel < m_maxPowerLevel)
506 {
507 NS_LOG_DEBUG("bploss >= MTL and power < maxPower => Increase Power");
508 station->m_pdTable[station->m_rateIndex][station->m_powerLevel] /= m_gamma;
509 NS_LOG_DEBUG("pdTable["
510 << +station->m_rateIndex << "][" << station->m_powerLevel << "] = "
511 << station->m_pdTable[station->m_rateIndex][station->m_powerLevel]);
512 station->m_powerLevel++;
513 ResetCountersBasic(station);
514 }
515 else if (station->m_rateIndex != 0)
516 {
517 NS_LOG_DEBUG("bploss >= MTL and power = maxPower => Decrease Rate");
518 station->m_pdTable[station->m_rateIndex][station->m_powerLevel] /= m_gamma;
519 NS_LOG_DEBUG("pdTable["
520 << +station->m_rateIndex << "][" << station->m_powerLevel << "] = "
521 << station->m_pdTable[station->m_rateIndex][station->m_powerLevel]);
522 station->m_rateIndex--;
523 ResetCountersBasic(station);
524 }
525 else
526 {
527 NS_LOG_DEBUG("bploss >= MTL but already at maxPower and minRate");
528 }
529 }
530 else if (wploss <= thresholds.m_ori)
531 {
532 if (station->m_rateIndex < station->m_nRate - 1)
533 {
534 NS_LOG_DEBUG("wploss <= ORI and rate < maxRate => Probabilistic Rate Increase");
535
536 // Recalculate probabilities of lower rates.
537 for (uint8_t i = 0; i <= station->m_rateIndex; i++)
538 {
539 station->m_pdTable[i][station->m_powerLevel] *= m_delta;
540 if (station->m_pdTable[i][station->m_powerLevel] > 1)
541 {
542 station->m_pdTable[i][station->m_powerLevel] = 1;
543 }
544 NS_LOG_DEBUG("pdTable[" << i << "][" << (int)station->m_powerLevel
545 << "] = " << station->m_pdTable[i][station->m_powerLevel]);
546 }
547 double rand = m_uniformRandomVariable->GetValue(0, 1);
548 if (rand < station->m_pdTable[station->m_rateIndex + 1][station->m_powerLevel])
549 {
550 NS_LOG_DEBUG("Increase Rate");
551 station->m_rateIndex++;
552 }
553 }
554 else if (station->m_powerLevel > m_minPowerLevel)
555 {
556 NS_LOG_DEBUG("wploss <= ORI and rate = maxRate => Probabilistic Power Decrease");
557
558 // Recalculate probabilities of higher powers.
559 for (uint32_t i = m_maxPowerLevel; i > station->m_powerLevel; i--)
560 {
561 station->m_pdTable[station->m_rateIndex][i] *= m_delta;
562 if (station->m_pdTable[station->m_rateIndex][i] > 1)
563 {
564 station->m_pdTable[station->m_rateIndex][i] = 1;
565 }
566 NS_LOG_DEBUG("pdTable[" << +station->m_rateIndex << "][" << i
567 << "] = " << station->m_pdTable[station->m_rateIndex][i]);
568 }
569 double rand = m_uniformRandomVariable->GetValue(0, 1);
570 if (rand < station->m_pdTable[station->m_rateIndex][station->m_powerLevel - 1])
571 {
572 NS_LOG_DEBUG("Decrease Power");
573 station->m_powerLevel--;
574 }
575 }
576 ResetCountersBasic(station);
577 }
578 else if (bploss > thresholds.m_ori && wploss < thresholds.m_mtl)
579 {
580 if (station->m_powerLevel > m_minPowerLevel)
581 {
582 NS_LOG_DEBUG("loss between ORI and MTL and power > minPowerLevel => Probabilistic "
583 "Power Decrease");
584
585 // Recalculate probabilities of higher powers.
586 for (uint32_t i = m_maxPowerLevel; i >= station->m_powerLevel; i--)
587 {
588 station->m_pdTable[station->m_rateIndex][i] *= m_delta;
589 if (station->m_pdTable[station->m_rateIndex][i] > 1)
590 {
591 station->m_pdTable[station->m_rateIndex][i] = 1;
592 }
593 NS_LOG_DEBUG("pdTable[" << +station->m_rateIndex << "][" << i
594 << "] = " << station->m_pdTable[station->m_rateIndex][i]);
595 }
596 double rand = m_uniformRandomVariable->GetValue(0, 1);
597 if (rand < station->m_pdTable[station->m_rateIndex][station->m_powerLevel - 1])
598 {
599 NS_LOG_DEBUG("Decrease Power");
600 station->m_powerLevel--;
601 }
602 ResetCountersBasic(station);
603 }
604 }
605 if (station->m_counter == 0)
606 {
607 ResetCountersBasic(station);
608 }
609}
610
611void
613{
614 NS_LOG_FUNCTION(this << station);
615 if (!station->m_adaptiveRtsOn && station->m_lastFrameFail)
616 {
617 station->m_adaptiveRtsWnd += 2;
618 station->m_rtsCounter = station->m_adaptiveRtsWnd;
619 }
620 else if ((station->m_adaptiveRtsOn && station->m_lastFrameFail) ||
621 (!station->m_adaptiveRtsOn && !station->m_lastFrameFail))
622 {
623 station->m_adaptiveRtsWnd = station->m_adaptiveRtsWnd / 2;
624 station->m_rtsCounter = station->m_adaptiveRtsWnd;
625 }
626 if (station->m_rtsCounter > 0)
627 {
628 station->m_adaptiveRtsOn = true;
629 station->m_rtsCounter--;
630 }
631 else
632 {
633 station->m_adaptiveRtsOn = false;
634 }
635}
636
639{
640 NS_LOG_FUNCTION(this << station << +index);
641 WifiMode mode = GetSupported(station, index);
642 return GetThresholds(station, mode);
643}
644
645} // namespace ns3
AttributeValue implementation for Boolean.
Definition: boolean.h:37
Class for representing data rates.
Definition: data-rate.h:89
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:77
void SetStream(int64_t stream)
Specifies the stream number for the RngStream.
Time m_sifs
Value of SIFS configured in the device.
Ptr< UniformRandomVariable > m_uniformRandomVariable
Provides uniform random variables for probabilistic changes.
uint8_t m_maxPowerLevel
Maximal power level.
void ResetCountersBasic(RrpaaWifiRemoteStation *station)
Reset the counters of the given station.
double m_beta
Beta value for RRPAA (value for calculating ORI threshold).
int64_t AssignStreams(int64_t stream) override
Assign a fixed random variable stream number to the random variables used by this model.
Time m_difs
Value of DIFS configured in the device.
WifiRemoteStation * DoCreateStation() const override
bool m_basic
If using the basic algorithm (without RTS/CTS).
void DoInitialize() override
Initialize() implementation.
void DoReportRtsFailed(WifiRemoteStation *station) override
This method is a pure virtual method that must be implemented by the sub-class.
void SetupPhy(const Ptr< WifiPhy > phy) override
Set up PHY associated with this device since it is the object that knows the full set of transmit rat...
TxTime m_calcTxTime
To hold all the calculated TxTime for all modes.
void CheckInit(RrpaaWifiRemoteStation *station)
Check for initializations.
WifiTxVector DoGetDataTxVector(WifiRemoteStation *station, uint16_t allowedWidth) override
TracedCallback< double, double, Mac48Address > m_powerChange
The trace source fired when the transmission power change.
uint8_t m_minPowerLevel
Differently form rate, power levels do not depend on the remote station.
void DoReportRtsOk(WifiRemoteStation *station, double ctsSnr, WifiMode ctsMode, double rtsSnr) override
This method is a pure virtual method that must be implemented by the sub-class.
void SetupMac(const Ptr< WifiMac > mac) override
Set up MAC associated with this device since it is the object that knows the full set of timing param...
void RunAdaptiveRtsAlgorithm(RrpaaWifiRemoteStation *station)
Run an enhanced algorithm which activates the use of RTS for the given station if the conditions are ...
TracedCallback< DataRate, DataRate, Mac48Address > m_rateChange
The trace source fired when the transmission rate change.
Time m_timeout
Timeout for the RRAA BASIC loss estimation block.
uint32_t m_ackLength
Ack frame length used to calculate mode TxTime (in bytes).
uint8_t m_nPowerLevels
Number of power levels.
WifiRrpaaThresholds GetThresholds(RrpaaWifiRemoteStation *station, WifiMode mode) const
Get the thresholds for the given station and mode.
void DoReportDataOk(WifiRemoteStation *station, double ackSnr, WifiMode ackMode, double dataSnr, uint16_t dataChannelWidth, uint8_t dataNss) override
This method is a pure virtual method that must be implemented by the sub-class.
double m_tau
Tau value for RRPAA (value for calculating EWND size).
void DoReportRxOk(WifiRemoteStation *station, double rxSnr, WifiMode txMode) override
This method is a pure virtual method that must be implemented by the sub-class.
double m_gamma
Gamma value for RRPAA (value for pdTable decrements).
Time GetCalcTxTime(WifiMode mode) const
Get the estimated TxTime of a packet with a given mode.
double m_delta
Delta value for RRPAA (value for pdTable increments).
void CheckTimeout(RrpaaWifiRemoteStation *station)
Check if the counter should be reset.
double m_alpha
Alpha value for RRPAA (value for calculating MTL threshold)
bool DoNeedRts(WifiRemoteStation *st, uint32_t size, bool normally) override
void DoReportFinalDataFailed(WifiRemoteStation *station) override
This method is a pure virtual method that must be implemented by the sub-class.
void DoReportDataFailed(WifiRemoteStation *station) override
This method is a pure virtual method that must be implemented by the sub-class.
void DoReportFinalRtsFailed(WifiRemoteStation *station) override
This method is a pure virtual method that must be implemented by the sub-class.
uint32_t m_frameLength
Data frame length used to calculate mode TxTime (in bytes).
void AddCalcTxTime(WifiMode mode, Time t)
Add transmission time for the given mode to an internal list.
void InitThresholds(RrpaaWifiRemoteStation *station)
Initialize the thresholds internal list for the given station.
WifiTxVector DoGetRtsTxVector(WifiRemoteStation *station) override
static TypeId GetTypeId()
Register this type.
void RunBasicAlgorithm(RrpaaWifiRemoteStation *station)
Find an appropriate rate and power for the given station, using a basic algorithm.
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:208
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:403
AttributeValue implementation for Time.
Definition: nstime.h:1413
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:932
Hold an unsigned integer type.
Definition: uinteger.h:45
double GetValue(double min, double max)
Get the next random value drawn from the distribution.
represent a single transmission mode
Definition: wifi-mode.h:51
WifiModulationClass GetModulationClass() const
Definition: wifi-mode.cc:185
uint64_t GetDataRate(uint16_t channelWidth, uint16_t guardInterval, uint8_t nss) const
Definition: wifi-mode.cc:122
double GetPowerDbm(uint8_t power) const
Get the power of the given power level in dBm.
Definition: wifi-phy.cc:690
hold a list of per-remote-station state.
uint16_t GetChannelWidth(const WifiRemoteStation *station) const
Return the channel width supported by the station.
uint8_t GetNSupported(const WifiRemoteStation *station) const
Return the number of modes supported by the given station.
Ptr< WifiPhy > GetPhy() const
Return the WifiPhy.
bool GetAggregation(const WifiRemoteStation *station) const
Return whether the given station supports A-MPDU.
bool GetHtSupported() const
Return whether the device has HT capability support enabled.
WifiMode GetNonErpSupported(const WifiRemoteStation *station, uint8_t i) const
Return whether non-ERP mode associated with the specified station at the specified index.
virtual void SetupPhy(const Ptr< WifiPhy > phy)
Set up PHY associated with this device since it is the object that knows the full set of transmit rat...
bool GetUseNonErpProtection() const
Return whether the device supports protection of non-ERP stations.
bool GetVhtSupported() const
Return whether the device has VHT capability support enabled.
bool GetShortPreambleEnabled() const
Return whether the device uses short PHY preambles.
WifiMode GetSupported(const WifiRemoteStation *station, uint8_t i) const
Return whether mode associated with the specified station at the specified index.
bool GetHeSupported() const
Return whether the device has HE capability support enabled.
virtual void SetupMac(const Ptr< WifiMac > mac)
Set up MAC associated with this device since it is the object that knows the full set of timing param...
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
void SetMode(WifiMode mode)
Sets the selected payload transmission mode.
void SetPreambleType(WifiPreamble preamble)
Sets the preamble type.
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Definition: boolean.h:81
Ptr< const AttributeChecker > MakeBooleanChecker()
Definition: boolean.cc:124
Ptr< const AttributeAccessor > MakeDoubleAccessor(T1 a1)
Definition: double.h:43
Ptr< const AttributeChecker > MakeTimeChecker()
Helper to make an unbounded Time checker.
Definition: nstime.h:1434
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Definition: nstime.h:1414
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:46
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:179
#define NS_ABORT_MSG(msg)
Unconditional abnormal program termination with a message.
Definition: abort.h:49
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:46
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1326
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
@ WIFI_PREAMBLE_LONG
Every class exported by the ns3 library is enclosed in the ns3 namespace.
std::vector< std::vector< double > > RrpaaProbabilitiesTable
List of probabilities.
WifiPreamble GetPreambleForTransmission(WifiModulationClass modulation, bool useShortPreamble)
Return the preamble to be used for the transmission.
std::vector< std::pair< WifiRrpaaThresholds, WifiMode > > RrpaaThresholdsTable
List of thresholds for each mode.
Hold per-remote-station state for RRPAA Wifi manager.
uint32_t m_rtsCounter
Counter for RTS transmission attempts.
uint32_t m_counter
Counter for transmission attempts.
bool m_initialized
For initializing variables.
uint32_t m_nFailed
Number of failed transmission attempts.
uint8_t m_prevPowerLevel
Power level of the previous transmission.
RrpaaThresholdsTable m_thresholds
RRPAA thresholds for this station.
Time m_lastReset
Time of the last reset.
bool m_adaptiveRtsOn
Check if Adaptive RTS mechanism is on.
uint8_t m_prevRateIndex
Rate index of the previous transmission.
bool m_lastFrameFail
Flag if the last frame sent has failed.
uint8_t m_nRate
Number of supported rates.
uint8_t m_powerLevel
Current power level.
RrpaaProbabilitiesTable m_pdTable
Probability table for power and rate changes.
uint8_t m_rateIndex
Current rate index.
uint32_t m_adaptiveRtsWnd
Window size for the Adaptive RTS mechanism.
hold per-remote-station state.
WifiRemoteStationState * m_state
Remote station state.
Mac48Address m_address
Mac48Address of the remote station.
Robust Rate and Power Adaptation Algorithm.
double m_ori
The Opportunistic Rate Increase threshold.
uint32_t m_ewnd
The Estimation Window size.
double m_mtl
The Maximum Tolerable Loss threshold.