netelem.h

#ifndef NETELEM_H
#define NETELEM_H

#include <queue>
#include <map>
#include <vector>
#include <list>
#include <stdio.h>

using namespace std;

#include "distrib.h"
#include "lstat.h"
#include "ev.h"

class Packet;
class NetElement;
class PacketSource;
class PacketSink;
class Server;
class SrcSink;
class Fragmenter;


class NetElement 
{
public:
  unsigned int              GetId(void) const;

  NetElement*      GetTo(unsigned int k) const;

  inline unsigned int GetSizeTo(void) const {
    return tovector_.size();
  };

  virtual void     Send     (timeunits now, Packet* p);

  virtual void     Recv     (timeunits now, Packet* p) = 0;  

  virtual void     Reset     (bool dump=false) = 0;  
  NetElement*      ConnectTo(NetElement* to);  

  virtual void     FragmentDrop (Packet* p);

  virtual ~NetElement(void);    
  static void traceOn(char* filename =0);
  bool IsTraceing(void) const {return namtraceflag;};
  FILE* traceFile(void) const {return fo;}
  void packetTrace(timeunits t, char event, Packet* p);
  static void Transit (timeunits t);

  static void Batch (timeunits tinitial, timeunits lapse, int batches);
  static void resetAll(bool dump=false);

private:
  //Trace-related variables
  static bool namtraceflag;
  static FILE* fo;

  static unsigned int numElements_;
  static list<NetElement*> resetList_;

  unsigned int     id_;
  vector <NetElement*> tovector_;  

protected:

  NetElement (void);
  virtual void     namConnectTrace (void);
};

class Packet {
private:
  static           unsigned long int totalPackets_;
  unsigned long int id_;          
  NetElement*      source_;       
  NetElement*      destination_;  
  unsigned int     bits_;         
  timeunits        timestamp_;    
  unsigned long    datagramid_;  
  unsigned int     totalbits_;   
  unsigned int     currenthop_;  
  
public:
  Packet (NetElement* src, NetElement* dst, 
          unsigned int bits, timeunits stamp, 
          unsigned long datagramid = 0, 
          unsigned int totalbits = 0, 
          unsigned int k = 0);
  virtual ~Packet(void);
  inline timeunits GetStamp(void) const {return timestamp_;};
  unsigned long int         GetPacketId(void) const;
  unsigned int              GetBits (void)    const;
  unsigned int     GetTotalBits (void) const;
  unsigned long    GetDatagramId (void) const;
  NetElement*      GetSrc(void)       const;
  NetElement*      GetDst(void)       const;
  unsigned int     GetPos (void) const;
  void             Jump(void);
  void             SetTotalBits (unsigned int b);
  void             SetBytes (unsigned int B);
  void             SetBits (unsigned int b);
  void             SetDatagramId (unsigned long id);
  void             Stamp(timeunits stamp); 
};

class Timer : public Event {
public:
  typedef void (NetElement::* TimerHandler)(timeunits, Packet*);

  Timer(timeunits t, unsigned int id, 
        NetElement* to, TimerHandler th, 
        Packet* p);
  ~Timer(void);
private:
  void              Handle(void);
  NetElement*       to_;
  TimerHandler      OnExpiry_; //to be called when this timer expires
  Packet*           packet_;   //packet this timer refers to
};
class PacketSource : public NetElement {
private:
  Distrib*          interarrival_; //Burst Inter-arrival time, in timeunits
  Distrib*          size_;         //Packet size, in bits
  LStat             S_interArrival; //Statistics
  vector <NetElement*> route_;
  LStat S_packetDelay_;
  //  virtual void      namConnectTrace (void);
  virtual void      Send  (timeunits now,  Packet *p);
  void              Recv  (timeunits now,  Packet *p);

protected:
  unsigned long int numPackets_;

public:
  PacketSource(Distrib* interarrival, Distrib* service);
  virtual ~PacketSource(void);
  virtual void      Start (timeunits now);
  void              Reset (bool dump=false);
  void              AccumDelay (timeunits t);
  PacketSource*     AddHop (NetElement* ne);
  inline NetElement* GetNextHop (unsigned int index) const {
    if(index<route_.size()) {
      return route_[index];
    }
    else {
      return 0;
    }
  }
};
class PacketSink : public NetElement {
private:
  void              Send  (timeunits now,  Packet *p);
public:
  PacketSink(void);  
  virtual ~PacketSink(void);
  virtual void      Recv  (timeunits now,  Packet *p);
  void              Reset (bool dump=false){};
  void              namConnectTrace(void);
};
class SrcSink : public PacketSink {
private:
  map <unsigned int, unsigned long> srcmap;//source, count
  map <unsigned int, unsigned long> srcfragmentsmap;//source, count
  map <unsigned long, unsigned int> srcfragmentscount;//datagram,bits
  map <unsigned long, unsigned int> srcdroppedscount;//datagram,bits

public:
  SrcSink (void);
  virtual ~SrcSink (void);
  virtual void Recv (timeunits now, Packet *p);
  virtual void FragmentDrop (Packet* p);
  void              Reset (bool dump=false);
};

