tbf-queue-disc.cc

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2017 Kungliga Tekniska Högskolan
 *               2017 Universita' degli Studi di Napoli Federico II
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * TBF, The Token Bucket Filter Queueing discipline
 *
 * This implementation is based on linux kernel code by
 * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *              Dmitry Torokhov <dtor@mail.ru> - allow attaching inner qdiscs -
 *                                               original idea by Martin Devera
 *
 * Implemented in ns-3 by: Surya Seetharaman <suryaseetharaman.9@gmail.com>
 *                         Stefano Avallone <stavallo@unina.it>
 */

#include "ns3/log.h"
#include "ns3/enum.h"
#include "ns3/simulator.h"
#include "ns3/uinteger.h"
#include "ns3/attribute.h"
#include "ns3/object-factory.h"
#include "ns3/drop-tail-queue.h"
#include "ns3/net-device-queue-interface.h"
#include "tbf-queue-disc.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("TbfQueueDisc");

NS_OBJECT_ENSURE_REGISTERED (TbfQueueDisc);

TypeId TbfQueueDisc::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::TbfQueueDisc")
    .SetParent<QueueDisc> ()
    .SetGroupName ("TrafficControl")
    .AddConstructor<TbfQueueDisc> ()
    .AddAttribute ("MaxSize",
                   "The max queue size",
                   QueueSizeValue (QueueSize ("1000p")),
                   MakeQueueSizeAccessor (&QueueDisc::SetMaxSize,
                                          &QueueDisc::GetMaxSize),
                   MakeQueueSizeChecker ())
    .AddAttribute ("Burst",
                   "Size of the first bucket in bytes",
                   UintegerValue (125000),
                   MakeUintegerAccessor (&TbfQueueDisc::SetBurst),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("Mtu",
                   "Size of the second bucket in bytes. If null, it is initialized"
                   " to the MTU of the attached NetDevice (if any)",
                   UintegerValue (0),
                   MakeUintegerAccessor (&TbfQueueDisc::SetMtu),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("Rate",
                   "Rate at which tokens enter the first bucket in bps or Bps.",
                   DataRateValue (DataRate ("125KB/s")),
                   MakeDataRateAccessor (&TbfQueueDisc::SetRate),
                   MakeDataRateChecker ())
    .AddAttribute ("PeakRate",
                   "Rate at which tokens enter the second bucket in bps or Bps."
                   "If null, there is no second bucket",
                   DataRateValue (DataRate ("0KB/s")),
                   MakeDataRateAccessor (&TbfQueueDisc::SetPeakRate),
                   MakeDataRateChecker ())
    .AddTraceSource ("TokensInFirstBucket",
                     "Number of First Bucket Tokens in bytes",
                     MakeTraceSourceAccessor (&TbfQueueDisc::m_btokens),
                     "ns3::TracedValueCallback::Uint32")
    .AddTraceSource ("TokensInSecondBucket",
                     "Number of Second Bucket Tokens in bytes",
                     MakeTraceSourceAccessor (&TbfQueueDisc::m_ptokens),
                     "ns3::TracedValueCallback::Uint32")
  ;

  return tid;
}

TbfQueueDisc::TbfQueueDisc ()
  : QueueDisc (QueueDiscSizePolicy::SINGLE_CHILD_QUEUE_DISC)
{
  NS_LOG_FUNCTION (this);
}

TbfQueueDisc::~TbfQueueDisc ()
{
  NS_LOG_FUNCTION (this);
}

void
TbfQueueDisc::DoDispose (void)
{
  NS_LOG_FUNCTION (this);
  QueueDisc::DoDispose ();
}

void
TbfQueueDisc::SetBurst (uint32_t burst)
{
  NS_LOG_FUNCTION (this << burst);
  m_burst = burst;
}

uint32_t
TbfQueueDisc::GetBurst (void) const
{
  NS_LOG_FUNCTION (this);
  return m_burst;
}

void
TbfQueueDisc::SetMtu (uint32_t mtu)
{
  NS_LOG_FUNCTION (this << mtu);
  m_mtu = mtu;
}

uint32_t
TbfQueueDisc::GetMtu (void) const
{
  NS_LOG_FUNCTION (this);
  return m_mtu;
}

void
TbfQueueDisc::SetRate (DataRate rate)
{
  NS_LOG_FUNCTION (this << rate);
  m_rate = rate;
}

DataRate
TbfQueueDisc::GetRate (void) const
{
  NS_LOG_FUNCTION (this);
  return m_rate;
}

void
TbfQueueDisc::SetPeakRate (DataRate peakRate)
{
  NS_LOG_FUNCTION (this << peakRate);
  m_peakRate = peakRate;
}

DataRate
TbfQueueDisc::GetPeakRate (void) const
{
  NS_LOG_FUNCTION (this);
  return m_peakRate;
}

uint32_t
TbfQueueDisc::GetFirstBucketTokens (void) const
{
  NS_LOG_FUNCTION (this);
  return m_btokens;
}

uint32_t
TbfQueueDisc::GetSecondBucketTokens (void) const
{
  NS_LOG_FUNCTION (this);
  return m_ptokens;
}

bool
TbfQueueDisc::DoEnqueue (Ptr<QueueDiscItem> item)
{
  NS_LOG_FUNCTION (this << item);

  bool retval = GetQueueDiscClass (0)->GetQueueDisc ()->Enqueue (item);

  // If Queue::Enqueue fails, QueueDisc::Drop is called by the child queue
  // disc because QueueDisc::AddQueueDiscClass sets the drop callback

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

  return retval;
}

Ptr<QueueDiscItem>
TbfQueueDisc::DoDequeue (void)
{
  NS_LOG_FUNCTION (this);
  Ptr<const QueueDiscItem> itemPeek = GetQueueDiscClass (0)->GetQueueDisc ()->Peek ();

  if (itemPeek)
    {
      uint32_t pktSize = itemPeek->GetSize ();
      NS_LOG_LOGIC ("Next packet size " << pktSize);

      int64_t btoks = 0;
      int64_t ptoks = 0;
      Time now = Simulator::Now ();

      double delta = (now  - m_timeCheckPoint).GetSeconds ();
      NS_LOG_LOGIC ("Time Difference delta " << delta);

      if (m_peakRate > DataRate ("0bps"))
        {
          ptoks =  m_ptokens + round (delta * (m_peakRate.GetBitRate () / 8));
          if (ptoks > m_mtu)
            {
              ptoks = m_mtu;
            }
          NS_LOG_LOGIC ("Number of ptokens we can consume " << ptoks);
          NS_LOG_LOGIC ("Required to dequeue next packet " << pktSize);
          ptoks -= pktSize;
        }

      btoks = m_btokens + round (delta * (m_rate.GetBitRate () / 8));

      if (btoks > m_burst)
        {
          btoks = m_burst;
        }

      NS_LOG_LOGIC ("Number of btokens we can consume " << btoks);
      NS_LOG_LOGIC ("Required to dequeue next packet " << pktSize);
      btoks -= pktSize;

      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.");
              return item;
            }

          m_timeCheckPoint = now;
          m_btokens = btoks;
          m_ptokens = ptoks;

          NS_LOG_LOGIC (m_btokens << " btokens and " << m_ptokens << " ptokens after packet dequeue");
          NS_LOG_LOGIC ("Current queue size: " << GetNPackets () << " packets, " << GetNBytes () << " bytes");

          return item;
        }

      // the watchdog timer setup.
      /* A packet gets blocked if the above if condition is not satisfied, i.e.
      both the ptoks and btoks are less than zero. In that case we have to 
      schedule the waking of queue when enough tokens are available. */
      if (m_id.IsExpired () == true)
        {
          Time requiredDelayTime = std::max (m_rate.CalculateBytesTxTime (-btoks),
                                             m_peakRate.CalculateBytesTxTime (-ptoks));

          m_id = Simulator::Schedule (requiredDelayTime, &QueueDisc::Run, this);
          NS_LOG_LOGIC("Waking Event Scheduled in " << requiredDelayTime);
        }
    }
  return 0;
}

