A Discrete-Event Network Simulator
API
tc-flow-control-test-suite.cc
Go to the documentation of this file.
1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2017 Universita' degli Studi di Napoli Federico II
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: Stefano Avallone <stavallo@unina.it>
19 *
20 */
21
22#include <algorithm>
23#include <string>
24
25#include "ns3/test.h"
26#include "ns3/uinteger.h"
27#include "ns3/pointer.h"
28#include "ns3/string.h"
29#include "ns3/double.h"
30#include "ns3/log.h"
31#include "ns3/simulator.h"
32#include "ns3/node-container.h"
33#include "ns3/traffic-control-layer.h"
34#include "ns3/traffic-control-helper.h"
35#include "ns3/simple-net-device-helper.h"
36#include "ns3/data-rate.h"
37#include "ns3/net-device-queue-interface.h"
38#include "ns3/queue.h"
39#include "ns3/config.h"
40
41using namespace ns3;
42
50public:
57 virtual ~QueueDiscTestItem ();
58
59 // Delete default constructor, copy constructor and assignment operator to avoid misuse
60 QueueDiscTestItem () = delete;
63
64 virtual void AddHeader (void);
65 virtual bool Mark(void);
66};
67
69 : QueueDiscItem (p, Mac48Address (), 0)
70{
71}
72
74{
75}
76
77void
79{
80}
81
82bool
84{
85 return false;
86}
87
95{
96public:
104 TcFlowControlTestCase (QueueSizeUnit tt, uint32_t deviceQueueLength, uint32_t totalTxPackets);
105 virtual ~TcFlowControlTestCase ();
106private:
107 virtual void DoRun (void);
113 void SendPackets (Ptr<Node> n, uint16_t nPackets);
120 void CheckPacketsInDeviceQueue (Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg);
127 void CheckDeviceQueueStopped (Ptr<NetDevice> dev, bool value, const std::string msg);
134 void CheckPacketsInQueueDisc (Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg);
138};
139
141 : TestCase ("Test the operation of the flow control mechanism"),
142 m_type (tt), m_deviceQueueLength(deviceQueueLength), m_totalTxPackets(totalTxPackets)
143{
144}
145
147{
148}
149
150void
152{
154 for (uint16_t i = 0; i < nPackets; i++)
155 {
156 tc->Send (n->GetDevice (0), Create<QueueDiscTestItem> (Create<Packet> (1000)));
157 }
158}
159
160void
161TcFlowControlTestCase::CheckPacketsInDeviceQueue (Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg)
162{
163 PointerValue ptr;
164 dev->GetAttributeFailSafe ("TxQueue", ptr);
165 Ptr<Queue<Packet> > queue = ptr.Get<Queue<Packet> > ();
166 NS_TEST_EXPECT_MSG_EQ (queue->GetNPackets (), nPackets, msg);
167}
168
169void
171{
173 NS_ASSERT_MSG (ndqi, "A device queue interface has not been aggregated to the device");
174 NS_TEST_EXPECT_MSG_EQ (ndqi->GetTxQueue (0)->IsStopped (), value, msg);
175}
176
177void
178TcFlowControlTestCase::CheckPacketsInQueueDisc (Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg)
179{
180 Ptr<TrafficControlLayer> tc = dev->GetNode ()->GetObject<TrafficControlLayer> ();
181 Ptr<QueueDisc> qdisc = tc->GetRootQueueDiscOnDevice (dev);
182 NS_TEST_EXPECT_MSG_EQ (qdisc->GetNPackets (), nPackets, msg);
183}
184
185
186void
188{
190 n.Create (2);
191
192 n.Get (0)->AggregateObject (CreateObject<TrafficControlLayer> ());
193 n.Get (1)->AggregateObject (CreateObject<TrafficControlLayer> ());
194
196
197 NetDeviceContainer rxDevC = simple.Install (n.Get (1));
198
199 simple.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("1Mb/s")));
200 simple.SetQueue ("ns3::DropTailQueue", "MaxSize",
202 ? std::to_string (m_deviceQueueLength) + "p"
203 : std::to_string (m_deviceQueueLength) + "B"));
204
205 Ptr<NetDevice> txDev;
206 txDev = simple.Install (n.Get (0), DynamicCast<SimpleChannel> (rxDevC.Get (0)->GetChannel ())).Get (0);
207 txDev->SetMtu (2500);
208
209 TrafficControlHelper tch = TrafficControlHelper::Default ();
210 tch.Install (txDev);
211
212 // transmit 10 packets at time 0
213 Simulator::Schedule (Time (Seconds (0)), &TcFlowControlTestCase::SendPackets,
214 this, n.Get (0), m_totalTxPackets);
215
217 {
218 /*
219 * When the device queue is in packet mode, all the packets enqueued in the
220 * queue disc are correctly transmitted, even if the device queue is stopped
221 * when the last packet is received from the upper layers
222 *
223 * We have the following invariants:
224 * - totalPackets = txPackets + deviceQueuePackets + qdiscPackets
225 * - deviceQueuePackets = MIN(totalPackets - txPackets, deviceQueueLen)
226 * - qdiscPackets = MAX(totalPackets - txPackets - deviceQueuePackets, 0)
227 *
228 * The transmission of each packet takes 1000B/1Mbps = 8ms
229 *
230 * We check the values of deviceQueuePackets and qdiscPackets 1ms after each
231 * packet is transmitted (i.e. at 1ms, 9ms, 17ms, ...), as well as verifying
232 * that the device queue is stopped or not, as appropriate.
233 */
234
235 uint32_t checkTimeMs = 0;
236 uint32_t deviceQueuePackets = 0;
237 uint32_t qdiscPackets = 0;
238
239 uint32_t txPackets = 0;
240 for (txPackets = 1; txPackets <= m_totalTxPackets; txPackets++)
241 {
242 checkTimeMs = 8 * (txPackets - 1) + 1; // Check 1ms after each packet is sent
243 deviceQueuePackets = std::min (m_totalTxPackets - txPackets, m_deviceQueueLength);
244 qdiscPackets = std::max (m_totalTxPackets - txPackets - deviceQueuePackets, (uint32_t)0);
245 if (deviceQueuePackets == m_deviceQueueLength)
246 {
247 Simulator::Schedule (
248 Time (MilliSeconds (checkTimeMs)),
250 "The device queue must be stopped after " + std::to_string (checkTimeMs) + "ms");
251 }
252 else
253 {
254 Simulator::Schedule (Time (MilliSeconds (checkTimeMs)),
256 false,
257 "The device queue must not be stopped after " +
258 std::to_string (checkTimeMs) + "ms");
259 }
260
261 Simulator::Schedule (
263 this, txDev, deviceQueuePackets,
264 "There must be " + std::to_string (m_deviceQueueLength) + " packets in the device after " +
265 std::to_string (checkTimeMs) + "ms");
266
267 Simulator::Schedule (
269 this, txDev, qdiscPackets,
270 "There must be " + std::to_string (qdiscPackets) +
271 " packets in the queue disc after " + std::to_string (checkTimeMs) + "ms");
272 }
273 }
274 else
275 {
276 // TODO: Make this test parametric as well, and add new test cases
277 /*
278 * When the device queue is in byte mode, all the packets enqueued in the
279 * queue disc are correctly transmitted, even if the device queue is stopped
280 * when the last packet is received from the upper layers
281 */
282
283 // The transmission of each packet takes 1000B/1Mbps = 8ms
284 // After 1ms, we have 3 packets in the device queue (stopped) and 6 in the queue disc
286 this, txDev, 3, "There must be 3 packets in the device queue after 1ms");
288 this, txDev, true, "The device queue must be stopped after 1ms");
290 this, txDev, 6, "There must be 6 packets in the queue disc after 1ms");
291
292 // After 9ms, we have 3 packets in the device queue (stopped) and 5 in the queue disc
294 this, txDev, 3, "There must be 3 packets in the device queue after 9ms");
296 this, txDev, true, "The device queue must be stopped after 9ms");
298 this, txDev, 5, "There must be 5 packets in the queue disc after 9ms");
299
300 // After 17ms, we have 3 packets in the device queue (stopped) and 4 in the queue disc
302 this, txDev, 3, "There must be 3 packets in the device queue after 17ms");
304 this, txDev, true, "The device queue must be stopped after 17ms");
306 this, txDev, 4, "There must be 4 packets in the queue disc after 17ms");
307
308 // After 25ms, we have 3 packets in the device queue (stopped) and 3 in the queue disc
310 this, txDev, 3, "There must be 3 packets in the device queue after 25ms");
312 this, txDev, true, "The device queue must be stopped after 25ms");
314 this, txDev, 3, "There must be 3 packets in the queue disc after 25ms");
315
316 // After 33ms, we have 3 packets in the device queue (stopped) and 2 in the queue disc
318 this, txDev, 3, "There must be 3 packets in the device queue after 33ms");
320 this, txDev, true, "The device queue must be stopped after 33ms");
322 this, txDev, 2, "There must be 2 packets in the queue disc after 33ms");
323
324 // After 41ms, we have 3 packets in the device queue (stopped) and 1 in the queue disc
326 this, txDev, 3, "There must be 3 packets in the device queue after 41ms");
328 this, txDev, true, "The device queue must be stopped after 41ms");
330 this, txDev, 1, "There must be 1 packet in the queue disc after 41ms");
331
332 // After 49ms, we have 3 packets in the device queue (stopped) and the queue disc is empty
334 this, txDev, 3, "There must be 3 packets in the device queue after 49ms");
336 this, txDev, true, "The device queue must be stopped after 49ms");
338 this, txDev, 0, "The queue disc must be empty after 49ms");
339
340 // After 57ms, we have 2 packets in the device queue (not stopped) and the queue disc is empty
342 this, txDev, 2, "There must be 2 packets in the device queue after 57ms");
344 this, txDev, false, "The device queue must not be stopped after 57ms");
346 this, txDev, 0, "The queue disc must be empty after 57ms");
347
348 // After 81ms, all packets must have been transmitted (the device queue and the queue disc are empty)
350 this, txDev, 0, "The device queue must be empty after 81ms");
352 this, txDev, false, "The device queue must not be stopped after 81ms");
354 this, txDev, 0, "The queue disc must be empty after 81ms");
355 }
356
358 Simulator::Destroy ();
359}
360
368{
369public:
371 : TestSuite ("tc-flow-control", UNIT)
372 {
373 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 1, 10), TestCase::QUICK);
374 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 5, 10), TestCase::QUICK);
375 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 9, 10), TestCase::QUICK);
376 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 10, 10), TestCase::QUICK);
377 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 11, 10), TestCase::QUICK);
378 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 15, 10), TestCase::QUICK);
379 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 1, 1), TestCase::QUICK);
380 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 2, 1), TestCase::QUICK);
381 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::PACKETS, 5, 1), TestCase::QUICK);
382
383 // TODO: Right now, this test only works for 5000B and 10 packets (it's hard coded). Should
384 // also be made parametric.
385 AddTestCase (new TcFlowControlTestCase (QueueSizeUnit::BYTES, 5000, 10), TestCase::QUICK);
386 }
#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.
Queue Disc Test Item.
virtual bool Mark(void)
Marks the packet as a substitute for dropping it, such as for Explicit Congestion Notification.
QueueDiscTestItem(const QueueDiscTestItem &)=delete
QueueDiscTestItem()=delete
QueueDiscTestItem & operator=(const QueueDiscTestItem &)=delete
virtual void AddHeader(void)
Add the header to the packet.
Traffic Control Flow Control Test Case.
uint32_t m_deviceQueueLength
the queue length of the device
void CheckPacketsInQueueDisc(Ptr< NetDevice > dev, uint16_t nPackets, const std::string msg)
Check if the queue disc stores the expected number of packets.
virtual void DoRun(void)
Implementation to actually run this TestCase.
void SendPackets(Ptr< Node > n, uint16_t nPackets)
Instruct a node to send a specified number of packets.
TcFlowControlTestCase(QueueSizeUnit tt, uint32_t deviceQueueLength, uint32_t totalTxPackets)
Constructor.
void CheckDeviceQueueStopped(Ptr< NetDevice > dev, bool value, const std::string msg)
Check if the device queue is in the expected status (stopped or not)
QueueSizeUnit m_type
the test type
void CheckPacketsInDeviceQueue(Ptr< NetDevice > dev, uint16_t nPackets, const std::string msg)
Check if the device queue stores the expected number of packets.
uint32_t m_totalTxPackets
the toal number of packets to transmit
Traffic Control Flow Control Test Suite.
Class for representing data rates.
Definition: data-rate.h:89
AttributeValue implementation for DataRate.
an EUI-48 address
Definition: mac48-address.h:44
holds a vector of ns3::NetDevice pointers
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Network device transmission queue interface.
keep track of a set of node pointers.
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.
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition: node.cc:144
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Ptr< T > Get(void) const
Definition: pointer.h:201
QueueDiscItem is the abstract base class for items that are stored in a queue disc.
Definition: queue-item.h:133
build a set of SimpleNetDevice objects
void SetQueue(std::string type, Ts &&... args)
Each net device must have a queue to pass packets through.
void SetDeviceAttribute(std::string n1, const AttributeValue &v1)
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::SimpleChannel with the attributes configured by SimpleNetDeviceHelper::Se...
Hold variables of type string.
Definition: string.h:41
encapsulates test code
Definition: test.h:994
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
A suite of tests to run.
Definition: test.h:1188
@ UNIT
This test suite implements a Unit Test.
Definition: test.h:1197
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
Build a set of QueueDisc objects.
QueueDiscContainer Install(NetDeviceContainer c)
Introspection did not find any typical Config paths.
#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:88
QueueSizeUnit
Enumeration of the operating modes of queues.
Definition: queue-size.h:43
@ BYTES
Use number of bytes for queue size.
Definition: queue-size.h:45
@ PACKETS
Use number of packets for queue size.
Definition: queue-size.h:44
#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:240
TcFlowControlTestSuite g_tcFlowControlTestSuite
the test suite
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1245
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1253
Every class exported by the ns3 library is enclosed in the ns3 namespace.