queue-disc.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2007, 2014 University of Washington
 *               2015 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
 */

#ifndef QUEUE_DISC_H
#define QUEUE_DISC_H

#include "ns3/object.h"
#include "ns3/traced-value.h"
#include "ns3/traced-callback.h"
#include "ns3/queue-item.h"
#include "ns3/queue-size.h"
#include <vector>
#include <map>
#include <functional>
#include <string>
#include "packet-filter.h"

namespace ns3 {

class QueueDisc;
template <typename Item> class Queue;
class NetDeviceQueueInterface;

class QueueDiscClass : public Object {
public:
  static TypeId GetTypeId (void);

  QueueDiscClass ();
  virtual ~QueueDiscClass ();

  Ptr<QueueDisc> GetQueueDisc (void) const;

  void SetQueueDisc (Ptr<QueueDisc> qd);

protected:
  virtual void DoDispose (void);

private:
  Ptr<QueueDisc> m_queueDisc;        
};

enum QueueDiscSizePolicy
{
  SINGLE_INTERNAL_QUEUE,       
  SINGLE_CHILD_QUEUE_DISC,     
  MULTIPLE_QUEUES,             
  NO_LIMITS                    
};


class QueueDisc : public Object {
public:

  struct Stats
  {
    uint32_t nTotalReceivedPackets;
    uint64_t nTotalReceivedBytes;
    uint32_t nTotalSentPackets;
    uint64_t nTotalSentBytes;
    uint32_t nTotalEnqueuedPackets;
    uint64_t nTotalEnqueuedBytes;
    uint32_t nTotalDequeuedPackets;
    uint64_t nTotalDequeuedBytes;
    uint32_t nTotalDroppedPackets;
    uint32_t nTotalDroppedPacketsBeforeEnqueue;
    std::map<std::string, uint32_t> nDroppedPacketsBeforeEnqueue;
    uint32_t nTotalDroppedPacketsAfterDequeue;
    std::map<std::string, uint32_t> nDroppedPacketsAfterDequeue;
    uint64_t nTotalDroppedBytes;
    uint64_t nTotalDroppedBytesBeforeEnqueue;
    std::map<std::string, uint64_t> nDroppedBytesBeforeEnqueue;
    uint64_t nTotalDroppedBytesAfterDequeue;
    std::map<std::string, uint64_t> nDroppedBytesAfterDequeue;
    uint32_t nTotalRequeuedPackets;
    uint64_t nTotalRequeuedBytes;
    uint32_t nTotalMarkedPackets;
    std::map<std::string, uint32_t> nMarkedPackets;
    uint32_t nTotalMarkedBytes;
    std::map<std::string, uint64_t> nMarkedBytes;

    Stats ();

    uint32_t GetNDroppedPackets (std::string reason) const;
    uint64_t GetNDroppedBytes (std::string reason) const;
    uint32_t GetNMarkedPackets (std::string reason) const;
    uint64_t GetNMarkedBytes (std::string reason) const;
    void Print (std::ostream &os) const;
  };

  static TypeId GetTypeId (void);

  QueueDisc (QueueDiscSizePolicy policy = QueueDiscSizePolicy::SINGLE_INTERNAL_QUEUE);

  QueueDisc (QueueDiscSizePolicy policy, QueueSizeUnit unit);

  virtual ~QueueDisc ();

  uint32_t GetNPackets (void) const;

  uint32_t GetNBytes (void) const;

  QueueSize GetMaxSize (void) const;

  bool SetMaxSize (QueueSize size);

  QueueSize GetCurrentSize (void);

  const Stats& GetStats (void);

  void SetNetDeviceQueueInterface (Ptr<NetDeviceQueueInterface> ndqi);

  Ptr<NetDeviceQueueInterface> GetNetDeviceQueueInterface (void) const;

  typedef std::function<void (Ptr<QueueDiscItem>)> SendCallback;

  void SetSendCallback (SendCallback func);

  SendCallback GetSendCallback (void) const;

  virtual void SetQuota (const uint32_t quota);

  virtual uint32_t GetQuota (void) const;

  bool Enqueue (Ptr<QueueDiscItem> item);

  Ptr<QueueDiscItem> Dequeue (void);

  Ptr<const QueueDiscItem> Peek (void);

  void Run (void);

  typedef Queue<QueueDiscItem> InternalQueue;

  void AddInternalQueue (Ptr<InternalQueue> queue);

  Ptr<InternalQueue> GetInternalQueue (std::size_t i) const;

  std::size_t GetNInternalQueues (void) const;

