d0/d91/tc-flow-control-test-suite_8cc_source.html

/*

 * Copyright (c) 2017 Universita' degli Studi di Napoli Federico II

 *

 * SPDX-License-Identifier: GPL-2.0-only

 *

 * Author: Stefano Avallone <stavallo@unina.it>

 *

 */


#include "ns3/config.h"

#include "ns3/data-rate.h"

#include "ns3/double.h"

#include "ns3/log.h"

#include "ns3/net-device-queue-interface.h"

#include "ns3/node-container.h"

#include "ns3/pointer.h"

#include "ns3/queue.h"

#include "ns3/simple-net-device-helper.h"

#include "ns3/simulator.h"

#include "ns3/string.h"

#include "ns3/test.h"

#include "ns3/traffic-control-helper.h"

#include "ns3/traffic-control-layer.h"

#include "ns3/uinteger.h"


#include <algorithm>

#include <string>


using namespace ns3;


/**

 * \ingroup traffic-control-test

 *

 * \brief Queue Disc Test Item

 */


class QueueDiscTestItem : public QueueDiscItem

{

  public:

    /**

     * Constructor

     *

     * \param p the packet stored in this item

     */

    QueueDiscTestItem(Ptr<Packet> p);

    ~QueueDiscTestItem() override;


    // Delete default constructor, copy constructor and assignment operator to avoid misuse

    QueueDiscTestItem() = delete;

    QueueDiscTestItem(const QueueDiscTestItem&) = delete;

    QueueDiscTestItem& operator=(const QueueDiscTestItem&) = delete;


    void AddHeader() override;

    bool Mark() override;

};


QueueDiscTestItem::QueueDiscTestItem(Ptr<Packet> p)

    : QueueDiscItem(p, Mac48Address(), 0)

{

}


QueueDiscTestItem::~QueueDiscTestItem()

{

}


void


QueueDiscTestItem::AddHeader()

{

}


bool


QueueDiscTestItem::Mark()

{

    return false;

}


/**

 * \ingroup traffic-control-test

 *

 * \brief Traffic Control Flow Control Test Case

 */


class TcFlowControlTestCase : public TestCase

{

  public:

    /**

     * Constructor

     *

     * \param tt the test type

     * \param deviceQueueLength the queue length of the device

     * \param totalTxPackets the total number of packets to transmit

     */

    TcFlowControlTestCase(QueueSizeUnit tt, uint32_t deviceQueueLength, uint32_t totalTxPackets);

    ~TcFlowControlTestCase() override;


  private:

    void DoRun() override;

    /**

     * Instruct a node to send a specified number of packets

     * \param n the node

     * \param nPackets the number of packets to send

     */

    void SendPackets(Ptr<Node> n, uint16_t nPackets);

    /**

     * Check if the device queue stores the expected number of packets

     * \param dev the device

     * \param nPackets the expected number of packets stored in the device queue

     * \param msg the message to print if a different number of packets are stored

     */

    void CheckPacketsInDeviceQueue(Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg);

    /**

     * Check if the device queue is in the expected status (stopped or not)

     * \param dev the device

     * \param value the expected status of the queue (true means stopped)

     * \param msg the message to print if the status of the device queue is different

     */

    void CheckDeviceQueueStopped(Ptr<NetDevice> dev, bool value, const std::string msg);

    /**

     * Check if the queue disc stores the expected number of packets

     * \param dev the device the queue disc is installed on

     * \param nPackets the expected number of packets stored in the queue disc

     * \param msg the message to print if a different number of packets are stored

     */

    void CheckPacketsInQueueDisc(Ptr<NetDevice> dev, uint16_t nPackets, const std::string msg);

    QueueSizeUnit m_type;         //!< the test type

    uint32_t m_deviceQueueLength; //!< the queue length of the device

    uint32_t m_totalTxPackets;    //!< the toal number of packets to transmit

};


TcFlowControlTestCase::TcFlowControlTestCase(QueueSizeUnit tt,

                                             uint32_t deviceQueueLength,

                                             uint32_t totalTxPackets)

    : TestCase("Test the operation of the flow control mechanism"),

      m_type(tt),

      m_deviceQueueLength(deviceQueueLength),

      m_totalTxPackets(totalTxPackets)