bool
TbfQueueDisc::CheckConfig (void)
{
  NS_LOG_FUNCTION (this);
  if (GetNInternalQueues () > 0)
    {
      NS_LOG_ERROR ("TbfQueueDisc cannot have internal queues");
      return false;
    }

  if (GetNPacketFilters () > 0)
    {
      NS_LOG_ERROR ("TbfQueueDisc cannot have packet filters");
      return false;
    }

  if (GetNQueueDiscClasses () == 0)
    {
      // create a FIFO queue disc
      ObjectFactory factory;
      factory.SetTypeId ("ns3::FifoQueueDisc");
      Ptr<QueueDisc> qd = factory.Create<QueueDisc> ();

      if (!qd->SetMaxSize (GetMaxSize ()))
        {
          NS_LOG_ERROR ("Cannot set the max size of the child queue disc to that of TbfQueueDisc");
          return false;
        }
      qd->Initialize ();

      Ptr<QueueDiscClass> c = CreateObject<QueueDiscClass> ();
      c->SetQueueDisc (qd);
      AddQueueDiscClass (c);
    }

  if (GetNQueueDiscClasses () != 1)
    {
      NS_LOG_ERROR ("TbfQueueDisc needs 1 child queue disc");
      return false;
    }

  if (m_mtu == 0 && GetNetDevice ())
    {
      m_mtu = GetNetDevice ()->GetMtu ();
    }

  if (m_mtu == 0 && m_peakRate > DataRate ("0bps"))
    {
      NS_LOG_ERROR ("A non-null peak rate has been set, but the mtu is null. No packet will be dequeued");
      return false;
    }

  if (m_burst <= m_mtu)
    {
      NS_LOG_WARN ("The size of the first bucket (" << m_burst << ") should be "
                    << "greater than the size of the second bucket (" << m_mtu << ").");
    }

  if (m_peakRate > DataRate ("0bps") && m_peakRate <= m_rate)
    {
      NS_LOG_WARN ("The rate for the second bucket (" << m_peakRate << ") should be "
                    << "greater than the rate for the first bucket (" << m_rate << ").");
    }

  return true;
}

void
TbfQueueDisc::InitializeParams (void)
{
  NS_LOG_FUNCTION (this);
  // Token Buckets are full at the beginning.
  m_btokens = m_burst;
  m_ptokens = m_mtu;
  // Initialising other variables to 0.
  m_timeCheckPoint = Seconds (0);
  m_id = EventId ();
}

} // namespace ns3