A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
tc-flow-control-test-suite.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2017 Universita' degli Studi di Napoli Federico II
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Stefano Avallone <stavallo@unina.it>
18 *
19 */
20
21#include "ns3/config.h"
22#include "ns3/data-rate.h"
23#include "ns3/double.h"
24#include "ns3/log.h"
25#include "ns3/net-device-queue-interface.h"
26#include "ns3/node-container.h"
27#include "ns3/pointer.h"
28#include "ns3/queue.h"
29#include "ns3/simple-net-device-helper.h"
30#include "ns3/simulator.h"
31#include "ns3/string.h"
32#include "ns3/test.h"
33#include "ns3/traffic-control-helper.h"
34#include "ns3/traffic-control-layer.h"
35#include "ns3/uinteger.h"
36
37#include <algorithm>
38#include <string>
39
40using namespace ns3;
41
42/**
43 * \ingroup traffic-control-test
44 *
45 * \brief Queue Disc Test Item
46 */
47class QueueDiscTestItem : public QueueDiscItem
48{
49 public:
50 /**
51 * Constructor
52 *
53 * \param p the packet stored in this item
54 */
55 QueueDiscTestItem(Ptr<Packet> p);
56 ~QueueDiscTestItem() override;
57
58 // Delete default constructor, copy constructor and assignment operator to avoid misuse
59 QueueDiscTestItem() = delete;
60 QueueDiscTestItem(const QueueDiscTestItem&) = delete;
61 QueueDiscTestItem& operator=(const QueueDiscTestItem&) = delete;
62
63 void AddHeader() override;
64 bool Mark() override;
65};
66
67QueueDiscTestItem::QueueDiscTestItem(Ptr<Packet> p)
68 : QueueDiscItem(p, Mac48Address(), 0)
69{
70}
71
72QueueDiscTestItem::~QueueDiscTestItem()
73{
74}
75
76void
77QueueDiscTestItem::AddHeader()
78{
79}
80
81bool
82QueueDiscTestItem::Mark()
83{
84 return false;
85}
86
87/**
88 * \ingroup traffic-control-test
89 *
90 * \brief Traffic Control Flow Control Test Case
91 */
92class TcFlowControlTestCase : public TestCase
93{
94 public:
95 /**
96 * Constructor
97 *
98 * \param tt the test type
99 * \param deviceQueueLength the queue length of the device
100 * \param totalTxPackets the total number of packets to transmit
101 */
102 TcFlowControlTestCase(QueueSizeUnit tt, uint32_t deviceQueueLength, uint32_t totalTxPackets);
103 ~TcFlowControlTestCase() override;
104
105 private:
106 void DoRun() override;
107 /**
108 * Instruct a node to send a specified number of packets
109 * \param n the node
110 * \param nPackets the number of packets to send
111 */
112 void SendPackets(Ptr<Node> n, uint16_t nPackets);
113 /**
114 * Check if the device queue stores the expected number of packets
115 * \param dev the device
116 * \param nPackets the expected number of packets stored in the device queue
117 * \param msg the message to print if a different number of packets are stored
118 */
119 void CheckPacketsInDeviceQueue(Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg);
120 /**
121 * Check if the device queue is in the expected status (stopped or not)
122 * \param dev the device
123 * \param value the expected status of the queue (true means stopped)
124 * \param msg the message to print if the status of the device queue is different
125 */
126 void CheckDeviceQueueStopped(Ptr<NetDevice> dev, bool value, const std::string msg);
127 /**
128 * Check if the queue disc stores the expected number of packets
129 * \param dev the device the queue disc is installed on
130 * \param nPackets the expected number of packets stored in the queue disc
131 * \param msg the message to print if a different number of packets are stored
132 */
133 void CheckPacketsInQueueDisc(Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg);
134 QueueSizeUnit m_type; //!< the test type
135 uint32_t m_deviceQueueLength; //!< the queue length of the device
136 uint32_t m_totalTxPackets; //!< the toal number of packets to transmit
137};
138
139TcFlowControlTestCase::TcFlowControlTestCase(QueueSizeUnit tt,
140 uint32_t deviceQueueLength,
141 uint32_t totalTxPackets)
142 : TestCase("Test the operation of the flow control mechanism"),
143 m_type(tt),
144 m_deviceQueueLength(deviceQueueLength),
145 m_totalTxPackets(totalTxPackets)
146{
147}
148
149TcFlowControlTestCase::~TcFlowControlTestCase()
150{
151}
152
153void
154TcFlowControlTestCase::SendPackets(Ptr<Node> n, uint16_t nPackets)
155{
156 Ptr<TrafficControlLayer> tc = n->GetObject<TrafficControlLayer>();
157 for (uint16_t i = 0; i < nPackets; i++)
158 {
159 tc->Send(n->GetDevice(0), Create<QueueDiscTestItem>(Create<Packet>(1000)));
160 }
161}
162
163void
164TcFlowControlTestCase::CheckPacketsInDeviceQueue(Ptr<NetDevice> dev,
165 uint16_t nPackets,
166 const std::string msg)
167{
168 PointerValue ptr;
169 dev->GetAttributeFailSafe("TxQueue", ptr);
170 Ptr<Queue<Packet>> queue = ptr.Get<Queue<Packet>>();
171 NS_TEST_EXPECT_MSG_EQ(queue->GetNPackets(), nPackets, msg);
172}
173
174void
175TcFlowControlTestCase::CheckDeviceQueueStopped(Ptr<NetDevice> dev,
176 bool value,
177 const std::string msg)
178{
179 Ptr<NetDeviceQueueInterface> ndqi = dev->GetObject<NetDeviceQueueInterface>();
180 NS_ASSERT_MSG(ndqi, "A device queue interface has not been aggregated to the device");
181 NS_TEST_EXPECT_MSG_EQ(ndqi->GetTxQueue(0)->IsStopped(), value, msg);
182}
183
184void
185TcFlowControlTestCase::CheckPacketsInQueueDisc(Ptr<NetDevice> dev,
186 uint16_t nPackets,
187 const std::string msg)
188{
189 Ptr<TrafficControlLayer> tc = dev->GetNode()->GetObject<TrafficControlLayer>();
190 Ptr<QueueDisc> qdisc = tc->GetRootQueueDiscOnDevice(dev);
191 NS_TEST_EXPECT_MSG_EQ(qdisc->GetNPackets(), nPackets, msg);
192}
193
194void
195TcFlowControlTestCase::DoRun()
196{
197 NodeContainer n;
198 n.Create(2);
199
200 n.Get(0)->AggregateObject(CreateObject<TrafficControlLayer>());
201 n.Get(1)->AggregateObject(CreateObject<TrafficControlLayer>());
202
203 SimpleNetDeviceHelper simple;
204
205 NetDeviceContainer rxDevC = simple.Install(n.Get(1));
206
207 simple.SetDeviceAttribute("DataRate", DataRateValue(DataRate("1Mb/s")));
208 simple.SetQueue("ns3::DropTailQueue",
209 "MaxSize",
210 StringValue(m_type == QueueSizeUnit::PACKETS
211 ? std::to_string(m_deviceQueueLength) + "p"
212 : std::to_string(m_deviceQueueLength) + "B"));
213
214 Ptr<NetDevice> txDev;
215 txDev =
216 simple.Install(n.Get(0), DynamicCast<SimpleChannel>(rxDevC.Get(0)->GetChannel())).Get(0);
217 txDev->SetMtu(2500);
218
219 TrafficControlHelper tch = TrafficControlHelper::Default();
220 tch.Install(txDev);
221
222 // transmit 10 packets at time 0
223 Simulator::Schedule(Time(Seconds(0)),
224 &TcFlowControlTestCase::SendPackets,
225 this,
226 n.Get(0),
227 m_totalTxPackets);
228
229 if (m_type == QueueSizeUnit::PACKETS)
230 {
231 /*
232 * When the device queue is in packet mode, all the packets enqueued in the
233 * queue disc are correctly transmitted, even if the device queue is stopped
234 * when the last packet is received from the upper layers
235 *
236 * We have the following invariants:
237 * - totalPackets = txPackets + deviceQueuePackets + qdiscPackets
238 * - deviceQueuePackets = MIN(totalPackets - txPackets, deviceQueueLen)
239 * - qdiscPackets = MAX(totalPackets - txPackets - deviceQueuePackets, 0)
240 *
241 * The transmission of each packet takes 1000B/1Mbps = 8ms
242 *
243 * We check the values of deviceQueuePackets and qdiscPackets 1ms after each
244 * packet is transmitted (i.e. at 1ms, 9ms, 17ms, ...), as well as verifying
245 * that the device queue is stopped or not, as appropriate.
246 */
247
248 uint32_t checkTimeMs = 0;
249 uint32_t deviceQueuePackets = 0;
250 uint32_t qdiscPackets = 0;
251
252 uint32_t txPackets = 0;
253 for (txPackets = 1; txPackets <= m_totalTxPackets; txPackets++)
254 {
255 checkTimeMs = 8 * (txPackets - 1) + 1; // Check 1ms after each packet is sent
256 deviceQueuePackets = std::min(m_totalTxPackets - txPackets, m_deviceQueueLength);
257 qdiscPackets = std::max(m_totalTxPackets - txPackets - deviceQueuePackets, (uint32_t)0);
258 if (deviceQueuePackets == m_deviceQueueLength)
259 {
260 Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),
261 &TcFlowControlTestCase::CheckDeviceQueueStopped,
262 this,
263 txDev,
264 true,
265 "The device queue must be stopped after " +
266 std::to_string(checkTimeMs) + "ms");
267 }
268 else
269 {
270 Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),
271 &TcFlowControlTestCase::CheckDeviceQueueStopped,
272 this,
273 txDev,
274 false,
275 "The device queue must not be stopped after " +
276 std::to_string(checkTimeMs) + "ms");
277 }
278
279 Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),
280 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
281 this,
282 txDev,
283 deviceQueuePackets,
284 "There must be " + std::to_string(m_deviceQueueLength) +
285 " packets in the device after " + std::to_string(checkTimeMs) +
286 "ms");
287
288 Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),
289 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
290 this,
291 txDev,
292 qdiscPackets,
293 "There must be " + std::to_string(qdiscPackets) +
294 " packets in the queue disc after " +
295 std::to_string(checkTimeMs) + "ms");
296 }
297 }
298 else
299 {
300 // TODO: Make this test parametric as well, and add new test cases
301 /*
302 * When the device queue is in byte mode, all the packets enqueued in the
303 * queue disc are correctly transmitted, even if the device queue is stopped
304 * when the last packet is received from the upper layers
305 */
306
307 // The transmission of each packet takes 1000B/1Mbps = 8ms
308 // After 1ms, we have 3 packets in the device queue (stopped) and 6 in the queue disc
309 Simulator::Schedule(Time(MilliSeconds(1)),
310 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
311 this,
312 txDev,
313 3,
314 "There must be 3 packets in the device queue after 1ms");
315 Simulator::Schedule(Time(MilliSeconds(1)),
316 &TcFlowControlTestCase::CheckDeviceQueueStopped,
317 this,
318 txDev,
319 true,
320 "The device queue must be stopped after 1ms");
321 Simulator::Schedule(Time(MilliSeconds(1)),
322 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
323 this,
324 txDev,
325 6,
326 "There must be 6 packets in the queue disc after 1ms");
327
328 // After 9ms, we have 3 packets in the device queue (stopped) and 5 in the queue disc
329 Simulator::Schedule(Time(MilliSeconds(9)),
330 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
331 this,
332 txDev,
333 3,
334 "There must be 3 packets in the device queue after 9ms");
335 Simulator::Schedule(Time(MilliSeconds(9)),
336 &TcFlowControlTestCase::CheckDeviceQueueStopped,
337 this,
338 txDev,
339 true,
340 "The device queue must be stopped after 9ms");
341 Simulator::Schedule(Time(MilliSeconds(9)),
342 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
343 this,
344 txDev,
345 5,
346 "There must be 5 packets in the queue disc after 9ms");
347
348 // After 17ms, we have 3 packets in the device queue (stopped) and 4 in the queue disc
349 Simulator::Schedule(Time(MilliSeconds(17)),
350 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
351 this,
352 txDev,
353 3,
354 "There must be 3 packets in the device queue after 17ms");
355 Simulator::Schedule(Time(MilliSeconds(17)),
356 &TcFlowControlTestCase::CheckDeviceQueueStopped,
357 this,
358 txDev,
359 true,
360 "The device queue must be stopped after 17ms");
361 Simulator::Schedule(Time(MilliSeconds(17)),
362 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
363 this,
364 txDev,
365 4,
366 "There must be 4 packets in the queue disc after 17ms");
367
368 // After 25ms, we have 3 packets in the device queue (stopped) and 3 in the queue disc
369 Simulator::Schedule(Time(MilliSeconds(25)),
370 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
371 this,
372 txDev,
373 3,
374 "There must be 3 packets in the device queue after 25ms");
375 Simulator::Schedule(Time(MilliSeconds(25)),
376 &TcFlowControlTestCase::CheckDeviceQueueStopped,
377 this,
378 txDev,
379 true,
380 "The device queue must be stopped after 25ms");
381 Simulator::Schedule(Time(MilliSeconds(25)),
382 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
383 this,
384 txDev,
385 3,
386 "There must be 3 packets in the queue disc after 25ms");
387
388 // After 33ms, we have 3 packets in the device queue (stopped) and 2 in the queue disc
389 Simulator::Schedule(Time(MilliSeconds(33)),
390 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
391 this,
392 txDev,
393 3,
394 "There must be 3 packets in the device queue after 33ms");
395 Simulator::Schedule(Time(MilliSeconds(33)),
396 &TcFlowControlTestCase::CheckDeviceQueueStopped,
397 this,
398 txDev,
399 true,
400 "The device queue must be stopped after 33ms");
401 Simulator::Schedule(Time(MilliSeconds(33)),
402 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
403 this,
404 txDev,
405 2,
406 "There must be 2 packets in the queue disc after 33ms");
407
408 // After 41ms, we have 3 packets in the device queue (stopped) and 1 in the queue disc
409 Simulator::Schedule(Time(MilliSeconds(41)),
410 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
411 this,
412 txDev,
413 3,
414 "There must be 3 packets in the device queue after 41ms");
415 Simulator::Schedule(Time(MilliSeconds(41)),
416 &TcFlowControlTestCase::CheckDeviceQueueStopped,
417 this,
418 txDev,
419 true,
420 "The device queue must be stopped after 41ms");
421 Simulator::Schedule(Time(MilliSeconds(41)),
422 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
423 this,
424 txDev,
425 1,
426 "There must be 1 packet in the queue disc after 41ms");
427
428 // After 49ms, we have 3 packets in the device queue (stopped) and the queue disc is empty
429 Simulator::Schedule(Time(MilliSeconds(49)),
430 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
431 this,
432 txDev,
433 3,
434 "There must be 3 packets in the device queue after 49ms");
435 Simulator::Schedule(Time(MilliSeconds(49)),
436 &TcFlowControlTestCase::CheckDeviceQueueStopped,
437 this,
438 txDev,
439 true,
440 "The device queue must be stopped after 49ms");
441 Simulator::Schedule(Time(MilliSeconds(49)),
442 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
443 this,
444 txDev,
445 0,
446 "The queue disc must be empty after 49ms");
447
448 // After 57ms, we have 2 packets in the device queue (not stopped) and the queue disc is
449 // empty
450 Simulator::Schedule(Time(MilliSeconds(57)),
451 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
452 this,
453 txDev,
454 2,
455 "There must be 2 packets in the device queue after 57ms");
456 Simulator::Schedule(Time(MilliSeconds(57)),
457 &TcFlowControlTestCase::CheckDeviceQueueStopped,
458 this,
459 txDev,
460 false,
461 "The device queue must not be stopped after 57ms");
462 Simulator::Schedule(Time(MilliSeconds(57)),
463 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
464 this,
465 txDev,
466 0,
467 "The queue disc must be empty after 57ms");
468
469 // After 81ms, all packets must have been transmitted (the device queue and the queue disc
470 // are empty)
471 Simulator::Schedule(Time(MilliSeconds(81)),
472 &TcFlowControlTestCase::CheckPacketsInDeviceQueue,
473 this,
474 txDev,
475 0,
476 "The device queue must be empty after 81ms");
477 Simulator::Schedule(Time(MilliSeconds(81)),
478 &TcFlowControlTestCase::CheckDeviceQueueStopped,
479 this,
480 txDev,
481 false,
482 "The device queue must not be stopped after 81ms");
483 Simulator::Schedule(Time(MilliSeconds(81)),
484 &TcFlowControlTestCase::CheckPacketsInQueueDisc,
485 this,
486 txDev,
487 0,
488 "The queue disc must be empty after 81ms");
489 }
490
491 Simulator::Run();
492 Simulator::Destroy();
493}
494
495/**
496 * \ingroup traffic-control-test
497 *
498 * \brief Traffic Control Flow Control Test Suite
499 */
500static class TcFlowControlTestSuite : public TestSuite
501{
502 public:
503 TcFlowControlTestSuite()
504 : TestSuite("tc-flow-control", Type::UNIT)
505 {
506 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 1, 10),
507 TestCase::Duration::QUICK);
508 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 5, 10),
509 TestCase::Duration::QUICK);
510 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 9, 10),
511 TestCase::Duration::QUICK);
512 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 10, 10),
513 TestCase::Duration::QUICK);
514 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 11, 10),
515 TestCase::Duration::QUICK);
516 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 15, 10),
517 TestCase::Duration::QUICK);
518 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 1, 1),
519 TestCase::Duration::QUICK);
520 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 2, 1),
521 TestCase::Duration::QUICK);
522 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 5, 1),
523 TestCase::Duration::QUICK);
524
525 // TODO: Right now, this test only works for 5000B and 10 packets (it's hard coded). Should
526 // also be made parametric.
527 AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::BYTES, 5000, 10),
528 TestCase::Duration::QUICK);
529 }
530} g_tcFlowControlTestSuite; ///< the test suite
QueueDiscTestItem
Queue Disc Test Item.
Definition: tc-flow-control-test-suite.cc:48
QueueDiscTestItem::Mark
bool Mark() override
Marks the packet as a substitute for dropping it, such as for Explicit Congestion Notification.
Definition: tc-flow-control-test-suite.cc:82
QueueDiscTestItem::QueueDiscTestItem
QueueDiscTestItem(const QueueDiscTestItem &)=delete
QueueDiscTestItem::QueueDiscTestItem
QueueDiscTestItem()=delete
QueueDiscTestItem::operator=
QueueDiscTestItem & operator=(const QueueDiscTestItem &)=delete
QueueDiscTestItem::AddHeader
void AddHeader() override
Add the header to the packet.
Definition: tc-flow-control-test-suite.cc:77
TcFlowControlTestCase
Traffic Control Flow Control Test Case.
Definition: tc-flow-control-test-suite.cc:93
TcFlowControlTestCase::m_deviceQueueLength
uint32_t m_deviceQueueLength
the queue length of the device
Definition: tc-flow-control-test-suite.cc:135
TcFlowControlTestCase::CheckPacketsInQueueDisc
void CheckPacketsInQueueDisc(Ptr< NetDevice > dev, uint16_t nPackets, const std::string msg)
Check if the queue disc stores the expected number of packets.
Definition: tc-flow-control-test-suite.cc:185
TcFlowControlTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: tc-flow-control-test-suite.cc:195
TcFlowControlTestCase::SendPackets
void SendPackets(Ptr< Node > n, uint16_t nPackets)
Instruct a node to send a specified number of packets.
Definition: tc-flow-control-test-suite.cc:154
TcFlowControlTestCase::TcFlowControlTestCase
TcFlowControlTestCase(QueueSizeUnit tt, uint32_t deviceQueueLength, uint32_t totalTxPackets)
Constructor.
Definition: tc-flow-control-test-suite.cc:139
TcFlowControlTestCase::CheckDeviceQueueStopped
void CheckDeviceQueueStopped(Ptr< NetDevice > dev, bool value, const std::string msg)
Check if the device queue is in the expected status (stopped or not)
Definition: tc-flow-control-test-suite.cc:175
TcFlowControlTestCase::m_type
QueueSizeUnit m_type
the test type
Definition: tc-flow-control-test-suite.cc:134
TcFlowControlTestCase::CheckPacketsInDeviceQueue
void CheckPacketsInDeviceQueue(Ptr< NetDevice > dev, uint16_t nPackets, const std::string msg)
Check if the device queue stores the expected number of packets.
Definition: tc-flow-control-test-suite.cc:164
TcFlowControlTestCase::m_totalTxPackets
uint32_t m_totalTxPackets
the toal number of packets to transmit
Definition: tc-flow-control-test-suite.cc:136
TcFlowControlTestSuite
Traffic Control Flow Control Test Suite.
Definition: tc-flow-control-test-suite.cc:501
ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:89
ns3::DataRateValue
AttributeValue implementation for DataRate.
Definition: data-rate.h:296
ns3::Mac48Address
an EUI-48 address
Definition: mac48-address.h:46
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:67
ns3::NetDeviceQueueInterface
Network device transmission queue interface.
Definition: net-device-queue-interface.h:231
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40
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:84
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:78
ns3::Object::AggregateObject
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:309
ns3::PointerValue
AttributeValue implementation for Pointer.
Definition: pointer.h:48
ns3::PointerValue::Get
Ptr< T > Get() const
Definition: pointer.h:234
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:77
ns3::QueueDiscItem
QueueDiscItem is the abstract base class for items that are stored in a queue disc.
Definition: queue-item.h:133
ns3::Queue
Template class for packet Queues.
Definition: queue.h:268
ns3::SimpleNetDeviceHelper
build a set of SimpleNetDevice objects
Definition: simple-net-device-helper.h:39
ns3::SimpleNetDeviceHelper::SetQueue
void SetQueue(std::string type, Ts &&... args)
Each net device must have a queue to pass packets through.
Definition: simple-net-device-helper.h:190
ns3::SimpleNetDeviceHelper::SetDeviceAttribute
void SetDeviceAttribute(std::string n1, const AttributeValue &v1)
Definition: simple-net-device-helper.cc:53
ns3::SimpleNetDeviceHelper::Install
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::SimpleChannel with the attributes configured by SimpleNetDeviceHelper::Se...
Definition: simple-net-device-helper.cc:77
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:571
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:178
ns3::StringValue
Hold variables of type string.
Definition: string.h:56
ns3::TestCase
encapsulates test code
Definition: test.h:1061
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1268
ns3::TestSuite::Type
Type
Type of test.
Definition: test.h:1275
ns3::TestSuite::UNIT
static constexpr auto UNIT
Definition: test.h:1286
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::TrafficControlHelper
Build a set of QueueDisc objects.
Definition: traffic-control-helper.h:119
ns3::TrafficControlHelper::Install
QueueDiscContainer Install(NetDeviceContainer c)
Definition: traffic-control-helper.cc:249
ns3::TrafficControlHelper::Default
static TrafficControlHelper Default(std::size_t nTxQueues=1)
Definition: traffic-control-helper.cc:108
ns3::TrafficControlLayer
The Traffic Control layer aims at introducing an equivalent of the Linux Traffic Control infrastructu...
Definition: traffic-control-layer.h:93
uint32_t
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:86
ns3::QueueSizeUnit
QueueSizeUnit
Enumeration of the operating modes of queues.
Definition: queue-size.h:44
NS_TEST_EXPECT_MSG_EQ
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:252
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1319
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1331
g_tcFlowControlTestSuite
TcFlowControlTestSuite g_tcFlowControlTestSuite
the test suite
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.