Attachment #3109 for bug #2924

View | Details | Raw Unified | Return to bug 2924
Collapse All | Expand All





* ``bool DoEnqueue (Ptr<QueueDiscItem> item)``:  Enqueue a packet
* ``Ptr<QueueDiscItem> DoDequeue (void)``:  Dequeue a packet
* ``Ptr<const QueueDiscItem> DoPeek (void) const``: Peek a packet
* ``bool CheckConfig (void) const``: Check if the configuration is correct
* ``void InitializeParams (void)``: Initialize queue disc parameters

and may override the default implementation of the following method:

* ``Ptr<const QueueDiscItem> DoPeek (void) const``: Peek the next packet to extract

The default implementation of the ``DoPeek`` method is based on the qdisc_peek_dequeued
function of the Linux kernel, which dequeues a packet and retains it in the
queue disc as a requeued packet. This approach is recommended
especially for queue discs for which it is not obvious what is the next
packet that will be dequeued (e.g., queue discs having multiple internal
queues or child queue discs or queue discs that drop packets after dequeue).

The C++ base class QueueDisc implements:

* methods to add/get a single queue, class or filter and methods to get the number \




  return m_dropNext;
}

Ptr<const QueueDiscItem>
CoDelQueueDisc::DoPeek (void)
{
  NS_LOG_FUNCTION (this);

  Ptr<const QueueDiscItem> item = PeekDequeued ();

  if (!item)
    {
      NS_LOG_LOGIC ("Queue empty");
      return 0;
    }

  NS_LOG_LOGIC ("Number packets " << GetInternalQueue (0)->GetNPackets ());
  NS_LOG_LOGIC ("Number bytes " << GetInternalQueue (0)->GetNBytes ());

  return item;
}