{

}


TcFlowControlTestCase::~TcFlowControlTestCase()

{

}


void


TcFlowControlTestCase::SendPackets(Ptr<Node> n, uint16_t nPackets)

{

    Ptr<TrafficControlLayer> tc = n->GetObject<TrafficControlLayer>();

    for (uint16_t i = 0; i < nPackets; i++)

    {

        tc->Send(n->GetDevice(0), Create<QueueDiscTestItem>(Create<Packet>(1000)));

    }

}


void


TcFlowControlTestCase::CheckPacketsInDeviceQueue(Ptr<NetDevice> dev,

                                                 uint16_t nPackets,

                                                 const std::string msg)

{

    PointerValue ptr;

    dev->GetAttributeFailSafe("TxQueue", ptr);

    Ptr<Queue<Packet>> queue = ptr.Get<Queue<Packet>>();

    NS_TEST_EXPECT_MSG_EQ(queue->GetNPackets(), nPackets, msg);

}


void


TcFlowControlTestCase::CheckDeviceQueueStopped(Ptr<NetDevice> dev,

                                               bool value,

                                               const std::string msg)

{

    Ptr<NetDeviceQueueInterface> ndqi = dev->GetObject<NetDeviceQueueInterface>();

    NS_ASSERT_MSG(ndqi, "A device queue interface has not been aggregated to the device");

    NS_TEST_EXPECT_MSG_EQ(ndqi->GetTxQueue(0)->IsStopped(), value, msg);

}


void


TcFlowControlTestCase::CheckPacketsInQueueDisc(Ptr<NetDevice> dev,

                                               uint16_t nPackets,

                                               const std::string msg)

{

    Ptr<TrafficControlLayer> tc = dev->GetNode()->GetObject<TrafficControlLayer>();

    Ptr<QueueDisc> qdisc = tc->GetRootQueueDiscOnDevice(dev);

    NS_TEST_EXPECT_MSG_EQ(qdisc->GetNPackets(), nPackets, msg);

}


void


TcFlowControlTestCase::DoRun()

