A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
adaptive-red-tests.cc
Go to the documentation of this file.
1
2/*
3 * Copyright (c) 2015 NITK Surathkal
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 *
7 * Author: Mohit P. Tahiliani <tahiliani@nitk.edu.in>
8 *
9 */
10
11/**
12 * NOTE: These validation tests are same as provided in ns-2
13 * (ns/tcl/test/test-suite-adaptive-red.tcl)
14 *
15 * In this code, tests 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14 and 15 refer to tests
16 * named red1, red1Adapt, red1ECN, fastlink, fastlinkECN, fastlinkAutowq, fastlinkAutothresh,
17 * fastlinkAdaptive, fastlinkAllAdapt, fastlinkAllAdaptECN, fastlinkAllAdapt1, longlink,
18 * longlinkAdapt and longlinkAdapt1, respectively in the ns-2 file
19 * mentioned above.
20 */
21
22/** Network topology for tests: 1, 2, 3 and 4
23 *
24 * 10Mb/s, 2ms 10Mb/s, 4ms
25 * n0--------------| |---------------n4
26 * | 1.5Mbps, 20ms |
27 * n2------------------n3
28 * 10Mb/s, 3ms | QueueLimit = 25 | 10Mb/s, 5ms
29 * n1--------------| |---------------n5
30 *
31 */
32
33/** Network topology for tests: 6, 7, 8, 9, 10, 11 and 12
34 *
35 * 100Mb/s, 2ms 100Mb/s, 4ms
36 * n0--------------| |---------------n4
37 * | 15Mbps, 20ms |
38 * n2------------------n3
39 * 100Mb/s, 3ms | QueueLimit = 1000 | 100Mb/s, 5ms
40 * n1--------------| |---------------n5
41 *
42 */
43
44/** Network topology for tests: 13, 14 and 15
45 *
46 * 10Mb/s, 0ms 10Mb/s, 2ms
47 * n0--------------| |---------------n4
48 * | 1.5Mbps, 100ms |
49 * n2------------------n3
50 * 10Mb/s, 1ms | QueueLimit = 100 | 10Mb/s, 3ms
51 * n1--------------| |---------------n5
52 *
53 */
54
55#include "ns3/applications-module.h"
56#include "ns3/core-module.h"
57#include "ns3/flow-monitor-helper.h"
58#include "ns3/internet-module.h"
59#include "ns3/network-module.h"
60#include "ns3/point-to-point-module.h"
61#include "ns3/traffic-control-module.h"
62
63using namespace ns3;
64
65NS_LOG_COMPONENT_DEFINE("AdaptiveRedTests");
66
67uint32_t checkTimes; //!< Number of times the queues have been checked.
68double avgQueueDiscSize; //!< Average QueueDisc size.
69
70// The times
71double global_start_time; //!< Global start time
72double global_stop_time; //!< Global stop time.
73double sink_start_time; //!< Sink start time.
74double sink_stop_time; //!< Sink stop time.
75double client_start_time; //!< Client start time.
76double client_stop_time; //!< Client stop time.
77
78NodeContainer n0n2; //!< Nodecontainer n0 + n2.
79NodeContainer n1n2; //!< Nodecontainer n1 + n2.
80NodeContainer n2n3; //!< Nodecontainer n2 + n3.
81NodeContainer n3n4; //!< Nodecontainer n3 + n4.
82NodeContainer n3n5; //!< Nodecontainer n3 + n5.
83
84Ipv4InterfaceContainer i0i2; //!< IPv4 interface container i0 + i2.
85Ipv4InterfaceContainer i1i2; //!< IPv4 interface container i1 + i2.
86Ipv4InterfaceContainer i2i3; //!< IPv4 interface container i2 + i3.
87Ipv4InterfaceContainer i3i4; //!< IPv4 interface container i3 + i4.
88Ipv4InterfaceContainer i3i5; //!< IPv4 interface container i3 + i5.
89
90std::stringstream filePlotQueueDisc; //!< Output file name for queue disc size.
91std::stringstream filePlotQueueDiscAvg; //!< Output file name for queue disc average.
92
93/**
94 * Check the queue disc size and write its stats to the output files.
95 *
96 * @param queue The queue to check.
97 */
98void
99CheckQueueDiscSize(Ptr<QueueDisc> queue)
100{
101 uint32_t qSize = queue->GetCurrentSize().GetValue();
102
103 avgQueueDiscSize += qSize;
104 checkTimes++;
105
106 // check queue disc size every 1/100 of a second
107 Simulator::Schedule(Seconds(0.01), &CheckQueueDiscSize, queue);
108
109 std::ofstream fPlotQueueDisc(filePlotQueueDisc.str(), std::ios::out | std::ios::app);
110 fPlotQueueDisc << Simulator::Now().GetSeconds() << " " << qSize << std::endl;
111 fPlotQueueDisc.close();
112
113 std::ofstream fPlotQueueDiscAvg(filePlotQueueDiscAvg.str(), std::ios::out | std::ios::app);
114 fPlotQueueDiscAvg << Simulator::Now().GetSeconds() << " " << avgQueueDiscSize / checkTimes
115 << std::endl;
116 fPlotQueueDiscAvg.close();
117}
118
119/**
120 * Setup the apps.
121 *
122 * @param test The test number.
123 */
124void
125BuildAppsTest(uint32_t test)
126{
127 // SINK is in the right side
128 uint16_t port = 50000;
129 Address sinkLocalAddress(InetSocketAddress(Ipv4Address::GetAny(), port));
130 PacketSinkHelper sinkHelper("ns3::TcpSocketFactory", sinkLocalAddress);
131 ApplicationContainer sinkApp = sinkHelper.Install(n3n4.Get(1));
132 sinkApp.Start(Seconds(sink_start_time));
133 sinkApp.Stop(Seconds(sink_stop_time));
134
135 // Connection one
136 // Clients are in left side
137 /*
138 * Create the OnOff applications to send TCP to the server
139 * onoffhelper is a client that send data to TCP destination
140 */
141 OnOffHelper clientHelper1("ns3::TcpSocketFactory", Address());
142 clientHelper1.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));
143 clientHelper1.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0]"));
144 clientHelper1.SetAttribute("PacketSize", UintegerValue(1000));
145
146 // Connection two
147 OnOffHelper clientHelper2("ns3::TcpSocketFactory", Address());
148 clientHelper2.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));
149 clientHelper2.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0]"));
150 clientHelper2.SetAttribute("PacketSize", UintegerValue(1000));
151
152 if (test == 6 || test == 7 || test == 8 || test == 9 || test == 10 || test == 12)
153 {
154 clientHelper1.SetAttribute("DataRate", DataRateValue(DataRate("100Mb/s")));
155 clientHelper2.SetAttribute("DataRate", DataRateValue(DataRate("100Mb/s")));
156 }
157 else
158 {
159 clientHelper1.SetAttribute("DataRate", DataRateValue(DataRate("10Mb/s")));
160 clientHelper2.SetAttribute("DataRate", DataRateValue(DataRate("10Mb/s")));
161 }
162
163 ApplicationContainer clientApps1;
164 AddressValue remoteAddress(InetSocketAddress(i3i4.GetAddress(1), port));
165 clientHelper1.SetAttribute("Remote", remoteAddress);
166 clientApps1.Add(clientHelper1.Install(n0n2.Get(0)));
167 clientApps1.Start(Seconds(client_start_time));
168 clientApps1.Stop(Seconds(client_stop_time));
169
170 ApplicationContainer clientApps2;
171 clientHelper2.SetAttribute("Remote", remoteAddress);
172 clientApps2.Add(clientHelper2.Install(n1n2.Get(0)));
173 clientApps2.Start(Seconds(client_start_time));
174 clientApps2.Stop(Seconds(client_stop_time));
175}
176
177int
178main(int argc, char* argv[])
179{
180 LogComponentEnable("RedQueueDisc", LOG_LEVEL_INFO);
181
182 uint32_t aredTest;
183 std::string aredLinkDataRate = "1.5Mbps";
184 std::string aredLinkDelay = "20ms";
185
186 std::string pathOut;
187 bool writeForPlot = false;
188 bool writePcap = false;
189 bool flowMonitor = false;
190
191 bool printAredStats = true;
192
193 global_start_time = 0.0;
194 sink_start_time = global_start_time;
195 client_start_time = global_start_time + 1.5;
196 global_stop_time = 7.0;
197 sink_stop_time = global_stop_time + 3.0;
198 client_stop_time = global_stop_time - 2.0;
199
200 // Configuration and command line parameter parsing
201 aredTest = 1;
202 // Will only save in the directory if enable opts below
203 pathOut = "."; // Current directory
204 CommandLine cmd(__FILE__);
205 cmd.AddValue("testNumber",
206 "Run test 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14 or 15",
207 aredTest);
208 cmd.AddValue("pathOut",
209 "Path to save results from --writeForPlot/--writePcap/--writeFlowMonitor",
210 pathOut);
211 cmd.AddValue("writeForPlot", "Write results for plot (gnuplot)", writeForPlot);
212 cmd.AddValue("writePcap", "Write results in pcapfile", writePcap);
213 cmd.AddValue("writeFlowMonitor", "Enable Flow Monitor and write their results", flowMonitor);
214
215 cmd.Parse(argc, argv);
216 if ((aredTest < 1) || (aredTest == 5) || (aredTest > 15))
217 {
218 std::cout << "Invalid test number. Supported tests are 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, "
219 "13, 14 or 15"
220 << std::endl;
221 exit(1);
222 }
223
224 NS_LOG_INFO("Create nodes");
225 NodeContainer c;
226 c.Create(6);
227 Names::Add("N0", c.Get(0));
228 Names::Add("N1", c.Get(1));
229 Names::Add("N2", c.Get(2));
230 Names::Add("N3", c.Get(3));
231 Names::Add("N4", c.Get(4));
232 Names::Add("N5", c.Get(5));
233 n0n2 = NodeContainer(c.Get(0), c.Get(2));
234 n1n2 = NodeContainer(c.Get(1), c.Get(2));
235 n2n3 = NodeContainer(c.Get(2), c.Get(3));
236 n3n4 = NodeContainer(c.Get(3), c.Get(4));
237 n3n5 = NodeContainer(c.Get(3), c.Get(5));
238
239 Config::SetDefault("ns3::TcpL4Protocol::SocketType", StringValue("ns3::TcpNewReno"));
240 // 42 = headers size
241 Config::SetDefault("ns3::TcpSocket::SegmentSize", UintegerValue(1000 - 42));
242 Config::SetDefault("ns3::TcpSocket::DelAckCount", UintegerValue(1));
243 GlobalValue::Bind("ChecksumEnabled", BooleanValue(false));
244
245 uint32_t meanPktSize = 1000;
246
247 // RED params
248 NS_LOG_INFO("Set RED params");
249 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("1000p"));
250 Config::SetDefault("ns3::RedQueueDisc::MeanPktSize", UintegerValue(meanPktSize));
251 Config::SetDefault("ns3::RedQueueDisc::Wait", BooleanValue(true));
252 Config::SetDefault("ns3::RedQueueDisc::Gentle", BooleanValue(true));
253 Config::SetDefault("ns3::RedQueueDisc::QW", DoubleValue(0.002));
254 Config::SetDefault("ns3::RedQueueDisc::MinTh", DoubleValue(5));
255 Config::SetDefault("ns3::RedQueueDisc::MaxTh", DoubleValue(15));
256
257 if (aredTest == 1) // test 1: red1
258 {
259 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("25p"));
260 }
261 else if (aredTest == 2) // test 2: red1Adapt
262 {
263 Config::SetDefault("ns3::RedQueueDisc::ARED", BooleanValue(true));
264 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
265 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("25p"));
266 }
267 else if (aredTest == 3) // test 3: red1ECN
268 {
269 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("25p"));
270 Config::SetDefault("ns3::TcpSocketBase::UseEcn", StringValue("On"));
271 Config::SetDefault("ns3::RedQueueDisc::UseEcn", BooleanValue(true));
272 }
273 else if (aredTest == 4) // test 4: red1AdaptECN
274 {
275 Config::SetDefault("ns3::RedQueueDisc::ARED", BooleanValue(true));
276 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
277 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("25p"));
278 Config::SetDefault("ns3::TcpSocketBase::UseEcn", StringValue("On"));
279 Config::SetDefault("ns3::RedQueueDisc::UseEcn", BooleanValue(true));
280 }
281 else if (aredTest == 7) // test 7: fastlinkAutowq
282 {
283 Config::SetDefault("ns3::RedQueueDisc::QW", DoubleValue(0.0));
284 }
285 else if (aredTest == 8) // test 8: fastlinkAutothresh
286 {
287 Config::SetDefault("ns3::RedQueueDisc::MinTh", DoubleValue(0));
288 Config::SetDefault("ns3::RedQueueDisc::MaxTh", DoubleValue(0));
289 }
290 else if (aredTest == 9) // test 9: fastlinkAdaptive
291 {
292 Config::SetDefault("ns3::RedQueueDisc::AdaptMaxP", BooleanValue(true));
293 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
294 }
295 else if (aredTest == 10) // test 10: fastlinkAllAdapt
296 {
297 Config::SetDefault("ns3::RedQueueDisc::ARED", BooleanValue(true));
298 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
299 }
300 else if (aredTest == 11) // test 11: fastlinkAllAdaptECN
301 {
302 Config::SetDefault("ns3::RedQueueDisc::ARED", BooleanValue(true));
303 Config::SetDefault("ns3::RedQueueDisc::UseHardDrop", BooleanValue(false));
304 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
305 Config::SetDefault("ns3::TcpSocketBase::UseEcn", StringValue("On"));
306 Config::SetDefault("ns3::RedQueueDisc::UseEcn", BooleanValue(true));
307 }
308 else if (aredTest == 12) // test 12: fastlinkAllAdapt1
309 {
310 Config::SetDefault("ns3::RedQueueDisc::ARED", BooleanValue(true));
311 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
312 Config::SetDefault("ns3::RedQueueDisc::TargetDelay", TimeValue(Seconds(0.2)));
313 }
314 else if (aredTest == 13) // test 13: longlink
315 {
316 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("100p"));
317 }
318 else if (aredTest == 14) // test 14: longlinkAdapt
319 {
320 Config::SetDefault("ns3::RedQueueDisc::ARED", BooleanValue(true));
321 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
322 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("100p"));
323 }
324 else if (aredTest == 15) // test 15: longlinkAdapt1
325 {
326 Config::SetDefault("ns3::RedQueueDisc::QW", DoubleValue(-1.0));
327 Config::SetDefault("ns3::RedQueueDisc::MinTh", DoubleValue(0));
328 Config::SetDefault("ns3::RedQueueDisc::MaxTh", DoubleValue(0));
329 Config::SetDefault("ns3::RedQueueDisc::AdaptMaxP", BooleanValue(true));
330 Config::SetDefault("ns3::RedQueueDisc::LInterm", DoubleValue(10));
331 Config::SetDefault("ns3::RedQueueDisc::MaxSize", StringValue("100p"));
332 }
333
334 NS_LOG_INFO("Install internet stack on all nodes.");
335 InternetStackHelper internet;
336 internet.Install(c);
337
338 TrafficControlHelper tchPfifo;
339 uint16_t handle = tchPfifo.SetRootQueueDisc("ns3::PfifoFastQueueDisc");
340 tchPfifo.AddInternalQueues(handle, 3, "ns3::DropTailQueue", "MaxSize", StringValue("1000p"));
341
342 TrafficControlHelper tchRed;
343 tchRed.SetRootQueueDisc("ns3::RedQueueDisc",
344 "LinkBandwidth",
345 StringValue(aredLinkDataRate),
346 "LinkDelay",
347 StringValue(aredLinkDelay));
348
349 NS_LOG_INFO("Create channels");
350 PointToPointHelper p2p;
351
352 NetDeviceContainer devn0n2;
353 NetDeviceContainer devn1n2;
354 NetDeviceContainer devn2n3;
355 NetDeviceContainer devn3n4;
356 NetDeviceContainer devn3n5;
357
358 QueueDiscContainer queueDiscs;
359
360 if (aredTest == 1 || aredTest == 2 || aredTest == 3 || aredTest == 4)
361 {
362 p2p.SetQueue("ns3::DropTailQueue");
363 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
364 p2p.SetChannelAttribute("Delay", StringValue("2ms"));
365 devn0n2 = p2p.Install(n0n2);
366 tchPfifo.Install(devn0n2);
367
368 p2p.SetQueue("ns3::DropTailQueue");
369 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
370 p2p.SetChannelAttribute("Delay", StringValue("3ms"));
371 devn1n2 = p2p.Install(n1n2);
372 tchPfifo.Install(devn1n2);
373
374 p2p.SetQueue("ns3::DropTailQueue");
375 p2p.SetDeviceAttribute("DataRate", StringValue(aredLinkDataRate));
376 p2p.SetChannelAttribute("Delay", StringValue(aredLinkDelay));
377 devn2n3 = p2p.Install(n2n3);
378 // only backbone link has ARED queue disc
379 queueDiscs = tchRed.Install(devn2n3);
380
381 p2p.SetQueue("ns3::DropTailQueue");
382 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
383 p2p.SetChannelAttribute("Delay", StringValue("4ms"));
384 devn3n4 = p2p.Install(n3n4);
385 tchPfifo.Install(devn3n4);
386
387 p2p.SetQueue("ns3::DropTailQueue");
388 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
389 p2p.SetChannelAttribute("Delay", StringValue("5ms"));
390 devn3n5 = p2p.Install(n3n5);
391 tchPfifo.Install(devn3n5);
392 }
393 else if (aredTest == 13 || aredTest == 14 || aredTest == 15)
394 {
395 p2p.SetQueue("ns3::DropTailQueue");
396 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
397 p2p.SetChannelAttribute("Delay", StringValue("0ms"));
398 devn0n2 = p2p.Install(n0n2);
399 tchPfifo.Install(devn0n2);
400
401 p2p.SetQueue("ns3::DropTailQueue");
402 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
403 p2p.SetChannelAttribute("Delay", StringValue("1ms"));
404 devn1n2 = p2p.Install(n1n2);
405 tchPfifo.Install(devn1n2);
406
407 p2p.SetQueue("ns3::DropTailQueue");
408 p2p.SetDeviceAttribute("DataRate", StringValue(aredLinkDataRate));
409 p2p.SetChannelAttribute("Delay", StringValue("100ms"));
410 devn2n3 = p2p.Install(n2n3);
411 // only backbone link has ARED queue disc
412 queueDiscs = tchRed.Install(devn2n3);
413
414 p2p.SetQueue("ns3::DropTailQueue");
415 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
416 p2p.SetChannelAttribute("Delay", StringValue("2ms"));
417 devn3n4 = p2p.Install(n3n4);
418 tchPfifo.Install(devn3n4);
419
420 p2p.SetQueue("ns3::DropTailQueue");
421 p2p.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
422 p2p.SetChannelAttribute("Delay", StringValue("3ms"));
423 devn3n5 = p2p.Install(n3n5);
424 tchPfifo.Install(devn3n5);
425 }
426 else if (aredTest == 6 || aredTest == 7 || aredTest == 8 || aredTest == 9 || aredTest == 10 ||
427 aredTest == 11 || aredTest == 12)
428 {
429 p2p.SetQueue("ns3::DropTailQueue");
430 p2p.SetDeviceAttribute("DataRate", StringValue("100Mbps"));
431 p2p.SetChannelAttribute("Delay", StringValue("2ms"));
432 devn0n2 = p2p.Install(n0n2);
433 tchPfifo.Install(devn0n2);
434
435 p2p.SetQueue("ns3::DropTailQueue");
436 p2p.SetDeviceAttribute("DataRate", StringValue("100Mbps"));
437 p2p.SetChannelAttribute("Delay", StringValue("3ms"));
438 devn1n2 = p2p.Install(n1n2);
439 tchPfifo.Install(devn1n2);
440
441 p2p.SetQueue("ns3::DropTailQueue");
442 p2p.SetDeviceAttribute("DataRate", StringValue("15Mbps"));
443 p2p.SetChannelAttribute("Delay", StringValue(aredLinkDelay));
444 devn2n3 = p2p.Install(n2n3);
445 // only backbone link has ARED queue disc
446 queueDiscs = tchRed.Install(devn2n3);
447
448 p2p.SetQueue("ns3::DropTailQueue");
449 p2p.SetDeviceAttribute("DataRate", StringValue("100Mbps"));
450 p2p.SetChannelAttribute("Delay", StringValue("4ms"));
451 devn3n4 = p2p.Install(n3n4);
452 tchPfifo.Install(devn3n4);
453
454 p2p.SetQueue("ns3::DropTailQueue");
455 p2p.SetDeviceAttribute("DataRate", StringValue("100Mbps"));
456 p2p.SetChannelAttribute("Delay", StringValue("5ms"));
457 devn3n5 = p2p.Install(n3n5);
458 tchPfifo.Install(devn3n5);
459 }
460
461 NS_LOG_INFO("Assign IP Addresses");
462 Ipv4AddressHelper ipv4;
463
464 ipv4.SetBase("10.1.1.0", "255.255.255.0");
465 i0i2 = ipv4.Assign(devn0n2);
466
467 ipv4.SetBase("10.1.2.0", "255.255.255.0");
468 i1i2 = ipv4.Assign(devn1n2);
469
470 ipv4.SetBase("10.1.3.0", "255.255.255.0");
471 i2i3 = ipv4.Assign(devn2n3);
472
473 ipv4.SetBase("10.1.4.0", "255.255.255.0");
474 i3i4 = ipv4.Assign(devn3n4);
475
476 ipv4.SetBase("10.1.5.0", "255.255.255.0");
477 i3i5 = ipv4.Assign(devn3n5);
478
479 // Set up the routing
480 Ipv4GlobalRoutingHelper::PopulateRoutingTables();
481
482 BuildAppsTest(aredTest);
483
484 if (writePcap)
485 {
486 PointToPointHelper ptp;
487 std::stringstream stmp;
488 stmp << pathOut << "/ared";
489 ptp.EnablePcapAll(stmp.str());
490 }
491
492 Ptr<FlowMonitor> flowmon;
493 if (flowMonitor)
494 {
495 FlowMonitorHelper flowmonHelper;
496 flowmon = flowmonHelper.InstallAll();
497 }
498
499 if (writeForPlot)
500 {
501 filePlotQueueDisc << pathOut << "/"
502 << "ared-queue-disc.plotme";
503 filePlotQueueDiscAvg << pathOut << "/"
504 << "ared-queue-disc_avg.plotme";
505
506 remove(filePlotQueueDisc.str().c_str());
507 remove(filePlotQueueDiscAvg.str().c_str());
508 Ptr<QueueDisc> queue = queueDiscs.Get(0);
509 Simulator::ScheduleNow(&CheckQueueDiscSize, queue);
510 }
511
512 Simulator::Stop(Seconds(sink_stop_time));
513 Simulator::Run();
514
515 QueueDisc::Stats st = queueDiscs.Get(0)->GetStats();
516
517 if (st.GetNDroppedPackets(RedQueueDisc::UNFORCED_DROP) == 0 &&
518 st.GetNMarkedPackets(RedQueueDisc::UNFORCED_MARK) == 0)
519 {
520 std::cout << "There should be some unforced drops or marks" << std::endl;
521 exit(1);
522 }
523
524 if (aredTest == 1 || aredTest == 2 || aredTest == 3 || aredTest == 4 || aredTest == 13)
525 {
526 if (st.GetNDroppedPackets(QueueDisc::INTERNAL_QUEUE_DROP) == 0)
527 {
528 std::cout << "There should be some drops due to queue full" << std::endl;
529 exit(1);
530 }
531 }
532 else
533 {
534 if (st.GetNDroppedPackets(QueueDisc::INTERNAL_QUEUE_DROP) != 0)
535 {
536 std::cout << "There should be zero drops due to queue full" << std::endl;
537 exit(1);
538 }
539 }
540
541 if (flowMonitor)
542 {
543 std::stringstream stmp;
544 stmp << pathOut << "/ared.flowmon";
545
546 flowmon->SerializeToXmlFile(stmp.str(), false, false);
547 }
548
549 if (printAredStats)
550 {
551 std::cout << "*** ARED stats from Node 2 queue ***" << std::endl;
552 std::cout << st << std::endl;
553 }
554
555 Simulator::Destroy();
556
557 return 0;
558}
i0i2
Ipv4InterfaceContainer i0i2
IPv4 interface container i0 + i2.
Definition adaptive-red-tests.cc:84
filePlotQueueDisc
std::stringstream filePlotQueueDisc
Output file name for queue disc size.
Definition adaptive-red-tests.cc:90
client_start_time
double client_start_time
Client start time.
Definition adaptive-red-tests.cc:75
sink_stop_time
double sink_stop_time
Sink stop time.
Definition adaptive-red-tests.cc:74
sink_start_time
double sink_start_time
Sink start time.
Definition adaptive-red-tests.cc:73
global_stop_time
double global_stop_time
Global stop time.
Definition adaptive-red-tests.cc:72
filePlotQueueDiscAvg
std::stringstream filePlotQueueDiscAvg
Output file name for queue disc average.
Definition adaptive-red-tests.cc:91
n2n3
NodeContainer n2n3
Nodecontainer n2 + n3.
Definition adaptive-red-tests.cc:80
CheckQueueDiscSize
void CheckQueueDiscSize(Ptr< QueueDisc > queue)
Check the queue disc size and write its stats to the output files.
Definition adaptive-red-tests.cc:99
n1n2
NodeContainer n1n2
Nodecontainer n1 + n2.
Definition adaptive-red-tests.cc:79
avgQueueDiscSize
double avgQueueDiscSize
Average QueueDisc size.
Definition adaptive-red-tests.cc:68
n3n4
NodeContainer n3n4
Nodecontainer n3 + n4.
Definition adaptive-red-tests.cc:81
global_start_time
double global_start_time
Global start time.
Definition adaptive-red-tests.cc:71
i1i2
Ipv4InterfaceContainer i1i2
IPv4 interface container i1 + i2.
Definition adaptive-red-tests.cc:85
i3i4
Ipv4InterfaceContainer i3i4
IPv4 interface container i3 + i4.
Definition adaptive-red-tests.cc:87
n0n2
NodeContainer n0n2
Nodecontainer n0 + n2.
Definition adaptive-red-tests.cc:78
client_stop_time
double client_stop_time
Client stop time.
Definition adaptive-red-tests.cc:76
checkTimes
uint32_t checkTimes
Number of times the queues have been checked.
Definition adaptive-red-tests.cc:67
n3n5
NodeContainer n3n5
Nodecontainer n3 + n5.
Definition adaptive-red-tests.cc:82
i3i5
Ipv4InterfaceContainer i3i5
IPv4 interface container i3 + i5.
Definition adaptive-red-tests.cc:88
i2i3
Ipv4InterfaceContainer i2i3
IPv4 interface container i2 + i3.
Definition adaptive-red-tests.cc:86
ns3::Address
a polymophic address class
Definition address.h:90
ns3::AddressValue
AttributeValue implementation for Address.
Definition address.h:275
ns3::ApplicationContainer
holds a vector of ns3::Application pointers.
Definition application-container.h:33
ns3::ApplicationContainer::Start
void Start(Time start) const
Start all of the Applications in this container at the start time given as a parameter.
Definition application-container.cc:81
ns3::ApplicationContainer::Add
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container.
Definition application-container.cc:59
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition boolean.h:26
ns3::CommandLine
Parse command-line arguments.
Definition command-line.h:221
ns3::DataRate
Class for representing data rates.
Definition data-rate.h:78
ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition data-rate.h:285
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
ns3::FlowMonitorHelper
Helper to enable IP flow monitoring on a set of Nodes.
Definition flow-monitor-helper.h:30
ns3::FlowMonitorHelper::InstallAll
Ptr< FlowMonitor > InstallAll()
Enable flow monitoring on all nodes.
Definition flow-monitor-helper.cc:116
ns3::GlobalValue::Bind
static void Bind(std::string name, const AttributeValue &value)
Iterate over the set of GlobalValues until a matching name is found and then set its value with Globa...
Definition global-value.cc:126
ns3::InetSocketAddress
an Inet address class
Definition inet-socket-address.h:31
ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition internet-stack-helper.h:81
ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition ipv4-address-helper.h:38
ns3::Ipv4Address::GetAny
static Ipv4Address GetAny()
Definition ipv4-address.cc:368
ns3::Ipv4GlobalRoutingHelper::PopulateRoutingTables
static void PopulateRoutingTables()
Build a routing database and initialize the routing tables of the nodes in the simulation.
Definition ipv4-global-routing-helper.cc:50
ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition ipv4-interface-container.h:45
ns3::Ipv4InterfaceContainer::GetAddress
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Definition ipv4-interface-container.cc:49
ns3::Names::Add
static void Add(std::string name, Ptr< Object > object)
Add the association between the string "name" and the Ptr<Object> obj.
Definition names.cc:764
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition net-device-container.h:32
ns3::NodeContainer
keep track of a set of node pointers.
Definition node-container.h:29
ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition node-container.cc:73
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition node-container.cc:67
ns3::OnOffHelper
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition on-off-helper.h:26
ns3::PacketSinkHelper
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
Definition packet-sink-helper.h:23
ns3::PcapHelperForDevice::EnablePcapAll
void EnablePcapAll(std::string prefix, bool promiscuous=false)
Enable pcap output on each device (which is of the appropriate type) in the set of all nodes created ...
Definition trace-helper.cc:453
ns3::PointToPointHelper
Build a set of PointToPointNetDevice objects.
Definition point-to-point-helper.h:33
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:66
ns3::QueueDiscContainer
Holds a vector of ns3::QueueDisc pointers.
Definition queue-disc-container.h:35
ns3::QueueDisc::INTERNAL_QUEUE_DROP
static constexpr const char * INTERNAL_QUEUE_DROP
Packet dropped by an internal queue.
Definition queue-disc.h:511
ns3::RedQueueDisc::UNFORCED_DROP
static constexpr const char * UNFORCED_DROP
Early probability drops.
Definition red-queue-disc.h:186
ns3::RedQueueDisc::UNFORCED_MARK
static constexpr const char * UNFORCED_MARK
Early probability marks.
Definition red-queue-disc.h:189
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:560
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition simulator.cc:197
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition simulator.cc:167
ns3::Simulator::ScheduleNow
static EventId ScheduleNow(FUNC f, Ts &&... args)
Schedule an event to expire Now.
Definition simulator.h:594
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:175
ns3::StringValue
Hold variables of type string.
Definition string.h:45
ns3::Time::GetSeconds
double GetSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition nstime.h:392
ns3::TimeValue
AttributeValue implementation for Time.
Definition nstime.h:1431
ns3::TrafficControlHelper
Build a set of QueueDisc objects.
Definition traffic-control-helper.h:108
ns3::TrafficControlHelper::SetRootQueueDisc
uint16_t SetRootQueueDisc(const std::string &type, Args &&... args)
Helper function used to set a root queue disc of the given type and with the given attributes.
Definition traffic-control-helper.h:375
ns3::UintegerValue
Hold an unsigned integer type.
Definition uinteger.h:34
uint32_t
port
uint16_t port
Definition dsdv-manet.cc:33
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:264
ns3::Create
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1344
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::LogComponentEnable
void LogComponentEnable(const std::string &name, LogLevel level)
Enable the logging output associated with that log component.
Definition log.cc:291
ns3::LOG_LEVEL_INFO
@ LOG_LEVEL_INFO
LOG_INFO and above.
Definition log.h:93
test
-ns3 Test suite for the ns3 wrapper script
BuildAppsTest
void BuildAppsTest()
Definition pie-example.cc:83
ns3::QueueDisc::Stats
Structure that keeps the queue disc statistics.
Definition queue-disc.h:177