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 <rng.h>
#include <packet.h>
#include <module.h>
#include <tclcl.h>
#include <map>
#include <queue>
#include <iostream>
#include <string.h>
#include <cmath>
#include <climits>
#include <algorithm>
 
// 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 void addUpLayerFromTag(int traffic_id, std::string tag);
 
  virtual void addLowLayerFromTag(int traffic_id, 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  */