Initial support for multiple transmission queues inside NetDevices

This patch adds a NetDeviceQueue class to store information about a single
transmission queue of a network device. This class is meant to store the
state of a transmission queue (i.e., whether the queue is stopped or not)
and some data used by techniques such as Byte Queue Limits. Also, multi-queue
aware queue discs can aggregate a child queue disc to an object of this class.
These features (excluding BQL) are added in subsequent commits.
The NetDevice class maintains a vector of NetDeviceQueue pointers, one for
each transmission queue. A NetDevice constructor is added which creates a
single transmission queue by default for every device. The number of transmission
queues can be modified (by child classes) by calling NetDevice::SetTxQueuesN.
Two public methods, GetTxQueue and GetTxQueuesN, are also added to the NetDevice class
to return the i-th NetDeviceQueue and the number of transmission queues, respectively.

src/network/model/net-device.cc

@@ -20,13 +20,38 @@
 
 #include "ns3/object.h"
 #include "ns3/log.h"
+#include "ns3/abort.h"
 #include "ns3/uinteger.h"
 #include "net-device.h"
 
 namespace ns3 {
 
 NS_LOG_COMPONENT_DEFINE ("NetDevice");
 
+NS_OBJECT_ENSURE_REGISTERED (NetDeviceQueue);
+
+TypeId NetDeviceQueue::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::NetDeviceQueue")
+    .SetParent<Object> ()
+    .SetGroupName("Network")
+  ;
+  return tid;
+}
+
+NetDeviceQueue::~NetDeviceQueue ()
+{
+  NS_LOG_FUNCTION (this);
+}
+
+void
+NetDeviceQueue::SetDevice (Ptr<NetDevice> device)
+{
+  NS_ABORT_MSG_UNLESS (m_device == 0, "Cannot change the device which a transmission queue belongs to.");
+  m_device = device;
+}
+
+
 NS_OBJECT_ENSURE_REGISTERED (NetDevice);
 
 TypeId NetDevice::GetTypeId (void)
@@ -38,9 +63,36 @@ TypeId NetDevice::GetTypeId (void)
   return tid;
 }
 
+NetDevice::NetDevice ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  Ptr<NetDeviceQueue> devQueue = Create<NetDeviceQueue> ();
+  devQueue->SetDevice (this);
+  m_txQueuesVector.push_back (devQueue);
+}
+
 NetDevice::~NetDevice ()
 {
   NS_LOG_FUNCTION (this);
 }
 
+void
+NetDevice::SetTxQueuesN (uint8_t numTxQueues)
+{
+  NS_ASSERT (numTxQueues > 0);
+
+  /// \todo check whether a queue disc has been aggregated to the device
+
+  uint8_t prevNumTxQueues = m_txQueuesVector.size ();
+  m_txQueuesVector.resize (numTxQueues);
+
+  // Allocate new NetDeviceQueues if the number of queues increased
+  for (uint8_t i = prevNumTxQueues; i < numTxQueues; i++)
+    {
+      Ptr<NetDeviceQueue> devQueue = Create<NetDeviceQueue> ();
+      devQueue->SetDevice (this);
+      m_txQueuesVector[i] = devQueue;
+    }
+}
+
 } // namespace ns3

src/network/model/net-device.h

@@ -22,6 +22,7 @@
 #define NET_DEVICE_H
 
 #include <string>
+#include <vector>
 #include <stdint.h>
 #include "ns3/callback.h"
 #include "ns3/object.h"
@@ -35,11 +36,55 @@ namespace ns3 {
 class Node;
 class Channel;
 class Packet;
+class NetDevice;
 
 /**
  * \ingroup network
  * \defgroup netdevice Network Device
  */
+/**
+ * \ingroup netdevice
+ *
+ * \brief Network device transmission queue
+ *
+ * This class stores information about a single transmission queue
+ * of a network device that is exposed to queue discs. Such information
+ * includes the state of the transmission queue (whether it has been
+ * stopped or not) and data used by techniques such as Byte Queue Limits.
+ * Also, multi-queue aware queue discs can aggregate a child queue disc
+ * to an object of this class.
+ *
+ * This class roughly models the struct netdev_queue of Linux.
+ * \todo Store the state information (done in a next commit)
+ * \todo Implement BQL
+ */
+class NetDeviceQueue : public SimpleRefCount<NetDeviceQueue>
+{
+public:
+  /**
+   * \brief Get the type ID.
+   * \return the object TypeId
+   */
+  static TypeId GetTypeId (void);
+
+  virtual ~NetDeviceQueue();
+
+  /**
+   * \return the device which this transmission queue belongs to.
+   */
+  inline Ptr<NetDevice> GetDevice (void) const;
+
+  /**
+   * \param device the device which this transmission queue belongs to.
+   *
+   * The device can be set just once.
+   */
+  virtual void SetDevice (Ptr<NetDevice> device);
+
+private:
+  Ptr<NetDevice> m_device;
+};
+
 /**
  * \ingroup netdevice
  *
@@ -80,6 +125,8 @@ class NetDevice : public Object
    * \return the object TypeId
    */
   static TypeId GetTypeId (void);
+
+  NetDevice ();
   virtual ~NetDevice();
 
   /**
@@ -339,8 +386,57 @@ class NetDevice : public Object
    */
   virtual bool SupportsSendFrom (void) const = 0;
 
+  /**
+   * \return the i-th transmission queue of the device.
+   *
+   * The index of the first transmission queue is zero.
+   */
+  inline Ptr<NetDeviceQueue> GetTxQueue (uint8_t i) const;
+
+  /**
+   * \return the number of (hardware) transmission queues.
+   */
+  inline uint8_t GetTxQueuesN (void) const;
+
+protected:
+  /**
+   * \param numTxQueues number of (hardware) transmission queues.
+   *
+   * Modifying the number of transmission queues is only permitted before a queue
+   * disc is aggregated to the device. This is because we have to set a wake
+   * callback for each transmission queue, and this is done when setting up
+   * queue discs.
+   */
+  virtual void SetTxQueuesN (uint8_t numTxQueues);
+
+private:
+  std::vector< Ptr<NetDeviceQueue> > m_txQueuesVector;
 };
 
 } // namespace ns3
 
+
+namespace ns3 {
+
+Ptr<NetDevice>
+NetDeviceQueue::GetDevice (void) const
+{
+  return m_device;
+}
+
+Ptr<NetDeviceQueue>
+NetDevice::GetTxQueue (uint8_t i) const
+{
+  NS_ASSERT (i < m_txQueuesVector.size ());
+  return m_txQueuesVector[i];
+}
+
+uint8_t
+NetDevice::GetTxQueuesN (void) const
+{
+  return m_txQueuesVector.size ();
+}
+
+} // namespace ns3
+
 #endif /* NET_DEVICE_H */