A Discrete-Event Network Simulator
API
adaptive-red-tests.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2015 NITK Surathkal
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: Mohit P. Tahiliani <tahiliani@nitk.edu.in>
19  *
20  */
21 
66 #include "ns3/core-module.h"
67 #include "ns3/network-module.h"
68 #include "ns3/internet-module.h"
69 #include "ns3/flow-monitor-helper.h"
70 #include "ns3/point-to-point-module.h"
71 #include "ns3/applications-module.h"
72 #include "ns3/traffic-control-module.h"
73 
74 using namespace ns3;
75 
76 NS_LOG_COMPONENT_DEFINE ("AdaptiveRedTests");
77 
78 uint32_t checkTimes;
79 double avgQueueDiscSize;
80 
81 // The times
82 double global_start_time;
83 double global_stop_time;
84 double sink_start_time;
85 double sink_stop_time;
86 double client_start_time;
87 double client_stop_time;
88 
89 NodeContainer n0n2;
90 NodeContainer n1n2;
91 NodeContainer n2n3;
92 NodeContainer n3n4;
93 NodeContainer n3n5;
94 
95 Ipv4InterfaceContainer i0i2;
96 Ipv4InterfaceContainer i1i2;
97 Ipv4InterfaceContainer i2i3;
98 Ipv4InterfaceContainer i3i4;
99 Ipv4InterfaceContainer i3i5;
100 
101 std::stringstream filePlotQueueDisc;
102 std::stringstream filePlotQueueDiscAvg;
103 
104 void
105 CheckQueueDiscSize (Ptr<QueueDisc> queue)
106 {
107  uint32_t qSize = StaticCast<RedQueueDisc> (queue)->GetQueueSize ();
108 
109  avgQueueDiscSize += qSize;
110  checkTimes++;
111 
112  // check queue disc size every 1/100 of a second
113  Simulator::Schedule (Seconds (0.01), &CheckQueueDiscSize, queue);
114 
115  std::ofstream fPlotQueueDisc (filePlotQueueDisc.str ().c_str (), std::ios::out | std::ios::app);
116  fPlotQueueDisc << Simulator::Now ().GetSeconds () << " " << qSize << std::endl;
117  fPlotQueueDisc.close ();
118 
119  std::ofstream fPlotQueueDiscAvg (filePlotQueueDiscAvg.str ().c_str (), std::ios::out | std::ios::app);
120  fPlotQueueDiscAvg << Simulator::Now ().GetSeconds () << " " << avgQueueDiscSize / checkTimes << std::endl;
121  fPlotQueueDiscAvg.close ();
122 }
123 
124 void
125 BuildAppsTest (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 
177 int
178 main (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;
205  cmd.AddValue ("testNumber", "Run test 1, 2, 6, 7, 8, 9, 10, 12, 13, 14 or 15", aredTest);
206  cmd.AddValue ("pathOut", "Path to save results from --writeForPlot/--writePcap/--writeFlowMonitor", pathOut);
207  cmd.AddValue ("writeForPlot", "<0/1> to write results for plot (gnuplot)", writeForPlot);
208  cmd.AddValue ("writePcap", "<0/1> to write results in pcapfile", writePcap);
209  cmd.AddValue ("writeFlowMonitor", "<0/1> to enable Flow Monitor and write their results", flowMonitor);
210 
211  cmd.Parse (argc, argv);
212  if ( (aredTest != 1) && (aredTest != 2) && (aredTest != 6) && (aredTest != 7) && (aredTest != 8) && (aredTest != 9) && (aredTest != 10) && (aredTest != 12) && (aredTest != 13) && (aredTest != 14) && (aredTest != 15) )
213  {
214  std::cout << "Invalid test number. Supported tests are 1, 2, 6, 7, 8, 9, 10, 12, 13, 14 or 15" << std::endl;
215  exit (1);
216  }
217 
218  NS_LOG_INFO ("Create nodes");
219  NodeContainer c;
220  c.Create (6);
221  Names::Add ( "N0", c.Get (0));
222  Names::Add ( "N1", c.Get (1));
223  Names::Add ( "N2", c.Get (2));
224  Names::Add ( "N3", c.Get (3));
225  Names::Add ( "N4", c.Get (4));
226  Names::Add ( "N5", c.Get (5));
227  n0n2 = NodeContainer (c.Get (0), c.Get (2));
228  n1n2 = NodeContainer (c.Get (1), c.Get (2));
229  n2n3 = NodeContainer (c.Get (2), c.Get (3));
230  n3n4 = NodeContainer (c.Get (3), c.Get (4));
231  n3n5 = NodeContainer (c.Get (3), c.Get (5));
232 
233  Config::SetDefault ("ns3::TcpL4Protocol::SocketType", StringValue ("ns3::TcpNewReno"));
234  // 42 = headers size
235  Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue (1000 - 42));
236  Config::SetDefault ("ns3::TcpSocket::DelAckCount", UintegerValue (1));
237  GlobalValue::Bind ("ChecksumEnabled", BooleanValue (false));
238 
239  uint32_t meanPktSize = 1000;
240 
241  // RED params
242  NS_LOG_INFO ("Set RED params");
243  Config::SetDefault ("ns3::RedQueueDisc::Mode", StringValue ("QUEUE_DISC_MODE_PACKETS"));
244  Config::SetDefault ("ns3::RedQueueDisc::MeanPktSize", UintegerValue (meanPktSize));
245  Config::SetDefault ("ns3::RedQueueDisc::Wait", BooleanValue (true));
246  Config::SetDefault ("ns3::RedQueueDisc::Gentle", BooleanValue (true));
247  Config::SetDefault ("ns3::RedQueueDisc::QW", DoubleValue (0.002));
248  Config::SetDefault ("ns3::RedQueueDisc::MinTh", DoubleValue (5));
249  Config::SetDefault ("ns3::RedQueueDisc::MaxTh", DoubleValue (15));
250  Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (1000));
251 
252  if (aredTest == 1) // test 1: red1
253  {
254  Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (25));
255  }
256  else if (aredTest == 2) // test 2: red1Adapt
257  {
258  Config::SetDefault ("ns3::RedQueueDisc::ARED", BooleanValue (true));
259  Config::SetDefault ("ns3::RedQueueDisc::LInterm", DoubleValue (10));
260  Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (25));
261  }
262  else if (aredTest == 7) // test 7: fastlinkAutowq
263  {
264  Config::SetDefault ("ns3::RedQueueDisc::QW", DoubleValue (0.0));
265  }
266  else if (aredTest == 8) // test 8: fastlinkAutothresh
267  {
268  Config::SetDefault ("ns3::RedQueueDisc::MinTh", DoubleValue (0));
269  Config::SetDefault ("ns3::RedQueueDisc::MaxTh", DoubleValue (0));
270  }
271  else if (aredTest == 9) // test 9: fastlinkAdaptive
272  {
273  Config::SetDefault ("ns3::RedQueueDisc::AdaptMaxP", BooleanValue (true));
274  Config::SetDefault ("ns3::RedQueueDisc::LInterm", DoubleValue (10));
275  }
276  else if (aredTest == 10) // test 10: fastlinkAllAdapt
277  {
278  Config::SetDefault ("ns3::RedQueueDisc::ARED", BooleanValue (true));
279  Config::SetDefault ("ns3::RedQueueDisc::LInterm", DoubleValue (10));
280  }
281  else if (aredTest == 12) // test 12: fastlinkAllAdapt1
282  {
283  Config::SetDefault ("ns3::RedQueueDisc::ARED", BooleanValue (true));
284  Config::SetDefault ("ns3::RedQueueDisc::LInterm", DoubleValue (10));
285  Config::SetDefault ("ns3::RedQueueDisc::TargetDelay", TimeValue (Seconds (0.2)));
286  }
287  else if (aredTest == 13) // test 13: longlink
288  {
289  Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (100));
290  }
291  else if (aredTest == 14) // test 14: longlinkAdapt
292  {
293  Config::SetDefault ("ns3::RedQueueDisc::ARED", BooleanValue (true));
294  Config::SetDefault ("ns3::RedQueueDisc::LInterm", DoubleValue (10));
295  Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (100));
296  }
297  else if (aredTest == 15) // test 15: longlinkAdapt1
298  {
299  Config::SetDefault ("ns3::RedQueueDisc::QW", DoubleValue (-1.0));
300  Config::SetDefault ("ns3::RedQueueDisc::MinTh", DoubleValue (0));
301  Config::SetDefault ("ns3::RedQueueDisc::MaxTh", DoubleValue (0));
302  Config::SetDefault ("ns3::RedQueueDisc::AdaptMaxP", BooleanValue (true));
303  Config::SetDefault ("ns3::RedQueueDisc::LInterm", DoubleValue (10));
304  Config::SetDefault ("ns3::RedQueueDisc::QueueLimit", UintegerValue (100));
305  }
306 
307  NS_LOG_INFO ("Install internet stack on all nodes.");
308  InternetStackHelper internet;
309  internet.Install (c);
310 
311  TrafficControlHelper tchPfifo;
312  uint16_t handle = tchPfifo.SetRootQueueDisc ("ns3::PfifoFastQueueDisc");
313  tchPfifo.AddInternalQueues (handle, 3, "ns3::DropTailQueue", "MaxPackets", UintegerValue (1000));
314 
315  TrafficControlHelper tchRed;
316  tchRed.SetRootQueueDisc ("ns3::RedQueueDisc", "LinkBandwidth", StringValue (aredLinkDataRate),
317  "LinkDelay", StringValue (aredLinkDelay));
318 
319  NS_LOG_INFO ("Create channels");
320  PointToPointHelper p2p;
321 
322  NetDeviceContainer devn0n2;
323  NetDeviceContainer devn1n2;
324  NetDeviceContainer devn2n3;
325  NetDeviceContainer devn3n4;
326  NetDeviceContainer devn3n5;
327 
328  QueueDiscContainer queueDiscs;
329 
330  if (aredTest == 1 || aredTest == 2)
331  {
332  p2p.SetQueue ("ns3::DropTailQueue");
333  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
334  p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));
335  devn0n2 = p2p.Install (n0n2);
336  tchPfifo.Install (devn0n2);
337 
338  p2p.SetQueue ("ns3::DropTailQueue");
339  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
340  p2p.SetChannelAttribute ("Delay", StringValue ("3ms"));
341  devn1n2 = p2p.Install (n1n2);
342  tchPfifo.Install (devn1n2);
343 
344  p2p.SetQueue ("ns3::DropTailQueue");
345  p2p.SetDeviceAttribute ("DataRate", StringValue (aredLinkDataRate));
346  p2p.SetChannelAttribute ("Delay", StringValue (aredLinkDelay));
347  devn2n3 = p2p.Install (n2n3);
348  // only backbone link has ARED queue disc
349  queueDiscs = tchRed.Install (devn2n3);
350 
351  p2p.SetQueue ("ns3::DropTailQueue");
352  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
353  p2p.SetChannelAttribute ("Delay", StringValue ("4ms"));
354  devn3n4 = p2p.Install (n3n4);
355  tchPfifo.Install (devn3n4);
356 
357  p2p.SetQueue ("ns3::DropTailQueue");
358  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
359  p2p.SetChannelAttribute ("Delay", StringValue ("5ms"));
360  devn3n5 = p2p.Install (n3n5);
361  tchPfifo.Install (devn3n5);
362  }
363  else if (aredTest == 13 || aredTest == 14 || aredTest == 15)
364  {
365  p2p.SetQueue ("ns3::DropTailQueue");
366  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
367  p2p.SetChannelAttribute ("Delay", StringValue ("0ms"));
368  devn0n2 = p2p.Install (n0n2);
369  tchPfifo.Install (devn0n2);
370 
371  p2p.SetQueue ("ns3::DropTailQueue");
372  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
373  p2p.SetChannelAttribute ("Delay", StringValue ("1ms"));
374  devn1n2 = p2p.Install (n1n2);
375  tchPfifo.Install (devn1n2);
376 
377  p2p.SetQueue ("ns3::DropTailQueue");
378  p2p.SetDeviceAttribute ("DataRate", StringValue (aredLinkDataRate));
379  p2p.SetChannelAttribute ("Delay", StringValue ("100ms"));
380  devn2n3 = p2p.Install (n2n3);
381  // only backbone link has ARED queue disc
382  queueDiscs = tchRed.Install (devn2n3);
383 
384  p2p.SetQueue ("ns3::DropTailQueue");
385  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
386  p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));
387  devn3n4 = p2p.Install (n3n4);
388  tchPfifo.Install (devn3n4);
389 
390  p2p.SetQueue ("ns3::DropTailQueue");
391  p2p.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
392  p2p.SetChannelAttribute ("Delay", StringValue ("3ms"));
393  devn3n5 = p2p.Install (n3n5);
394  tchPfifo.Install (devn3n5);
395  }
396  else if (aredTest == 6 || aredTest == 7 || aredTest == 8 || aredTest == 9 || aredTest == 10 || aredTest == 12)
397  {
398  p2p.SetQueue ("ns3::DropTailQueue");
399  p2p.SetDeviceAttribute ("DataRate", StringValue ("100Mbps"));
400  p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));
401  devn0n2 = p2p.Install (n0n2);
402  tchPfifo.Install (devn0n2);
403 
404  p2p.SetQueue ("ns3::DropTailQueue");
405  p2p.SetDeviceAttribute ("DataRate", StringValue ("100Mbps"));
406  p2p.SetChannelAttribute ("Delay", StringValue ("3ms"));
407  devn1n2 = p2p.Install (n1n2);
408  tchPfifo.Install (devn1n2);
409 
410  p2p.SetQueue ("ns3::DropTailQueue");
411  p2p.SetDeviceAttribute ("DataRate", StringValue ("15Mbps"));
412  p2p.SetChannelAttribute ("Delay", StringValue (aredLinkDelay));
413  devn2n3 = p2p.Install (n2n3);
414  // only backbone link has ARED queue disc
415  queueDiscs = tchRed.Install (devn2n3);
416 
417  p2p.SetQueue ("ns3::DropTailQueue");
418  p2p.SetDeviceAttribute ("DataRate", StringValue ("100Mbps"));
419  p2p.SetChannelAttribute ("Delay", StringValue ("4ms"));
420  devn3n4 = p2p.Install (n3n4);
421  tchPfifo.Install (devn3n4);
422 
423  p2p.SetQueue ("ns3::DropTailQueue");
424  p2p.SetDeviceAttribute ("DataRate", StringValue ("100Mbps"));
425  p2p.SetChannelAttribute ("Delay", StringValue ("5ms"));
426  devn3n5 = p2p.Install (n3n5);
427  tchPfifo.Install (devn3n5);
428  }
429 
430  NS_LOG_INFO ("Assign IP Addresses");
431  Ipv4AddressHelper ipv4;
432 
433  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
434  i0i2 = ipv4.Assign (devn0n2);
435 
436  ipv4.SetBase ("10.1.2.0", "255.255.255.0");
437  i1i2 = ipv4.Assign (devn1n2);
438 
439  ipv4.SetBase ("10.1.3.0", "255.255.255.0");
440  i2i3 = ipv4.Assign (devn2n3);
441 
442  ipv4.SetBase ("10.1.4.0", "255.255.255.0");
443  i3i4 = ipv4.Assign (devn3n4);
444 
445  ipv4.SetBase ("10.1.5.0", "255.255.255.0");
446  i3i5 = ipv4.Assign (devn3n5);
447 
448  // Set up the routing
449  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
450 
451  BuildAppsTest (aredTest);
452 
453  if (writePcap)
454  {
455  PointToPointHelper ptp;
456  std::stringstream stmp;
457  stmp << pathOut << "/ared";
458  ptp.EnablePcapAll (stmp.str ().c_str ());
459  }
460 
461  Ptr<FlowMonitor> flowmon;
462  if (flowMonitor)
463  {
464  FlowMonitorHelper flowmonHelper;
465  flowmon = flowmonHelper.InstallAll ();
466  }
467 
468  if (writeForPlot)
469  {
470  filePlotQueueDisc << pathOut << "/" << "ared-queue-disc.plotme";
471  filePlotQueueDiscAvg << pathOut << "/" << "ared-queue-disc_avg.plotme";
472 
473  remove (filePlotQueueDisc.str ().c_str ());
474  remove (filePlotQueueDiscAvg.str ().c_str ());
475  Ptr<QueueDisc> queue = queueDiscs.Get (0);
476  Simulator::ScheduleNow (&CheckQueueDiscSize, queue);
477  }
478 
479  Simulator::Stop (Seconds (sink_stop_time));
480  Simulator::Run ();
481 
482  QueueDisc::Stats st = queueDiscs.Get (0)->GetStats ();
483 
484  if (st.GetNDroppedPackets (RedQueueDisc::UNFORCED_DROP) == 0)
485  {
486  std::cout << "There should be some unforced drops" << std::endl;
487  exit (1);
488  }
489 
490  if (aredTest == 1 || aredTest == 2 || aredTest == 13)
491  {
492  if (st.GetNDroppedPackets (QueueDisc::INTERNAL_QUEUE_DROP) == 0)
493  {
494  std::cout << "There should be some drops due to queue full" << std::endl;
495  exit (1);
496  }
497  }
498  else
499  {
500  if (st.GetNDroppedPackets (QueueDisc::INTERNAL_QUEUE_DROP) != 0)
501  {
502  std::cout << "There should be zero drops due to queue full" << std::endl;
503  exit (1);
504  }
505  }
506 
507  if (flowMonitor)
508  {
509  std::stringstream stmp;
510  stmp << pathOut << "/ared.flowmon";
511 
512  flowmon->SerializeToXmlFile (stmp.str ().c_str (), false, false);
513  }
514 
515  if (printAredStats)
516  {
517  std::cout << "*** ARED stats from Node 2 queue ***" << std::endl;
518  std::cout << st << std::endl;
519  }
520 
521  Simulator::Destroy ();
522 
523  return 0;
524 }
ns3::QueueDisc::Stats
Structure that keeps the queue disc statistics.
Definition: queue-disc.h:155
ns3::ApplicationContainer
holds a vector of ns3::Application pointers.
Definition: application-container.h:41
ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:40
ns3::Ipv4Address::GetAny
static Ipv4Address GetAny(void)
Definition: ipv4-address.cc:388
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:36
ns3::TrafficControlHelper::Install
QueueDiscContainer Install(NetDeviceContainer c)
Definition: traffic-control-helper.cc:405
ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr and interface index.
Definition: ipv4-interface-container.h:54
ns3::Ipv4GlobalRoutingHelper::PopulateRoutingTables
static void PopulateRoutingTables(void)
Build a routing database and initialize the routing tables of the nodes in the simulation.
Definition: ipv4-global-routing-helper.cc:61
ns3::StringValue
Hold variables of type string.
Definition: string.h:41
n3n5
NodeContainer n3n5
Definition: adaptive-red-tests.cc:93
ns3::PointToPointHelper::Install
NetDeviceContainer Install(NodeContainer c)
Definition: point-to-point-helper.cc:220
ns3::ApplicationContainer::Add
void Add(ApplicationContainer other)
Append the contents of another ApplicationContainer to the end of this container. ...
Definition: application-container.cc:64
i3i5
Ipv4InterfaceContainer i3i5
Definition: adaptive-red-tests.cc:99
ns3::PointToPointHelper::SetQueue
void SetQueue(std::string type, std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue())
Each point to point net device must have a queue to pass packets through.
Definition: point-to-point-helper.cc:50
i1i2
Ipv4InterfaceContainer i1i2
Definition: adaptive-red-tests.cc:96
i3i4
Ipv4InterfaceContainer i3i4
Definition: adaptive-red-tests.cc:98
ns3::Simulator::Run
static void Run(void)
Run the simulation.
Definition: simulator.cc:226
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201
avgQueueDiscSize
double avgQueueDiscSize
Definition: adaptive-red-tests.cc:79
ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:86
ns3::LOG_LEVEL_INFO
LOG_INFO and above.
Definition: log.h:103
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:277
ns3::PacketSinkHelper
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes...
Definition: packet-sink-helper.h:35
ns3::PointToPointHelper
Build a set of PointToPointNetDevice objects.
Definition: point-to-point-helper.h:43
ns3::PointToPointHelper::SetDeviceAttribute
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
Definition: point-to-point-helper.cc:66
ns3::OnOffHelper
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:42
second.cmd
tuple cmd
Definition: second.py:35
ns3::RedQueueDisc::UNFORCED_DROP
static constexpr const char * UNFORCED_DROP
Early probability drops.
Definition: red-queue-disc.h:234
filePlotQueueDiscAvg
std::stringstream filePlotQueueDiscAvg
Definition: adaptive-red-tests.cc:102
port
uint16_t port
Definition: dsdv-manet.cc:44
ns3::Address
a polymophic address class
Definition: address.h:90
n3n4
NodeContainer n3n4
Definition: adaptive-red-tests.cc:92
ns3::QueueDiscContainer
Holds a vector of ns3::QueueDisc pointers.
Definition: queue-disc-container.h:44
ns3::Names::Add
static void Add(std::string name, Ptr< Object > object)
Add the association between the string "name" and the Ptr obj.
Definition: names.cc:770
ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:88
ns3::Time::GetSeconds
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:341
client_start_time
double client_start_time
Definition: adaptive-red-tests.cc:86
ns3::QueueDiscContainer::Get
Ptr< QueueDisc > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Definition: queue-disc-container.cc:53
ns3::LogComponentEnable
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:369
sink_stop_time
double sink_stop_time
Definition: adaptive-red-tests.cc:85
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:439
ns3::Simulator::Schedule
static EventId Schedule(Time const &delay, MEM mem_ptr, OBJ obj)
Schedule an event to expire after delay.
Definition: simulator.h:1375
BuildAppsTest
void BuildAppsTest(uint32_t test)
Definition: adaptive-red-tests.cc:125
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1055
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:41
checkTimes
uint32_t checkTimes
Definition: adaptive-red-tests.cc:76
ns3::TrafficControlHelper
Build a set of QueueDisc objects.
Definition: traffic-control-helper.h:118
ns3::QueueDisc::GetStats
const Stats & GetStats(void)
Retrieve all the collected statistics.
Definition: queue-disc.cc:411
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:155
ns3::FlowMonitorHelper::InstallAll
Ptr< FlowMonitor > InstallAll()
Enable flow monitoring on all nodes.
Definition: flow-monitor-helper.cc:135
ns3::ApplicationContainer::Start
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
Definition: application-container.cc:84
ns3::QueueDisc::Stats::GetNDroppedPackets
uint32_t GetNDroppedPackets(std::string reason) const
Get the number of packets dropped for the given reason.
Definition: queue-disc.cc:113
ns3::CommandLine
Parse command-line arguments.
Definition: command-line.h:205
ns3::Simulator::Destroy
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:190
sink_start_time
double sink_start_time
Definition: adaptive-red-tests.cc:84
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:38
ns3::TrafficControlHelper::SetRootQueueDisc
uint16_t SetRootQueueDisc(std::string type, std::string n01="", const AttributeValue &v01=EmptyAttributeValue(), std::string n02="", const AttributeValue &v02=EmptyAttributeValue(), std::string n03="", const AttributeValue &v03=EmptyAttributeValue(), std::string n04="", const AttributeValue &v04=EmptyAttributeValue(), std::string n05="", const AttributeValue &v05=EmptyAttributeValue(), std::string n06="", const AttributeValue &v06=EmptyAttributeValue(), std::string n07="", const AttributeValue &v07=EmptyAttributeValue(), std::string n08="", const AttributeValue &v08=EmptyAttributeValue(), std::string n09="", const AttributeValue &v09=EmptyAttributeValue(), std::string n10="", const AttributeValue &v10=EmptyAttributeValue(), std::string n11="", const AttributeValue &v11=EmptyAttributeValue(), std::string n12="", const AttributeValue &v12=EmptyAttributeValue(), std::string n13="", const AttributeValue &v13=EmptyAttributeValue(), std::string n14="", const AttributeValue &v14=EmptyAttributeValue(), std::string n15="", const AttributeValue &v15=EmptyAttributeValue())
Helper function used to set a root queue disc of the given type and with the given attributes...
Definition: traffic-control-helper.cc:119
ns3::InternetStackHelper::Install
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Definition: internet-stack-helper.cc:357
n2n3
NodeContainer n2n3
Definition: adaptive-red-tests.cc:91
ns3::FlowMonitorHelper
Helper to enable IP flow monitoring on a set of Nodes.
Definition: flow-monitor-helper.h:39
ns3::Simulator::ScheduleNow
static EventId ScheduleNow(MEM mem_ptr, OBJ obj)
Schedule an event to expire Now.
Definition: simulator.h:1564
ns3::Simulator::Now
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:249
i0i2
Ipv4InterfaceContainer i0i2
Definition: adaptive-red-tests.cc:95
ns3::PointToPointHelper::SetChannelAttribute
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
Definition: point-to-point-helper.cc:72
client_stop_time
double client_stop_time
Definition: adaptive-red-tests.cc:87
global_start_time
double global_start_time
Definition: adaptive-red-tests.cc:82
ns3::AddressValue
AttributeValue implementation for Address.
Definition: address.h:278
ns3::ApplicationContainer::Stop
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter...
Definition: application-container.cc:93
ns3::Ipv4AddressHelper::Assign
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Definition: ipv4-address-helper.cc:134
ns3::TrafficControlHelper::AddInternalQueues
void AddInternalQueues(uint16_t handle, uint16_t count, std::string type, std::string n01="", const AttributeValue &v01=EmptyAttributeValue(), std::string n02="", const AttributeValue &v02=EmptyAttributeValue(), std::string n03="", const AttributeValue &v03=EmptyAttributeValue(), std::string n04="", const AttributeValue &v04=EmptyAttributeValue(), std::string n05="", const AttributeValue &v05=EmptyAttributeValue(), std::string n06="", const AttributeValue &v06=EmptyAttributeValue(), std::string n07="", const AttributeValue &v07=EmptyAttributeValue(), std::string n08="", const AttributeValue &v08=EmptyAttributeValue())
Helper function used to add the given number of internal queues (of the given type and with the given...
Definition: traffic-control-helper.cc:161
ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition: data-rate.h:242
ns3::CommandLine::AddValue
void AddValue(const std::string &name, const std::string &help, T &value)
Add a program argument, assigning to POD.
Definition: command-line.h:498
ns3::Simulator::Stop
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:234
ns3::FlowMonitor::SerializeToXmlFile
void SerializeToXmlFile(std::string fileName, bool enableHistograms, bool enableProbes)
Same as SerializeToXmlStream, but writes to a file instead.
Definition: flow-monitor.cc:494
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Definition: node-container.cc:88
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:993
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:782
filePlotQueueDisc
std::stringstream filePlotQueueDisc
Definition: adaptive-red-tests.cc:101
ns3::PacketSinkHelper::Install
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
Definition: packet-sink-helper.cc:55
ns3::CommandLine::Parse
void Parse(int argc, char *argv[])
Parse the program arguments.
Definition: command-line.cc:113
ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition: ipv4-address-helper.h:47
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:93
n0n2
NodeContainer n0n2
Definition: adaptive-red-tests.cc:89
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'...
Definition: double.h:41
global_stop_time
double global_stop_time
Definition: adaptive-red-tests.cc:83
ns3::OnOffHelper::Install
ApplicationContainer Install(NodeContainer c) const
Install an ns3::OnOffApplication on each node of the input container configured with all the attribut...
Definition: on-off-helper.cc:59
CheckQueueDiscSize
void CheckQueueDiscSize(Ptr< QueueDisc > queue)
Definition: adaptive-red-tests.cc:105
n1n2
NodeContainer n1n2
Definition: adaptive-red-tests.cc:90
ns3::OnOffHelper::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Helper function used to set the underlying application attributes.
Definition: on-off-helper.cc:40
i2i3
Ipv4InterfaceContainer i2i3
Definition: adaptive-red-tests.cc:97
ns3::QueueDisc::INTERNAL_QUEUE_DROP
static constexpr const char * INTERNAL_QUEUE_DROP
Packet dropped by an internal queue.
Definition: queue-disc.h:422
ns3::Ipv4AddressHelper::SetBase
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Definition: ipv4-address-helper.cc:63
ns3::Ipv4InterfaceContainer::GetAddress
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Definition: ipv4-interface-container.cc:59