{

    NodeContainer n;

    n.Create(2);


    n.Get(0)->AggregateObject(CreateObject<TrafficControlLayer>());

    n.Get(1)->AggregateObject(CreateObject<TrafficControlLayer>());


    SimpleNetDeviceHelper simple;


    NetDeviceContainer rxDevC = simple.Install(n.Get(1));


    simple.SetDeviceAttribute("DataRate", DataRateValue(DataRate("1Mb/s")));

    simple.SetQueue("ns3::DropTailQueue",

                    "MaxSize",

                    StringValue(m_type == QueueSizeUnit::PACKETS

                                    ? std::to_string(m_deviceQueueLength) + "p"

                                    : std::to_string(m_deviceQueueLength) + "B"));


    Ptr<NetDevice> txDev;

    txDev =

        simple.Install(n.Get(0), DynamicCast<SimpleChannel>(rxDevC.Get(0)->GetChannel())).Get(0);

    txDev->SetMtu(2500);


    TrafficControlHelper tch = TrafficControlHelper::Default();

    tch.Install(txDev);


    // transmit 10 packets at time 0

    Simulator::Schedule(Time(Seconds(0)),

                        &TcFlowControlTestCase::SendPackets,

                        this,

                        n.Get(0),

                        m_totalTxPackets);


    if (m_type == QueueSizeUnit::PACKETS)

    {

        /*

         * When the device queue is in packet mode, all the packets enqueued in the

         * queue disc are correctly transmitted, even if the device queue is stopped

         * when the last packet is received from the upper layers

         *

         * We have the following invariants:

         *  - totalPackets = txPackets + deviceQueuePackets + qdiscPackets

         *  - deviceQueuePackets = MIN(totalPackets - txPackets, deviceQueueLen)

         *  - qdiscPackets = MAX(totalPackets - txPackets - deviceQueuePackets, 0)

         *

         * The transmission of each packet takes 1000B/1Mbps = 8ms

         *

         * We check the values of deviceQueuePackets and qdiscPackets 1ms after each

         * packet is transmitted (i.e. at 1ms, 9ms, 17ms, ...), as well as verifying

         * that the device queue is stopped or not, as appropriate.

         */


        uint32_t checkTimeMs = 0;

        uint32_t deviceQueuePackets = 0;

        uint32_t qdiscPackets = 0;


        uint32_t txPackets = 0;

        for (txPackets = 1; txPackets <= m_totalTxPackets; txPackets++)

        {

            checkTimeMs = 8 * (txPackets - 1) + 1; // Check 1ms after each packet is sent

            deviceQueuePackets = std::min(m_totalTxPackets - txPackets, m_deviceQueueLength);

            qdiscPackets = std::max(m_totalTxPackets - txPackets - deviceQueuePackets, (uint32_t)0);

            if (deviceQueuePackets == m_deviceQueueLength)

            {

                Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),

                                    &TcFlowControlTestCase::CheckDeviceQueueStopped,

                                    this,

                                    txDev,

                                    true,

                                    "The device queue must be stopped after " +

                                        std::to_string(checkTimeMs) + "ms");

            }

            else

            {

                Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),

                                    &TcFlowControlTestCase::CheckDeviceQueueStopped,

                                    this,

                                    txDev,

                                    false,

                                    "The device queue must not be stopped after " +

                                        std::to_string(checkTimeMs) + "ms");

            }


            Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),

                                &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                                this,

                                txDev,

                                deviceQueuePackets,

                                "There must be " + std::to_string(m_deviceQueueLength) +

                                    " packets in the device after " + std::to_string(checkTimeMs) +

                                    "ms");


            Simulator::Schedule(Time(MilliSeconds(checkTimeMs)),

                                &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                                this,

                                txDev,

                                qdiscPackets,

                                "There must be " + std::to_string(qdiscPackets) +

                                    " packets in the queue disc after " +

                                    std::to_string(checkTimeMs) + "ms");

        }

    }

    else

    {

        // TODO: Make this test parametric as well, and add new test cases

        /*

         * When the device queue is in byte mode, all the packets enqueued in the

         * queue disc are correctly transmitted, even if the device queue is stopped

         * when the last packet is received from the upper layers

         */


        // The transmission of each packet takes 1000B/1Mbps = 8ms

        // After 1ms, we have 3 packets in the device queue (stopped) and 6 in the queue disc

        Simulator::Schedule(Time(MilliSeconds(1)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the device queue after 1ms");

        Simulator::Schedule(Time(MilliSeconds(1)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            true,

                            "The device queue must be stopped after 1ms");

        Simulator::Schedule(Time(MilliSeconds(1)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            6,

                            "There must be 6 packets in the queue disc after 1ms");


        // After 9ms, we have 3 packets in the device queue (stopped) and 5 in the queue disc

        Simulator::Schedule(Time(MilliSeconds(9)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the device queue after 9ms");

        Simulator::Schedule(Time(MilliSeconds(9)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            true,

                            "The device queue must be stopped after 9ms");

        Simulator::Schedule(Time(MilliSeconds(9)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            5,

                            "There must be 5 packets in the queue disc after 9ms");


        // After 17ms, we have 3 packets in the device queue (stopped) and 4 in the queue disc

        Simulator::Schedule(Time(MilliSeconds(17)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the device queue after 17ms");

        Simulator::Schedule(Time(MilliSeconds(17)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            true,

                            "The device queue must be stopped after 17ms");

        Simulator::Schedule(Time(MilliSeconds(17)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            4,

                            "There must be 4 packets in the queue disc after 17ms");


        // After 25ms, we have 3 packets in the device queue (stopped) and 3 in the queue disc

        Simulator::Schedule(Time(MilliSeconds(25)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the device queue after 25ms");

        Simulator::Schedule(Time(MilliSeconds(25)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            true,

                            "The device queue must be stopped after 25ms");

        Simulator::Schedule(Time(MilliSeconds(25)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the queue disc after 25ms");


        // After 33ms, we have 3 packets in the device queue (stopped) and 2 in the queue disc

        Simulator::Schedule(Time(MilliSeconds(33)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the device queue after 33ms");

        Simulator::Schedule(Time(MilliSeconds(33)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            true,

                            "The device queue must be stopped after 33ms");

        Simulator::Schedule(Time(MilliSeconds(33)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            2,

                            "There must be 2 packets in the queue disc after 33ms");


        // After 41ms, we have 3 packets in the device queue (stopped) and 1 in the queue disc

        Simulator::Schedule(Time(MilliSeconds(41)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the device queue after 41ms");

        Simulator::Schedule(Time(MilliSeconds(41)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            true,

                            "The device queue must be stopped after 41ms");

        Simulator::Schedule(Time(MilliSeconds(41)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            1,

                            "There must be 1 packet in the queue disc after 41ms");


        // After 49ms, we have 3 packets in the device queue (stopped) and the queue disc is empty

        Simulator::Schedule(Time(MilliSeconds(49)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            3,

                            "There must be 3 packets in the device queue after 49ms");

        Simulator::Schedule(Time(MilliSeconds(49)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            true,

                            "The device queue must be stopped after 49ms");

        Simulator::Schedule(Time(MilliSeconds(49)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            0,

                            "The queue disc must be empty after 49ms");


        // After 57ms, we have 2 packets in the device queue (not stopped) and the queue disc is

        // empty

        Simulator::Schedule(Time(MilliSeconds(57)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            2,

                            "There must be 2 packets in the device queue after 57ms");

        Simulator::Schedule(Time(MilliSeconds(57)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            false,

                            "The device queue must not be stopped after 57ms");

        Simulator::Schedule(Time(MilliSeconds(57)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            0,

                            "The queue disc must be empty after 57ms");


        // After 81ms, all packets must have been transmitted (the device queue and the queue disc

        // are empty)

        Simulator::Schedule(Time(MilliSeconds(81)),

                            &TcFlowControlTestCase::CheckPacketsInDeviceQueue,

                            this,

                            txDev,

                            0,

                            "The device queue must be empty after 81ms");

        Simulator::Schedule(Time(MilliSeconds(81)),

                            &TcFlowControlTestCase::CheckDeviceQueueStopped,

                            this,

                            txDev,

                            false,

                            "The device queue must not be stopped after 81ms");

        Simulator::Schedule(Time(MilliSeconds(81)),

                            &TcFlowControlTestCase::CheckPacketsInQueueDisc,

                            this,

                            txDev,

                            0,

                            "The queue disc must be empty after 81ms");

    }


    Simulator::Run();

    Simulator::Destroy();

}


/**

 * \ingroup traffic-control-test

 *

 * \brief Traffic Control Flow Control Test Suite

 */


static class TcFlowControlTestSuite : public TestSuite

{

  public:


    TcFlowControlTestSuite()

        : TestSuite("tc-flow-control", Type::UNIT)

    {

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 1, 10),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 5, 10),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 9, 10),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 10, 10),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 11, 10),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 15, 10),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 1, 1),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 2, 1),

                    TestCase::Duration::QUICK);

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::PACKETS, 5, 1),

                    TestCase::Duration::QUICK);


        // TODO: Right now, this test only works for 5000B and 10 packets (it's hard coded). Should

        // also be made parametric.

        AddTestCase(new TcFlowControlTestCase(QueueSizeUnit::BYTES, 5000, 10),

                    TestCase::Duration::QUICK);

    }


} g_tcFlowControlTestSuite; ///< the test suite


QueueDiscTestItem
Queue Disc Test Item.
Definition tc-flow-control-test-suite.cc:37

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:71

QueueDiscTestItem::QueueDiscTestItem
QueueDiscTestItem(const QueueDiscTestItem &)=delete

QueueDiscTestItem::QueueDiscTestItem
QueueDiscTestItem()=delete

QueueDiscTestItem::operator=
QueueDiscTestItem & operator=(const QueueDiscTestItem &)=delete

QueueDiscTestItem::~QueueDiscTestItem
~QueueDiscTestItem() override
Definition tc-flow-control-test-suite.cc:61

QueueDiscTestItem::AddHeader
void AddHeader() override
Add the header to the packet.
Definition tc-flow-control-test-suite.cc:66

TcFlowControlTestCase
Traffic Control Flow Control Test Case.
Definition tc-flow-control-test-suite.cc:82

TcFlowControlTestCase::m_deviceQueueLength
uint32_t m_deviceQueueLength
the queue length of the device
Definition tc-flow-control-test-suite.cc:124

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:174

TcFlowControlTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition tc-flow-control-test-suite.cc:184

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:143

TcFlowControlTestCase::TcFlowControlTestCase
TcFlowControlTestCase(QueueSizeUnit tt, uint32_t deviceQueueLength, uint32_t totalTxPackets)
Constructor.
Definition tc-flow-control-test-suite.cc:128

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:164

TcFlowControlTestCase::~TcFlowControlTestCase
~TcFlowControlTestCase() override
Definition tc-flow-control-test-suite.cc:138

TcFlowControlTestCase::m_type
QueueSizeUnit m_type
the test type
Definition tc-flow-control-test-suite.cc:123

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:153

TcFlowControlTestCase::m_totalTxPackets
uint32_t m_totalTxPackets
the toal number of packets to transmit
Definition tc-flow-control-test-suite.cc:125

TcFlowControlTestSuite
Traffic Control Flow Control Test Suite.
Definition tc-flow-control-test-suite.cc:490

TcFlowControlTestSuite::TcFlowControlTestSuite
TcFlowControlTestSuite()
Definition tc-flow-control-test-suite.cc:492

ns3::DataRate
Class for representing data rates.
Definition data-rate.h:78

ns3::DataRateValue
Definition data-rate.h:285

ns3::Mac48Address
an EUI-48 address
Definition mac48-address.h:35

ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition net-device-container.h:32

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:56

ns3::NetDeviceQueueInterface
Network device transmission queue interface.
Definition net-device-queue-interface.h:220

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::Object::AggregateObject
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition object.cc:298

ns3::PointerValue
AttributeValue implementation for Pointer.

ns3::PointerValue::Get
Ptr< T > Get() const
Definition pointer.h:223

ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition mpi-test-fixtures.h:37

ns3::QueueDiscItem
QueueDiscItem is the abstract base class for items that are stored in a queue disc.
Definition queue-item.h:122

ns3::Queue
Template class for packet Queues.
Definition queue.h:257

ns3::SimpleNetDeviceHelper
build a set of SimpleNetDevice objects
Definition simple-net-device-helper.h:28

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:179

ns3::SimpleNetDeviceHelper::SetDeviceAttribute
void SetDeviceAttribute(std::string n1, const AttributeValue &v1)
Definition simple-net-device-helper.cc:42

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:66

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::Run
static void Run()
Run the simulation.
Definition simulator.cc:167

ns3::StringValue
Hold variables of type string.
Definition string.h:45

ns3::TestCase
encapsulates test code
Definition test.h:1050

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:292

ns3::TestSuite
A suite of tests to run.
Definition test.h:1267

ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1274

ns3::TestSuite::UNIT
static constexpr auto UNIT
Definition test.h:1291

ns3::Time
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94

ns3::TrafficControlHelper
Build a set of QueueDisc objects.
Definition traffic-control-helper.h:108

ns3::TrafficControlHelper::Install
QueueDiscContainer Install(NetDeviceContainer c)
Definition traffic-control-helper.cc:238

ns3::TrafficControlHelper::Default
static TrafficControlHelper Default(std::size_t nTxQueues=1)
Definition traffic-control-helper.cc:97

ns3::TrafficControlLayer
The Traffic Control layer aims at introducing an equivalent of the Linux Traffic Control infrastructu...
Definition traffic-control-layer.h:88

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:75

ns3::CreateObject
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619

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::QueueSizeUnit
QueueSizeUnit
Enumeration of the operating modes of queues.
Definition queue-size.h:33

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:241

ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308

ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1320

g_tcFlowControlTestSuite
TcFlowControlTestSuite g_tcFlowControlTestSuite
the test suite

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::DynamicCast
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
Definition ptr.h:580