Regarding an error and inaccurate results in Wi-Fi 7 simulation

36 views

Skip to first unread message

jomon charly

unread,

Jun 27, 2024, 9:33:14 AM (7 days ago) Jun 27

to ns-3-users

Respected Sir/Madam,

I am Jomon K Charly, a Ph.D. student from the National Institute of Technology Karaikal, India.

I am working on a project related to IEEE 802.11be and using NS-3 for simulating Wi-Fi 7 and analyzing throughput.

Our setup consists of one access point, 48 stations, and four links/channels (one 2.4 GHz, one 5 GHz, and two 6 GHz links). We have configured constant mobility and placed stations 100 meters apart, with a simulation time of 100 seconds.

We are encountering an issue when increasing the number of stations beyond 48. The error message is:

"NS_ASSERT failed, cond="GetMac()->CanForwardPacketsTo(rxAddr)", msg="Cannot forward frame to 00:00:00:00:00:f6", +2.178316000s 30 file=/home/jomon/ns-allinone-3.42/ns-3.42/src/wifi/model/wifi-mac-queue-scheduler-impl.h, line=369
NS_FATAL, terminating
terminate called without an active exception
Command 'build/scratch/ns3.42-wifi-eht-network1111-default' died with <Signals.SIGABRT: 6>."

The Maxmissedbeacons are taken as 100 with command

mac.SetType("ns3::StaWifiMac", "Ssid", SsidValue(ssid),"MaxMissedBeacons", UintegerValue(100));

When I increase the value of MaxMissedBeacons from 100 to 1000, there is no error, but the throughput we get beyond 57 stations is zero.

Our research aims to associate more than 100 stations with an access point, but this error and inaccurate results limits our simulation capabilities in NS-3.

We are using latest 3.42.

Please assist us in resolving this issue.

Code that we have used

...............................................................................................................................................................

#include "ns3/boolean.h"
#include "ns3/command-line.h"
#include "ns3/config.h"
#include "ns3/double.h"
#include "ns3/eht-phy.h"
#include "ns3/enum.h"
#include "ns3/internet-stack-helper.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/log.h"
#include "ns3/mobility-helper.h"
#include "ns3/multi-model-spectrum-channel.h"
#include "ns3/on-off-helper.h"
#include "ns3/packet-sink-helper.h"
#include "ns3/packet-sink.h"
#include "ns3/rng-seed-manager.h"
#include "ns3/spectrum-wifi-helper.h"
#include "ns3/ssid.h"
#include "ns3/string.h"
#include "ns3/udp-client-server-helper.h"
#include "ns3/udp-server.h"
#include "ns3/uinteger.h"
#include "ns3/wifi-acknowledgment.h"
#include "ns3/yans-wifi-channel.h"
#include "ns3/yans-wifi-helper.h"

#include <array>
#include <functional>
#include <numeric>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE("eht-wifi-network");

/**
* \param udp true if UDP is used, false if TCP is used
* \param serverApp a container of server applications
* \param payloadSize the size in bytes of the packets
* \return the bytes received by each server application
*/
std::vector<uint64_t>
GetRxBytes(bool udp, const ApplicationContainer& serverApp, uint32_t payloadSize)
{
std::vector<uint64_t> rxBytes(serverApp.GetN(), 0);
if (udp)
{
for (uint32_t i = 0; i < serverApp.GetN(); i++)
{
rxBytes[i] = payloadSize * DynamicCast<UdpServer>(serverApp.Get(i))->GetReceived();
}
}
else
{
for (uint32_t i = 0; i < serverApp.GetN(); i++)
{
rxBytes[i] = DynamicCast<PacketSink>(serverApp.Get(i))->GetTotalRx();
}
}
return rxBytes;
}