  void AddPacketFilter (Ptr<PacketFilter> filter);

  Ptr<PacketFilter> GetPacketFilter (std::size_t i) const;

  std::size_t GetNPacketFilters (void) const;

  void AddQueueDiscClass (Ptr<QueueDiscClass> qdClass);

  Ptr<QueueDiscClass> GetQueueDiscClass (std::size_t i) const;

  std::size_t GetNQueueDiscClasses (void) const;

  int32_t Classify (Ptr<QueueDiscItem> item);

  enum WakeMode
    {
      WAKE_ROOT = 0x00,
      WAKE_CHILD = 0x01
    };

  virtual WakeMode GetWakeMode (void) const;

  // Reasons for dropping packets
  static constexpr const char* INTERNAL_QUEUE_DROP = "Dropped by internal queue";    
  static constexpr const char* CHILD_QUEUE_DISC_DROP = "(Dropped by child queue disc) "; 
  static constexpr const char* CHILD_QUEUE_DISC_MARK = "(Marked by child queue disc) "; 

protected:
  virtual void DoDispose (void);

  void DoInitialize (void);

  void DropBeforeEnqueue (Ptr<const QueueDiscItem> item, const char* reason);

  void DropAfterDequeue (Ptr<const QueueDiscItem> item, const char* reason);

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

private:
  QueueDisc (const QueueDisc &o);

  QueueDisc &operator = (const QueueDisc &o);

  virtual bool DoEnqueue (Ptr<QueueDiscItem> item) = 0;

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

  virtual Ptr<const QueueDiscItem> DoPeek (void);

  virtual bool CheckConfig (void) = 0;

  virtual void InitializeParams (void) = 0;

  bool RunBegin (void);

  void RunEnd (void);

  bool Restart (void);

  Ptr<QueueDiscItem> DequeuePacket (void);

  void Requeue (Ptr<QueueDiscItem> item);

  bool Transmit (Ptr<QueueDiscItem> item);

  void PacketEnqueued (Ptr<const QueueDiscItem> item);

  void PacketDequeued (Ptr<const QueueDiscItem> item);

  static const uint32_t DEFAULT_QUOTA = 64; 

  std::vector<Ptr<InternalQueue> > m_queues;    
  std::vector<Ptr<PacketFilter> > m_filters;    
  std::vector<Ptr<QueueDiscClass> > m_classes;  

  TracedValue<uint32_t> m_nPackets; 
  TracedValue<uint32_t> m_nBytes;   
  TracedCallback<Time> m_sojourn;   
  QueueSize m_maxSize;              

  Stats m_stats;                    
  uint32_t m_quota;                 
  Ptr<NetDeviceQueueInterface> m_devQueueIface;   
  SendCallback m_send;              
  bool m_running;                   
  Ptr<QueueDiscItem> m_requeued;    
  bool m_peeked;                    
  std::string m_childQueueDiscDropMsg;  
  std::string m_childQueueDiscMarkMsg;  
  QueueDiscSizePolicy m_sizePolicy;     
  bool m_prohibitChangeMode;            

  TracedCallback<Ptr<const QueueDiscItem> > m_traceEnqueue;
  TracedCallback<Ptr<const QueueDiscItem> > m_traceDequeue;
  TracedCallback<Ptr<const QueueDiscItem> > m_traceRequeue;
  TracedCallback<Ptr<const QueueDiscItem> > m_traceDrop;
  TracedCallback<Ptr<const QueueDiscItem>, const char* > m_traceDropBeforeEnqueue;
  TracedCallback<Ptr<const QueueDiscItem>, const char* > m_traceDropAfterDequeue;
  TracedCallback<Ptr<const QueueDiscItem>, const char* > m_traceMark;

  typedef std::function<void (Ptr<const QueueDiscItem>)> InternalQueueDropFunctor;
  typedef std::function<void (Ptr<const QueueDiscItem>, const char*)> ChildQueueDiscDropFunctor;
  typedef std::function<void (Ptr<const QueueDiscItem>, const char*)> ChildQueueDiscMarkFunctor;

  InternalQueueDropFunctor m_internalQueueDbeFunctor;
  InternalQueueDropFunctor m_internalQueueDadFunctor;
  ChildQueueDiscDropFunctor m_childQueueDiscDbeFunctor;
  ChildQueueDiscDropFunctor m_childQueueDiscDadFunctor;
  ChildQueueDiscMarkFunctor m_childQueueDiscMarkFunctor;
};

std::ostream& operator<< (std::ostream& os, const QueueDisc::Stats &stats);

} // namespace ns3

#endif /* QueueDisc */