uwmulti-traffic-control.h

Go to the documentation of this file.

//
// Copyright (c) 2014 Regents of the SIGNET lab, University of Padova.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. Neither the name of the University of Padova (SIGNET lab) nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#ifndef UWMULTI_TRAFFIC_Control_H
#define UWMULTI_TRAFFIC_Control_H
 
#include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <module.h>
#include <packet.h>
#include <queue>
#include <rng.h>
#include <string.h>
#include <tclcl.h>
 
// DEFINE BEHAVIORS
#define DEFAULT 1
 
struct BufferType {
    enum BufferBehavior {
        DISCARD_INCOMING = 0, // Discard incoming packets
        CIRCULAR // Discard old packets (first packets in the queue)
    };
    uint max_size; 
    BufferBehavior behavior_buff; 
    double send_delay; 
    uint pkts_lost; 
    double last_sched_tx; 
    BufferType(uint size, BufferBehavior behav, double del)
        : max_size(size)
        , behavior_buff(behav)
        , send_delay(del)
        , pkts_lost(0)
        , last_sched_tx(0)
    {
    }
 
    double
    getUpdatedDelay(double time_instant)
    {
        if ((time_instant - last_sched_tx) >= send_delay) {
            last_sched_tx = time_instant;
            return 0; // last_sched_tx - time_instant
        } else {
            last_sched_tx = last_sched_tx + send_delay;
            return std::max(last_sched_tx - time_instant,
                    0.0); // max to avoid problem with double precision
        }
    }
};
 
// DEFINE STATES
 
typedef std::map<int, int> UpTrafficMap; 
typedef std::pair<int, int> BehaviorItem; 
typedef std::map<int, BehaviorItem> BehaviorMap; 
typedef std::map<int, BehaviorMap> DownTrafficMap; 
typedef std::queue<Packet *> Buffer;
typedef std::map<int, Buffer *> DownTrafficBuffer; 
typedef std::map<int, BufferType> BufferTrafficFeature;
 
class UwMultiTrafficControl : public Module
{
 
public:
    UwMultiTrafficControl();
 
    virtual ~UwMultiTrafficControl()
    {
    }
 
    virtual int command(int, const char *const *);
 
    virtual void recv(Packet *p);
 
protected:
    int debug_; 
    UpTrafficMap up_map; 
    DownTrafficMap down_map; 
    DownTrafficBuffer down_buffer; 
    BufferTrafficFeature
            buffer_feature_map; 
    virtual void recvFromUpperLayers(Packet *p);
 
    virtual void manageBuffer(int traffic);
 
    virtual void insertInBuffer(Packet *p, int traffic);
 
    virtual Packet *removeFromBuffer(int traffic);
 
    virtual Packet *getFromBuffer(int traffic);
 
    void inline insertTraffic2UpLayer(int traffic, int upper_layer_id)
    {
        up_map[traffic] = upper_layer_id;
    }
 
    void inline insertTraffic2LowerLayer(int traffic, int lower_layer_stack,
            int lower_layer_id, int behavior)
    {
        down_map[traffic][lower_layer_stack] =
                std::make_pair(lower_layer_id, behavior);
        // std::cout << "down_map(" << traffic << ", " << lower_layer_stack <<
        // ") = " << (down_map[traffic][lower_layer_stack]).first << std::endl;
    }
 
    virtual int getBestLowerLayer(int traffic, Packet *p = NULL);
 
    virtual int getUpperLayer(int traffic);
 
    virtual void eraseTraffic2LowerLayer(int traffic, int lower_layer_stack);
 
    virtual void eraseTraffic2Low(int traffic);
 
    virtual void eraseTraffic2Up(int traffic);
 
    virtual bool addUpLayerFromTag(int traffic_id, const std::string &tag);
 
    virtual bool addLowLayerFromTag(
            int traffic_id, const std::string &tag, int behavior);
 
    void setBufferFeature(int traffic_id, int max_size, bool is_circular,
            double send_down_delay = 0);
 
    virtual void incrPktLoss(int traffic_id);
 
    virtual uint getDiscardedPacket(int traffic_id) const;
 
private:
    // Variables
};
 
#endif /* UWMULTI_TRAFFIC_Control_H  */