20#include "ns3/boolean.h"
21#include "ns3/command-line.h"
22#include "ns3/config.h"
23#include "ns3/double.h"
24#include "ns3/eht-phy.h"
26#include "ns3/internet-stack-helper.h"
27#include "ns3/ipv4-address-helper.h"
29#include "ns3/mobility-helper.h"
30#include "ns3/multi-model-spectrum-channel.h"
31#include "ns3/on-off-helper.h"
32#include "ns3/packet-sink-helper.h"
33#include "ns3/packet-sink.h"
34#include "ns3/spectrum-wifi-helper.h"
36#include "ns3/string.h"
37#include "ns3/udp-client-server-helper.h"
38#include "ns3/udp-server.h"
39#include "ns3/uinteger.h"
40#include "ns3/wifi-acknowledgment.h"
41#include "ns3/yans-wifi-channel.h"
42#include "ns3/yans-wifi-helper.h"
79 std::vector<uint64_t> rxBytes(serverApp.
GetN(), 0);
84 rxBytes[i] = payloadSize * DynamicCast<UdpServer>(serverApp.
Get(i))->GetReceived();
91 rxBytes[i] = DynamicCast<PacketSink>(serverApp.
Get(i))->GetTotalRx();
114 auto newRxBytes =
GetRxBytes(udp, serverApp, payloadSize);
117 std::cout <<
"[" << (now - tputInterval).As(
Time::S) <<
" - " << now.
As(
Time::S)
118 <<
"] Per-STA Throughput (Mbit/s):";
120 for (std::size_t i = 0; i < newRxBytes.size(); i++)
122 std::cout <<
"\t\t(" << i <<
") "
125 std::cout << std::endl;
127 rxBytes.swap(newRxBytes);
143main(
int argc,
char* argv[])
148 uint16_t mpduBufferSize{512};
149 std::string emlsrLinks;
150 uint16_t paddingDelayUsec{32};
151 uint16_t transitionDelayUsec{128};
152 uint16_t channelSwitchDelayUsec{100};
153 bool switchAuxPhy{
true};
154 uint16_t auxPhyChWidth{20};
155 bool auxPhyTxCapable{
true};
156 Time simulationTime{
"10s"};
157 double distance{1.0};
159 double frequency2{0};
163 std::size_t nStations{1};
164 std::string dlAckSeqType{
"NO-OFDMA"};
165 bool enableUlOfdma{
false};
166 bool enableBsrp{
false};
170 Time tputInterval{0};
171 double minExpectedThroughput{0};
172 double maxExpectedThroughput{0};
173 Time accessReqInterval{0};
178 "Whether the first link operates in the 2.4, 5 or 6 GHz band (other values gets rejected)",
182 "Whether the second link operates in the 2.4, 5 or 6 GHz band (0 means the device has one "
183 "link, otherwise the band must be different than first link and third link)",
187 "Whether the third link operates in the 2.4, 5 or 6 GHz band (0 means the device has up to "
188 "two links, otherwise the band must be different than first link and second link)",
190 cmd.AddValue(
"emlsrLinks",
191 "The comma separated list of IDs of EMLSR links (for MLDs only)",
193 cmd.AddValue(
"emlsrPaddingDelay",
194 "The EMLSR padding delay in microseconds (0, 32, 64, 128 or 256)",
196 cmd.AddValue(
"emlsrTransitionDelay",
197 "The EMLSR transition delay in microseconds (0, 16, 32, 64, 128 or 256)",
198 transitionDelayUsec);
199 cmd.AddValue(
"emlsrAuxSwitch",
200 "Whether Aux PHY should switch channel to operate on the link on which "
201 "the Main PHY was operating before moving to the link of the Aux PHY. ",
203 cmd.AddValue(
"emlsrAuxChWidth",
204 "The maximum channel width (MHz) supported by Aux PHYs.",
206 cmd.AddValue(
"emlsrAuxTxCapable",
207 "Whether Aux PHYs are capable of transmitting.",
209 cmd.AddValue(
"channelSwitchDelay",
210 "The PHY channel switch delay in microseconds",
211 channelSwitchDelayUsec);
212 cmd.AddValue(
"distance",
213 "Distance in meters between the station and the access point",
215 cmd.AddValue(
"simulationTime",
"Simulation time", simulationTime);
216 cmd.AddValue(
"udp",
"UDP if set to 1, TCP otherwise", udp);
217 cmd.AddValue(
"downlink",
218 "Generate downlink flows if set to 1, uplink flows otherwise",
220 cmd.AddValue(
"useRts",
"Enable/disable RTS/CTS", useRts);
221 cmd.AddValue(
"mpduBufferSize",
222 "Size (in number of MPDUs) of the BlockAck buffer",
224 cmd.AddValue(
"nStations",
"Number of non-AP EHT stations", nStations);
225 cmd.AddValue(
"dlAckType",
226 "Ack sequence type for DL OFDMA (NO-OFDMA, ACK-SU-FORMAT, MU-BAR, AGGR-MU-BAR)",
228 cmd.AddValue(
"enableUlOfdma",
229 "Enable UL OFDMA (useful if DL OFDMA is enabled and TCP is used)",
231 cmd.AddValue(
"enableBsrp",
232 "Enable BSRP (useful if DL and UL OFDMA are enabled and TCP is used)",
235 "muSchedAccessReqInterval",
236 "Duration of the interval between two requests for channel access made by the MU scheduler",
238 cmd.AddValue(
"mcs",
"if set, limit testing to a specific MCS (0-11)", mcs);
239 cmd.AddValue(
"payloadSize",
"The application payload size in bytes", payloadSize);
240 cmd.AddValue(
"tputInterval",
"duration of intervals for throughput measurement", tputInterval);
241 cmd.AddValue(
"minExpectedThroughput",
242 "if set, simulation fails if the lowest throughput is below this value",
243 minExpectedThroughput);
244 cmd.AddValue(
"maxExpectedThroughput",
245 "if set, simulation fails if the highest throughput is above this value",
246 maxExpectedThroughput);
247 cmd.Parse(argc, argv);
255 if (dlAckSeqType ==
"ACK-SU-FORMAT")
260 else if (dlAckSeqType ==
"MU-BAR")
265 else if (dlAckSeqType ==
"AGGR-MU-BAR")
270 else if (dlAckSeqType !=
"NO-OFDMA")
272 NS_ABORT_MSG(
"Invalid DL ack sequence type (must be NO-OFDMA, ACK-SU-FORMAT, MU-BAR or "
276 double prevThroughput[12] = {0};
278 std::cout <<
"MCS value"
284 <<
"Throughput" <<
'\n';
287 if (mcs >= 0 && mcs <= 13)
292 for (
int mcs = minMcs; mcs <= maxMcs; mcs++)
296 uint16_t maxChannelWidth =
297 (frequency != 2.4 && frequency2 != 2.4 && frequency3 != 2.4) ? 160 : 40;
298 int minGi = enableUlOfdma ? 1600 : 800;
299 for (
int channelWidth = 20; channelWidth <= maxChannelWidth;)
301 for (
int gi = 3200; gi >= minGi;)
319 std::array<std::string, 3> channelStr;
320 std::array<FrequencyRange, 3> freqRanges;
322 std::string dataModeStr =
"EhtMcs" + std::to_string(mcs);
323 std::string ctrlRateStr;
326 if (frequency2 == frequency || frequency3 == frequency ||
327 (frequency3 != 0 && frequency3 == frequency2))
332 for (
auto freq : {frequency, frequency2, frequency3})
334 if (nLinks > 0 && freq == 0)
338 channelStr[nLinks] =
"{0, " + std::to_string(channelWidth) +
", ";
341 channelStr[nLinks] +=
"BAND_6GHZ, 0}";
345 wifi.SetRemoteStationManager(nLinks,
346 "ns3::ConstantRateWifiManager",
354 channelStr[nLinks] +=
"BAND_5GHZ, 0}";
356 ctrlRateStr =
"OfdmRate" + std::to_string(nonHtRefRateMbps) +
"Mbps";
357 wifi.SetRemoteStationManager(nLinks,
358 "ns3::ConstantRateWifiManager",
364 else if (freq == 2.4)
366 channelStr[nLinks] +=
"BAND_2_4GHZ, 0}";
370 ctrlRateStr =
"ErpOfdmRate" + std::to_string(nonHtRefRateMbps) +
"Mbps";
371 wifi.SetRemoteStationManager(nLinks,
372 "ns3::ConstantRateWifiManager",
385 if (nLinks > 1 && !emlsrLinks.empty())
402 mac.SetType(
"ns3::StaWifiMac",
"Ssid",
SsidValue(ssid));
403 mac.SetEmlsrManager(
"ns3::DefaultEmlsrManager",
408 "EmlsrTransitionDelay",
414 "AuxPhyChannelWidth",
416 for (uint8_t linkId = 0; linkId < nLinks; linkId++)
418 phy.Set(linkId,
"ChannelSettings",
StringValue(channelStr[linkId]));
420 auto spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
421 auto lossModel = CreateObject<LogDistancePropagationLossModel>();
422 spectrumChannel->AddPropagationLossModel(lossModel);
423 phy.AddChannel(spectrumChannel, freqRanges[linkId]);
427 if (dlAckSeqType !=
"NO-OFDMA")
429 mac.SetMultiUserScheduler(
"ns3::RrMultiUserScheduler",
437 mac.SetType(
"ns3::ApWifiMac",
438 "EnableBeaconJitter",
442 apDevice =
wifi.Install(phy, mac, wifiApNode);
444 int64_t streamNumber = 100;
445 streamNumber +=
wifi.AssignStreams(apDevice, streamNumber);
446 streamNumber +=
wifi.AssignStreams(staDevices, streamNumber);
450 "/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/GuardInterval",
452 Config::Set(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MpduBufferSize",
459 positionAlloc->Add(Vector(0.0, 0.0, 0.0));
460 positionAlloc->Add(Vector(distance, 0.0, 0.0));
461 mobility.SetPositionAllocator(positionAlloc);
463 mobility.SetMobilityModel(
"ns3::ConstantPositionMobilityModel");
470 stack.Install(wifiApNode);
471 stack.Install(wifiStaNodes);
472 streamNumber +=
stack.AssignStreams(wifiApNode, streamNumber);
473 streamNumber +=
stack.AssignStreams(wifiStaNodes, streamNumber);
476 address.SetBase(
"192.168.1.0",
"255.255.255.0");
480 staNodeInterfaces =
address.Assign(staDevices);
481 apNodeInterface =
address.Assign(apDevice);
485 auto serverNodes = downlink ? std::ref(wifiStaNodes) :
std::ref(
wifiApNode);
488 for (std::size_t i = 0; i < nStations; i++)
491 : apNodeInterface.
Get(0));
502 serverApp =
server.Install(serverNodes.get());
503 streamNumber +=
server.AssignStreams(serverNodes.get(), streamNumber);
507 const auto packetInterval = payloadSize * 8.0 / maxLoad;
509 for (std::size_t i = 0; i < nStations; i++)
516 streamNumber +=
client.AssignStreams(clientNodes.
Get(i), streamNumber);
525 uint16_t
port = 50000;
529 streamNumber +=
packetSinkHelper.AssignStreams(serverNodes.get(), streamNumber);
534 for (std::size_t i = 0; i < nStations; i++)
537 onoff.SetAttribute(
"OnTime",
538 StringValue(
"ns3::ConstantRandomVariable[Constant=1]"));
539 onoff.SetAttribute(
"OffTime",
540 StringValue(
"ns3::ConstantRandomVariable[Constant=0]"));
545 onoff.SetAttribute(
"Remote", remoteAddress);
547 streamNumber +=
onoff.AssignStreams(clientNodes.
Get(i), streamNumber);
555 std::vector<uint64_t> cumulRxBytes(nStations, 0);
557 if (tputInterval.IsStrictlyPositive())
566 simulationTime +
Seconds(1.0));
576 auto tolerance = 0.10;
577 cumulRxBytes =
GetRxBytes(udp, serverApp, payloadSize);
578 auto rxBytes = std::accumulate(cumulRxBytes.cbegin(), cumulRxBytes.cend(), 0.0);
579 auto throughput = (rxBytes * 8) / simulationTime.GetMicroSeconds();
583 std::cout << mcs <<
"\t\t\t" << channelWidth <<
" MHz\t\t\t" << gi <<
" ns\t\t\t"
587 if (mcs == minMcs && channelWidth == 20 && gi == 3200)
589 if (
throughput * (1 + tolerance) < minExpectedThroughput)
596 if (mcs == maxMcs && channelWidth == maxChannelWidth && gi == 800)
598 if (maxExpectedThroughput > 0 &&
599 throughput > maxExpectedThroughput * (1 + tolerance))
616 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.
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 GetNonHtReferenceRate(uint8_t mcsValue)
Calculate the rate in bps of the non-HT Reference Rate corresponding to the supplied HE MCS index.
static uint64_t GetDataRate(uint8_t mcsValue, uint16_t channelWidth, uint16_t guardInterval, uint8_t nss)
Return the data rate corresponding to the supplied EHT MCS index, channel width, guard interval,...
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
create MAC layers for a ns3::WifiNetDevice.
@ DLT_IEEE802_11_RADIO
Include Radiotap link layer information.
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.
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.
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)