/**
* Print average throughput over an intermediate time interval.
* \param rxBytes a vector of the amount of bytes received by each server application
* \param udp true if UDP is used, false if TCP is used
* \param serverApp a container of server applications
* \param payloadSize the size in bytes of the packets
* \param tputInterval the duration of an intermediate time interval
* \param simulationTime the simulation time in seconds
*/
void
PrintIntermediateTput(std::vector<uint64_t>& rxBytes,
bool udp,
const ApplicationContainer& serverApp,
uint32_t payloadSize,
Time tputInterval,
double simulationTime)
{
auto newRxBytes = GetRxBytes(udp, serverApp, payloadSize);
Time now = Simulator::Now();

std::cout << "[" << (now - tputInterval).As(Time::S) << " - " << now.As(Time::S)
<< "] Per-STA Throughput (Mbit/s):";

for (std::size_t i = 0; i < newRxBytes.size(); i++)
{
std::cout << "\t\t(" << i << ") "
<< (newRxBytes[i] - rxBytes[i]) * 8. / tputInterval.GetMicroSeconds(); // Mbit/s
}
std::cout << std::endl;

rxBytes.swap(newRxBytes);

if (now < Seconds(simulationTime) - NanoSeconds(1))
{
Simulator::Schedule(Min(tputInterval, Seconds(simulationTime) - now - NanoSeconds(1)),
&PrintIntermediateTput,
rxBytes,
udp,
serverApp,
payloadSize,
tputInterval,
simulationTime);
}
}

