cobalt-queue-disc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 NITK Surathkal
 *
 * 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
 *
 * Cobalt, the CoDel - BLUE - Alternate Queueing discipline
 * Based on linux code.
 *
 * Ported to ns-3 by: Vignesh Kannan <vignesh2496@gmail.com>
 *                    Harsh Lara <harshapplefan@gmail.com>
 *                    Jendaipou Palmei <jendaipoupalmei@gmail.com>
 *                    Shefali Gupta <shefaligups11@gmail.com>
 *                    Mohit P. Tahiliani <tahiliani@nitk.edu.in>
 *
 */
 
#ifndef COBALT_H
#define COBALT_H
 
#include "queue-disc.h"
 
#include "ns3/boolean.h"
#include "ns3/data-rate.h"
#include "ns3/nstime.h"
#include "ns3/random-variable-stream.h"
#include "ns3/simulator.h"
#include "ns3/string.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/traced-value.h"
 
namespace ns3
{
 
#define REC_INV_SQRT_CACHE (16)
#define DEFAULT_COBALT_LIMIT 1000
 
class TraceContainer;
 
class CobaltQueueDisc : public QueueDisc
{
  public:
    static TypeId GetTypeId();
 
    CobaltQueueDisc();
 
    ~CobaltQueueDisc() override;
 
    Time GetTarget() const;
 
    Time GetInterval() const;
 
    int64_t GetDropNext() const;
 
    static constexpr const char* TARGET_EXCEEDED_DROP =
        "Target exceeded drop";                                     
    static constexpr const char* OVERLIMIT_DROP = "Overlimit drop"; 
    static constexpr const char* FORCED_MARK =
        "forcedMark"; 
    static constexpr const char* CE_THRESHOLD_EXCEEDED_MARK =
        "CE threshold exceeded mark"; 
 
    double GetPdrop() const;
 
    int64_t AssignStreams(int64_t stream);
 
    int64_t Time2CoDel(Time t) const;
 
  protected:
    void DoDispose() override;
 
  private:
    bool DoEnqueue(Ptr<QueueDiscItem> item) override;
    Ptr<QueueDiscItem> DoDequeue() override;
    Ptr<const QueueDiscItem> DoPeek() override;
    bool CheckConfig() override;
 
    void InitializeParams() override;
 
    void NewtonStep();
 
    int64_t ControlLaw(int64_t t);
 
    void InvSqrt();
 
    void CacheInit();
 
    bool CoDelTimeAfter(int64_t a, int64_t b);
 
    bool CoDelTimeAfterEq(int64_t a, int64_t b);
 
    void CobaltQueueFull(int64_t now);
 
    void CobaltQueueEmpty(int64_t now);
 
    bool CobaltShouldDrop(Ptr<QueueDiscItem> item, int64_t now);
 
    // Common to CoDel and Blue
    // Maintained by Cobalt
    Stats m_stats; 
 
    // Codel parameters
    // Maintained by Cobalt
    TracedValue<uint32_t> m_count;   
    TracedValue<int64_t> m_dropNext; 
    TracedValue<bool> m_dropping;    
    uint32_t m_recInvSqrt;           
    uint32_t m_recInvSqrtCache[REC_INV_SQRT_CACHE] = {
        0}; 
 
    // Supplied by user
    Time m_interval;      
    Time m_target;        
    bool m_useEcn;        
    Time m_ceThreshold;   
    bool m_useL4s;        
    Time m_blueThreshold; 
 
    // Blue parameters
    // Maintained by Cobalt
    Ptr<UniformRandomVariable> m_uv; 
    uint32_t m_lastUpdateTimeBlue;   
 
    // Supplied by user
    double m_increment; 
    double m_decrement; 
    double m_pDrop;     
};
 
} // namespace ns3
 
#endif /* COBALT_H */