9#include "ns3/attribute-container.h"
10#include "ns3/boolean.h"
11#include "ns3/command-line.h"
12#include "ns3/config.h"
13#include "ns3/double.h"
14#include "ns3/eht-phy.h"
16#include "ns3/internet-stack-helper.h"
17#include "ns3/ipv4-address-helper.h"
19#include "ns3/mobility-helper.h"
20#include "ns3/multi-model-spectrum-channel.h"
21#include "ns3/on-off-helper.h"
22#include "ns3/packet-sink-helper.h"
23#include "ns3/packet-sink.h"
24#include "ns3/spectrum-wifi-helper.h"
26#include "ns3/string.h"
27#include "ns3/udp-client-server-helper.h"
28#include "ns3/udp-server.h"
29#include "ns3/uinteger.h"
30#include "ns3/wifi-acknowledgment.h"
31#include "ns3/yans-wifi-channel.h"
32#include "ns3/yans-wifi-helper.h"
71 std::vector<uint64_t> rxBytes(serverApp.
GetN(), 0);
106 auto newRxBytes =
GetRxBytes(udp, serverApp, payloadSize);
109 std::cout <<
"[" << (now - tputInterval).As(
Time::S) <<
" - " << now.
As(
Time::S)
110 <<
"] Per-STA Throughput (Mbit/s):";
112 for (std::size_t i = 0; i < newRxBytes.size(); i++)
114 std::cout <<
"\t\t(" << i <<
") "
117 std::cout << std::endl;
119 rxBytes.swap(newRxBytes);
135main(
int argc,
char* argv[])
140 bool use80Plus80{
false};
141 uint16_t mpduBufferSize{512};
142 std::string emlsrMgrTypeId{
"ns3::DefaultEmlsrManager"};
143 std::string emlsrLinks;
144 uint16_t paddingDelayUsec{32};
145 uint16_t transitionDelayUsec{128};
146 Time channelSwitchDelay{
"100us"};
147 bool switchAuxPhy{
true};
148 uint16_t auxPhyChWidth{20};
149 bool auxPhyTxCapable{
true};
150 Time simulationTime{
"10s"};
153 double frequency2{0};
157 std::size_t nStations{1};
158 std::string dlAckSeqType{
"NO-OFDMA"};
159 bool enableUlOfdma{
false};
160 bool enableBsrp{
false};
162 std::vector<uint64_t> mcsValues;
163 int channelWidth{-1};
164 int guardInterval{-1};
167 Time tputInterval{0};
168 double minExpectedThroughput{0.0};
169 double maxExpectedThroughput{0.0};
170 Time accessReqInterval{0};
175 "Whether the first link operates in the 2.4, 5 or 6 GHz band (other values gets rejected)",
179 "Whether the second link operates in the 2.4, 5 or 6 GHz band (0 means the device has one "
180 "link, otherwise the band must be different than first link and third link)",
184 "Whether the third link operates in the 2.4, 5 or 6 GHz band (0 means the device has up to "
185 "two links, otherwise the band must be different than first link and second link)",
187 cmd.AddValue(
"emlsrMgrTypeId",
"The ns-3 TypeId of the EMLSR manager to use", emlsrMgrTypeId);
188 cmd.AddValue(
"emlsrLinks",
189 "The comma separated list of IDs of EMLSR links (for MLDs only)",
191 cmd.AddValue(
"emlsrPaddingDelay",
192 "The EMLSR padding delay in microseconds (0, 32, 64, 128 or 256)",
194 cmd.AddValue(
"emlsrTransitionDelay",
195 "The EMLSR transition delay in microseconds (0, 16, 32, 64, 128 or 256)",
196 transitionDelayUsec);
197 cmd.AddValue(
"emlsrAuxSwitch",
198 "Whether Aux PHY should switch channel to operate on the link on which "
199 "the Main PHY was operating before moving to the link of the Aux PHY. ",
201 cmd.AddValue(
"emlsrAuxChWidth",
202 "The maximum channel width (MHz) supported by Aux PHYs.",
204 cmd.AddValue(
"emlsrAuxTxCapable",
205 "Whether Aux PHYs are capable of transmitting.",
207 cmd.AddValue(
"channelSwitchDelay",
"The PHY channel switch delay", channelSwitchDelay);
208 cmd.AddValue(
"distance",
209 "Distance in meters between the station and the access point",
211 cmd.AddValue(
"simulationTime",
"Simulation time", simulationTime);
212 cmd.AddValue(
"udp",
"UDP if set to 1, TCP otherwise", udp);
213 cmd.AddValue(
"downlink",
214 "Generate downlink flows if set to 1, uplink flows otherwise",
216 cmd.AddValue(
"useRts",
"Enable/disable RTS/CTS", useRts);
217 cmd.AddValue(
"use80Plus80",
"Enable/disable use of 80+80 MHz", use80Plus80);
218 cmd.AddValue(
"mpduBufferSize",
219 "Size (in number of MPDUs) of the BlockAck buffer",
221 cmd.AddValue(
"nStations",
"Number of non-AP EHT stations", nStations);
222 cmd.AddValue(
"dlAckType",
223 "Ack sequence type for DL OFDMA (NO-OFDMA, ACK-SU-FORMAT, MU-BAR, AGGR-MU-BAR)",
225 cmd.AddValue(
"enableUlOfdma",
226 "Enable UL OFDMA (useful if DL OFDMA is enabled and TCP is used)",
228 cmd.AddValue(
"enableBsrp",
229 "Enable BSRP (useful if DL and UL OFDMA are enabled and TCP is used)",
232 "muSchedAccessReqInterval",
233 "Duration of the interval between two requests for channel access made by the MU scheduler",
237 "list of comma separated MCS values to test; if unset, all MCS values (0-13) are tested",
239 cmd.AddValue(
"channelWidth",
240 "if set, limit testing to a specific channel width expressed in MHz (20, 40, 80, "
243 cmd.AddValue(
"guardInterval",
244 "if set, limit testing to a specific guard interval duration expressed in "
245 "nanoseconds (800, 1600 or 3200 ns)",
247 cmd.AddValue(
"payloadSize",
"The application payload size in bytes", payloadSize);
248 cmd.AddValue(
"tputInterval",
"duration of intervals for throughput measurement", tputInterval);
249 cmd.AddValue(
"minExpectedThroughput",
250 "if set, simulation fails if the lowest throughput is below this value",
251 minExpectedThroughput);
252 cmd.AddValue(
"maxExpectedThroughput",
253 "if set, simulation fails if the highest throughput is above this value",
254 maxExpectedThroughput);
255 cmd.Parse(argc, argv);
263 if (dlAckSeqType ==
"ACK-SU-FORMAT")
268 else if (dlAckSeqType ==
"MU-BAR")
273 else if (dlAckSeqType ==
"AGGR-MU-BAR")
278 else if (dlAckSeqType !=
"NO-OFDMA")
280 NS_ABORT_MSG(
"Invalid DL ack sequence type (must be NO-OFDMA, ACK-SU-FORMAT, MU-BAR or "
284 double prevThroughput[15] = {0};
286 std::cout <<
"MCS value"
292 <<
"Throughput" <<
'\n';
298 for (uint8_t mcs = minMcs; mcs <= maxMcs; ++mcs)
300 mcsValues.push_back(mcs);
308 attr.DeserializeFromString(mcsStr, checker);
309 mcsValues = attr.Get();
310 std::sort(mcsValues.begin(), mcsValues.end());
313 int minChannelWidth = 20;
314 int maxChannelWidth =
315 ((frequency != 2.4) && (frequency2 != 2.4) && (frequency3 != 2.4))
316 ? (((frequency == 6) && (frequency2 == 0) && (frequency3 == 0)) ? 320 : 160)
318 if ((channelWidth != -1) &&
319 ((channelWidth < minChannelWidth) || (channelWidth > maxChannelWidth)))
321 NS_FATAL_ERROR(
"Invalid channel width: " << channelWidth <<
" MHz");
323 if (channelWidth >= minChannelWidth && channelWidth <= maxChannelWidth)
325 minChannelWidth = channelWidth;
326 maxChannelWidth = channelWidth;
328 int minGi = enableUlOfdma ? 1600 : 800;
330 if (guardInterval >= minGi && guardInterval <= maxGi)
332 minGi = guardInterval;
333 maxGi = guardInterval;
336 for (
const auto mcs : mcsValues)
340 for (
int width = minChannelWidth; width <= maxChannelWidth; width *= 2)
342 const auto is80Plus80 = (use80Plus80 && (width == 160));
343 const std::string widthStr = is80Plus80 ?
"80+80" : std::to_string(width);
344 const auto segmentWidthStr = is80Plus80 ?
"80" : widthStr;
345 for (
int gi = maxGi; gi >= minGi; gi /= 2)
363 std::array<std::string, 3> channelStr;
364 std::array<FrequencyRange, 3> freqRanges;
366 std::string dataModeStr =
"EhtMcs" + std::to_string(mcs);
367 std::string ctrlRateStr;
370 if (frequency2 == frequency || frequency3 == frequency ||
371 (frequency3 != 0 && frequency3 == frequency2))
376 for (
auto freq : {frequency, frequency2, frequency3})
378 if (nLinks > 0 && freq == 0)
382 channelStr[nLinks] =
"{0, " + segmentWidthStr +
", ";
385 channelStr[nLinks] +=
"BAND_6GHZ, 0}";
389 wifi.SetRemoteStationManager(nLinks,
390 "ns3::ConstantRateWifiManager",
398 channelStr[nLinks] +=
"BAND_5GHZ, 0}";
400 ctrlRateStr =
"OfdmRate" + std::to_string(nonHtRefRateMbps) +
"Mbps";
401 wifi.SetRemoteStationManager(nLinks,
402 "ns3::ConstantRateWifiManager",
408 else if (freq == 2.4)
410 channelStr[nLinks] +=
"BAND_2_4GHZ, 0}";
414 ctrlRateStr =
"ErpOfdmRate" + std::to_string(nonHtRefRateMbps) +
"Mbps";
415 wifi.SetRemoteStationManager(nLinks,
416 "ns3::ConstantRateWifiManager",
429 channelStr[nLinks] += std::string(
";") + channelStr[nLinks];
435 if (nLinks > 1 && !emlsrLinks.empty())
444 phy.Set(
"ChannelSwitchDelay",
TimeValue(channelSwitchDelay));
446 mac.SetType(
"ns3::StaWifiMac",
"Ssid",
SsidValue(ssid));
447 mac.SetEmlsrManager(emlsrMgrTypeId,
452 "EmlsrTransitionDelay",
458 "AuxPhyChannelWidth",
460 for (uint8_t linkId = 0; linkId < nLinks; linkId++)
462 phy.Set(linkId,
"ChannelSettings",
StringValue(channelStr[linkId]));
466 spectrumChannel->AddPropagationLossModel(lossModel);
467 phy.AddChannel(spectrumChannel, freqRanges[linkId]);
471 if (dlAckSeqType !=
"NO-OFDMA")
473 mac.SetMultiUserScheduler(
"ns3::RrMultiUserScheduler",
481 mac.SetType(
"ns3::ApWifiMac",
482 "EnableBeaconJitter",
486 apDevice =
wifi.Install(phy, mac, wifiApNode);
488 int64_t streamNumber = 100;
494 "/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/GuardInterval",
496 Config::Set(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MpduBufferSize",
503 positionAlloc->Add(Vector(0.0, 0.0, 0.0));
504 positionAlloc->Add(Vector(distance, 0.0, 0.0));
505 mobility.SetPositionAllocator(positionAlloc);
507 mobility.SetMobilityModel(
"ns3::ConstantPositionMobilityModel");
514 stack.Install(wifiApNode);
515 stack.Install(wifiStaNodes);
516 streamNumber +=
stack.AssignStreams(wifiApNode, streamNumber);
517 streamNumber +=
stack.AssignStreams(wifiStaNodes, streamNumber);
520 address.SetBase(
"192.168.1.0",
"255.255.255.0");
524 staNodeInterfaces =
address.Assign(staDevices);
525 apNodeInterface =
address.Assign(apDevice);
529 auto serverNodes = downlink ? std::ref(wifiStaNodes) :
std::ref(
wifiApNode);
532 for (std::size_t i = 0; i < nStations; i++)
535 : apNodeInterface.Get(0));
539 const auto maxLoad = nLinks *
541 MHz_u{
static_cast<double>(width)},
550 serverApp =
server.Install(serverNodes.get());
551 streamNumber +=
server.AssignStreams(serverNodes.get(), streamNumber);
555 const auto packetInterval = payloadSize * 8.0 / maxLoad;
557 for (std::size_t i = 0; i < nStations; i++)
564 streamNumber +=
client.AssignStreams(clientNodes.
Get(i), streamNumber);
573 uint16_t
port = 50000;
577 streamNumber +=
packetSinkHelper.AssignStreams(serverNodes.get(), streamNumber);
582 for (std::size_t i = 0; i < nStations; i++)
585 onoff.SetAttribute(
"OnTime",
586 StringValue(
"ns3::ConstantRandomVariable[Constant=1]"));
587 onoff.SetAttribute(
"OffTime",
588 StringValue(
"ns3::ConstantRandomVariable[Constant=0]"));
593 onoff.SetAttribute(
"Remote", remoteAddress);
595 streamNumber +=
onoff.AssignStreams(clientNodes.
Get(i), streamNumber);
603 std::vector<uint64_t> cumulRxBytes(nStations, 0);
605 if (tputInterval.IsStrictlyPositive())
624 auto tolerance = 0.10;
625 cumulRxBytes =
GetRxBytes(udp, serverApp, payloadSize);
626 auto rxBytes = std::accumulate(cumulRxBytes.cbegin(), cumulRxBytes.cend(), 0.0);
627 auto throughput = (rxBytes * 8) / simulationTime.GetMicroSeconds();
631 std::cout << +mcs <<
"\t\t\t" << widthStr <<
" MHz\t\t"
632 << (widthStr.size() > 3 ?
"" :
"\t") << gi <<
" ns\t\t\t" <<
throughput
633 <<
" Mbit/s" << std::endl;
636 if (mcs == minMcs && width == 20 && gi == 3200)
638 if (
throughput * (1 + tolerance) < minExpectedThroughput)
645 if (mcs == maxMcs && width == maxChannelWidth && gi == 800)
647 if (maxExpectedThroughput > 0 &&
648 throughput > maxExpectedThroughput * (1 + tolerance))
665 if (
throughput * (1 + tolerance) > prevThroughput[index])
a polymophic address class
AttributeValue implementation for Address.
holds a vector of ns3::Application pointers.
void Start(Time start) const
Start all of the Applications in this container at the start time given as a parameter.
Ptr< Application > Get(uint32_t i) const
Get the Ptr<Application> stored in this container at a given index.
void Stop(Time stop) const
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter.
uint32_t GetN() const
Get the number of Ptr<Application> stored in this container.
A container for one type of attribute.
AttributeValue implementation for Boolean.
Parse command-line arguments.
AttributeValue implementation for DataRate.
This class can be used to hold variables of floating point type such as 'double' or 'float'.
static uint64_t GetDataRate(uint8_t mcsValue, MHz_u channelWidth, Time guardInterval, uint8_t nss)
Return the data rate corresponding to the supplied EHT MCS index, channel width, guard interval,...
static uint64_t GetNonHtReferenceRate(uint8_t mcsValue)
Calculate the rate in bps of the non-HT Reference Rate corresponding to the supplied HE MCS index.
Hold variables of type enum.
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
static Ipv4Address GetAny()
holds a vector of std::pair of Ptr<Ipv4> and interface index.
std::pair< Ptr< Ipv4 >, uint32_t > Get(uint32_t i) const
Get the std::pair of an Ptr<Ipv4> and interface stored at the location specified by the index.
Helper class used to assign positions and mobility models to nodes.
holds a vector of ns3::NetDevice pointers
keep track of a set of node pointers.
void Add(const NodeContainer &nc)
Append the contents of another NodeContainer to the end of this container.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
Smart pointer class similar to boost::intrusive_ptr.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
static Time Now()
Return the current simulation virtual time.
static void Run()
Run the simulation.
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Make it easy to create and manage PHY objects for the spectrum model.
The IEEE 802.11 SSID Information Element.
AttributeValue implementation for Ssid.
Hold variables of type string.
Simulation virtual time values and global simulation resolution.
TimeWithUnit As(const Unit unit=Time::AUTO) const
Attach a unit to a Time, to facilitate output in a specific unit.
int64_t GetMicroSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
AttributeValue implementation for Time.
Create a client application which sends UDP packets carrying a 32bit sequence number and a 64 bit tim...
Create a server application which waits for input UDP packets and uses the information carried into t...
Hold an unsigned integer type.
helps to create WifiNetDevice objects
static int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used by the PHY and MAC aspects ...
create MAC layers for a ns3::WifiNetDevice.
@ DLT_IEEE802_11_RADIO
Include Radiotap link layer information.
Ptr< AttributeChecker > MakeAttributeContainerChecker()
Make uninitialized AttributeContainerChecker using explicit types.
Ptr< const AttributeChecker > MakeUintegerChecker()
void SetDefault(std::string name, const AttributeValue &value)
void Set(std::string path, const AttributeValue &value)
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
#define NS_ABORT_MSG(msg)
Unconditional abnormal program termination with a message.
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Time Seconds(double value)
Construct a Time in the indicated unit.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
constexpr FrequencyRange WIFI_SPECTRUM_6_GHZ
Identifier for the frequency range covering the wifi spectrum in the 6 GHz band.
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
constexpr FrequencyRange WIFI_SPECTRUM_5_GHZ
Identifier for the frequency range covering the wifi spectrum in the 5 GHz band.
constexpr FrequencyRange WIFI_SPECTRUM_2_4_GHZ
Identifier for the frequency range covering the wifi spectrum in the 2.4 GHz band.
void PrintIntermediateTput(std::vector< uint64_t > &rxBytes, bool udp, const ApplicationContainer &serverApp, uint32_t payloadSize, Time tputInterval, Time simulationTime)
Print average throughput over an intermediate time interval.
std::vector< uint64_t > GetRxBytes(bool udp, const ApplicationContainer &serverApp, uint32_t payloadSize)