bool
CoDelQueueDisc::CoDelTimeAfter (uint32_t a, uint32_t b)
{

(-)a/src/traffic-control/model/codel-queue-disc.h (-1 lines)

Lines 124-130 private:	Link Here

124

*/

124

*/

125

  virtual Ptr<QueueDiscItem> DoDequeue (void);

125

  virtual Ptr<QueueDiscItem> DoDequeue (void);

126

127

  virtual Ptr<const QueueDiscItem> DoPeek (void);

128

  virtual bool CheckConfig (void);

127

  virtual bool CheckConfig (void);

129

128

130

/**

129

/**




  return item;
}

Ptr<const QueueDiscItem>
FqCoDelQueueDisc::DoPeek (void)
{
  NS_LOG_FUNCTION (this);

  return PeekDequeued ();
}

bool
FqCoDelQueueDisc::CheckConfig (void)
{

(-)a/src/traffic-control/model/fq-codel-queue-disc.h (-1 lines)

Lines 133-139 public:	Link Here

133

private:

133

private:

134

  virtual bool DoEnqueue (Ptr<QueueDiscItem> item);

134

  virtual bool DoEnqueue (Ptr<QueueDiscItem> item);

135

  virtual Ptr<QueueDiscItem> DoDequeue (void);

135

  virtual Ptr<QueueDiscItem> DoDequeue (void);

136

  virtual Ptr<const QueueDiscItem> DoPeek (void);

137

  virtual bool CheckConfig (void);

136

  virtual bool CheckConfig (void);

138

  virtual void InitializeParams (void);

137

  virtual void InitializeParams (void);

139

138




  return item;
}

Ptr<const QueueDiscItem>
PieQueueDisc::DoPeek ()
{
  NS_LOG_FUNCTION (this);

  Ptr<const QueueDiscItem> item = PeekDequeued ();

  if (!item)
    {
      NS_LOG_LOGIC ("Queue empty");
      return 0;
    }

  NS_LOG_LOGIC ("Number packets " << GetInternalQueue (0)->GetNPackets ());
  NS_LOG_LOGIC ("Number bytes " << GetInternalQueue (0)->GetNBytes ());

  return item;
}

bool
PieQueueDisc::CheckConfig (void)
{

(-)a/src/traffic-control/model/pie-queue-disc.h (-1 lines)

Lines 107-113 protected:	Link Here

107

private:

107

private:

108

  virtual bool DoEnqueue (Ptr<QueueDiscItem> item);

108

  virtual bool DoEnqueue (Ptr<QueueDiscItem> item);

109

  virtual Ptr<QueueDiscItem> DoDequeue (void);

109

  virtual Ptr<QueueDiscItem> DoDequeue (void);

110

  virtual Ptr<const QueueDiscItem> DoPeek (void);

111

  virtual bool CheckConfig (void);

110

  virtual bool CheckConfig (void);

112

111

113

/**

112

/**




{
  NS_LOG_FUNCTION (this);

  // The QueueDisc::DoPeek method dequeues a packet and keeps it as a requeued
  // packet. Thus, first check whether a peeked packet exists. Otherwise, call
  // the private DoDequeue method.
  Ptr<QueueDiscItem> item = m_requeued;

  if (item)
    {
      m_requeued = 0;
    }
  else
    {
      item = DoDequeue ();
    }

  NS_ASSERT (m_nPackets == m_stats.nTotalEnqueuedPackets - m_stats.nTotalDequeuedPackets);
  NS_ASSERT (m_nBytes == m_stats.nTotalEnqueuedBytes - m_stats.nTotalDequeuedBytes);

}

Ptr<const QueueDiscItem>
QueueDisc::DoPeek (void)
{
  NS_LOG_FUNCTION (this);


  return m_requeued;
}

Ptr<QueueDiscItem>
QueueDisc::DequeuePeeked (void)
{
  NS_LOG_FUNCTION (this);

  Ptr<QueueDiscItem> item = m_requeued;

  if (item)
    {
      m_requeued = 0;
    }
  else
    {
      item = Dequeue ();
    }

  return item;
}

void
QueueDisc::Run (void)
{




  bool Enqueue (Ptr<QueueDiscItem> item);

  /**
   * Extract from the queue disc the packet that has been dequeued by calling
   * Peek, if any, or call the private DoDequeue method (which must be
   * implemented by derived classes) to dequeue a packet, otherwise.
   *
   * \return 0 if the operation was not successful; the item otherwise.
   */
  Ptr<QueueDiscItem> Dequeue (void);

  /**
   * Get a copy of the next packet the queue discipline will extract, without
   * actually extracting the packet. This function only calls the (private)
   * DoPeek function.
   * \return 0 if the operation was not successful; the item otherwise.
   */
  Ptr<const QueueDiscItem> Peek (void);

  /**
   * Extract from the queue disc the packet that has been dequeued by calling
   * PeekDequeued.
   *
   * \return 0 if the operation was not successful; the item otherwise.
   */
  Ptr<QueueDiscItem> DequeuePeeked (void);

  /**
   * Modelled after the Linux function __qdisc_run (net/sched/sch_generic.c)
   * Dequeues multiple packets, until a quota is exceeded or sending a packet

   */
  bool Mark (Ptr<QueueDiscItem> item, const char* reason);

  /**
   * Dequeue a packet and retain it in the queue disc as a requeued packet.
   * The packet is not traced as requeued, nor is the total count of requeued
   * packets increased. The dequeued packet is not counted in the backlog of
   * the queue disc and is actually extracted from the queue disc by calling
   * DequeuePeeked. Queue discs can point their DoPeek method to this one. This
   * is recommended especially for queue discs for which it is not obvious what
   * is the next packet that will be dequeued (e.g., queue discs having multiple
   * internal queues or child queue discs or queue discs that drop packets
   * after dequeue).
   *
   * \return 0 if the operation was not successful; the item otherwise.
   */
  Ptr<const QueueDiscItem> PeekDequeued (void);

private:
  /**
   * \brief Copy constructor

  virtual Ptr<QueueDiscItem> DoDequeue (void) = 0;

  /**
   * \brief Return a copy of the next packet the queue disc will extract.
   *
   * The implementation of this method is based on the qdisc_peek_dequeued
   * function of the Linux kernel, which dequeues a packet and retains it in the
   * queue disc as a requeued packet. The packet is not traced as requeued, nor
   * is the total count of requeued packets increased. The dequeued packet is
   * not counted in the backlog of the queue disc and is actually extracted from
   * the queue disc by calling DequeuePeeked. This approach is recommended
   * especially for queue discs for which it is not obvious what is the next
   * packet that will be dequeued (e.g., queue discs having multiple internal
   * queues or child queue discs or queue discs that drop packets after dequeue).
   * Subclasses can however provide their own implementation of this method that
   * overrides the default one.
   *
   * \return 0 if the operation was not successful; the packet otherwise.
   */
  virtual Ptr<const QueueDiscItem> DoPeek (void);

  /**
   * Check whether the current configuration is correct. Default objects (such




  return retval;
}

Ptr<const QueueDiscItem>
TbfQueueDisc::DoPeek ()
{
  NS_LOG_FUNCTION (this);

  Ptr<const QueueDiscItem> item = PeekDequeued ();

  if (!item)
    {
      NS_LOG_LOGIC ("No packet returned");
      return 0;
    }

  NS_LOG_LOGIC ("Current queue size: " << GetNPackets () << " packets, " << GetNBytes () << " bytes");

  return item;
}

Ptr<QueueDiscItem>
TbfQueueDisc::DoDequeue (void)
{


      if ((btoks|ptoks) >= 0) // else packet blocked
        {
          Ptr<QueueDiscItem> item = GetQueueDiscClass (0)->GetQueueDisc ()->Dequeue ();
          if (!item)
            {
              NS_LOG_DEBUG ("That's odd! Expecting the peeked packet, we got no packet.");

(-)a/src/traffic-control/model/tbf-queue-disc.h (-1 lines)

Lines 149-155 private:	Link Here

149

150

  virtual bool DoEnqueue (Ptr<QueueDiscItem> item);

150

  virtual bool DoEnqueue (Ptr<QueueDiscItem> item);

151

  virtual Ptr<QueueDiscItem> DoDequeue (void);

151

  virtual Ptr<QueueDiscItem> DoDequeue (void);

152

  virtual Ptr<const QueueDiscItem> DoPeek (void);

153

  virtual bool CheckConfig (void);

152

  virtual bool CheckConfig (void);

154

  virtual void InitializeParams (void);

153

  virtual void InitializeParams (void);

155

154

Return to bug 2924