typedef enum queuediscipline {
  fifo, 
  lifo, 
  sjf   
};
class CmpPacket {
public:
  CmpPacket (queuediscipline discipline = fifo) : discipline_(discipline) {
    // Empty
  }

  inline bool operator() (Packet*& p1, Packet*& p2) const {
    // The return funtion is defined by the discipline used in the constructor
    switch (discipline_){
    case sjf: return p1->GetBits() > p2->GetBits();
    case lifo: return p1->GetStamp() < p2->GetStamp();
    case fifo:
    default: return p1->GetStamp() > p2->GetStamp();
    }
  }

private:
  queuediscipline discipline_; // Keeps the comparison discipline
};
class Server : public NetElement {
public:
  Server  (char* name,           //Identifies the server
           double rBin,          //Server capacity in bits/timeunit
           int qsize=-1,         //Queue size, -1 means infinite
           timeunits delay = 0,  //Additional constant delay 
           //(e.g. propagation delay)
           queuediscipline discipline = fifo,  //Queueing discipline
           unsigned int mtu = 0, // Maximun Tranfer Unit 
           double pebit = 0); // Bit error probability
  virtual ~Server(void);
  void          Send (timeunits now, Packet *p);
  void          Recv (timeunits now, Packet *p);

  void          Reset (bool dump=false);

private:

  char*        name_;
  double       rBin_; //In bits per timeunit
  int maxQ_;   //Max Queue Size, in bits, signed.
  timeunits   delay_; //In timeunits
  unsigned int mtu_; // In bits
  int inSystemPackets_; /* 0  when empty system
                         * 1  when queue empty and 
                         *     packet being served and
                         * >1 when packet being served and
                         *     others waiting
                         * signed, to compare to maxQ_ w/o warnings
                         */

  unsigned long int droppedPackets_;
  double pebit_; 
  
  Unif01 txnError_;

  int inSystemBits_; //output token bucket

  //Packet queue. Packets are sorted according to their timestamp_
  priority_queue <Packet*, vector<Packet*>, CmpPacket>* qPacket_; 
 
  
  LStat         S_serviceTime; //Service Time
  LStat         S_obsNumPackets;//Observed num of pkts in the server
  TStat         T_numPackets;   //Expected num of pkts in the server
  TStat         T_load;        //Server load

  void          DeQueue (timeunits now, Packet *p);
  void          namConnectTrace (void);
};

class Fragmenter : public NetElement {
private:
  unsigned int mtu_; // Maximum Transfer Unit.
  void       namConnectTrace (void);
  void       Send  (timeunits now,  Packet *p);
  void       Recv  (timeunits now,  Packet *p);
public:
  Fragmenter (unsigned int mtu = 0);
  void              Reset (bool dump=false){};

  virtual ~Fragmenter(void);
};



class SourceState {
private:
  Distrib* duration_;       // Duration, in timeunits
  Distrib* interarrival_;   // Trx. rate in this state, in bits/timeunit
  int      samplesize_;     // In bits
  int      sampleCount_;
public:
  SourceState(Distrib* duration, Distrib* interarrival, int samplesize);
  virtual ~SourceState(void);
  int GetSampleSize(void) const;
  timeunits GetDuration(void) const;
  virtual timeunits GetInterarrival(void) const;
  inline void AddToPacketCount (int n) { sampleCount_ += n;}
};


class BiStateSource : public PacketSource {
private:
  int state_;
  timeunits maxDelay_;
  SourceState *s_[2];
  
  timeunits pendingTimeStamp_;
  int pendingBits_;
  int evid_;

  void              Reset (bool dump=false){};
  void              Send(timeunits now,  Packet *p);
public:
  BiStateSource (SourceState* on, SourceState* off, timeunits maxdelay = 0);

  virtual ~BiStateSource(void);
  void Start(timeunits now);
};


class Enveloper : public NetElement {
private:
  unsigned int bitOverhead_;
  void       Send  (timeunits now,  Packet *p);
  void       Recv  (timeunits now,  Packet *p);
  void              Reset (bool dump=false){};
public:
  Enveloper (unsigned int bOh);
  ~Enveloper (void){};
};


class VoIPEnveloper : public Enveloper {
private:
  void              Reset (bool dump=false){};
public:
  VoIPEnveloper (void) : Enveloper(320){};
  ~VoIPEnveloper (void){};
};



class VoiceTraceFileSource : public PacketSource {
private:
  static const int maxEvents_;
  int fd_;
  bool loop_;
  int offset_;
  int nfpp_;
  timeunits tuPerSample_;
  char activeCode_;
  int  activeBitSize_;
  char sidCode_;
  int  sidBitSize_;
  int  position_;
  void Reset(bool dump=false){};
  void Recv(timeunits now, Packet *p){};
  void Send(timeunits now,  Packet *p);
public:
  VoiceTraceFileSource (const char* infile, 
                        bool loop,
                        int offset, 
                        int nfpp, 
                        timeunits tuPerSample,
                        char activeCode, int activeBitSize, 
                        char sidCode, int sidBitSize);
    
  void Start(timeunits now);
  virtual ~VoiceTraceFileSource (void);
};

#endif

---