18#include "ns3/ampdu-subframe-header.h"
19#include "ns3/application-container.h"
20#include "ns3/boolean.h"
21#include "ns3/command-line.h"
22#include "ns3/config.h"
23#include "ns3/double.h"
24#include "ns3/gnuplot.h"
25#include "ns3/integer.h"
27#include "ns3/mobility-helper.h"
28#include "ns3/node-list.h"
29#include "ns3/packet-socket-client.h"
30#include "ns3/packet-socket-helper.h"
31#include "ns3/packet-socket-server.h"
32#include "ns3/propagation-delay-model.h"
33#include "ns3/propagation-loss-model.h"
34#include "ns3/queue-size.h"
35#include "ns3/rng-seed-manager.h"
37#include "ns3/string.h"
38#include "ns3/uinteger.h"
39#include "ns3/wifi-mac-header.h"
40#include "ns3/wifi-mac.h"
41#include "ns3/wifi-net-device.h"
42#include "ns3/yans-wifi-helper.h"
48#define PI 3.1415926535
64std::map<Mac48Address, uint64_t>
66std::map<Mac48Address, uint64_t>
68std::map<Mac48Address, uint64_t>
72std::map<Mac48Address, uint64_t>
77std::map<Mac48Address, uint64_t>
80std::map<Mac48Address, uint64_t>
83std::map<Mac48Address, uint64_t>
86std::map<Mac48Address, uint64_t>
90std::map<Mac48Address, Time>
93std::map<Mac48Address, Time>
109std::map<std::string ,
110 std::map<
unsigned int ,
double >>
297 {
"ErpOfdmRate12Mbps",
310 {
"ErpOfdmRate18Mbps",
323 {
"ErpOfdmRate24Mbps",
336 {
"ErpOfdmRate36Mbps",
349 {
"ErpOfdmRate48Mbps",
362 {
"ErpOfdmRate54Mbps",
1003std::map<std::string ,
1004 std::map<
unsigned int ,
double >>
1165 {
"ErpOfdmRate6Mbps",
1178 {
"ErpOfdmRate9Mbps",
1191 {
"ErpOfdmRate12Mbps",
1204 {
"ErpOfdmRate18Mbps",
1217 {
"ErpOfdmRate24Mbps",
1230 {
"ErpOfdmRate36Mbps",
1243 {
"ErpOfdmRate48Mbps",
1256 {
"ErpOfdmRate54Mbps",
1905 std::string sub = context.substr(10);
1906 uint32_t pos = sub.find(
"/Device");
1907 return std::stoi(sub.substr(0, pos));
1919 std::string sub = context.substr(10);
1920 uint32_t pos = sub.find(
"/Device");
1921 uint32_t nodeId = std::stoi(sub.substr(0, pos));
1924 for (
uint32_t i = 0; i < n->GetNDevices(); i++)
1947 uint64_t increment = 1)
1949 auto it = counter.find(addr);
1950 if (it != counter.end())
1952 it->second += increment;
1956 counter.insert(std::make_pair(addr, increment));
1974 uint16_t channelFreqMhz,
1985 packet->RemoveHeader(subHdr);
1987 packet = packet->CreateFragment(0,
static_cast<uint32_t>(extractedLength));
1990 packet->PeekHeader(hdr);
1997 if (packet->GetSize() >=
pktSize)
2046 <<
" val=" << newVal);
2050 << newVal << std::endl;
2065 <<
" size=" << p->GetSize());
2080 <<
" psduDuration=" << psduDuration);
2094 <<
" size=" << p->GetSize() <<
" reason=" << reason);
2150 NS_FATAL_ERROR(
"All devices should send with same power, so no packet switch during "
2151 "preamble detection should occur!");
2178 <<
" size=" << p->GetSize());
2197 uint8_t nMpdus = (p->GetSize() /
pktSize);
2200 <<
" nMPDUs=" << +nMpdus <<
" snr=" << snr <<
" mode=" << mode
2201 <<
" preamble=" << preamble);
2206 NS_FATAL_ERROR(
"A-MPDU settings not properly applied: maximum configured MPDUs is "
2207 << +
maxMpdus <<
" but received an A-MPDU containing " << +nMpdus
2210 NS_LOG_WARN(
"Warning: less MPDUs aggregated in a received A-MPDU ("
2211 << +nMpdus <<
") than configured (" << +
maxMpdus <<
")");
2231 <<
" size=" << p->GetSize() <<
" snr=" << snr);
2250 <<
" size=" << p->GetSize() <<
" " << txPowerW);
2254 <<
" size=" << p->GetSize() <<
" " << txPowerW << std::endl;
2273 <<
" " << p->GetSize());
2288 << p->GetSize() << std::endl;
2304 << p->GetSize() << std::endl;
2321 <<
" " << p->GetSize() <<
" " << addr << std::endl;
2417 uint16_t guardIntervalNs,
2438 uint16_t guardIntervalNs,
2450 wifiNodes.
Create(networkSize + 1);
2454 wifiNodes.
Create(networkSize);
2458 phy.SetErrorRateModel(
"ns3::NistErrorRateModel");
2459 phy.SetChannel(wifiChannel.
Create());
2463 const auto& wifi = helper;
2469 uint64_t beaconInterval = std::min<uint64_t>(
2470 (ceil((duration.
GetSeconds() * 1000000) / 1024) * 1024),
2472 mac.SetType(
"ns3::ApWifiMac",
2479 devices = wifi.Install(phy, mac, wifiNodes.
Get(0));
2481 mac.SetType(
"ns3::StaWifiMac",
2488 for (
uint32_t i = 1; i < nNodes; ++i)
2490 devices.Add(wifi.Install(phy, mac, wifiNodes.
Get(i)));
2495 mac.SetType(
"ns3::AdhocWifiMac");
2498 devices = wifi.Install(phy, mac, wifiNodes);
2504 "/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported",
2506 Config::Set(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/GuardInterval",
2510 for (
uint32_t i = 0; i < nNodes; ++i)
2514 wifi_dev->GetMac()->SetAttribute(
"BE_MaxAmpduSize",
2516 wifi_dev->GetMac()->SetAttribute(
"BK_MaxAmpduSize",
2518 wifi_dev->GetMac()->SetAttribute(
"VO_MaxAmpduSize",
2520 wifi_dev->GetMac()->SetAttribute(
"VI_MaxAmpduSize",
2526 mobility.SetMobilityModel(
"ns3::ConstantPositionMobilityModel");
2528 positionAlloc->Add(Vector(1.0, 1.0, 0.0));
2531 const auto angle = (
static_cast<degree_u>(360) / (nNodes - 1));
2532 for (
uint32_t i = 0; i < (nNodes - 1); ++i)
2534 positionAlloc->Add(Vector(1.0 + (distance * cos((i * angle *
PI) / 180)),
2535 1.0 + (distance * sin((i * angle *
PI) / 180)),
2539 mobility.SetPositionAllocator(positionAlloc);
2540 mobility.Install(wifiNodes);
2543 packetSocket.
Install(wifiNodes);
2547 startTime->SetAttribute(
"Stream",
IntegerValue(trialNumber));
2551 for (; i < nNodes; ++i)
2553 uint32_t j = infra ? 0 : (i + 1) % nNodes;
2560 client->SetRemote(socketAddr);
2564 client->SetAttribute(
"Interval",
TimeValue(pktInterval));
2565 double start = startTime->GetValue();
2566 NS_LOG_DEBUG(
"Client " << i <<
" starting at " << start);
2567 client->SetStartTime(
Seconds(start));
2570 server->SetLocal(socketAddr);
2576 "/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/MonitorSnifferRx",
2582 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::StaWifiMac/Assoc",
2584 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::StaWifiMac/DeAssoc",
2593 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::WifiMac/" + txop +
2597 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::WifiMac/" + txop +
2601 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyTxBegin",
2604 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyTxEnd",
2607 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxBegin",
2611 "/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxPayloadBegin",
2614 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxDrop",
2617 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxEnd",
2620 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/State/RxError",
2623 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/State/RxOk",
2626 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx",
2629 Config::Connect(
"/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx",
2632 Config::Connect(
"/NodeList/*/$ns3::Node/ApplicationList/*/$ns3::PacketSocketClient/Tx",
2640 phy.EnablePcap(
"wifi_bianchi_pcap", devices);
2670 auto it = counter.find(addr);
2671 if (it != counter.end())
2679main(
int argc,
char* argv[])
2685 double duration = 100;
2690 std::string workDir =
"./";
2691 std::string phyMode =
2693 std::string standard(
"11a");
2694 bool validate =
false;
2696 uint16_t plotBianchiModel =
2698 double maxRelativeError =
2701 double frequency = 5;
2702 uint16_t channelWidth = 20;
2703 uint16_t guardIntervalNs = 800;
2705 uint16_t pktInterval =
2709 dBm_u apTxPower = 16;
2710 dBm_u staTxPower = 16;
2724 "ns3::WifiMacQueue::MaxSize",
2729 cmd.AddValue(
"verbose",
2730 "Logging level (0: no log - 1: simulation script logs - 2: all logs)",
2732 cmd.AddValue(
"tracing",
"Generate trace files",
tracing);
2733 cmd.AddValue(
"pktSize",
"The packet size in bytes",
pktSize);
2734 cmd.AddValue(
"trials",
"The maximal number of runs per network size", trials);
2735 cmd.AddValue(
"duration",
"Time duration for each trial in seconds", duration);
2736 cmd.AddValue(
"pcap",
"Enable/disable PCAP tracing", pcap);
2737 cmd.AddValue(
"infra",
"True to use infrastructure mode, false to use ring adhoc mode", infra);
2738 cmd.AddValue(
"workDir",
"The working directory used to store generated files", workDir);
2739 cmd.AddValue(
"phyMode",
"Set the constant PHY mode string used to transmit frames", phyMode);
2740 cmd.AddValue(
"standard",
"Set the standard (11a, 11b, 11g, 11n, 11ac, 11ax)", standard);
2741 cmd.AddValue(
"nMinStas",
"Minimum number of stations to start with", nMinStas);
2742 cmd.AddValue(
"nMaxStas",
"Maximum number of stations to start with", nMaxStas);
2743 cmd.AddValue(
"nStepSize",
"Number of stations to add at each step", nStepSize);
2744 cmd.AddValue(
"plotBianchiModel",
2745 "First bit corresponds to the DIFS model, second bit to the EIFS model",
2747 cmd.AddValue(
"validate",
2748 "Enable/disable validation of the ns-3 simulations against the Bianchi model",
2750 cmd.AddValue(
"maxRelativeError",
2751 "The maximum relative error tolerated between ns-3 results and the Bianchi model "
2752 "(used for regression, i.e. when the validate flag is set)",
2754 cmd.AddValue(
"frequency",
"Set the operating frequency band in GHz: 2.4, 5 or 6", frequency);
2755 cmd.AddValue(
"channelWidth",
2756 "Set the constant channel width in MHz (only for 11n/ac/ax)",
2758 cmd.AddValue(
"guardIntervalNs",
2759 "Set the the guard interval in nanoseconds (800 or 400 for 11n/ac, 800 or 1600 or "
2762 cmd.AddValue(
"maxMpdus",
2763 "Set the maximum number of MPDUs in A-MPDUs (0 to disable MPDU aggregation)",
2765 cmd.AddValue(
"distance",
"Set the distance in meters between the AP and the STAs", distance);
2766 cmd.AddValue(
"apTxPower",
2767 "Set the transmit power of the AP in dBm (if infrastructure only)",
2769 cmd.AddValue(
"staTxPower",
2770 "Set the transmit power of each STA in dBm (or all STAs if adhoc)",
2772 cmd.AddValue(
"pktInterval",
"Set the socket packet interval in microseconds", pktInterval);
2773 cmd.Parse(argc, argv);
2785 NS_FATAL_ERROR(
"Failed to open file wifi-bianchi-backoff-trace.out");
2790 NS_FATAL_ERROR(
"Failed to open file wifi-bianchi-phy-tx-trace.out");
2795 NS_FATAL_ERROR(
"Failed to open file wifi-bianchi-mac-tx-trace.out");
2800 NS_FATAL_ERROR(
"Failed to open file wifi-bianchi-mac-rx-trace.out");
2805 NS_FATAL_ERROR(
"Failed to open file wifi-bianchi-socket-send-trace.out");
2822 std::stringstream phyModeStr;
2823 phyModeStr << phyMode;
2824 if (phyMode.find(
"Mcs") != std::string::npos)
2826 phyModeStr <<
"_" << channelWidth <<
"MHz";
2829 std::stringstream ss;
2830 ss <<
"wifi-" << standard <<
"-p-" <<
pktSize << (infra ?
"-infrastructure" :
"-adhoc") <<
"-r-"
2831 << phyModeStr.str() <<
"-min-" << nMinStas <<
"-max-" << nMaxStas <<
"-step-" << nStepSize
2832 <<
"-throughput.plt";
2833 std::ofstream throughputPlot(ss.str());
2835 ss <<
"wifi-" << standard <<
"-p-" <<
pktSize << (infra ?
"-infrastructure" :
"-adhoc") <<
"-r-"
2836 << phyModeStr.str() <<
"-min-" << nMinStas <<
"-max-" << nMaxStas <<
"-step-" << nStepSize
2837 <<
"-throughput.eps";
2841 if (standard ==
"11a")
2847 else if (standard ==
"11b")
2853 else if (standard ==
"11g")
2859 else if (standard ==
"11n")
2861 if (frequency == 2.4 || frequency == 5)
2867 NS_FATAL_ERROR(
"Unsupported frequency band " << frequency <<
" GHz for standard "
2871 else if (standard ==
"11ac")
2876 else if (standard ==
"11ax")
2878 if (frequency == 2.4 || frequency == 5 || frequency == 6)
2884 NS_FATAL_ERROR(
"Unsupported frequency band " << frequency <<
" GHz for standard "
2893 std::string channelStr =
"{0, " + std::to_string(channelWidth) +
", BAND_" +
2894 (frequency == 2.4 ?
"2_4" : (frequency == 5 ?
"5" :
"6")) +
"GHZ, 0}";
2908 "ReferenceDistance",
2913 else if (frequency == 5)
2919 "ReferenceDistance",
2930 "ReferenceDistance",
2937 wifi.SetStandard(wifiStandard);
2938 wifi.SetRemoteStationManager(
"ns3::ConstantRateWifiManager",
2954 double averageThroughput;
2955 std::vector<double> throughputArray(trials);
2956 for (
uint32_t n = nMinStas; n <= nMaxStas; n += nStepSize)
2958 averageThroughput = 0;
2960 for (
uint32_t runIndex = 0; runIndex < trials; runIndex++)
2976 std::cout <<
"Trial " << runIndex + 1 <<
" of " << trials <<
"; " << phyModeStr.str()
2977 <<
" for " << n <<
" nodes " << std::endl;
2980 cwTraceFile <<
"# Trial " << runIndex + 1 <<
" of " << trials <<
"; "
2981 << phyModeStr.str() <<
" for " << n <<
" nodes" << std::endl;
2983 << phyModeStr.str() <<
" for " << n <<
" nodes" << std::endl;
2984 phyTxTraceFile <<
"# Trial " << runIndex + 1 <<
" of " << trials <<
"; "
2985 << phyModeStr.str() <<
" for " << n <<
" nodes" << std::endl;
2986 macTxTraceFile <<
"# Trial " << runIndex + 1 <<
" of " << trials <<
"; "
2987 << phyModeStr.str() <<
" for " << n <<
" nodes" << std::endl;
2988 macRxTraceFile <<
"# Trial " << runIndex + 1 <<
" of " << trials <<
"; "
2989 << phyModeStr.str() <<
" for " << n <<
" nodes" << std::endl;
2991 << phyModeStr.str() <<
" for " << n <<
" nodes" << std::endl;
3016 Time dataTransferDuration = last -
first;
3017 double nodeThroughput =
3018 (it->second * 8 /
static_cast<double>(dataTransferDuration.
GetMicroSeconds()));
3025 uint64_t nodeRxEventWhileDecodingPreamble =
3030 uint64_t nodeRxEvents = nodePhyHeaderFailures + nodePsduFailures + nodePsduSuccess +
3031 nodeRxEventWhileDecodingPreamble + nodeRxEventWhileRxing +
3032 nodeRxEventWhileTxing + nodeRxEventAbortedByTx;
3033 std::cout <<
"Node " << it->first <<
": TX packets " << nodeTxPackets
3034 <<
"; RX packets " << nodeRxPackets <<
"; PHY header failures "
3035 << nodePhyHeaderFailures <<
"; PSDU failures " << nodePsduFailures
3036 <<
"; PSDU success " << nodePsduSuccess
3037 <<
"; RX events while decoding preamble "
3038 << nodeRxEventWhileDecodingPreamble <<
"; RX events while RXing "
3039 << nodeRxEventWhileRxing <<
"; RX events while TXing "
3040 << nodeRxEventWhileTxing <<
"; RX events aborted by TX "
3041 << nodeRxEventAbortedByTx <<
"; total RX events " << nodeRxEvents
3042 <<
"; total events " << nodeTxPackets + nodeRxEvents <<
"; time first RX "
3043 <<
first <<
"; time last RX " << last <<
"; dataTransferDuration "
3044 << dataTransferDuration <<
"; throughput " << nodeThroughput <<
" Mbps"
3047 std::cout <<
"Total throughput: " <<
throughput <<
" Mbps" << std::endl;
3051 averageThroughput = averageThroughput / trials;
3053 bool rateFound =
false;
3054 double relativeErrorDifs = 0;
3055 double relativeErrorEifs = 0;
3060 auto it = itDifs->second.find(n);
3061 if (it != itDifs->second.end())
3063 relativeErrorDifs = (std::abs(averageThroughput - it->second) / it->second);
3064 std::cout <<
"Relative error (DIFS): " << 100 * relativeErrorDifs <<
"%"
3069 NS_FATAL_ERROR(
"No Bianchi results (DIFS) calculated for that number of stations!");
3076 auto it = itEifs->second.find(n);
3077 if (it != itEifs->second.end())
3079 relativeErrorEifs = (std::abs(averageThroughput - it->second) / it->second);
3080 std::cout <<
"Relative error (EIFS): " << 100 * relativeErrorEifs <<
"%"
3085 NS_FATAL_ERROR(
"No Bianchi results (EIFS) calculated for that number of stations!");
3088 if (!rateFound && validate)
3092 double relativeError = std::min(relativeErrorDifs, relativeErrorEifs);
3093 if (validate && (relativeError > maxRelativeError))
3099 for (
uint32_t i = 0; i < trials; ++i)
3101 stDev += pow(throughputArray[i] - averageThroughput, 2);
3103 stDev = sqrt(stDev / (trials - 1));
3104 dataset.
Add(n, averageThroughput, stDev);
3111 for (
uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
3114 auto it = itDifs->second.find(i);
3115 if (it != itDifs->second.end())
3119 datasetBianchiDifs.
Add(i, value);
3124 for (
uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
3126 datasetBianchiDifs.
Add(i, 0.0);
3133 for (
uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
3136 auto it = itEifs->second.find(i);
3137 if (it != itEifs->second.end())
3141 datasetBianchiEifs.
Add(i, value);
3146 for (
uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
3148 datasetBianchiEifs.
Add(i, 0.0);
3152 datasetBianchiEifs.
SetTitle(
"Bianchi (EIFS - lower bound)");
3153 datasetBianchiDifs.
SetTitle(
"Bianchi (DIFS - upper bound)");
3155 gnuplot.
SetTerminal(
"postscript eps color enh \"Times-BoldItalic\"");
3156 gnuplot.
SetLegend(
"Number of competing stations",
"Throughput (Mbps)");
3158 ss <<
"Frame size " <<
pktSize <<
" bytes";
3161 ss <<
"set xrange [" << nMinStas <<
":" << nMaxStas <<
"]\n"
3162 <<
"set xtics " << nStepSize <<
"\n"
3163 <<
"set grid xtics ytics\n"
3165 <<
"set style line 1 linewidth 5\n"
3166 <<
"set style line 2 linewidth 5\n"
3167 <<
"set style line 3 linewidth 5\n"
3168 <<
"set style line 4 linewidth 5\n"
3169 <<
"set style line 5 linewidth 5\n"
3170 <<
"set style line 6 linewidth 5\n"
3171 <<
"set style line 7 linewidth 5\n"
3172 <<
"set style line 8 linewidth 5\n"
3173 <<
"set style increment user";
3175 if (plotBianchiModel & 0x0001)
3177 datasetBianchiDifs.
SetTitle(
"Bianchi");
3180 if (plotBianchiModel & 0x0002)
3182 datasetBianchiEifs.
SetTitle(
"Bianchi");
3185 if (plotBianchiModel == 0x0003)
3187 datasetBianchiEifs.
SetTitle(
"Bianchi (EIFS - lower bound)");
3188 datasetBianchiDifs.
SetTitle(
"Bianchi (DIFS - upper bound)");
3191 throughputPlot.close();
WiFi adhoc experiment class.
Gnuplot2dDataset Run(const WifiHelper &wifi, const YansWifiPhyHelper &wifiPhy, const WifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel)
Run an experiment.
a polymophic address class
holds a vector of ns3::Application pointers.
AttributeValue implementation for Boolean.
Parse command-line arguments.
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Class to represent a 2D points plot.
void SetErrorBars(ErrorBars errorBars)
void SetStyle(Style style)
void Add(double x, double y)
void SetTitle(const std::string &title)
Change line title.
a simple class to generate gnuplot-ready plotting commands from a set of datasets.
void AddDataset(const GnuplotDataset &dataset)
void SetLegend(const std::string &xLegend, const std::string &yLegend)
void SetTerminal(const std::string &terminal)
void GenerateOutput(std::ostream &os)
Writes gnuplot commands and data values to a single output stream.
void SetExtra(const std::string &extra)
void SetTitle(const std::string &title)
Hold a signed integer type.
static Mac48Address ConvertFrom(const Address &address)
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.
uint32_t GetN() const
Get the number of Ptr<Node> stored in this container.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
uint32_t AddApplication(Ptr< Application > application)
Associate an Application to this Node.
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
static Ptr< Node > GetNode(uint32_t n)
an address for a packet socket
void SetProtocol(uint16_t protocol)
Set the protocol.
void SetPhysicalAddress(const Address address)
Set the destination address.
void SetSingleDevice(uint32_t device)
Set the address to match only a specified NetDevice.
Give ns3::PacketSocket powers to ns3::Node.
void Install(Ptr< Node > node) const
Aggregate an instance of a ns3::PacketSocketFactory onto the provided node.
Smart pointer class similar to boost::intrusive_ptr.
Class for representing queue sizes.
AttributeValue implementation for QueueSize.
static void SetRun(uint64_t run)
Set the run number of simulation.
static void SetSeed(uint32_t seed)
Set the seed.
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.
The IEEE 802.11 SSID Information Element.
AttributeValue implementation for Ssid.
Hold variables of type string.
Simulation virtual time values and global simulation resolution.
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
int64_t GetMicroSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
AttributeValue implementation for Time.
Hold an unsigned integer type.
helps to create WifiNetDevice objects
static void EnableLogComponents(LogLevel logLevel=LOG_LEVEL_ALL)
Helper to enable all WifiNetDevice log components with one statement.
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.
represent a single transmission mode
Hold together all Wifi-related objects.
void DisablePreambleDetectionModel()
Disable the preamble detection model on all links.
@ DLT_IEEE802_11_RADIO
Include Radiotap link layer information.
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
bool IsAggregation() const
Checks whether the PSDU contains A-MPDU.
manage and create wifi channel objects for the YANS model.
void SetPropagationDelay(std::string name, Ts &&... args)
void AddPropagationLoss(std::string name, Ts &&... args)
Ptr< YansWifiChannel > Create() const
Make it easy to create and manage PHY objects for the YANS model.
void experiment(std::string queue_disc_type)
void SetDefault(std::string name, const AttributeValue &value)
void Connect(std::string path, const CallbackBase &cb)
void Set(std::string path, const AttributeValue &value)
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
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.
WifiStandard
Identifies the IEEE 802.11 specifications that a Wifi device can be configured to use.
WifiPhyRxfailureReason
Enumeration of the possible reception failure reasons.
WifiPreamble
The type of preamble to be used by an IEEE 802.11 transmission.
@ PREAMBLE_DETECT_FAILURE
@ FRAME_CAPTURE_PACKET_SWITCH
@ SIGNAL_DETECTION_ABORTED_BY_TX
@ RECEPTION_ABORTED_BY_TX
@ PREAMBLE_DETECTION_PACKET_SWITCH
Every class exported by the ns3 library is enclosed in the ns3 namespace.
void LogComponentEnable(const std::string &name, LogLevel level)
Enable the logging output associated with that log component.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
std::map< WifiSpectrumBandInfo, Watt_u > RxPowerWattPerChannelBand
A map of the received power for each band.
@ LOG_LEVEL_ALL
Print everything.
@ LOG_LEVEL_WARN
LOG_WARN and above.
Ptr< T1 > StaticCast(const Ptr< T2 > &p)
Cast a Ptr.
SignalNoiseDbm structure.
std::map< Mac48Address, uint64_t > rxEventAbortedByTx
Map that stores the number of reception events aborted per STA because the PHY has started to transmi...
void BackoffTrace(std::string context, uint32_t newVal, uint8_t)
Backoff trace.
std::map< Mac48Address, uint64_t > rxEventWhileTxing
Map that stores the number of reception events per STA that occurred while PHY was already transmitti...
void PhyRxErrorTrace(std::string context, Ptr< const Packet > p, double snr)
PHY RX error trace.
std::map< Mac48Address, uint64_t > packetsReceived
Map that stores the total packets received per STA (and addressed to that STA)
std::ofstream backoffTraceFile
File that traces backoff over time.
void RestartCalc()
Reset the stats.
std::map< Mac48Address, uint64_t > bytesReceived
Map that stores the total bytes received per STA (and addressed to that STA)
std::map< Mac48Address, uint64_t > rxEventWhileDecodingPreamble
Map that stores the number of reception events per STA that occurred while PHY was already decoding a...
void AssociationLog(std::string context, Mac48Address address)
Association log trace.
void SocketSendTrace(std::string context, Ptr< const Packet > p, const Address &addr)
Socket send trace.
bool tracing
Flag to enable/disable generation of tracing files.
void CwTrace(std::string context, uint32_t cw, uint8_t)
Contention window trace.
uint32_t ContextToNodeId(std::string context)
Parse context strings of the form "/NodeList/x/DeviceList/x/..." to extract the NodeId integer.
std::map< Mac48Address, uint64_t > rxEventWhileRxing
Map that stores the number of reception events per STA that occurred while PHY was already receiving ...
void TracePacketReception(std::string context, Ptr< const Packet > p, uint16_t channelFreqMhz, WifiTxVector txVector, MpduInfo aMpdu, SignalNoiseDbm signalNoise, uint16_t staId)
Trace a packet reception.
void PhyRxDropTrace(std::string context, Ptr< const Packet > p, WifiPhyRxfailureReason reason)
PHY Drop trace.
void PhyTxTrace(std::string context, Ptr< const Packet > p, double txPowerW)
PHY TX trace.
std::map< Mac48Address, uint64_t > psduFailed
Map that stores the total number of unsuccessfuly received PSDUS (for which the PHY header was succes...
#define PI
Avoid std::numbers::pi because it's C++20.
std::map< Mac48Address, uint64_t > packetsTransmitted
Map that stores the total packets transmitted per STA.
std::map< std::string, std::map< unsigned int, double > > bianchiResultsDifs
Table of the expected values for DIFS.
std::map< Mac48Address, Time > timeLastReceived
Map that stores the time at which the last packet was received per STA (and the packet is addressed t...
std::map< Mac48Address, Time > timeFirstTransmitted
Map that stores the time at which the first packet was transmitted per STA.
uint8_t maxMpdus
The maximum number of MPDUs in A-MPDUs (0 to disable MPDU aggregation)
void PhyRxDoneTrace(std::string context, Ptr< const Packet > p)
PHY RX end trace.
std::set< uint32_t > associated
Contains the IDs of the STAs that successfully associated to the access point (in infrastructure mode...
std::map< Mac48Address, uint64_t > phyHeaderFailed
Map that stores the total number of unsuccessfuly received PHY headers per STA.
void MacTxTrace(std::string context, Ptr< const Packet > p)
MAC TX trace.
std::ofstream socketSendTraceFile
File that traces packets transmitted by the application over time.
uint64_t GetCount(const std::map< Mac48Address, uint64_t > &counter, Mac48Address addr)
Get the Counter associated with a MAC address.
std::ofstream macTxTraceFile
File that traces MAC transmissions over time.
void PhyRxTrace(std::string context, Ptr< const Packet > p, RxPowerWattPerChannelBand power)
PHY Rx trace.
std::ofstream phyTxTraceFile
File that traces PHY transmissions over time.
void IncrementCounter(std::map< Mac48Address, uint64_t > &counter, Mac48Address addr, uint64_t increment=1)
Incremement the counter for a given address.
std::map< Mac48Address, Time > timeFirstReceived
Map that stores the time at which the first packet was received per STA (and the packet is addressed ...
uint32_t pktSize
packet size used for the simulation (in bytes)
std::map< Mac48Address, uint64_t > psduSucceeded
Map that stores the total number of successfully received PSDUs per STA (including PSDUs not addresse...
std::map< Mac48Address, Time > timeLastTransmitted
Map that stores the time at which the last packet was transmitted per STA.
std::map< std::string, std::map< unsigned int, double > > bianchiResultsEifs
Table of the expected values for EIFS.
void MacRxTrace(std::string context, Ptr< const Packet > p)
MAC RX trace.
void PhyTxDoneTrace(std::string context, Ptr< const Packet > p)
PHY TX end trace.
void PhyRxPayloadTrace(std::string context, WifiTxVector txVector, Time psduDuration)
PHY Rx trace.
Mac48Address ContextToMac(std::string context)
Parse context strings of the form "/NodeList/x/DeviceList/x/..." and fetch the Mac address.
void PhyRxOkTrace(std::string context, Ptr< const Packet > p, double snr, WifiMode mode, WifiPreamble preamble)
PHY successful RX trace.
void DisassociationLog(std::string context, Mac48Address address)
Deassociation log trace.
std::ofstream cwTraceFile
File that traces CW over time.
std::ofstream macRxTraceFile
File that traces MAC receptions over time.