int
main(int argc, char* argv[])
{
bool udp{true};
bool downlink{false};
bool useRts{true};
uint16_t mpduBufferSize{512};
std::string emlsrLinks;
uint16_t paddingDelayUsec{32};
uint16_t transitionDelayUsec{128};
uint16_t channelSwitchDelayUsec{100};
bool switchAuxPhy{true};
double simulationTime{10}; // seconds
double distance{100}; // meters
double frequency{2.4}; // whether the first link operates in the 2.4, 5 or 6 GHz
double frequency2{5}; // whether the second link operates in the 2.4, 5 or 6 GHz (0 means no
// second link exists)
double frequency3{
6.1}; // whether the third link operates in the 2.4, 5 or 6 GHz (0 means no third link exists)
double frequency4{
6.2};
std::size_t nStations{61};
std::string dlAckSeqType{"NO-OFDMA"};
bool enableUlOfdma{true};
bool enableBsrp{true};
int mcs{-1}; // -1 indicates an unset value
uint32_t payloadSize =
700; // must fit in the max TX duration when transmitting at MCS 0 over an RU of 26 tones
Time tputInterval{0}; // interval for detailed throughput measurement
double minExpectedThroughput{0};
double maxExpectedThroughput{0};
Time accessReqInterval{0};

CommandLine cmd(__FILE__);
cmd.AddValue(
"frequency",
"Whether the first link operates in the 2.4, 5 or 6 GHz band (other values gets rejected)",
frequency);
cmd.AddValue(
"frequency2",
"Whether the second link operates in the 2.4, 5 or 6 GHz band (0 means the device has one "
"link, otherwise the band must be different than first link and third link)",
frequency2);
cmd.AddValue(
"frequency3",
"Whether the third link operates in the 2.4, 5 or 6 GHz band (0 means the device has up to "
"two links, otherwise the band must be different than first link and second link)",
frequency3);
cmd.AddValue("frequency4","Whether the third link operates in the 2.4, 5 or 6 GHz band (0 means the device has up to "
"two links, otherwise the band must be different than first link and second link)",
frequency4);
cmd.AddValue("emlsrLinks",
"The comma separated list of IDs of EMLSR links (for MLDs only)",
emlsrLinks);
cmd.AddValue("emlsrPaddingDelay",
"The EMLSR padding delay in microseconds (0, 32, 64, 128 or 256)",
paddingDelayUsec);
cmd.AddValue("emlsrTransitionDelay",
"The EMLSR transition delay in microseconds (0, 16, 32, 64, 128 or 256)",
transitionDelayUsec);
cmd.AddValue("emlsrAuxSwitch",
"Whether Aux PHY should switch channel to operate on the link on which "
"the Main PHY was operating before moving to the link of the Aux PHY. ",
switchAuxPhy);
cmd.AddValue("channelSwitchDelay",
"The PHY channel switch delay in microseconds",
channelSwitchDelayUsec);
cmd.AddValue("distance",
"Distance in meters between the station and the access point",
distance);
cmd.AddValue("simulationTime", "Simulation time in seconds", simulationTime);
cmd.AddValue("udp", "UDP if set to 1, TCP otherwise", udp);
cmd.AddValue("downlink",
"Generate downlink flows if set to 1, uplink flows otherwise",
downlink);
cmd.AddValue("useRts", "Enable/disable RTS/CTS", useRts);
cmd.AddValue("mpduBufferSize",
"Size (in number of MPDUs) of the BlockAck buffer",
mpduBufferSize);
cmd.AddValue("nStations", "Number of non-AP HE stations", nStations);
cmd.AddValue("dlAckType",
"Ack sequence type for DL OFDMA (NO-OFDMA, ACK-SU-FORMAT, MU-BAR, AGGR-MU-BAR)",
dlAckSeqType);
cmd.AddValue("enableUlOfdma",
"Enable UL OFDMA (useful if DL OFDMA is enabled and TCP is used)",
enableUlOfdma);
cmd.AddValue("enableBsrp",
"Enable BSRP (useful if DL and UL OFDMA are enabled and TCP is used)",
enableBsrp);
cmd.AddValue(
"muSchedAccessReqInterval",
"Duration of the interval between two requests for channel access made by the MU scheduler",
accessReqInterval);
cmd.AddValue("mcs", "if set, limit testing to a specific MCS (0-11)", mcs);
cmd.AddValue("payloadSize", "The application payload size in bytes", payloadSize);
cmd.AddValue("tputInterval", "duration of intervals for throughput measurement", tputInterval);
cmd.AddValue("minExpectedThroughput",
"if set, simulation fails if the lowest throughput is below this value",
minExpectedThroughput);
cmd.AddValue("maxExpectedThroughput",
"if set, simulation fails if the highest throughput is above this value",
maxExpectedThroughput);
cmd.Parse(argc, argv);

if (useRts)
{
Config::SetDefault("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue("0"));
Config::SetDefault("ns3::WifiDefaultProtectionManager::EnableMuRts", BooleanValue(true));
}

if (dlAckSeqType == "ACK-SU-FORMAT")
{
Config::SetDefault("ns3::WifiDefaultAckManager::DlMuAckSequenceType",
EnumValue(WifiAcknowledgment::DL_MU_BAR_BA_SEQUENCE));
}
else if (dlAckSeqType == "MU-BAR")
{
Config::SetDefault("ns3::WifiDefaultAckManager::DlMuAckSequenceType",
EnumValue(WifiAcknowledgment::DL_MU_TF_MU_BAR));
}
else if (dlAckSeqType == "AGGR-MU-BAR")
{
Config::SetDefault("ns3::WifiDefaultAckManager::DlMuAckSequenceType",
EnumValue(WifiAcknowledgment::DL_MU_AGGREGATE_TF));
}
else if (dlAckSeqType != "NO-OFDMA")
{
NS_ABORT_MSG("Invalid DL ack sequence type (must be NO-OFDMA, ACK-SU-FORMAT, MU-BAR or "
"AGGR-MU-BAR)");
}

double prevThroughput[12] = {0};

std::cout << "MCS value"
<< "\t\t"
<< "Channel width"
<< "\t\t"
<< "GI"
<< "\t\t\t"
<< "Throughput" << '\n';
int minMcs = 8;
int maxMcs = 8;
if (mcs >= 8 && mcs <= 8)
{
minMcs = mcs;
maxMcs = mcs;
}
for (int mcs = minMcs; mcs <= maxMcs; mcs++)
{
uint8_t index = 0;
double previous = 0;

for (int channelWidth = 20; channelWidth <= 20;) // MHz
{
for (int gi = 3200; gi >= 3200;) // Nanoseconds
{
if (!udp)
{
Config::SetDefault("ns3::TcpSocket::SegmentSize", UintegerValue(payloadSize));
}

NodeContainer wifiStaNodes;
wifiStaNodes.Create(nStations);
NodeContainer wifiApNode;
wifiApNode.Create(1);

NetDeviceContainer apDevice;
NetDeviceContainer staDevices;
WifiMacHelper mac;
WifiHelper wifi;

wifi.SetStandard(WIFI_STANDARD_80211be);
std::array<std::string, 4> channelStr;
std::array<FrequencyRange, 4> freqRanges;
uint8_t nLinks = 0;
std::string dataModeStr = "EhtMcs" + std::to_string(mcs);
std::string ctrlRateStr;
uint64_t nonHtRefRateMbps = EhtPhy::GetNonHtReferenceRate(mcs) / 1e6;

if (frequency2 == frequency || frequency3 == frequency ||
(frequency3 != 0 && frequency3 == frequency2 ))
{
std::cout << "Frequency values must be unique!" << std::endl;
return 0;
}

for (auto freq : {frequency, frequency2, frequency3,frequency4})
{
if (nLinks > 0 && freq == 0)
{
break;
}

if (freq == 6.1)
{
channelStr[nLinks] = "{141, " + std::to_string(channelWidth) + ", ";
channelStr[nLinks] += "BAND_6GHZ, 0}";
freqRanges[nLinks] = WIFI_SPECTRUM_6_GHZ;
//Config::SetDefault("ns3::LogDistancePropagationLossModel::ReferenceLoss",DoubleValue(48));
wifi.SetRemoteStationManager(nLinks,
"ns3::ConstantRateWifiManager",
"DataMode",
StringValue(dataModeStr),
"ControlMode",
StringValue(dataModeStr));
}
else if (freq == 6.2)
{
channelStr[nLinks] = "{221, " + std::to_string(channelWidth) + ", ";
channelStr[nLinks] += "BAND_6GHZ, 0}";
freqRanges[nLinks] = WIFI_SPECTRUM_6_GHZ;
//Config::SetDefault("ns3::LogDistancePropagationLossModel::ReferenceLoss",DoubleValue(48));
wifi.SetRemoteStationManager(nLinks,
"ns3::ConstantRateWifiManager",
"DataMode",
StringValue(dataModeStr),
"ControlMode",
StringValue(dataModeStr));
}

else if (freq == 5)
{
channelStr[nLinks] = "{40, " + std::to_string(channelWidth) + ", ";
channelStr[nLinks] += "BAND_5GHZ, 0}";
freqRanges[nLinks] = WIFI_SPECTRUM_5_GHZ;
ctrlRateStr = "OfdmRate" + std::to_string(nonHtRefRateMbps) + "Mbps";
wifi.SetRemoteStationManager(nLinks,
"ns3::ConstantRateWifiManager",
"DataMode",
StringValue(dataModeStr),
"ControlMode",
StringValue(ctrlRateStr));
}
else if (freq == 2.4)
{
channelStr[nLinks] = "{9, " + std::to_string(channelWidth) + ", ";
channelStr[nLinks] += "BAND_2_4GHZ, 0}";
freqRanges[nLinks] = WIFI_SPECTRUM_2_4_GHZ;
//Config::SetDefault("ns3::LogDistancePropagationLossModel::ReferenceLoss",DoubleValue(40));
ctrlRateStr = "ErpOfdmRate" + std::to_string(nonHtRefRateMbps) + "Mbps";
wifi.SetRemoteStationManager(nLinks,
"ns3::ConstantRateWifiManager",
"DataMode",
StringValue(dataModeStr),
"ControlMode",
StringValue(ctrlRateStr));
}
else
{
std::cout << "Wrong frequency value!" << std::endl;
return 0;
}
nLinks++;

}

if (nLinks > 1 && !emlsrLinks.empty())
{
wifi.ConfigEhtOptions("EmlsrActivated", BooleanValue(true));
}

Ssid ssid = Ssid("ns3-80211be");

/*
* SingleModelSpectrumChannel cannot be used with 802.11be because two
* spectrum models are required: one with 78.125 kHz bands for HE PPDUs
* and one with 312.5 kHz bands for, e.g., non-HT PPDUs (for more details,
* see issue #408 (CLOSED))
*/
SpectrumWifiPhyHelper phy(nLinks);
phy.SetPcapDataLinkType(WifiPhyHelper::DLT_IEEE802_11_RADIO);
phy.Set("ChannelSwitchDelay", TimeValue(MicroSeconds(channelSwitchDelayUsec)));

mac.SetType("ns3::StaWifiMac", "Ssid", SsidValue(ssid),"MaxMissedBeacons", UintegerValue(1000));

mac.SetEmlsrManager("ns3::DefaultEmlsrManager",
"EmlsrLinkSet",
StringValue(emlsrLinks),
"EmlsrPaddingDelay",
TimeValue(MicroSeconds(paddingDelayUsec)),
"EmlsrTransitionDelay",
TimeValue(MicroSeconds(transitionDelayUsec)),
"SwitchAuxPhy",
BooleanValue(switchAuxPhy));
for (uint8_t linkId = 0; linkId < nLinks; linkId++)
{
phy.Set(linkId, "ChannelSettings", StringValue(channelStr[linkId]));

auto spectrumChannel = CreateObject<MultiModelSpectrumChannel>();
//auto lossModel = CreateObject<LogDistancePropagationLossModel>();
//spectrumChannel->AddPropagationLossModel(lossModel);
phy.AddChannel(spectrumChannel, freqRanges[linkId]);
}
staDevices = wifi.Install(phy, mac, wifiStaNodes);

if (dlAckSeqType != "NO-OFDMA")
{
mac.SetMultiUserScheduler("ns3::RrMultiUserScheduler",
"EnableUlOfdma",
BooleanValue(enableUlOfdma),
"EnableBsrp",
BooleanValue(enableBsrp),
"AccessReqInterval",
TimeValue(accessReqInterval));
}
mac.SetType("ns3::ApWifiMac",
"EnableBeaconJitter",
BooleanValue(false),
"Ssid",
SsidValue(ssid));
apDevice = wifi.Install(phy, mac, wifiApNode);

RngSeedManager::SetSeed(1);
RngSeedManager::SetRun(1);
int64_t streamNumber = 100;
streamNumber += wifi.AssignStreams(apDevice, streamNumber);
streamNumber += wifi.AssignStreams(staDevices, streamNumber);

// Set guard interval and MPDU buffer size
Config::Set(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/GuardInterval",
TimeValue(NanoSeconds(gi)));
Config::Set("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MpduBufferSize",
UintegerValue(mpduBufferSize));

// mobility.
MobilityHelper mobility;

Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();

// Add the positions of the AP and stations around a circle
for (uint32_t i = 0; i < wifiStaNodes.GetN(); i++) {
double angle = 2 * M_PI * i / wifiStaNodes.GetN();
double x = distance * cos(angle);
double y = distance * sin(angle);
positionAlloc->Add(Vector(x, y, 0.0));
}

// Add the position of the AP at the center
positionAlloc->Add(Vector(0.0, 0.0, 0.0));

// Set the position allocator for the mobility model
mobility.SetPositionAllocator(positionAlloc);

mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");

mobility.Install(wifiApNode);
mobility.Install(wifiStaNodes);

/* Internet stack*/
InternetStackHelper stack;
stack.Install(wifiApNode);
stack.Install(wifiStaNodes);

Ipv4AddressHelper address;
address.SetBase("192.168.1.0", "255.255.255.0");
Ipv4InterfaceContainer staNodeInterfaces;
Ipv4InterfaceContainer apNodeInterface;

staNodeInterfaces = address.Assign(staDevices);
apNodeInterface = address.Assign(apDevice);

/* Setting applications */
ApplicationContainer serverApp;
auto serverNodes = downlink ? std::ref(wifiStaNodes) : std::ref(wifiApNode);
Ipv4InterfaceContainer serverInterfaces;
NodeContainer clientNodes;
for (std::size_t i = 0; i < nStations; i++)
{
serverInterfaces.Add(downlink ? staNodeInterfaces.Get(i)
: apNodeInterface.Get(0));
clientNodes.Add(downlink ? wifiApNode.Get(0) : wifiStaNodes.Get(i));
}

if (udp)
{
// UDP flow
uint16_t port = 9;
UdpServerHelper server(port);
serverApp = server.Install(serverNodes.get());
serverApp.Start(Seconds(0.0));
serverApp.Stop(Seconds(simulationTime + 1));

for (std::size_t i = 0; i < nStations; i++)
{
UdpClientHelper client(serverInterfaces.GetAddress(i), port);
client.SetAttribute("MaxPackets", UintegerValue(4294967295U));
client.SetAttribute("Interval", TimeValue(Time("0.00001"))); // packets/s
client.SetAttribute("PacketSize", UintegerValue(payloadSize));
ApplicationContainer clientApp = client.Install(clientNodes.Get(i));
clientApp.Start(Seconds(1.0));
clientApp.Stop(Seconds(simulationTime + 1));
}
}
else
{
// TCP flow
uint16_t port = 50000;
Address localAddress(InetSocketAddress(Ipv4Address::GetAny(), port));
PacketSinkHelper packetSinkHelper("ns3::TcpSocketFactory", localAddress);
serverApp = packetSinkHelper.Install(serverNodes.get());
serverApp.Start(Seconds(0.0));
serverApp.Stop(Seconds(simulationTime + 1));

for (std::size_t i = 0; i < nStations; i++)
{
OnOffHelper onoff("ns3::TcpSocketFactory", Ipv4Address::GetAny());
onoff.SetAttribute("OnTime",
StringValue("ns3::ConstantRandomVariable[Constant=1]"));
onoff.SetAttribute("OffTime",
StringValue("ns3::ConstantRandomVariable[Constant=0]"));
onoff.SetAttribute("PacketSize", UintegerValue(payloadSize));
onoff.SetAttribute("DataRate", DataRateValue(1000000000)); // bit/s
AddressValue remoteAddress(
InetSocketAddress(serverInterfaces.GetAddress(i), port));
onoff.SetAttribute("Remote", remoteAddress);
ApplicationContainer clientApp = onoff.Install(clientNodes.Get(i));
clientApp.Start(Seconds(1.0));
clientApp.Stop(Seconds(simulationTime + 1));
}
}

// cumulative number of bytes received by each server application
std::vector<uint64_t> cumulRxBytes(nStations, 0);

if (tputInterval.IsStrictlyPositive())
{
Simulator::Schedule(Seconds(1) + tputInterval,
&PrintIntermediateTput,
cumulRxBytes,
udp,
serverApp,
payloadSize,
tputInterval,
simulationTime + 1);
}

Simulator::Stop(Seconds(simulationTime + 1));
Simulator::Run();

// When multiple stations are used, there are chances that association requests
// collide and hence the throughput may be lower than expected. Therefore, we relax
// the check that the throughput cannot decrease by introducing a scaling factor (or
// tolerance)
double tolerance = 0.10;
cumulRxBytes = GetRxBytes(udp, serverApp, payloadSize);
uint64_t rxBytes = std::accumulate(cumulRxBytes.cbegin(), cumulRxBytes.cend(), 0);
double throughput = (rxBytes * 8) / (simulationTime * 1000000.0); // Mbit/s

Simulator::Destroy();

std::cout << mcs << "\t\t\t" << channelWidth << " MHz\t\t\t" << gi << " ns\t\t\t"
<< throughput << " Mbit/s" <<std::endl;

// test first element
if (mcs == 0 && channelWidth == 20 && gi == 3200)
{
if (throughput * (1 + tolerance) < minExpectedThroughput)
{
NS_LOG_ERROR("Obtained throughput " << throughput << " is not expected!");
exit(1);
}
}
// test last element
if (mcs == 11 && channelWidth == 160 && gi == 800)
{
if (maxExpectedThroughput > 0 &&
throughput > maxExpectedThroughput * (1 + tolerance))
{
NS_LOG_ERROR("Obtained throughput " << throughput << " is not expected!");
exit(1);
}
}
// test previous throughput is smaller (for the same mcs)
if (throughput * (1 + tolerance) > previous)
{
previous = throughput;
}
else if (throughput > 0)
{
NS_LOG_ERROR("Obtained throughput " << throughput << " is not expected!");
exit(1);
}
// test previous throughput is smaller (for the same channel width and GI)
if (throughput * (1 + tolerance) > prevThroughput[index])
{
prevThroughput[index] = throughput;
}
else if (throughput > 0)
{
NS_LOG_ERROR("Obtained throughput " << throughput << " is not expected!");
exit(1);
}
index++;
gi /= 2;
}
channelWidth *= 2;
}
}
return 0;
}

.....................................................................................................................................

Yours faithfully,

Jomon K Charly

Research Scholar

Department of ECE

NIT Karaikal.

Reply all

Reply to author

Forward

0 new messages