Implementation of Random Early Detection (RED). More...

#include <REDDropper.h>

Inheritance diagram for inet::REDDropper:

Public Member Functions
	REDDropper ()

Public Member Functions inherited from inet::AlgorithmicDropperBase
	AlgorithmicDropperBase ()

virtual	~AlgorithmicDropperBase ()

Public Member Functions inherited from inet::IQueueAccess
virtual	~IQueueAccess ()

Protected Member Functions
virtual	~REDDropper ()

virtual void	initialize () override

virtual bool	shouldDrop (cPacket *packet) override

virtual void	sendOut (cPacket *packet) override

Protected Member Functions inherited from inet::AlgorithmicDropperBase
virtual void	handleMessage (cMessage *msg) override

virtual void	dropPacket (cPacket *packet)

virtual int	getLength () const override
	Returns the number of frames in the queue. More...

virtual int	getByteLength () const override
	Returns the number of bytes in the queue. More...

Protected Attributes
double	wq = 0.0

double *	minths = nullptr

double *	maxths = nullptr

double *	maxps = nullptr

double *	pkrates = nullptr

double *	count = nullptr

double	avg = 0.0

simtime_t	q_time

Protected Attributes inherited from inet::AlgorithmicDropperBase
int	numGates

std::vector< IQueueAccess * >	outQueues

std::set< IQueueAccess * >	outQueueSet

Detailed Description

Implementation of Random Early Detection (RED).

Constructor & Destructor Documentation

inet::REDDropper::REDDropper ( )

inline

45 {}

inet::REDDropper::~REDDropper ( )

protectedvirtual

 {
     delete[] minths;
     delete[] maxths;
     delete[] maxps;
     delete[] pkrates;
     delete[] count;
     q_time = 0;
 }

Member Function Documentation

void inet::REDDropper::initialize ( )

overrideprotectedvirtual

Reimplemented from inet::AlgorithmicDropperBase.

 {
     AlgorithmicDropperBase::initialize();
 
     wq = par("wq");
     if (wq < 0.0 || wq > 1.0)
         throw cRuntimeError("Invalid value for wq parameter: %g", wq);
 
     minths = new double[numGates];
     maxths = new double[numGates];
     maxps = new double[numGates];
     pkrates = new double[numGates];
     count = new double[numGates];
 
     cStringTokenizer minthTokens(par("minths"));
     cStringTokenizer maxthTokens(par("maxths"));
     cStringTokenizer maxpTokens(par("maxps"));
     cStringTokenizer pkrateTokens(par("pkrates"));
     for (int i = 0; i < numGates; ++i) {
         minths[i] = minthTokens.hasMoreTokens() ? utils::atod(minthTokens.nextToken()) :
             (i > 0 ? minths[i - 1] : 5.0);
         maxths[i] = maxthTokens.hasMoreTokens() ? utils::atod(maxthTokens.nextToken()) :
             (i > 0 ? maxths[i - 1] : 50.0);
         maxps[i] = maxpTokens.hasMoreTokens() ? utils::atod(maxpTokens.nextToken()) :
             (i > 0 ? maxps[i - 1] : 0.02);
         pkrates[i] = pkrateTokens.hasMoreTokens() ? utils::atod(pkrateTokens.nextToken()) :
             (i > 0 ? pkrates[i-1] : 150);
         count[i] = -1;
 
         if (minths[i] < 0.0)
             throw cRuntimeError("minth parameter must not be negative");
         if (maxths[i] < 0.0)
             throw cRuntimeError("maxth parameter must not be negative");
         if (minths[i] >= maxths[i])
             throw cRuntimeError("minth must be smaller than maxth");
         if (maxps[i] < 0.0 || maxps[i] > 1.0)
             throw cRuntimeError("Invalid value for maxp parameter: %g", maxps[i]);
         if (pkrates[i] < 0.0)
             throw cRuntimeError("Invalid value for pkrates parameter: %g", pkrates[i]);
     }
 }

void inet::REDDropper::sendOut ( cPacket * packet )

overrideprotectedvirtual

Reimplemented from inet::AlgorithmicDropperBase.

 {
     AlgorithmicDropperBase::sendOut(packet);
     // TD: Set the time stamp q_time when the queue gets empty.
     const int queueLength = getLength();
     if (queueLength == 0)
         q_time = simTime();
 }

bool inet::REDDropper::shouldDrop ( cPacket * packet )

overrideprotectedvirtual

Implements inet::AlgorithmicDropperBase.

 {
     const int i = packet->getArrivalGate()->getIndex();
     ASSERT(i >= 0 && i < numGates);
     const double minth = minths[i];
     const double maxth = maxths[i];
     const double maxp = maxps[i];
     const double pkrate = pkrates[i];
     const int queueLength = getLength();
 
     if (queueLength > 0)
     {
         // TD: This following calculation is only useful when the queue is not empty!
         avg = (1 - wq) * avg + wq * queueLength;
     }
     else
     {
         // TD: Added behaviour for empty queue.
         const double m = SIMTIME_DBL(simTime() - q_time) * pkrate;
         avg = pow(1 - wq, m) * avg;
     }
 
     if (minth <= avg && avg < maxth)
     {
         count[i]++;
         const double pb = maxp * (avg - minth) / (maxth - minth);
         const double pa = pb / (1 - count[i] * pb); // TD: Adapted to work as in [Floyd93].
         if (dblrand() < pa)
         {
             EV << "Random early packet drop (avg queue len=" << avg << ", pa=" << pb << ")\n";
             count[i] = 0;
             return true;
         }
     }
     else if (avg >= maxth) {
         EV << "Avg queue len " << avg << " >= maxth, dropping packet.\n";
         count[i] = 0;
         return true;
     }
     else if (queueLength >= maxth) {    // maxth is also the "hard" limit
         EV << "Queue len " << queueLength << " >= maxth, dropping packet.\n";
         count[i] = 0;
         return true;
     }
     else
     {
         count[i] = -1;
     }
 
     return false;
 }