A Discrete-Event Network Simulator
API
wifi-bianchi.cc
Go to the documentation of this file.
1/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2012 The Boeing Company
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation;
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * Author: Gary Pei <guangyu.pei@boeing.com>
19 *
20 * Updated by Tom Henderson, Rohan Patidar, Hao Yin and S├ębastien Deronne
21 */
22
23// This program conducts a Bianchi analysis of a wifi network.
24// Bianchi analysis involves saturating the network and observing how
25// the maximum achievable throughput is governed by the DCF or ECDA
26// channel access mechanisms. This program offers many configurable
27// options, traces, and a validation option; the main output is a Gnuplot
28// plot file plotting throughput vs. number of nodes.
29
30#include <fstream>
31#include "ns3/log.h"
32#include "ns3/config.h"
33#include "ns3/gnuplot.h"
34#include "ns3/boolean.h"
35#include "ns3/string.h"
36#include "ns3/double.h"
37#include "ns3/integer.h"
38#include "ns3/uinteger.h"
39#include "ns3/command-line.h"
40#include "ns3/node-list.h"
41#include "ns3/yans-wifi-helper.h"
42#include "ns3/ssid.h"
43#include "ns3/wifi-mac-header.h"
44#include "ns3/queue-size.h"
45#include "ns3/propagation-loss-model.h"
46#include "ns3/propagation-delay-model.h"
47#include "ns3/rng-seed-manager.h"
48#include "ns3/mobility-helper.h"
49#include "ns3/wifi-net-device.h"
50#include "ns3/packet-socket-helper.h"
51#include "ns3/packet-socket-client.h"
52#include "ns3/packet-socket-server.h"
53#include "ns3/application-container.h"
54#include "ns3/ampdu-subframe-header.h"
55#include "ns3/wifi-mac.h"
56
58#define PI 3.1415926535
59
60NS_LOG_COMPONENT_DEFINE ("WifiBianchi");
61
62using namespace ns3;
63
64std::ofstream cwTraceFile;
65std::ofstream backoffTraceFile;
66std::ofstream phyTxTraceFile;
67std::ofstream macTxTraceFile;
68std::ofstream macRxTraceFile;
69std::ofstream socketSendTraceFile;
70
71std::map<Mac48Address, uint64_t> packetsReceived;
72std::map<Mac48Address, uint64_t> bytesReceived;
73std::map<Mac48Address, uint64_t> packetsTransmitted;
74std::map<Mac48Address, uint64_t> psduFailed;
75std::map<Mac48Address, uint64_t> psduSucceeded;
76std::map<Mac48Address, uint64_t> phyHeaderFailed;
77std::map<Mac48Address, uint64_t> rxEventWhileTxing;
78std::map<Mac48Address, uint64_t> rxEventWhileRxing;
79std::map<Mac48Address, uint64_t> rxEventWhileDecodingPreamble;
80std::map<Mac48Address, uint64_t> rxEventAbortedByTx;
81
82std::map<Mac48Address, Time> timeFirstReceived;
83std::map<Mac48Address, Time> timeLastReceived;
84std::map<Mac48Address, Time> timeFirstTransmitted;
85std::map<Mac48Address, Time> timeLastTransmitted;
86
87std::set<uint32_t> associated;
88
89bool tracing = false;
91uint8_t maxMpdus = 0;
92
94std::map<std::string /* mode */, std::map<unsigned int /* number of nodes */, double /* calculated throughput */> > bianchiResultsEifs =
95{
96/* 11b */
97 {"DsssRate1Mbps", {
98 {5, 0.8418}, {10, 0.7831}, {15, 0.7460}, {20, 0.7186}, {25, 0.6973}, {30, 0.6802}, {35, 0.6639}, {40, 0.6501}, {45, 0.6386}, {50, 0.6285},
99 }},
100 {"DsssRate2Mbps", {
101 {5, 1.6170}, {10, 1.5075}, {15, 1.4371}, {20, 1.3849}, {25, 1.3442}, {30, 1.3115}, {35, 1.2803}, {40, 1.2538}, {45, 1.2317}, {50, 1.2124},
102 }},
103 {"DsssRate5_5Mbps", {
104 {5, 3.8565}, {10, 3.6170}, {15, 3.4554}, {20, 3.3339}, {25, 3.2385}, {30, 3.1613}, {35, 3.0878}, {40, 3.0249}, {45, 2.9725}, {50, 2.9266},
105 }},
106 {"DsssRate11Mbps", {
107 {5, 6.3821}, {10, 6.0269}, {15, 5.7718}, {20, 5.5765}, {25, 5.4217}, {30, 5.2958}, {35, 5.1755}, {40, 5.0722}, {45, 4.9860}, {50, 4.9103},
108 }},
109/* 11a */
110 {"OfdmRate6Mbps", {
111 {5, 4.6899}, {10, 4.3197}, {15, 4.1107}, {20, 3.9589}, {25, 3.8478}, {30, 3.7490}, {35, 3.6618}, {40, 3.5927}, {45, 3.5358}, {50, 3.4711},
112 }},
113 {"OfdmRate9Mbps", {
114 {5, 6.8188}, {10, 6.2885}, {15, 5.9874}, {20, 5.7680}, {25, 5.6073}, {30, 5.4642}, {35, 5.3378}, {40, 5.2376}, {45, 5.1551}, {50, 5.0612},
115 }},
116 {"OfdmRate12Mbps", {
117 {5, 8.8972}, {10, 8.2154}, {15, 7.8259}, {20, 7.5415}, {25, 7.3329}, {30, 7.1469}, {35, 6.9825}, {40, 6.8521}, {45, 6.7447}, {50, 6.6225},
118 }},
119 {"OfdmRate18Mbps", {
120 {5, 12.6719}, {10, 11.7273}, {15, 11.1814}, {20, 10.7810}, {25, 10.4866}, {30, 10.2237}, {35, 9.9910}, {40, 9.8061}, {45, 9.6538}, {50, 9.4804},
121 }},
122 {"OfdmRate24Mbps", {
123 {5, 16.0836}, {10, 14.9153}, {15, 14.2327}, {20, 13.7300}, {25, 13.3595}, {30, 13.0281}, {35, 12.7343}, {40, 12.5008}, {45, 12.3083}, {50, 12.0889},
124 }},
125 {"OfdmRate36Mbps", {
126 {5, 22.0092}, {10, 20.4836}, {15, 19.5743}, {20, 18.8997}, {25, 18.4002}, {30, 17.9524}, {35, 17.5545}, {40, 17.2377}, {45, 16.9760}, {50, 16.6777},
127 }},
128 {"OfdmRate48Mbps", {
129 {5, 26.8382}, {10, 25.0509}, {15, 23.9672}, {20, 23.1581}, {25, 22.5568}, {30, 22.0165}, {35, 21.5355}, {40, 21.1519}, {45, 20.8348}, {50, 20.4729},
130 }},
131 {"OfdmRate54Mbps", {
132 {5, 29.2861}, {10, 27.3763}, {15, 26.2078}, {20, 25.3325}, {25, 24.6808}, {30, 24.0944}, {35, 23.5719}, {40, 23.1549}, {45, 22.8100}, {50, 22.4162},
133 }},
134/* 11g */
135 {"ErpOfdmRate6Mbps", {
136 {5, 4.6899}, {10, 4.3197}, {15, 4.1107}, {20, 3.9589}, {25, 3.8478}, {30, 3.7490}, {35, 3.6618}, {40, 3.5927}, {45, 3.5358}, {50, 3.4711},
137 }},
138 {"ErpOfdmRate9Mbps", {
139 {5, 6.8188}, {10, 6.2885}, {15, 5.9874}, {20, 5.7680}, {25, 5.6073}, {30, 5.4642}, {35, 5.3378}, {40, 5.2376}, {45, 5.1551}, {50, 5.0612},
140 }},
141 {"ErpOfdmRate12Mbps", {
142 {5, 8.8972}, {10, 8.2154}, {15, 7.8259}, {20, 7.5415}, {25, 7.3329}, {30, 7.1469}, {35, 6.9825}, {40, 6.8521}, {45, 6.7447}, {50, 6.6225},
143 }},
144 {"ErpOfdmRate18Mbps", {
145 {5, 12.6719}, {10, 11.7273}, {15, 11.1814}, {20, 10.7810}, {25, 10.4866}, {30, 10.2237}, {35, 9.9910}, {40, 9.8061}, {45, 9.6538}, {50, 9.4804},
146 }},
147 {"ErpOfdmRate24Mbps", {
148 {5, 16.0836}, {10, 14.9153}, {15, 14.2327}, {20, 13.7300}, {25, 13.3595}, {30, 13.0281}, {35, 12.7343}, {40, 12.5008}, {45, 12.3083}, {50, 12.0889},
149 }},
150 {"ErpOfdmRate36Mbps", {
151 {5, 22.0092}, {10, 20.4836}, {15, 19.5743}, {20, 18.8997}, {25, 18.4002}, {30, 17.9524}, {35, 17.5545}, {40, 17.2377}, {45, 16.9760}, {50, 16.6777},
152 }},
153 {"ErpOfdmRate48Mbps", {
154 {5, 26.8382}, {10, 25.0509}, {15, 23.9672}, {20, 23.1581}, {25, 22.5568}, {30, 22.0165}, {35, 21.5355}, {40, 21.1519}, {45, 20.8348}, {50, 20.4729},
155 }},
156 {"ErpOfdmRate54Mbps", {
157 {5, 29.2861}, {10, 27.3763}, {15, 26.2078}, {20, 25.3325}, {25, 24.6808}, {30, 24.0944}, {35, 23.5719}, {40, 23.1549}, {45, 22.8100}, {50, 22.4162},
158 }},
159/* 11ax, no frame aggregation */
160 {"HeMcs0_20MHz", {
161 {5, 6.3381}, {10, 5.8172}, {15, 5.5223}, {20, 5.3146}, {25, 5.1525}, {30, 5.0187}, {35, 4.9039}, {40, 4.8034}, {45, 4.7134}, {50, 4.6317},
162 }},
163 {"HeMcs1_20MHz", {
164 {5, 11.6580}, {10, 10.7369}, {15, 10.2068}, {20, 9.8309}, {25, 9.5365}, {30, 9.2930}, {35, 9.0837}, {40, 8.9001}, {45, 8.7355}, {50, 8.5860},
165 }},
166 {"HeMcs2_20MHz", {
167 {5, 15.8572}, {10, 14.6445}, {15, 13.9367}, {20, 13.4323}, {25, 13.0361}, {30, 12.7076}, {35, 12.4249}, {40, 12.1766}, {45, 11.9538}, {50, 11.7511},
168 }},
169 {"HeMcs3_20MHz", {
170 {5, 19.7457}, {10, 18.2820}, {15, 17.4163}, {20, 16.7963}, {25, 16.3078}, {30, 15.9021}, {35, 15.5524}, {40, 15.2449}, {45, 14.9687}, {50, 14.7173},
171 }},
172 {"HeMcs4_20MHz", {
173 {5, 25.8947}, {10, 24.0721}, {15, 22.9698}, {20, 22.1738}, {25, 21.5437}, {30, 21.0186}, {35, 20.5650}, {40, 20.1654}, {45, 19.8059}, {50, 19.4784},
174 }},
175 {"HeMcs5_20MHz", {
176 {5, 30.0542}, {10, 28.0155}, {15, 26.7625}, {20, 25.8523}, {25, 25.1295}, {30, 24.5258}, {35, 24.0034}, {40, 23.5426}, {45, 23.1277}, {50, 22.7492},
177 }},
178 {"HeMcs6_20MHz", {
179 {5, 32.6789}, {10, 30.5150}, {15, 29.1708}, {20, 28.1907}, {25, 27.4107}, {30, 26.7583}, {35, 26.1931}, {40, 25.6941}, {45, 25.2446}, {50, 24.8343},
180 }},
181 {"HeMcs7_20MHz", {
182 {5, 34.1710}, {10, 31.9398}, {15, 30.5451}, {20, 29.5261}, {25, 28.7140}, {30, 28.0342}, {35, 27.4449}, {40, 26.9245}, {45, 26.4554}, {50, 26.0271},
183 }},
184 {"HeMcs8_20MHz", {
185 {5, 37.6051}, {10, 35.2296}, {15, 33.7228}, {20, 32.6160}, {25, 31.7314}, {30, 30.9895}, {35, 30.3455}, {40, 29.7760}, {45, 29.2623}, {50, 28.7929},
186 }},
187 {"HeMcs9_20MHz", {
188 {5, 39.5947}, {10, 37.1424}, {15, 35.5731}, {20, 34.4169}, {25, 33.4911}, {30, 32.7138}, {35, 32.0385}, {40, 31.4410}, {45, 30.9016}, {50, 30.4086},
189 }},
190 {"HeMcs10_20MHz", {
191 {5, 39.5947}, {10, 37.1424}, {15, 35.5731}, {20, 34.4169}, {25, 33.4911}, {30, 32.7138}, {35, 32.0385}, {40, 31.4410}, {45, 30.9016}, {50, 30.4086},
192 }},
193 {"HeMcs11_20MHz", {
194 {5, 41.8065}, {10, 39.2749}, {15, 37.6383}, {20, 36.4282}, {25, 35.4575}, {30, 34.6414}, {35, 33.9316}, {40, 33.3031}, {45, 32.7355}, {50, 32.2164},
195 }},
196 {"HeMcs0_40MHz", {
197 {5, 11.4999}, {10, 10.5902}, {15, 10.0669}, {20, 9.6960}, {25, 9.4055}, {30, 9.1652}, {35, 8.9587}, {40, 8.7775}, {45, 8.6151}, {50, 8.4676},
198 }},
199 {"HeMcs1_40MHz", {
200 {5, 19.5937}, {10, 18.1394}, {15, 17.2798}, {20, 16.6642}, {25, 16.1793}, {30, 15.7766}, {35, 15.4295}, {40, 15.1242}, {45, 14.8502}, {50, 14.6007},
201 }},
202 {"HeMcs2_40MHz", {
203 {5, 25.6338}, {10, 23.8255}, {15, 22.7329}, {20, 21.9442}, {25, 21.3200}, {30, 20.7999}, {35, 20.3506}, {40, 19.9549}, {45, 19.5990}, {50, 19.2746},
204 }},
205 {"HeMcs3_40MHz", {
206 {5, 30.0542}, {10, 28.0155}, {15, 26.7625}, {20, 25.8523}, {25, 25.1295}, {30, 24.5258}, {35, 24.0034}, {40, 23.5426}, {45, 23.1277}, {50, 22.7492},
207 }},
208 {"HeMcs4_40MHz", {
209 {5, 37.6051}, {10, 35.2296}, {15, 33.7228}, {20, 32.6160}, {25, 31.7314}, {30, 30.9895}, {35, 30.3455}, {40, 29.7760}, {45, 29.2623}, {50, 28.7929},
210 }},
211 {"HeMcs5_40MHz", {
212 {5, 41.8065}, {10, 39.2749}, {15, 37.6383}, {20, 36.4282}, {25, 35.4575}, {30, 34.6414}, {35, 33.9316}, {40, 33.3031}, {45, 32.7355}, {50, 32.2164},
213 }},
214 {"HeMcs6_40MHz", {
215 {5, 44.2801}, {10, 41.6672}, {15, 39.9580}, {20, 38.6892}, {25, 37.6692}, {30, 36.8103}, {35, 36.0625}, {40, 35.3998}, {45, 34.8008}, {50, 34.2528},
216 }},
217 {"HeMcs7_40MHz", {
218 {5, 44.2801}, {10, 41.6672}, {15, 39.9580}, {20, 38.6892}, {25, 37.6692}, {30, 36.8103}, {35, 36.0625}, {40, 35.3998}, {45, 34.8008}, {50, 34.2528},
219 }},
220 {"HeMcs8_40MHz", {
221 {5, 47.0648}, {10, 44.3699}, {15, 42.5825}, {20, 41.2495}, {25, 40.1751}, {30, 39.2689}, {35, 38.4790}, {40, 37.7781}, {45, 37.1443}, {50, 36.5639},
222 }},
223 {"HeMcs9_40MHz", {
224 {5, 50.2233}, {10, 47.4474}, {15, 45.5760}, {20, 44.1727}, {25, 43.0382}, {30, 42.0794}, {35, 41.2425}, {40, 40.4991}, {45, 39.8262}, {50, 39.2095},
225 }},
226 {"HeMcs10_40MHz", {
227 {5, 50.2233}, {10, 47.4474}, {15, 45.5760}, {20, 44.1727}, {25, 43.0382}, {30, 42.0794}, {35, 41.2425}, {40, 40.4991}, {45, 39.8262}, {50, 39.2095},
228 }},
229 {"HeMcs11_40MHz", {
230 {5, 50.2233}, {10, 47.4474}, {15, 45.5760}, {20, 44.1727}, {25, 43.0382}, {30, 42.0794}, {35, 41.2425}, {40, 40.4991}, {45, 39.8262}, {50, 39.2095},
231 }},
232 {"HeMcs0_80MHz", {
233 {5, 19.6542}, {10, 18.1962}, {15, 17.3342}, {20, 16.7168}, {25, 16.2305}, {30, 15.8265}, {35, 15.4784}, {40, 15.1723}, {45, 14.8973}, {50, 14.6471},
234 }},
235 {"HeMcs1_80MHz", {
236 {5, 30.9311}, {10, 28.8495}, {15, 27.5657}, {20, 26.6320}, {25, 25.8899}, {30, 25.2699}, {35, 24.7332}, {40, 24.2595}, {45, 23.8330}, {50, 23.4439},
237 }},
238 {"HeMcs2_80MHz", {
239 {5, 37.0575}, {10, 34.7039}, {15, 33.2146}, {20, 32.1216}, {25, 31.2485}, {30, 30.5164}, {35, 29.8811}, {40, 29.3194}, {45, 28.8127}, {50, 28.3499},
240 }},
241 {"HeMcs3_80MHz", {
242 {5, 41.8065}, {10, 39.2749}, {15, 37.6383}, {20, 36.4282}, {25, 35.4575}, {30, 34.6414}, {35, 33.9316}, {40, 33.3031}, {45, 32.7355}, {50, 32.2164},
243 }},
244 {"HeMcs4_80MHz", {
245 {5, 47.0648}, {10, 44.3699}, {15, 42.5825}, {20, 41.2495}, {25, 40.1751}, {30, 39.2689}, {35, 38.4790}, {40, 37.7781}, {45, 37.1443}, {50, 36.5639},
246 }},
247 {"HeMcs5_80MHz", {
248 {5, 50.2233}, {10, 47.4474}, {15, 45.5760}, {20, 44.1727}, {25, 43.0382}, {30, 42.0794}, {35, 41.2425}, {40, 40.4991}, {45, 39.8262}, {50, 39.2095},
249 }},
250 {"HeMcs6_80MHz", {
251 {5, 53.8362}, {10, 50.9837}, {15, 49.0221}, {20, 47.5418}, {25, 46.3407}, {30, 45.3233}, {35, 44.4337}, {40, 43.6425}, {45, 42.9255}, {50, 42.2678},
252 }},
253 {"HeMcs7_80MHz", {
254 {5, 53.8362}, {10, 50.9837}, {15, 49.0221}, {20, 47.5418}, {25, 46.3407}, {30, 45.3233}, {35, 44.4337}, {40, 43.6425}, {45, 42.9255}, {50, 42.2678},
255 }},
256 {"HeMcs8_80MHz", {
257 {5, 53.8362}, {10, 50.9837}, {15, 49.0221}, {20, 47.5418}, {25, 46.3407}, {30, 45.3233}, {35, 44.4337}, {40, 43.6425}, {45, 42.9255}, {50, 42.2678},
258 }},
259 {"HeMcs9_80MHz", {
260 {5, 58.0092}, {10, 55.0896}, {15, 53.0321}, {20, 51.4672}, {25, 50.1922}, {30, 49.1091}, {35, 48.1601}, {40, 47.3148}, {45, 46.5478}, {50, 45.8436},
261 }},
262 {"HeMcs10_80MHz", {
263 {5, 58.0092}, {10, 55.0896}, {15, 53.0321}, {20, 51.4672}, {25, 50.1922}, {30, 49.1091}, {35, 48.1601}, {40, 47.3148}, {45, 46.5478}, {50, 45.8436},
264 }},
265 {"HeMcs11_80MHz", {
266 {5, 58.0092}, {10, 55.0896}, {15, 53.0321}, {20, 51.4672}, {25, 50.1922}, {30, 49.1091}, {35, 48.1601}, {40, 47.3148}, {45, 46.5478}, {50, 45.8436},
267 }},
268 {"HeMcs0_160MHz", {
269 {5, 29.8428}, {10, 27.8145}, {15, 26.5689}, {20, 25.6645}, {25, 24.9463}, {30, 24.3466}, {35, 23.8276}, {40, 23.3699}, {45, 22.9578}, {50, 22.5819},
270 }},
271 {"HeMcs1_160MHz", {
272 {5, 41.1308}, {10, 38.6227}, {15, 37.0064}, {20, 35.8126}, {25, 34.8556}, {30, 34.0513}, {35, 33.3520}, {40, 32.7329}, {45, 32.1739}, {50, 31.6628},
273 }},
274 {"HeMcs2_160MHz", {
275 {5, 46.2101}, {10, 43.5393}, {15, 41.7755}, {20, 40.4620}, {25, 39.4041}, {30, 38.5123}, {35, 37.7353}, {40, 37.0461}, {45, 36.4229}, {50, 35.8524},
276 }},
277 {"HeMcs3_160MHz", {
278 {5, 50.2233}, {10, 47.4474}, {15, 45.5760}, {20, 44.1727}, {25, 43.0382}, {30, 42.0794}, {35, 41.2425}, {40, 40.4991}, {45, 39.8262}, {50, 39.2095},
279 }},
280 {"HeMcs4_160MHz", {
281 {5, 53.8362}, {10, 50.9837}, {15, 49.0221}, {20, 47.5418}, {25, 46.3407}, {30, 45.3233}, {35, 44.4337}, {40, 43.6425}, {45, 42.9255}, {50, 42.2678},
282 }},
283 {"HeMcs5_160MHz", {
284 {5, 58.0092}, {10, 55.0896}, {15, 53.0321}, {20, 51.4672}, {25, 50.1922}, {30, 49.1091}, {35, 48.1601}, {40, 47.3148}, {45, 46.5478}, {50, 45.8436},
285 }},
286 {"HeMcs6_160MHz", {
287 {5, 58.0092}, {10, 55.0896}, {15, 53.0321}, {20, 51.4672}, {25, 50.1922}, {30, 49.1091}, {35, 48.1601}, {40, 47.3148}, {45, 46.5478}, {50, 45.8436},
288 }},
289 {"HeMcs7_160MHz", {
290 {5, 58.0092}, {10, 55.0896}, {15, 53.0321}, {20, 51.4672}, {25, 50.1922}, {30, 49.1091}, {35, 48.1601}, {40, 47.3148}, {45, 46.5478}, {50, 45.8436},
291 }},
292 {"HeMcs8_160MHz", {
293 {5, 58.0092}, {10, 55.0896}, {15, 53.0321}, {20, 51.4672}, {25, 50.1922}, {30, 49.1091}, {35, 48.1601}, {40, 47.3148}, {45, 46.5478}, {50, 45.8436},
294 }},
295 {"HeMcs9_160MHz", {
296 {5, 62.8834}, {10, 59.9147}, {15, 57.7564}, {20, 56.0992}, {25, 54.7419}, {30, 53.5850}, {35, 52.5689}, {40, 51.6620}, {45, 50.8379}, {50, 50.0803},
297 }},
298 {"HeMcs10_160MHz", {
299 {5, 62.8834}, {10, 59.9147}, {15, 57.7564}, {20, 56.0992}, {25, 54.7419}, {30, 53.5850}, {35, 52.5689}, {40, 51.6620}, {45, 50.8379}, {50, 50.0803},
300 }},
301 {"HeMcs11_160MHz", {
302 {5, 62.8834}, {10, 59.9147}, {15, 57.7564}, {20, 56.0992}, {25, 54.7419}, {30, 53.5850}, {35, 52.5689}, {40, 51.6620}, {45, 50.8379}, {50, 50.0803},
303 }},
304};
305
307std::map<std::string /* mode */, std::map<unsigned int /* number of nodes */, double /* calculated throughput */> > bianchiResultsDifs =
308{
309/* 11b */
310 {"DsssRate1Mbps", {
311 {5, 0.8437}, {10, 0.7861}, {15, 0.7496}, {20, 0.7226}, {25, 0.7016}, {30, 0.6847}, {35, 0.6686}, {40, 0.6549}, {45, 0.6435}, {50, 0.6336},
312 }},
313 {"DsssRate2Mbps", {
314 {5, 1.6228}, {10, 1.5168}, {15, 1.4482}, {20, 1.3972}, {25, 1.3574}, {30, 1.3253}, {35, 1.2947}, {40, 1.2687}, {45, 1.2469}, {50, 1.2279},
315 }},
316 {"DsssRate5_5Mbps", {
317 {5, 3.8896}, {10, 3.6707}, {15, 3.5203}, {20, 3.4063}, {25, 3.3161}, {30, 3.2429}, {35, 3.1729}, {40, 3.1128}, {45, 3.0625}, {50, 3.0184},
318 }},
319 {"DsssRate11Mbps", {
320 {5, 6.4734}, {10, 6.1774}, {15, 5.9553}, {20, 5.7819}, {25, 5.6429}, {30, 5.5289}, {35, 5.4191}, {40, 5.3243}, {45, 5.2446}, {50, 5.1745},
321 }},
322/* 11a */
323 {"OfdmRate6Mbps", {
324 {5, 4.7087}, {10, 4.3453}, {15, 4.1397}, {20, 3.9899}, {25, 3.8802}, {30, 3.7824}, {35, 3.6961}, {40, 3.6276}, {45, 3.5712}, {50, 3.5071},
325 }},
326 {"OfdmRate9Mbps", {
327 {5, 6.8586}, {10, 6.3431}, {15, 6.0489}, {20, 5.8340}, {25, 5.6762}, {30, 5.5355}, {35, 5.4110}, {40, 5.3122}, {45, 5.2307}, {50, 5.1380},
328 }},
329 {"OfdmRate12Mbps", {
330 {5, 8.9515}, {10, 8.2901}, {15, 7.9102}, {20, 7.6319}, {25, 7.4274}, {30, 7.2447}, {35, 7.0829}, {40, 6.9544}, {45, 6.8485}, {50, 6.7278},
331 }},
332 {"OfdmRate18Mbps", {
333 {5, 12.7822}, {10, 11.8801}, {15, 11.3543}, {20, 10.9668}, {25, 10.6809}, {30, 10.4249}, {35, 10.1978}, {40, 10.0171}, {45, 9.8679}, {50, 9.6978},
334 }},
335 {"OfdmRate24Mbps", {
336 {5, 16.2470}, {10, 15.1426}, {15, 14.4904}, {20, 14.0072}, {25, 13.6496}, {30, 13.3288}, {35, 13.0436}, {40, 12.8164}, {45, 12.6286}, {50, 12.4144},
337 }},
338 {"OfdmRate36Mbps", {
339 {5, 22.3164}, {10, 20.9147}, {15, 20.0649}, {20, 19.4289}, {25, 18.9552}, {30, 18.5284}, {35, 18.1476}, {40, 17.8434}, {45, 17.5915}, {50, 17.3036},
340 }},
341 {"OfdmRate48Mbps", {
342 {5, 27.2963}, {10, 25.6987}, {15, 24.7069}, {20, 23.9578}, {25, 23.3965}, {30, 22.8891}, {35, 22.4350}, {40, 22.0713}, {45, 21.7696}, {50, 21.4243},
343 }},
344 {"OfdmRate54Mbps", {
345 {5, 29.8324}, {10, 28.1519}, {15, 27.0948}, {20, 26.2925}, {25, 25.6896}, {30, 25.1434}, {35, 24.6539}, {40, 24.2613}, {45, 23.9353}, {50, 23.5618},
346 }},
347/* 11g */
348 {"ErpOfdmRate6Mbps", {
349 {5, 4.7087}, {10, 4.3453}, {15, 4.1397}, {20, 3.9899}, {25, 3.8802}, {30, 3.7824}, {35, 3.6961}, {40, 3.6276}, {45, 3.5712}, {50, 3.5071},
350 }},
351 {"ErpOfdmRate9Mbps", {
352 {5, 6.8586}, {10, 6.3431}, {15, 6.0489}, {20, 5.8340}, {25, 5.6762}, {30, 5.5355}, {35, 5.4110}, {40, 5.3122}, {45, 5.2307}, {50, 5.1380},
353 }},
354 {"ErpOfdmRate12Mbps", {
355 {5, 8.9515}, {10, 8.2901}, {15, 7.9102}, {20, 7.6319}, {25, 7.4274}, {30, 7.2447}, {35, 7.0829}, {40, 6.9544}, {45, 6.8485}, {50, 6.7278},
356 }},
357 {"ErpOfdmRate18Mbps", {
358 {5, 12.7822}, {10, 11.8801}, {15, 11.3543}, {20, 10.9668}, {25, 10.6809}, {30, 10.4249}, {35, 10.1978}, {40, 10.0171}, {45, 9.8679}, {50, 9.6978},
359 }},
360 {"ErpOfdmRate24Mbps", {
361 {5, 16.2470}, {10, 15.1426}, {15, 14.4904}, {20, 14.0072}, {25, 13.6496}, {30, 13.3288}, {35, 13.0436}, {40, 12.8164}, {45, 12.6286}, {50, 12.4144},
362 }},
363 {"ErpOfdmRate36Mbps", {
364 {5, 22.3164}, {10, 20.9147}, {15, 20.0649}, {20, 19.4289}, {25, 18.9552}, {30, 18.5284}, {35, 18.1476}, {40, 17.8434}, {45, 17.5915}, {50, 17.3036},
365 }},
366 {"ErpOfdmRate48Mbps", {
367 {5, 27.2963}, {10, 25.6987}, {15, 24.7069}, {20, 23.9578}, {25, 23.3965}, {30, 22.8891}, {35, 22.4350}, {40, 22.0713}, {45, 21.7696}, {50, 21.4243},
368 }},
369 {"ErpOfdmRate54Mbps", {
370 {5, 29.8324}, {10, 28.1519}, {15, 27.0948}, {20, 26.2925}, {25, 25.6896}, {30, 25.1434}, {35, 24.6539}, {40, 24.2613}, {45, 23.9353}, {50, 23.5618},
371 }},
372/* 11ax, no frame aggregation */
373 {"HeMcs0_20MHz", {
374 {5, 6.3746}, {10, 5.8670}, {15, 5.5782}, {20, 5.3742}, {25, 5.2147}, {30, 5.0829}, {35, 4.9696}, {40, 4.8703}, {45, 4.7813}, {50, 4.7004},
375 }},
376 {"HeMcs1_20MHz", {
377 {5, 11.7574}, {10, 10.8735}, {15, 10.3606}, {20, 9.9954}, {25, 9.7084}, {30, 9.4704}, {35, 9.2654}, {40, 9.0853}, {45, 8.9235}, {50, 8.7763},
378 }},
379 {"HeMcs2_20MHz", {
380 {5, 16.0419}, {10, 14.8998}, {15, 14.2252}, {20, 13.7413}, {25, 13.3594}, {30, 13.0417}, {35, 12.7674}, {40, 12.5258}, {45, 12.3086}, {50, 12.1107},
381 }},
382 {"HeMcs3_20MHz", {
383 {5, 20.0089}, {10, 18.6480}, {15, 17.8309}, {20, 17.2410}, {25, 16.7736}, {30, 16.3837}, {35, 16.0465}, {40, 15.7491}, {45, 15.4813}, {50, 15.2369},
384 }},
385 {"HeMcs4_20MHz", {
386 {5, 26.3492}, {10, 24.7107}, {15, 23.6964}, {20, 22.9553}, {25, 22.3640}, {30, 21.8683}, {35, 21.4379}, {40, 21.0571}, {45, 20.7134}, {50, 20.3991},
387 }},
388 {"HeMcs5_20MHz", {
389 {5, 30.6683}, {10, 28.8843}, {15, 27.7540}, {20, 26.9210}, {25, 26.2528}, {30, 25.6906}, {35, 25.2012}, {40, 24.7671}, {45, 24.3746}, {50, 24.0151},
390 }},
391 {"HeMcs6_20MHz", {
392 {5, 33.4062}, {10, 31.5485}, {15, 30.3527}, {20, 29.4662}, {25, 28.7527}, {30, 28.1508}, {35, 27.6259}, {40, 27.1597}, {45, 26.7376}, {50, 26.3507},
393 }},
394 {"HeMcs7_20MHz", {
395 {5, 34.9671}, {10, 33.0739}, {15, 31.8436}, {20, 30.9282}, {25, 30.1900}, {30, 29.5665}, {35, 29.0221}, {40, 28.5382}, {45, 28.0997}, {50, 27.6975},
396 }},
397 {"HeMcs8_20MHz", {
398 {5, 38.5714}, {10, 36.6144}, {15, 35.3124}, {20, 34.3355}, {25, 33.5438}, {30, 32.8728}, {35, 32.2854}, {40, 31.7623}, {45, 31.2874}, {50, 30.8512},
399 }},
400 {"HeMcs9_20MHz", {
401 {5, 40.6674}, {10, 38.6851}, {15, 37.3466}, {20, 36.3371}, {25, 35.5165}, {30, 34.8197}, {35, 34.2087}, {40, 33.6638}, {45, 33.1688}, {50, 32.7137},
402 }},
403 {"HeMcs10_20MHz", {
404 {5, 40.6674}, {10, 38.6851}, {15, 37.3466}, {20, 36.3371}, {25, 35.5165}, {30, 34.8197}, {35, 34.2087}, {40, 33.6638}, {45, 33.1688}, {50, 32.7137},
405 }},
406 {"HeMcs11_20MHz", {
407 {5, 43.0043}, {10, 41.0039}, {15, 39.6294}, {20, 38.5865}, {25, 37.7358}, {30, 37.0116}, {35, 36.3756}, {40, 35.8076}, {45, 35.2909}, {50, 34.8154},
408 }},
409 {"HeMcs0_40MHz", {
410 {5, 11.6208}, {10, 10.7566}, {15, 10.2544}, {20, 9.8965}, {25, 9.6151}, {30, 9.3815}, {35, 9.1804}, {40, 9.0035}, {45, 8.8446}, {50, 8.7000},
411 }},
412 {"HeMcs1_40MHz", {
413 {5, 19.8764}, {10, 18.5328}, {15, 17.7255}, {20, 17.1424}, {25, 16.6803}, {30, 16.2947}, {35, 15.9612}, {40, 15.6668}, {45, 15.4018}, {50, 15.1599},
414 }},
415 {"HeMcs2_40MHz", {
416 {5, 26.1198}, {10, 24.5088}, {15, 23.5107}, {20, 22.7810}, {25, 22.1986}, {30, 21.7101}, {35, 21.2858}, {40, 20.9104}, {45, 20.5714}, {50, 20.2613},
417 }},
418 {"HeMcs3_40MHz", {
419 {5, 30.6683}, {10, 28.8843}, {15, 27.7540}, {20, 26.9210}, {25, 26.2528}, {30, 25.6906}, {35, 25.2012}, {40, 24.7671}, {45, 24.3746}, {50, 24.0151},
420 }},
421 {"HeMcs4_40MHz", {
422 {5, 38.5714}, {10, 36.6144}, {15, 35.3124}, {20, 34.3355}, {25, 33.5438}, {30, 32.8728}, {35, 32.2854}, {40, 31.7623}, {45, 31.2874}, {50, 30.8512},
423 }},
424 {"HeMcs5_40MHz", {
425 {5, 43.0043}, {10, 41.0039}, {15, 39.6294}, {20, 38.5865}, {25, 37.7358}, {30, 37.0116}, {35, 36.3756}, {40, 35.8076}, {45, 35.2909}, {50, 34.8154},
426 }},
427 {"HeMcs6_40MHz", {
428 {5, 45.6261}, {10, 43.6185}, {15, 42.2095}, {20, 41.1328}, {25, 40.2509}, {30, 39.4981}, {35, 38.8356}, {40, 38.2430}, {45, 37.7032}, {50, 37.2058},
429 }},
430 {"HeMcs7_40MHz", {
431 {5, 45.6261}, {10, 43.6185}, {15, 42.2095}, {20, 41.1328}, {25, 40.2509}, {30, 39.4981}, {35, 38.8356}, {40, 38.2430}, {45, 37.7032}, {50, 37.2058},
432 }},
433 {"HeMcs8_40MHz", {
434 {5, 48.5883}, {10, 46.5892}, {15, 45.1489}, {20, 44.0388}, {25, 43.1252}, {30, 42.3428}, {35, 41.6525}, {40, 41.0338}, {45, 40.4694}, {50, 39.9486},
435 }},
436 {"HeMcs9_40MHz", {
437 {5, 51.9619}, {10, 49.9941}, {15, 48.5284}, {20, 47.3867}, {25, 46.4416}, {30, 45.6290}, {35, 44.9099}, {40, 44.2640}, {45, 43.6736}, {50, 43.1279},
438 }},
439 {"HeMcs10_40MHz", {
440 {5, 51.9619}, {10, 49.9941}, {15, 48.5284}, {20, 47.3867}, {25, 46.4416}, {30, 45.6290}, {35, 44.9099}, {40, 44.2640}, {45, 43.6736}, {50, 43.1279},
441 }},
442 {"HeMcs11_40MHz", {
443 {5, 51.9619}, {10, 49.9941}, {15, 48.5284}, {20, 47.3867}, {25, 46.4416}, {30, 45.6290}, {35, 44.9099}, {40, 44.2640}, {45, 43.6736}, {50, 43.1279},
444 }},
445 {"HeMcs0_80MHz", {
446 {5, 20.0101}, {10, 18.6928}, {15, 17.8976}, {20, 17.3219}, {25, 16.8648}, {30, 16.4830}, {35, 16.1523}, {40, 15.8603}, {45, 15.5971}, {50, 15.3567},
447 }},
448 {"HeMcs1_80MHz", {
449 {5, 31.6415}, {10, 29.8575}, {15, 28.7177}, {20, 27.8747}, {25, 27.1971}, {30, 26.6261}, {35, 26.1283}, {40, 25.6865}, {45, 25.2866}, {50, 24.9200},
450 }},
451 {"HeMcs2_80MHz", {
452 {5, 38.0818}, {10, 36.1730}, {15, 34.9016}, {20, 33.9470}, {25, 33.1729}, {30, 32.5165}, {35, 31.9417}, {40, 31.4295}, {45, 30.9645}, {50, 30.5372},
453 }},
454 {"HeMcs3_80MHz", {
455 {5, 43.0043}, {10, 41.0039}, {15, 39.6294}, {20, 38.5865}, {25, 37.7358}, {30, 37.0116}, {35, 36.3756}, {40, 35.8076}, {45, 35.2909}, {50, 34.8154},
456 }},
457 {"HeMcs4_80MHz", {
458 {5, 48.5883}, {10, 46.5892}, {15, 45.1489}, {20, 44.0388}, {25, 43.1252}, {30, 42.3428}, {35, 41.6525}, {40, 41.0338}, {45, 40.4694}, {50, 39.9486},
459 }},
460 {"HeMcs5_80MHz", {
461 {5, 51.9619}, {10, 49.9941}, {15, 48.5284}, {20, 47.3867}, {25, 46.4416}, {30, 45.6290}, {35, 44.9099}, {40, 44.2640}, {45, 43.6736}, {50, 43.1279},
462 }},
463 {"HeMcs6_80MHz", {
464 {5, 55.8389}, {10, 53.9360}, {15, 52.4548}, {20, 51.2855}, {25, 50.3106}, {30, 49.4682}, {35, 48.7201}, {40, 48.0462}, {45, 47.4288}, {50, 46.8571},
465 }},
466 {"HeMcs7_80MHz", {
467 {5, 55.8389}, {10, 53.9360}, {15, 52.4548}, {20, 51.2855}, {25, 50.3106}, {30, 49.4682}, {35, 48.7201}, {40, 48.0462}, {45, 47.4288}, {50, 46.8571},
468 }},
469 {"HeMcs8_80MHz", {
470 {5, 55.8389}, {10, 53.9360}, {15, 52.4548}, {20, 51.2855}, {25, 50.3106}, {30, 49.4682}, {35, 48.7201}, {40, 48.0462}, {45, 47.4288}, {50, 46.8571},
471 }},
472 {"HeMcs9_80MHz", {
473 {5, 60.3411}, {10, 58.5527}, {15, 57.0724}, {20, 55.8834}, {25, 54.8827}, {30, 54.0128}, {35, 53.2368}, {40, 52.5352}, {45, 51.8906}, {50, 51.2922},
474 }},
475 {"HeMcs10_80MHz", {
476 {5, 60.3411}, {10, 58.5527}, {15, 57.0724}, {20, 55.8834}, {25, 54.8827}, {30, 54.0128}, {35, 53.2368}, {40, 52.5352}, {45, 51.8906}, {50, 51.2922},
477 }},
478 {"HeMcs11_80MHz", {
479 {5, 60.3411}, {10, 58.5527}, {15, 57.0724}, {20, 55.8834}, {25, 54.8827}, {30, 54.0128}, {35, 53.2368}, {40, 52.5352}, {45, 51.8906}, {50, 51.2922},
480 }},
481 {"HeMcs0_160MHz", {
482 {5, 30.6710}, {10, 28.9919}, {15, 27.9160}, {20, 27.1188}, {25, 26.4770}, {30, 25.9355}, {35, 25.4630}, {40, 25.0432}, {45, 24.6629}, {50, 24.3141},
483 }},
484 {"HeMcs1_160MHz", {
485 {5, 42.3965}, {10, 40.4510}, {15, 39.1127}, {20, 38.0965}, {25, 37.2670}, {30, 36.5606}, {35, 35.9398}, {40, 35.3852}, {45, 34.8806}, {50, 34.4160},
486 }},
487 {"HeMcs2_160MHz", {
488 {5, 47.8139}, {10, 45.8767}, {15, 44.4795}, {20, 43.4017}, {25, 42.5141}, {30, 41.7535}, {35, 41.0821}, {40, 40.4801}, {45, 39.9307}, {50, 39.4236},
489 }},
490 {"HeMcs3_160MHz", {
491 {5, 51.9619}, {10, 49.9941}, {15, 48.5284}, {20, 47.3867}, {25, 46.4416}, {30, 45.6290}, {35, 44.9099}, {40, 44.2640}, {45, 43.6736}, {50, 43.1279},
492 }},
493 {"HeMcs4_160MHz", {
494 {5, 55.8389}, {10, 53.9360}, {15, 52.4548}, {20, 51.2855}, {25, 50.3106}, {30, 49.4682}, {35, 48.7201}, {40, 48.0462}, {45, 47.4288}, {50, 46.8571},
495 }},
496 {"HeMcs5_160MHz", {
497 {5, 60.3411}, {10, 58.5527}, {15, 57.0724}, {20, 55.8834}, {25, 54.8827}, {30, 54.0128}, {35, 53.2368}, {40, 52.5352}, {45, 51.8906}, {50, 51.2922},
498 }},
499 {"HeMcs6_160MHz", {
500 {5, 60.3411}, {10, 58.5527}, {15, 57.0724}, {20, 55.8834}, {25, 54.8827}, {30, 54.0128}, {35, 53.2368}, {40, 52.5352}, {45, 51.8906}, {50, 51.2922},
501 }},
502 {"HeMcs7_160MHz", {
503 {5, 60.3411}, {10, 58.5527}, {15, 57.0724}, {20, 55.8834}, {25, 54.8827}, {30, 54.0128}, {35, 53.2368}, {40, 52.5352}, {45, 51.8906}, {50, 51.2922},
504 }},
505 {"HeMcs8_160MHz", {
506 {5, 60.3411}, {10, 58.5527}, {15, 57.0724}, {20, 55.8834}, {25, 54.8827}, {30, 54.0128}, {35, 53.2368}, {40, 52.5352}, {45, 51.8906}, {50, 51.2922},
507 }},
508 {"HeMcs9_160MHz", {
509 {5, 65.6329}, {10, 64.0336}, {15, 62.5814}, {20, 61.3869}, {25, 60.3690}, {30, 59.4769}, {35, 58.6764}, {40, 57.9495}, {45, 57.2790}, {50, 56.6548},
510 }},
511 {"HeMcs10_160MHz", {
512 {5, 65.6329}, {10, 64.0336}, {15, 62.5814}, {20, 61.3869}, {25, 60.3690}, {30, 59.4769}, {35, 58.6764}, {40, 57.9495}, {45, 57.2790}, {50, 56.6548},
513 }},
514 {"HeMcs11_160MHz", {
515 {5, 65.6329}, {10, 64.0336}, {15, 62.5814}, {20, 61.3869}, {25, 60.3690}, {30, 59.4769}, {35, 58.6764}, {40, 57.9495}, {45, 57.2790}, {50, 56.6548},
516 }},
517};
518
526ContextToNodeId (std::string context)
527{
528 std::string sub = context.substr (10);
529 uint32_t pos = sub.find ("/Device");
530 return atoi (sub.substr (0, pos).c_str ());
531}
532
540ContextToMac (std::string context)
541{
542 std::string sub = context.substr (10);
543 uint32_t pos = sub.find ("/Device");
544 uint32_t nodeId = atoi (sub.substr (0, pos).c_str ());
545 Ptr<Node> n = NodeList::GetNode (nodeId);
547 for (uint32_t i = 0; i < n->GetNDevices (); i++)
548 {
549 d = n->GetDevice (i)->GetObject<WifiNetDevice> ();
550 if (d)
551 {
552 break;
553 }
554 }
555 return Mac48Address::ConvertFrom (d->GetAddress ());
556}
557
558// Functions for tracing.
559
567void
568IncrementCounter (std::map<Mac48Address, uint64_t> & counter, Mac48Address addr, uint64_t increment = 1)
569{
570 auto it = counter.find (addr);
571 if (it != counter.end ())
572 {
573 it->second += increment;
574 }
575 else
576 {
577 counter.insert (std::make_pair (addr, increment));
578 }
579}
580
592void
593TracePacketReception (std::string context, Ptr<const Packet> p, uint16_t channelFreqMhz, WifiTxVector txVector, MpduInfo aMpdu, SignalNoiseDbm signalNoise, uint16_t staId)
594{
595 Ptr<Packet> packet = p->Copy ();
596 if (txVector.IsAggregation ())
597 {
598 AmpduSubframeHeader subHdr;
599 uint32_t extractedLength;
600 packet->RemoveHeader (subHdr);
601 extractedLength = subHdr.GetLength ();
602 packet = packet->CreateFragment (0, static_cast<uint32_t> (extractedLength));
603 }
604 WifiMacHeader hdr;
605 packet->PeekHeader (hdr);
606 // hdr.GetAddr1() is the receiving MAC address
607 if (hdr.GetAddr1 () != ContextToMac (context))
608 {
609 return;
610 }
611 // hdr.GetAddr2() is the sending MAC address
612 if (packet->GetSize () >= pktSize) // ignore non-data frames
613 {
616 auto itTimeFirstReceived = timeFirstReceived.find (hdr.GetAddr2 ());
617 if (itTimeFirstReceived == timeFirstReceived.end ())
618 {
619 timeFirstReceived.insert (std::make_pair (hdr.GetAddr2 (), Simulator::Now ()));
620 }
621 auto itTimeLastReceived = timeLastReceived.find (hdr.GetAddr2 ());
622 if (itTimeLastReceived != timeLastReceived.end ())
623 {
624 itTimeLastReceived->second = Simulator::Now ();
625 }
626 else
627 {
628 timeLastReceived.insert (std::make_pair (hdr.GetAddr2 (), Simulator::Now ()));
629 }
630 }
631}
632
639void
640CwTrace (std::string context, uint32_t cw, uint8_t /* linkId */)
641{
642 NS_LOG_INFO ("CW time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " val=" << cw);
643 if (tracing)
644 {
645 cwTraceFile << Simulator::Now ().GetSeconds () << " " << ContextToNodeId (context) << " " << cw << std::endl;
646 }
647}
648
655void
656BackoffTrace (std::string context, uint32_t newVal, uint8_t /* linkId */)
657{
658 NS_LOG_INFO ("Backoff time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " val=" << newVal);
659 if (tracing)
660 {
661 backoffTraceFile << Simulator::Now ().GetSeconds () << " " << ContextToNodeId (context) << " " << newVal << std::endl;
662 }
663}
664
672void
674{
675 NS_LOG_INFO ("PHY-RX-START time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " size=" << p->GetSize ());
676}
677
685void
686PhyRxPayloadTrace (std::string context, WifiTxVector txVector, Time psduDuration)
687{
688 NS_LOG_INFO ("PHY-RX-PAYLOAD-START time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " psduDuration=" << psduDuration);
689}
690
698void
700{
701 NS_LOG_INFO ("PHY-RX-DROP time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " size=" << p->GetSize () << " reason=" << reason);
702 Mac48Address addr = ContextToMac (context);
703 switch (reason)
704 {
706 NS_FATAL_ERROR ("RX packet with unsupported settings!");
707 break;
709 NS_FATAL_ERROR ("Channel is switching!");
710 break;
712 {
713 if (p->GetSize () >= pktSize) // ignore non-data frames
714 {
716 }
717 break;
718 }
719 case RXING:
720 {
721 if (p->GetSize () >= pktSize) // ignore non-data frames
722 {
724 }
725 break;
726 }
727 case TXING:
728 {
729 if (p->GetSize () >= pktSize) // ignore non-data frames
730 {
732 }
733 break;
734 }
735 case SLEEPING:
736 NS_FATAL_ERROR ("Device is sleeping!");
737 break;
739 NS_FATAL_ERROR ("Preamble should always be detected!");
740 break;
742 {
743 if (p->GetSize () >= pktSize) // ignore non-data frames
744 {
746 }
747 break;
748 }
749 case L_SIG_FAILURE:
750 {
751 if (p->GetSize () >= pktSize) // ignore non-data frames
752 {
754 }
755 break;
756 }
757 case HT_SIG_FAILURE:
758 case SIG_A_FAILURE:
759 case SIG_B_FAILURE:
760 NS_FATAL_ERROR ("Unexpected PHY header failure!");
762 NS_FATAL_ERROR ("All devices should send with same power, so no packet switch during preamble detection should occur!");
763 break;
765 NS_FATAL_ERROR ("Frame capture should be disabled!");
766 break;
768 NS_FATAL_ERROR ("Unexpected CCA reset!");
769 break;
770 case UNKNOWN:
771 default:
772 NS_FATAL_ERROR ("Unknown drop reason!");
773 break;
774 }
775}
776
783void
784PhyRxDoneTrace (std::string context, Ptr<const Packet> p)
785{
786 NS_LOG_INFO ("PHY-RX-END time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " size=" << p->GetSize ());
787}
788
798void
799PhyRxOkTrace (std::string context, Ptr<const Packet> p, double snr, WifiMode mode, WifiPreamble preamble)
800{
801 uint8_t nMpdus = (p->GetSize () / pktSize);
802 NS_LOG_INFO ("PHY-RX-OK time=" << Simulator::Now ().As (Time::S)
803 << " node=" << ContextToNodeId (context)
804 << " size=" << p->GetSize ()
805 << " nMPDUs=" << +nMpdus
806 << " snr=" << snr
807 << " mode=" << mode
808 << " preamble=" << preamble);
809 if ((maxMpdus != 0) && (nMpdus != 0) && (nMpdus != maxMpdus))
810 {
811 if (nMpdus > maxMpdus)
812 {
813 NS_FATAL_ERROR ("A-MPDU settings not properly applied: maximum configured MPDUs is " << +maxMpdus << " but received an A-MPDU containing " << +nMpdus << " MPDUs");
814 }
815 NS_LOG_WARN ("Warning: less MPDUs aggregated in a received A-MPDU (" << +nMpdus << ") than configured (" << +maxMpdus << ")");
816 }
817 if (p->GetSize () >= pktSize) // ignore non-data frames
818 {
819 Mac48Address addr = ContextToMac (context);
821 }
822}
823
831void
832PhyRxErrorTrace (std::string context, Ptr<const Packet> p, double snr)
833{
834 NS_LOG_INFO ("PHY-RX-ERROR time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " size=" << p->GetSize () << " snr=" << snr);
835 if (p->GetSize () >= pktSize) // ignore non-data frames
836 {
837 Mac48Address addr = ContextToMac (context);
839 }
840}
841
849void
850PhyTxTrace (std::string context, Ptr<const Packet> p, double txPowerW)
851{
852 NS_LOG_INFO ("PHY-TX-START time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " size=" << p->GetSize () << " " << txPowerW);
853 if (tracing)
854 {
855 phyTxTraceFile << Simulator::Now ().GetSeconds () << " " << ContextToNodeId (context) << " size=" << p->GetSize () << " " << txPowerW << std::endl;
856 }
857 if (p->GetSize () >= pktSize) // ignore non-data frames
858 {
859 Mac48Address addr = ContextToMac (context);
861 }
862}
863
870void
871PhyTxDoneTrace (std::string context, Ptr<const Packet> p)
872{
873 NS_LOG_INFO ("PHY-TX-END time=" << Simulator::Now () << " node=" << ContextToNodeId (context) << " " << p->GetSize ());
874}
875
882void
883MacTxTrace (std::string context, Ptr<const Packet> p)
884{
885 if (tracing)
886 {
887 macTxTraceFile << Simulator::Now ().GetSeconds () << " " << ContextToNodeId (context) << " " << p->GetSize () << std::endl;
888 }
889}
890
897void
898MacRxTrace (std::string context, Ptr<const Packet> p)
899{
900 if (tracing)
901 {
902 macRxTraceFile << Simulator::Now ().GetSeconds () << " " << ContextToNodeId (context) << " " << p->GetSize () << std::endl;
903 }
904}
905
913void
914SocketSendTrace (std::string context, Ptr<const Packet> p, const Address &addr)
915{
916 if (tracing)
917 {
918 socketSendTraceFile << Simulator::Now ().GetSeconds () << " " << ContextToNodeId (context) << " " << p->GetSize () << " " << addr << std::endl;
919 }
920}
921
928void
929AssociationLog (std::string context, Mac48Address address)
930{
931 uint32_t nodeId = ContextToNodeId (context);
932 auto it = associated.find (nodeId);
933 if (it == associated.end ())
934 {
935 NS_LOG_DEBUG ("Association: time=" << Simulator::Now () << " node=" << nodeId);
936 associated.insert (it, nodeId);
937 }
938 else
939 {
940 NS_FATAL_ERROR (nodeId << " is already associated!");
941 }
942}
943
950void
952{
953 uint32_t nodeId = ContextToNodeId (context);
954 NS_LOG_DEBUG ("Disassociation: time=" << Simulator::Now () << " node=" << nodeId);
955 NS_FATAL_ERROR ("Device should not disassociate!");
956}
957
961void
963{
964 bytesReceived.clear ();
965 packetsReceived.clear ();
966 packetsTransmitted.clear ();
967 psduFailed.clear ();
968 psduSucceeded.clear ();
969 phyHeaderFailed.clear ();
970 timeFirstReceived.clear ();
971 timeLastReceived.clear ();
973 rxEventWhileRxing.clear ();
974 rxEventWhileTxing.clear ();
975 rxEventAbortedByTx.clear ();
976}
977
981class Experiment
982{
983public:
985
1005 int Run (const WifiHelper &wifi, const YansWifiPhyHelper &wifiPhy, const WifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel,
1006 uint32_t trialNumber, uint32_t networkSize, Time duration, bool pcap, bool infra, uint16_t guardIntervalNs,
1007 double distanceM, double apTxPowerDbm, double staTxPowerDbm, Time pktInterval);
1008};
1009
1011{
1012}
1013
1014int
1015Experiment::Run (const WifiHelper &helper, const YansWifiPhyHelper &wifiPhy, const WifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel,
1016 uint32_t trialNumber, uint32_t networkSize, Time duration, bool pcap, bool infra, uint16_t guardIntervalNs,
1017 double distance, double apTxPowerDbm, double staTxPowerDbm, Time pktInterval)
1018{
1019 RngSeedManager::SetSeed (10);
1020 RngSeedManager::SetRun (10);
1021
1022 NodeContainer wifiNodes;
1023 if (infra)
1024 {
1025 wifiNodes.Create (networkSize + 1);
1026 }
1027 else
1028 {
1029 wifiNodes.Create (networkSize);
1030 }
1031
1032 YansWifiPhyHelper phy = wifiPhy;
1033 phy.SetErrorRateModel ("ns3::NistErrorRateModel");
1034 phy.SetChannel (wifiChannel.Create ());
1035 phy.SetPcapDataLinkType (WifiPhyHelper::DLT_IEEE802_11_RADIO);
1036
1037 WifiMacHelper mac = wifiMac;
1038 WifiHelper wifi = helper;
1040 uint32_t nNodes = wifiNodes.GetN ();
1041 if (infra)
1042 {
1043 Ssid ssid = Ssid ("wifi-bianchi");
1044 uint64_t beaconInterval = std::min<uint64_t> ((ceil ((duration.GetSeconds () * 1000000) / 1024) * 1024), (65535 * 1024)); //beacon interval needs to be a multiple of time units (1024 us)
1045 mac.SetType ("ns3::ApWifiMac",
1046 "BeaconInterval", TimeValue (MicroSeconds (beaconInterval)),
1047 "Ssid", SsidValue (ssid));
1048 phy.Set ("TxPowerStart", DoubleValue (apTxPowerDbm));
1049 phy.Set ("TxPowerEnd", DoubleValue (apTxPowerDbm));
1050 devices = wifi.Install (phy, mac, wifiNodes.Get (0));
1051
1052 mac.SetType ("ns3::StaWifiMac",
1053 "MaxMissedBeacons", UintegerValue (std::numeric_limits<uint32_t>::max ()),
1054 "Ssid", SsidValue (ssid));
1055 phy.Set ("TxPowerStart", DoubleValue (staTxPowerDbm));
1056 phy.Set ("TxPowerEnd", DoubleValue (staTxPowerDbm));
1057 for (uint32_t i = 1; i < nNodes; ++i)
1058 {
1059 devices.Add (wifi.Install (phy, mac, wifiNodes.Get (i)));
1060 }
1061 }
1062 else
1063 {
1064 mac.SetType ("ns3::AdhocWifiMac");
1065 phy.Set ("TxPowerStart", DoubleValue (staTxPowerDbm));
1066 phy.Set ("TxPowerEnd", DoubleValue (staTxPowerDbm));
1067 devices = wifi.Install (phy, mac, wifiNodes);
1068 }
1069
1070 wifi.AssignStreams (devices, trialNumber);
1071
1072 Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HtConfiguration/ShortGuardIntervalSupported", BooleanValue (guardIntervalNs == 400));
1073 Config::Set ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/HeConfiguration/GuardInterval", TimeValue (NanoSeconds (guardIntervalNs)));
1074
1075 // Configure aggregation
1076 for (uint32_t i = 0; i < nNodes; ++i)
1077 {
1078 Ptr<NetDevice> dev = wifiNodes.Get (i)->GetDevice (0);
1079 Ptr<WifiNetDevice> wifi_dev = DynamicCast<WifiNetDevice> (dev);
1080 wifi_dev->GetMac ()->SetAttribute ("BE_MaxAmpduSize", UintegerValue (maxMpdus * (pktSize + 50)));
1081 wifi_dev->GetMac ()->SetAttribute ("BK_MaxAmpduSize", UintegerValue (maxMpdus * (pktSize + 50)));
1082 wifi_dev->GetMac ()->SetAttribute ("VO_MaxAmpduSize", UintegerValue (maxMpdus * (pktSize + 50)));
1083 wifi_dev->GetMac ()->SetAttribute ("VI_MaxAmpduSize", UintegerValue (maxMpdus * (pktSize + 50)));
1084 }
1085
1087 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
1088 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
1089 // Set postion for AP
1090 positionAlloc->Add (Vector (1.0, 1.0, 0.0));
1091
1092 // Set postion for STAs
1093 double angle = (static_cast<double> (360) / (nNodes - 1));
1094 for (uint32_t i = 0; i < (nNodes - 1); ++i)
1095 {
1096 positionAlloc->Add (Vector (1.0 + (distance * cos ((i * angle * PI) / 180)), 1.0 + (distance * sin ((i * angle * PI) / 180)), 0.0));
1097 }
1098
1099 mobility.SetPositionAllocator (positionAlloc);
1100 mobility.Install (wifiNodes);
1101
1102 PacketSocketHelper packetSocket;
1103 packetSocket.Install (wifiNodes);
1104
1106 Ptr<UniformRandomVariable> startTime = CreateObject<UniformRandomVariable> ();
1107 startTime->SetAttribute ("Stream", IntegerValue (trialNumber));
1108 startTime->SetAttribute ("Max", DoubleValue (5.0));
1109
1110 uint32_t i = infra ? 1 : 0;
1111 for (; i < nNodes; ++i)
1112 {
1113 uint32_t j = infra ? 0 : (i + 1) % nNodes;
1114 PacketSocketAddress socketAddr;
1115 socketAddr.SetSingleDevice (devices.Get (i)->GetIfIndex ());
1116 socketAddr.SetPhysicalAddress (devices.Get (j)->GetAddress ());
1117 socketAddr.SetProtocol (1);
1118
1119 Ptr<PacketSocketClient> client = CreateObject<PacketSocketClient> ();
1120 client->SetRemote (socketAddr);
1121 wifiNodes.Get (i)->AddApplication (client);
1122 client->SetAttribute ("PacketSize", UintegerValue (pktSize));
1123 client->SetAttribute ("MaxPackets", UintegerValue (0));
1124 client->SetAttribute ("Interval", TimeValue (pktInterval));
1125 double start = startTime->GetValue ();
1126 NS_LOG_DEBUG ("Client " << i << " starting at " << start);
1127 client->SetStartTime (Seconds (start));
1128
1129 Ptr<PacketSocketServer> server = CreateObject<PacketSocketServer> ();
1130 server->SetLocal (socketAddr);
1131 wifiNodes.Get (j)->AddApplication (server);
1132 }
1133
1134 // Log packet receptions
1135 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/MonitorSnifferRx", MakeCallback (&TracePacketReception));
1136
1137 // Log association and disassociation
1138 if (infra)
1139 {
1140 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::StaWifiMac/Assoc", MakeCallback (&AssociationLog));
1141 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::StaWifiMac/DeAssoc", MakeCallback (&DisassociationLog));
1142 }
1143
1144 // Trace CW evolution
1145 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::WifiMac/Txop/CwTrace", MakeCallback (&CwTrace));
1146 // Trace backoff evolution
1147 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/$ns3::WifiMac/Txop/BackoffTrace", MakeCallback (&BackoffTrace));
1148 // Trace PHY Tx start events
1149 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyTxBegin", MakeCallback (&PhyTxTrace));
1150 // Trace PHY Tx end events
1151 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyTxEnd", MakeCallback (&PhyTxDoneTrace));
1152 // Trace PHY Rx start events
1153 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxBegin", MakeCallback (&PhyRxTrace));
1154 // Trace PHY Rx payload start events
1155 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxPayloadBegin", MakeCallback (&PhyRxPayloadTrace));
1156 // Trace PHY Rx drop events
1157 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxDrop", MakeCallback (&PhyRxDropTrace));
1158 // Trace PHY Rx end events
1159 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/PhyRxEnd", MakeCallback (&PhyRxDoneTrace));
1160 // Trace PHY Rx error events
1161 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/State/RxError", MakeCallback (&PhyRxErrorTrace));
1162 // Trace PHY Rx success events
1163 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/$ns3::WifiPhy/State/RxOk", MakeCallback (&PhyRxOkTrace));
1164 // Trace packet transmission by the device
1165 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx", MakeCallback (&MacTxTrace));
1166 // Trace packet receptions to the device
1167 Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx", MakeCallback (&MacRxTrace));
1168 // Trace packets transmitted by the application
1169 Config::Connect ("/NodeList/*/$ns3::Node/ApplicationList/*/$ns3::PacketSocketClient/Tx", MakeCallback (&SocketSendTrace));
1170
1171 Simulator::Schedule (Seconds (10), &RestartCalc);
1172 Simulator::Stop (Seconds (10) + duration);
1173
1174 if (pcap)
1175 {
1176 phy.EnablePcap ("wifi_bianchi_pcap", devices);
1177 }
1178
1179 Simulator::Run ();
1180 Simulator::Destroy ();
1181
1182 if (tracing)
1183 {
1184 cwTraceFile.flush ();
1185 backoffTraceFile.flush ();
1186 phyTxTraceFile.flush ();
1187 macTxTraceFile.flush ();
1188 macRxTraceFile.flush ();
1189 socketSendTraceFile.flush ();
1190 }
1191
1192 return 0;
1193}
1194
1202uint64_t
1203GetCount (const std::map<Mac48Address, uint64_t> & counter, Mac48Address addr)
1204{
1205 uint64_t count = 0;
1206 auto it = counter.find (addr);
1207 if (it != counter.end ())
1208 {
1209 count = it->second;
1210 }
1211 return count;
1212}
1213
1214int main (int argc, char *argv[])
1215{
1216 uint32_t nMinStas = 5;
1217 uint32_t nMaxStas = 50;
1218 uint32_t nStepSize = 5;
1219 uint32_t verbose = 0;
1220 double duration = 100;
1221 uint32_t trials = 1;
1222 bool pcap = false;
1223 bool infra = false;
1224 std::string workDir = "./";
1225 std::string phyMode = "OfdmRate54Mbps";
1226 std::string standard ("11a");
1227 bool validate = false;
1228 uint16_t plotBianchiModel = 0x01;
1229 double maxRelativeError = 0.015;
1230 double frequency = 5;
1231 uint16_t channelWidth = 20;
1232 uint16_t guardIntervalNs = 800;
1233 uint16_t pktInterval = 1000;
1234 double distance = 0.001;
1235 double apTxPower = 16;
1236 double staTxPower = 16;
1237
1238 // Disable fragmentation and RTS/CTS
1239 Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("22000"));
1240 Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("22000"));
1241 // Disable short retransmission failure (make retransmissions persistent)
1242 Config::SetDefault ("ns3::WifiRemoteStationManager::MaxSlrc", UintegerValue (std::numeric_limits<uint32_t>::max ()));
1243 Config::SetDefault ("ns3::WifiRemoteStationManager::MaxSsrc", UintegerValue (std::numeric_limits<uint32_t>::max ()));
1244 // Set maximum queue size to the largest value and set maximum queue delay to be larger than the simulation time
1246 Config::SetDefault ("ns3::WifiMacQueue::MaxDelay", TimeValue (Seconds (2 * duration)));
1247
1248 CommandLine cmd (__FILE__);
1249 cmd.AddValue ("verbose", "Logging level (0: no log - 1: simulation script logs - 2: all logs)", verbose);
1250 cmd.AddValue ("tracing", "Generate trace files", tracing);
1251 cmd.AddValue ("pktSize", "The packet size in bytes", pktSize);
1252 cmd.AddValue ("trials", "The maximal number of runs per network size", trials);
1253 cmd.AddValue ("duration", "Time duration for each trial in seconds", duration);
1254 cmd.AddValue ("pcap", "Enable/disable PCAP tracing", pcap);
1255 cmd.AddValue ("infra", "True to use infrastructure mode, false to use ring adhoc mode", infra);
1256 cmd.AddValue ("workDir", "The working directory used to store generated files", workDir);
1257 cmd.AddValue ("phyMode", "Set the constant PHY mode string used to transmit frames", phyMode);
1258 cmd.AddValue ("standard", "Set the standard (11a, 11b, 11g, 11n, 11ac, 11ax)", standard);
1259 cmd.AddValue ("nMinStas", "Minimum number of stations to start with", nMinStas);
1260 cmd.AddValue ("nMaxStas", "Maximum number of stations to start with", nMaxStas);
1261 cmd.AddValue ("nStepSize", "Number of stations to add at each step", nStepSize);
1262 cmd.AddValue ("plotBianchiModel", "First bit corresponds to the DIFS model, second bit to the EIFS model", plotBianchiModel);
1263 cmd.AddValue ("validate", "Enable/disable validation of the ns-3 simulations against the Bianchi model", validate);
1264 cmd.AddValue ("maxRelativeError", "The maximum relative error tolerated between ns-3 results and the Bianchi model (used for regression, i.e. when the validate flag is set)", maxRelativeError);
1265 cmd.AddValue ("frequency", "Set the operating frequency band in GHz: 2.4, 5 or 6", frequency);
1266 cmd.AddValue ("channelWidth", "Set the constant channel width in MHz (only for 11n/ac/ax)", channelWidth);
1267 cmd.AddValue ("guardIntervalNs", "Set the the guard interval in nanoseconds (800 or 400 for 11n/ac, 800 or 1600 or 3200 for 11 ax)", guardIntervalNs);
1268 cmd.AddValue ("maxMpdus", "Set the maximum number of MPDUs in A-MPDUs (0 to disable MPDU aggregation)", maxMpdus);
1269 cmd.AddValue ("distance", "Set the distance in meters between the AP and the STAs", distance);
1270 cmd.AddValue ("apTxPower", "Set the transmit power of the AP in dBm (if infrastructure only)", apTxPower);
1271 cmd.AddValue ("staTxPower", "Set the transmit power of each STA in dBm (or all STAs if adhoc)", staTxPower);
1272 cmd.AddValue ("pktInterval", "Set the socket packet interval in microseconds", pktInterval);
1273 cmd.Parse (argc, argv);
1274
1275 if (tracing)
1276 {
1277 cwTraceFile.open ("wifi-bianchi-cw-trace.out");
1278 if (!cwTraceFile.is_open ())
1279 {
1280 NS_FATAL_ERROR ("Failed to open file wifi-bianchi-cw-trace.out");
1281 }
1282 backoffTraceFile.open ("wifi-bianchi-backoff-trace.out");
1283 if (!backoffTraceFile.is_open ())
1284 {
1285 NS_FATAL_ERROR ("Failed to open file wifi-bianchi-backoff-trace.out");
1286 }
1287 phyTxTraceFile.open ("wifi-bianchi-phy-tx-trace.out");
1288 if (!phyTxTraceFile.is_open ())
1289 {
1290 NS_FATAL_ERROR ("Failed to open file wifi-bianchi-phy-tx-trace.out");
1291 }
1292 macTxTraceFile.open ("wifi-bianchi-mac-tx-trace.out");
1293 if (!macTxTraceFile.is_open ())
1294 {
1295 NS_FATAL_ERROR ("Failed to open file wifi-bianchi-mac-tx-trace.out");
1296 }
1297 macRxTraceFile.open ("wifi-bianchi-mac-rx-trace.out");
1298 if (!macRxTraceFile.is_open ())
1299 {
1300 NS_FATAL_ERROR ("Failed to open file wifi-bianchi-mac-rx-trace.out");
1301 }
1302 socketSendTraceFile.open ("wifi-bianchi-socket-send-trace.out");
1303 if (!socketSendTraceFile.is_open ())
1304 {
1305 NS_FATAL_ERROR ("Failed to open file wifi-bianchi-socket-send-trace.out");
1306 }
1307 }
1308
1309 if (verbose >= 1)
1310 {
1311 LogComponentEnable ("WifiBianchi", LOG_LEVEL_ALL);
1312 }
1313 else
1314 {
1315 LogComponentEnable ("WifiBianchi", LOG_LEVEL_WARN);
1316 }
1317 if (verbose >= 2)
1318 {
1319 WifiHelper::EnableLogComponents ();
1320 }
1321
1322 std::stringstream phyModeStr;
1323 phyModeStr << phyMode;
1324 if (phyMode.find ("Mcs") != std::string::npos)
1325 {
1326 phyModeStr << "_" << channelWidth << "MHz";
1327 }
1328
1329 std::stringstream ss;
1330 ss << "wifi-"<< standard << "-p-" << pktSize << (infra ? "-infrastructure" : "-adhoc") << "-r-" << phyModeStr.str () << "-min-" << nMinStas << "-max-" << nMaxStas << "-step-" << nStepSize << "-throughput.plt";
1331 std::ofstream throughputPlot (ss.str ().c_str ());
1332 ss.str ("");
1333 ss << "wifi-" << standard << "-p-" << pktSize << (infra ? "-infrastructure" : "-adhoc") <<"-r-" << phyModeStr.str () << "-min-" << nMinStas << "-max-" << nMaxStas << "-step-" << nStepSize << "-throughput.eps";
1334 Gnuplot gnuplot = Gnuplot (ss.str ());
1335
1336 WifiStandard wifiStandard;
1337 if (standard == "11a")
1338 {
1339 wifiStandard = WIFI_STANDARD_80211a;
1340 frequency = 5;
1341 channelWidth = 20;
1342 }
1343 else if (standard == "11b")
1344 {
1345 wifiStandard = WIFI_STANDARD_80211b;
1346 frequency = 2.4;
1347 channelWidth = 22;
1348 }
1349 else if (standard == "11g")
1350 {
1351 wifiStandard = WIFI_STANDARD_80211g;
1352 frequency = 2.4;
1353 channelWidth = 20;
1354 }
1355 else if (standard == "11n")
1356 {
1357 if (frequency == 2.4)
1358 {
1359 wifiStandard = WIFI_STANDARD_80211n;
1360 }
1361 else if (frequency == 5)
1362 {
1363 wifiStandard = WIFI_STANDARD_80211n;
1364 }
1365 else
1366 {
1367 NS_FATAL_ERROR ("Unsupported frequency band " << frequency << " GHz for standard " << standard);
1368 }
1369 }
1370 else if (standard == "11ac")
1371 {
1372 wifiStandard = WIFI_STANDARD_80211ac;
1373 frequency = 5;
1374 }
1375 else if (standard == "11ax")
1376 {
1377 if (frequency == 2.4)
1378 {
1379 wifiStandard = WIFI_STANDARD_80211ax;
1380 }
1381 else if (frequency == 5)
1382 {
1383 wifiStandard = WIFI_STANDARD_80211ax;
1384 }
1385 else if (frequency == 6)
1386 {
1387 wifiStandard = WIFI_STANDARD_80211ax;
1388 }
1389 else
1390 {
1391 NS_FATAL_ERROR ("Unsupported frequency band " << frequency << " GHz for standard " << standard);
1392 }
1393 }
1394 else
1395 {
1396 NS_FATAL_ERROR ("Unsupported standard: " << standard);
1397 }
1398
1399 std::string channelStr = "{0, " + std::to_string (channelWidth) + ", BAND_"
1400 + (frequency == 2.4 ? "2_4" : (frequency == 5 ? "5" : "6"))
1401 + "GHZ, 0}";
1402 Config::SetDefault ("ns3::WifiPhy::ChannelSettings", StringValue (channelStr));
1403
1404 YansWifiPhyHelper wifiPhy;
1406
1407 YansWifiChannelHelper wifiChannel;
1408 wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
1409 if (frequency == 6)
1410 {
1411 // Reference Loss for Friss at 1 m with 6.0 GHz
1412 wifiChannel.AddPropagationLoss ("ns3::LogDistancePropagationLossModel",
1413 "Exponent", DoubleValue (2.0),
1414 "ReferenceDistance", DoubleValue (1.0),
1415 "ReferenceLoss", DoubleValue (49.013));
1416 }
1417 else if (frequency == 5)
1418 {
1419 // Reference Loss for Friss at 1 m with 5.15 GHz
1420 wifiChannel.AddPropagationLoss ("ns3::LogDistancePropagationLossModel",
1421 "Exponent", DoubleValue (2.0),
1422 "ReferenceDistance", DoubleValue (1.0),
1423 "ReferenceLoss", DoubleValue (46.6777));
1424 }
1425 else
1426 {
1427 // Reference Loss for Friss at 1 m with 2.4 GHz
1428 wifiChannel.AddPropagationLoss ("ns3::LogDistancePropagationLossModel",
1429 "Exponent", DoubleValue (2.0),
1430 "ReferenceDistance", DoubleValue (1.0),
1431 "ReferenceLoss", DoubleValue (40.046));
1432 }
1433
1435 wifi.SetStandard (wifiStandard);
1436 wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",
1437 "DataMode", StringValue (phyMode),
1438 "ControlMode", StringValue (phyMode));
1439
1440 Gnuplot2dDataset dataset;
1441 Gnuplot2dDataset datasetBianchiEifs;
1442 Gnuplot2dDataset datasetBianchiDifs;
1443 dataset.SetErrorBars (Gnuplot2dDataset::Y);
1444 dataset.SetStyle (Gnuplot2dDataset::LINES_POINTS);
1445 datasetBianchiEifs.SetStyle (Gnuplot2dDataset::LINES_POINTS);
1446 datasetBianchiDifs.SetStyle (Gnuplot2dDataset::LINES_POINTS);
1447
1449 WifiMacHelper wifiMac;
1450 double averageThroughput, throughputArray[trials];
1451 for (uint32_t n = nMinStas; n <= nMaxStas; n += nStepSize)
1452 {
1453 averageThroughput = 0;
1454 double throughput;
1455 for (uint32_t runIndex = 0; runIndex < trials; runIndex++)
1456 {
1457 packetsReceived.clear ();
1458 bytesReceived.clear ();
1459 packetsTransmitted.clear ();
1460 psduFailed.clear ();
1461 psduSucceeded.clear ();
1462 phyHeaderFailed.clear ();
1463 timeFirstReceived.clear ();
1464 timeLastReceived.clear ();
1466 rxEventWhileRxing.clear ();
1467 rxEventWhileTxing.clear ();
1468 rxEventAbortedByTx.clear ();
1469 associated.clear ();
1470 throughput = 0;
1471 std::cout << "Trial " << runIndex + 1 << " of " << trials << "; "<< phyModeStr.str () << " for " << n << " nodes " << std::endl;
1472 if (tracing)
1473 {
1474 cwTraceFile << "# Trial " << runIndex + 1 << " of " << trials << "; "<< phyModeStr.str () << " for " << n << " nodes" << std::endl;
1475 backoffTraceFile << "# Trial " << runIndex + 1 << " of " << trials << "; "<< phyModeStr.str () << " for " << n << " nodes" << std::endl;
1476 phyTxTraceFile << "# Trial " << runIndex + 1 << " of " << trials << "; " << phyModeStr.str () << " for " << n << " nodes" << std::endl;
1477 macTxTraceFile << "# Trial " << runIndex + 1 << " of " << trials << "; " << phyModeStr.str () << " for " << n << " nodes" << std::endl;
1478 macRxTraceFile << "# Trial " << runIndex + 1 << " of " << trials << "; " << phyModeStr.str () << " for " << n << " nodes" << std::endl;
1479 socketSendTraceFile << "# Trial " << runIndex + 1 << " of " << trials << "; " << phyModeStr.str () << " for " << n << " nodes" << std::endl;
1480 }
1481 experiment.Run (wifi, wifiPhy, wifiMac, wifiChannel, runIndex, n, Seconds (duration), pcap, infra, guardIntervalNs, distance, apTxPower, staTxPower, MicroSeconds (pktInterval));
1482 uint32_t k = 0;
1483 if (bytesReceived.size () != n)
1484 {
1485 NS_FATAL_ERROR ("Not all stations got traffic!");
1486 }
1487 for (auto it = bytesReceived.begin (); it != bytesReceived.end (); it++, k++)
1488 {
1489 Time first = timeFirstReceived.find (it->first)->second;
1490 Time last = timeLastReceived.find (it->first)->second;
1491 Time dataTransferDuration = last - first;
1492 double nodeThroughput = (it->second * 8 / static_cast<double> (dataTransferDuration.GetMicroSeconds ()));
1493 throughput += nodeThroughput;
1494 uint64_t nodeTxPackets = GetCount (packetsTransmitted, it->first);
1495 uint64_t nodeRxPackets = GetCount (packetsReceived, it->first);
1496 uint64_t nodePhyHeaderFailures = GetCount (phyHeaderFailed, it->first);
1497 uint64_t nodePsduFailures = GetCount (psduFailed, it->first);
1498 uint64_t nodePsduSuccess = GetCount (psduSucceeded, it->first);
1499 uint64_t nodeRxEventWhileDecodingPreamble = GetCount (rxEventWhileDecodingPreamble, it->first);
1500 uint64_t nodeRxEventWhileRxing = GetCount (rxEventWhileRxing, it->first);
1501 uint64_t nodeRxEventWhileTxing = GetCount (rxEventWhileTxing, it->first);
1502 uint64_t nodeRxEventAbortedByTx = GetCount (rxEventAbortedByTx, it->first);
1503 uint64_t nodeRxEvents =
1504 nodePhyHeaderFailures + nodePsduFailures + nodePsduSuccess + nodeRxEventWhileDecodingPreamble +
1505 nodeRxEventWhileRxing + nodeRxEventWhileTxing + nodeRxEventAbortedByTx;
1506 std::cout << "Node " << it->first
1507 << ": TX packets " << nodeTxPackets
1508 << "; RX packets " << nodeRxPackets
1509 << "; PHY header failures " << nodePhyHeaderFailures
1510 << "; PSDU failures " << nodePsduFailures
1511 << "; PSDU success " << nodePsduSuccess
1512 << "; RX events while decoding preamble " << nodeRxEventWhileDecodingPreamble
1513 << "; RX events while RXing " << nodeRxEventWhileRxing
1514 << "; RX events while TXing " << nodeRxEventWhileTxing
1515 << "; RX events aborted by TX " << nodeRxEventAbortedByTx
1516 << "; total RX events " << nodeRxEvents
1517 << "; total events " << nodeTxPackets + nodeRxEvents
1518 << "; time first RX " << first
1519 << "; time last RX " << last
1520 << "; dataTransferDuration " << dataTransferDuration
1521 << "; throughput " << nodeThroughput << " Mbps" << std::endl;
1522 }
1523 std::cout << "Total throughput: " << throughput << " Mbps" << std::endl;
1524 averageThroughput += throughput;
1525 throughputArray[runIndex] = throughput;
1526 }
1527 averageThroughput = averageThroughput / trials;
1528
1529 bool rateFound = false;
1530 double relativeErrorDifs = 0;
1531 double relativeErrorEifs = 0;
1532 auto itDifs = bianchiResultsDifs.find (phyModeStr.str ());
1533 if (itDifs != bianchiResultsDifs.end ())
1534 {
1535 rateFound = true;
1536 auto it = itDifs->second.find (n);
1537 if (it != itDifs->second.end ())
1538 {
1539 relativeErrorDifs = (std::abs (averageThroughput - it->second) / it->second);
1540 std::cout << "Relative error (DIFS): " << 100 * relativeErrorDifs << "%" << std::endl;
1541 }
1542 else if (validate)
1543 {
1544 NS_FATAL_ERROR ("No Bianchi results (DIFS) calculated for that number of stations!");
1545 }
1546 }
1547 auto itEifs = bianchiResultsEifs.find (phyModeStr.str ());
1548 if (itEifs != bianchiResultsEifs.end ())
1549 {
1550 rateFound = true;
1551 auto it = itEifs->second.find (n);
1552 if (it != itEifs->second.end ())
1553 {
1554 relativeErrorEifs = (std::abs (averageThroughput - it->second) / it->second);
1555 std::cout << "Relative error (EIFS): " << 100 * relativeErrorEifs << "%" << std::endl;
1556 }
1557 else if (validate)
1558 {
1559 NS_FATAL_ERROR ("No Bianchi results (EIFS) calculated for that number of stations!");
1560 }
1561 }
1562 if (!rateFound && validate)
1563 {
1564 NS_FATAL_ERROR ("No Bianchi results calculated for that rate!");
1565 }
1566 double relativeError = std::min (relativeErrorDifs, relativeErrorEifs);
1567 if (validate && (relativeError > maxRelativeError))
1568 {
1569 NS_FATAL_ERROR ("Relative error is too high!");
1570 }
1571
1572 double stDev = 0;
1573 for (uint32_t i = 0; i < trials; ++i)
1574 {
1575 stDev += pow (throughputArray[i] - averageThroughput, 2);
1576 }
1577 stDev = sqrt (stDev / (trials - 1));
1578 dataset.Add (n, averageThroughput, stDev);
1579 }
1580 dataset.SetTitle ("ns-3");
1581
1582 auto itDifs = bianchiResultsDifs.find (phyModeStr.str ());
1583 if (itDifs != bianchiResultsDifs.end ())
1584 {
1585 for (uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
1586 {
1587 double value = 0.0;
1588 auto it = itDifs->second.find (i);
1589 if (it != itDifs->second.end ())
1590 {
1591 value = it->second;
1592 }
1593 datasetBianchiDifs.Add (i, value);
1594 }
1595 }
1596 else
1597 {
1598 for (uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
1599 {
1600 datasetBianchiDifs.Add (i, 0.0);
1601 }
1602 }
1603
1604 auto itEifs = bianchiResultsEifs.find (phyModeStr.str ());
1605 if (itEifs != bianchiResultsEifs.end ())
1606 {
1607 for (uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
1608 {
1609 double value = 0.0;
1610 auto it = itEifs->second.find (i);
1611 if (it != itEifs->second.end ())
1612 {
1613 value = it->second;
1614 }
1615 datasetBianchiEifs.Add (i, value);
1616 }
1617 }
1618 else
1619 {
1620 for (uint32_t i = nMinStas; i <= nMaxStas; i += nStepSize)
1621 {
1622 datasetBianchiEifs.Add (i, 0.0);
1623 }
1624 }
1625
1626 datasetBianchiEifs.SetTitle ("Bianchi (EIFS - lower bound)");
1627 datasetBianchiDifs.SetTitle ("Bianchi (DIFS - upper bound)");
1628 gnuplot.AddDataset (dataset);
1629 gnuplot.SetTerminal ("postscript eps color enh \"Times-BoldItalic\"");
1630 gnuplot.SetLegend ("Number of competing stations", "Throughput (Mbps)");
1631 ss.str ("");
1632 ss << "Frame size " << pktSize << " bytes";
1633 gnuplot.SetTitle (ss.str ());
1634 ss.str ("");
1635 ss << "set xrange [" << nMinStas << ":" << nMaxStas << "]\n"
1636 << "set xtics " << nStepSize << "\n"
1637 << "set grid xtics ytics\n"
1638 << "set mytics\n"
1639 << "set style line 1 linewidth 5\n"
1640 << "set style line 2 linewidth 5\n"
1641 << "set style line 3 linewidth 5\n"
1642 << "set style line 4 linewidth 5\n"
1643 << "set style line 5 linewidth 5\n"
1644 << "set style line 6 linewidth 5\n"
1645 << "set style line 7 linewidth 5\n"
1646 << "set style line 8 linewidth 5\n"
1647 << "set style increment user";
1648 gnuplot.SetExtra (ss.str ());
1649 if (plotBianchiModel & 0x0001)
1650 {
1651 datasetBianchiDifs.SetTitle ("Bianchi");
1652 gnuplot.AddDataset (datasetBianchiDifs);
1653 }
1654 if (plotBianchiModel & 0x0002)
1655 {
1656 datasetBianchiEifs.SetTitle ("Bianchi");
1657 gnuplot.AddDataset (datasetBianchiEifs);
1658 }
1659 if (plotBianchiModel == 0x0003)
1660 {
1661 datasetBianchiEifs.SetTitle ("Bianchi (EIFS - lower bound)");
1662 datasetBianchiDifs.SetTitle ("Bianchi (DIFS - upper bound)");
1663 }
1664 gnuplot.GenerateOutput (throughputPlot);
1665 throughputPlot.close ();
1666
1667 if (tracing)
1668 {
1669 cwTraceFile.close ();
1670 backoffTraceFile.close ();
1671 phyTxTraceFile.close ();
1672 macTxTraceFile.close ();
1673 macRxTraceFile.close ();
1674 socketSendTraceFile.close ();
1675 }
1676
1677 return 0;
1678}
#define min(a, b)
Definition: 80211b.c:42
#define max(a, b)
Definition: 80211b.c:43
void Run(ObjectFactory &factory, uint32_t pop, uint32_t total, uint32_t runs, Ptr< RandomVariableStream > eventStream, bool calRev)
Perform the runs for a single scheduler type.
WiFi adhoc experiment class.
Definition: wifi-adhoc.cc:46
Gnuplot2dDataset Run(const WifiHelper &wifi, const YansWifiPhyHelper &wifiPhy, const WifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel)
Run an experiment.
Definition: wifi-adhoc.cc:160
a polymophic address class
Definition: address.h:91
Headers for A-MPDU subframes.
uint16_t GetLength(void) const
Return the length field.
holds a vector of ns3::Application pointers.
AttributeValue implementation for Boolean.
Definition: boolean.h:37
Parse command-line arguments.
Definition: command-line.h:229
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
Class to represent a 2D points plot.
Definition: gnuplot.h:118
void SetErrorBars(enum ErrorBars errorBars)
Definition: gnuplot.cc:355
void SetStyle(enum Style style)
Definition: gnuplot.cc:344
void Add(double x, double y)
Definition: gnuplot.cc:361
void SetTitle(const std::string &title)
Change line title.
Definition: gnuplot.cc:141
a simple class to generate gnuplot-ready plotting commands from a set of datasets.
Definition: gnuplot.h:372
void AddDataset(const GnuplotDataset &dataset)
Definition: gnuplot.cc:758
void SetLegend(const std::string &xLegend, const std::string &yLegend)
Definition: gnuplot.cc:738
void SetTerminal(const std::string &terminal)
Definition: gnuplot.cc:726
void GenerateOutput(std::ostream &os)
Writes gnuplot commands and data values to a single output stream.
Definition: gnuplot.cc:764
void SetExtra(const std::string &extra)
Definition: gnuplot.cc:745
void SetTitle(const std::string &title)
Definition: gnuplot.cc:732
Hold a signed integer type.
Definition: integer.h:44
an EUI-48 address
Definition: mac48-address.h:44
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(void) 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 GetNDevices(void) const
Definition: node.cc:152
uint32_t AddApplication(Ptr< Application > application)
Associate an Application to this Node.
Definition: node.cc:159
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition: node.cc:144
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:256
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
uint32_t PeekHeader(Header &header) const
Deserialize but does not remove the header from the internal buffer.
Definition: packet.cc:290
Ptr< Packet > CreateFragment(uint32_t start, uint32_t length) const
Create a new packet which contains a fragment of the original packet.
Definition: packet.cc:227
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:856
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.
Class for representing queue sizes.
Definition: queue-size.h:95
AttributeValue implementation for QueueSize.
The IEEE 802.11 SSID Information Element.
Definition: ssid.h:36
AttributeValue implementation for Ssid.
Hold variables of type string.
Definition: string.h:41
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
int64_t GetMicroSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:388
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:380
AttributeValue implementation for Time.
Definition: nstime.h:1309
Hold an unsigned integer type.
Definition: uinteger.h:44
double GetValue(double min, double max)
Get the next random value, as a double in the specified range .
helps to create WifiNetDevice objects
Definition: wifi-helper.h:322
Implements the IEEE 802.11 MAC header.
Mac48Address GetAddr2(void) const
Return the address in the Address 2 field.
Mac48Address GetAddr1(void) const
Return the address in the Address 1 field.
create MAC layers for a ns3::WifiNetDevice.
represent a single transmission mode
Definition: wifi-mode.h:48
Hold together all Wifi-related objects.
Ptr< WifiMac > GetMac(void) const
Address GetAddress(void) const override
void DisablePreambleDetectionModel()
Disable the preamble detection model on all links.
Definition: wifi-helper.cc:177
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
bool IsAggregation(void) const
Checks whether the PSDU contains A-MPDU.
manage and create wifi channel objects for the YANS model.
Ptr< YansWifiChannel > Create(void) const
void SetPropagationDelay(std::string name, Ts &&... args)
void AddPropagationLoss(std::string name, Ts &&... args)
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)
Definition: config.cc:849
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:920
void Set(std::string path, const AttributeValue &value)
Definition: config.cc:839
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:206
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:274
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:266
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:282
@ PACKETS
Use number of packets for queue size.
Definition: queue-size.h:44
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1261
Time NanoSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1269
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1245
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.
@ WIFI_STANDARD_80211a
@ WIFI_STANDARD_80211n
@ WIFI_STANDARD_80211g
@ WIFI_STANDARD_80211ax
@ WIFI_STANDARD_80211ac
@ WIFI_STANDARD_80211b
@ OBSS_PD_CCA_RESET
@ PREAMBLE_DETECT_FAILURE
@ FRAME_CAPTURE_PACKET_SWITCH
@ UNSUPPORTED_SETTINGS
@ L_SIG_FAILURE
@ RECEPTION_ABORTED_BY_TX
@ SIG_A_FAILURE
@ CHANNEL_SWITCHING
@ BUSY_DECODING_PREAMBLE
@ SIG_B_FAILURE
@ HT_SIG_FAILURE
@ PREAMBLE_DETECTION_PACKET_SWITCH
Definition: first.py:1
address
Definition: first.py:40
devices
Definition: first.py:35
Every class exported by the ns3 library is enclosed in the ns3 namespace.
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...
Definition: callback.h:661
std::map< WifiSpectrumBand, double > RxPowerWattPerChannelBand
A map of the received power (Watts) for each band.
Definition: phy-entity.h:77
@ LOG_LEVEL_ALL
Print everything.
Definition: log.h:117
@ LOG_LEVEL_WARN
LOG_WARN and above.
Definition: log.h:102
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:361
cmd
Definition: second.py:43
ssid
Definition: third.py:88
mac
Definition: third.py:87
wifi
Definition: third.py:90
mobility
Definition: third.py:98
phy
Definition: third.py:84
def start()
Definition: core.py:1852
bool verbose
MpduInfo structure.
Definition: phy-entity.h:62
SignalNoiseDbm structure.
Definition: phy-entity.h:55
std::map< Mac48Address, uint64_t > rxEventAbortedByTx
Map that stores the number of reception events aborted per STA because the PHY has started to transmi...
Definition: wifi-bianchi.cc:80
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 occured while PHY was already transmittin...
Definition: wifi-bianchi.cc:77
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)
Definition: wifi-bianchi.cc:71
std::ofstream backoffTraceFile
File that traces backoff over time.
Definition: wifi-bianchi.cc:65
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)
Definition: wifi-bianchi.cc:72
std::map< Mac48Address, uint64_t > rxEventWhileDecodingPreamble
Map that stores the number of reception events per STA that occured while PHY was already decoding a ...
Definition: wifi-bianchi.cc:79
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.
Definition: wifi-bianchi.cc:89
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 occured while PHY was already receiving a...
Definition: wifi-bianchi.cc:78
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 unsuccessfully received PSDUS (for which the PHY header was succe...
Definition: wifi-bianchi.cc:74
#define PI
Avoid std::numbers::pi because it's C++20.
Definition: wifi-bianchi.cc:58
std::map< Mac48Address, uint64_t > packetsTransmitted
Map that stores the total packets transmitted per STA.
Definition: wifi-bianchi.cc:73
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...
Definition: wifi-bianchi.cc:83
std::map< Mac48Address, Time > timeFirstTransmitted
Map that stores the time at which the first packet was transmitted per STA.
Definition: wifi-bianchi.cc:84
uint8_t maxMpdus
The maximum number of MPDUs in A-MPDUs (0 to disable MPDU aggregation)
Definition: wifi-bianchi.cc:91
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...
Definition: wifi-bianchi.cc:87
std::map< Mac48Address, uint64_t > phyHeaderFailed
Map that stores the total number of unsuccessfully received PHY headers per STA.
Definition: wifi-bianchi.cc:76
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.
Definition: wifi-bianchi.cc:69
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.
Definition: wifi-bianchi.cc:67
void PhyRxTrace(std::string context, Ptr< const Packet > p, RxPowerWattPerChannelBand power)
PHY Rx trace.
std::ofstream phyTxTraceFile
File that traces PHY transmissions over time.
Definition: wifi-bianchi.cc:66
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 ...
Definition: wifi-bianchi.cc:82
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:90
std::map< Mac48Address, uint64_t > psduSucceeded
Map that stores the total number of successfully received PSDUs per STA (including PSDUs not addresse...
Definition: wifi-bianchi.cc:75
std::map< Mac48Address, Time > timeLastTransmitted
Map that stores the time at which the last packet was transmitted per STA.
Definition: wifi-bianchi.cc:85
std::map< std::string, std::map< unsigned int, double > > bianchiResultsEifs
Table of the expected values for EIFS.
Definition: wifi-bianchi.cc:94
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.
Definition: wifi-bianchi.cc:64
std::ofstream macRxTraceFile
File that traces MAC receptions over time.
Definition: wifi-bianchi.cc:68