ns-2.28/mac/mac-802_16.h

Go to the documentation of this file.

/****************************************************************************
 * This file contains SS and BS class definitions. 
 * Both of these classes are derived from an abstract base class 
 *
 * Revisions:
 *   $A0:  4/2/03:  int byte counters were exceeding the large int...
 *                  change to double
 *   $A1:  6/22/2003:  change int byte counters to doubles
 *   $A2: 7/16/04:  added look_at_queue method so we can examine packets queued
 *                  in the SS.
 *                  And, added filterACKs method to allow ack suppression
 *   $A4: 8/10/04:  Added print_short_map_list 
 *   $A5: 9/18/04:  Added  counter: total_num_mgt_pkts_US
 *   $A6: 9/28/04:  added packetTrace method in bs code
 *   $A7: 2/17/2005: upstream rate control (Viraj)
 *   $A8: 3/6/05:   Support tracking avg number of IP packets per concat frame    
 *   $A9: 3/27/05:  Fixed bug with default upstream flow table index
 *   $A10: 4/7/05:  Added insert_pkt_to_Head() method
 *   $A11: 4/29/05: Added timingsTrace() method to the SS
 *   $A12: 5/3/05:  Add MapPropDelay variable to BS
 *   $A13: 3/15/06: (J. Freitag) included non-real-time service
 *   $A14: 4/03/06: (J. Freitag) included downlink QoS scheduling services
 *   $A15: 8/30/06: (J. Freitag) new uplink scheduling algorithm at the base station
 *   $A16: 4/27/07: (J. Freitag) included extended-real-time service
 *   $A17: 7/10/07: (J. Freitag) included periodic aggregate bandwidth request 
 *   $A18: 7/16/07: (J. Freitag) included the ertPS service in the downlink direction
 *   $A19: 08/13/07: (J. Freitag) excluded the DataGrantPending, since in the 802.16 standard
 *                   the SSs has no knowledge about the pending grants in the BS queues. 
  ***************************************************************************/

#ifndef ns_mac_802_16_h
#define ns_mac_802_16_h

#include "hdr-802_16.h"

/*=======================MACRO & CONSTANT DEFINITIONS=====================*/

#define SET_RX_STATE(x)                 \
  {                                             \
    rx_state_ = (x);                            \
  }
#define SET_TX_STATE(x)                         \
  {                                                     \
    tx_state_ = (x);                                    \
  }

/*========================END MACRO DEFINTIONS=============================*/



/*=======================CLASS DEFINITIONS============================*/

/*=======================Abstract Base class declaration===============*/
class Mac802_16BS;

/*************************************************************************

*************************************************************************/
class Mac802_16 : public Mac 
{
  friend class TxPkt802_16Timer;
  friend class RxPkt802_16Timer;
  
 public:
  /* Timers */
  TxPkt802_16Timer mhTxPkt_ ;
  RxPkt802_16Timer mhRxPkt_ ;
  
  /* 
     Variables to store configurable parameters for channels  
     These variables will be filled-in by calling 
     'command' function from the TCL code
  */    
  
  struct upstream_channel   upchannel;  /* Upstream channel parameters */
  struct downstream_channel downchannel;/* Downstream channel parameters*/
  
  char      collision;       /* Indicate whether collision occured */
  u_int16_t bytes_pminislot; /* Number of bytes per mini-slot */
  u_int32_t minislots_psec;  /* Number of min-slots per second */
  double    size_mslots;     /* In micro-seconds..*/    
  u_int16_t size_ureqgrant;
  
  /* Simulation statistics variables */
  
  u_int32_t avg_pkts;
  u_int32_t avg_bytes;
  u_int32_t num_pkts;  /* Num of packets received per sec */
  
  //$A1
  double num_bytes; /* Num of bytes received per sec */
  
  /*STATISTICS*/
  u_int32_t total_num_sent_pkts; /* total Num of packets sent */
  
  /*
    Note:  need this to be a TracedDouble to access from tcl right ????
  */
  //$A0:  Need to change to a  double to avoid int overrun
  
  double total_num_sent_bytes; /* total Num of bytes received 
                                  used to for BSdown 
                                  used to for SSup */
  
  //$A5
  u_int32_t total_num_mgt_pkts_US; /* total Num of mgt received  */
  u_int32_t total_num_rng_pkts_US; 
  u_int32_t total_num_concat_pkts_US; 
  u_int32_t total_num_frag_pkts_US; 
  u_int32_t total_num_req_pkts_US; 
  u_int32_t total_num_plaindata_pkts_US; 
  u_int32_t total_num_concatdata_pkts_US; 
  u_int32_t total_num_frames_US; 
  u_int32_t total_num_BE_pkts_US; 
  u_int32_t total_num_RTVBR_pkts_US; 
  u_int32_t total_num_UGS_pkts_US; 
  u_int32_t total_num_OTHER_pkts_US; 
  
  u_int32_t total_num_rx_pkts; /* total Num of packets received */
  
  //$A0
  double total_num_rx_bytes; /* total Num of bytes received 
                                used to for BSup 
                                used to for SSdown */
  
  //$A1
  double total_num_BW_bytesUP;   /* total Num of bytes for BW calculation*/
  double total_num_BW_bytesDOWN; /* total Num of bytes for BW calculation*/
  
  double total_num_appbytesUS;   /*total Num app bytes received 
                                   on US w/o 802_16 overhead*/
  
  double total_num_appbytesDS;   /*total Num app bytes forwarded 
                                   on DS w/o 802_16 overhead*/
  
  u_int32_t total_packets_dropped;/* total packets dropped
                                     for bs, this is downstream,
                                     for ss, this is upstream*/
  
  double last_BWCalcTime;            /* Indicates the last time the BW was computed*/
  
  double last_rtime;                 /* Indicates the last time the avg was taken */
  
  u_int32_t avg_mgmtpkts;
  u_int32_t num_mgmtpkts;            /* Num of packets received per sec */
  u_int32_t avg_mgmtbytes;
  u_int32_t num_mgmtbytes;           /* Num of packets received per sec */
  double last_mmgmttime;             /* Indicates the last time the avg
                                        was taken */    

  /* 
     Support for multiple 802_16 lans. The array stores address of each
     bs, so that ss's can use it during the registration 
  */  
  static int lan_num;
  static Mac802_16BS* bs_arr[NUM_802_16_LANS];
  
  /* Internal MAC state */
  MacState rx_state_;   // incoming state (MAC_RECV or MAC_IDLE)
  MacState tx_state_;   // outgoing state
  int tx_active_;
  
  /* Methods */
  Mac802_16();
  virtual ~Mac802_16(){};
  
  virtual void BsUcdHandler(Event *e) {};
  virtual void BsSyncHandler(Event *e) {};
  virtual void BsRngHandler(Event *e) {};
  virtual void BsMapHandler(Event *e) {};
  virtual void SSRngHandler(Event *e) {};
  virtual void SSSndTimerHandler(Event *e) {};
  virtual void SSReqTimerHandler(Event *e) {};
  virtual void RecvFrame(Packet* p,int i) {};
  virtual void BsSendHandler(Event *e) {};
  virtual void BsSndTimerHandler(Event *e) {};
  //$A15
  virtual void BsWindowTimerHandler(Event * e) {};
  
  //#ifdef RATE_CONTROL//-------------------------------------------------
  virtual void BsTokenHandler(Event *e) {};
  //#endif//--------------------------------------------------------------
  
  int command(int argc, const char*const* argv);
  
  /* Timer handler */
  void recvHandler(Event *e);
  void sendHandler(Event *e);
  void recv(Packet* p, Handler *h);
  void configure_upstream();
  void set_bit(u_char*,int,int);
  void dump_pkt(Packet*);
  char ClassifyDataMgmt(Packet*); 
  int is_idle();
  int match(Packet*, struct flow_classifier);
  int bit_on(u_char, int);
  u_int32_t calculate_slots(double,double);
  u_int32_t power(u_int32_t,u_int32_t);
  double TX_Time(Packet *p,int);
  Packet* AllocPkt(int);  

  //$A14
  void insert_alloclist(aptr&,u_int16_t,double,double,u_int16_t,u_int32_t);
  int CanBeSent(aptr&,Packet*,u_int32_t);
  int len_queue(plist);

  //$A16
  int CanErtPSBeSent(aptr&, Packet*);

};
 
/*================= End Abstract Base class declaration===============*/
 

/*=======================BS class declaration=======================*/

/*************************************************************************

*************************************************************************/
class Mac802_16BS : public Mac802_16 
{
  friend class Map802_16Timer;
  friend class BsUcd802_16Timer;
  friend class BsRng802_16Timer;
  friend class BsSync802_16Timer;
  friend class BsTxPkt802_16Timer;
  friend class BsServiceFlowSendTimer;
  
  //#ifdef RATE_CONTROL //-------------------------------------------------
  friend class BsToken802_16Timer;
  //#endif //--------------------------------------------------------------
  
 public:
  struct ss_record *SSRecord; /* All the SSs information will be stored*/
  
  u_int16_t CurrIndexSSTable;
  
  /* Registration function called by SSs before they start*/
  
  int register_to_bs(int macaddr, 
                       u_int16_t priority,
                       u_char def_up,
                       u_char def_dn,
                       struct upstream_sflow *UpEntry,
                       u_char UpSize, 
                       struct downstream_sflow *DownEntry, 
                       u_char DownSize);
  
  int compare_priority(priority_array_p A, priority_array_p B);

  Mac802_16BS();
  ~Mac802_16BS(){};
  
 protected:
  int  command(int argc, const char*const* argv);
  
 private:

  //$A15 - window used to control the provision of the minimum BW requests
  double window_;  

  /* Timer variables */
  Map802_16Timer mhMap_;
  BsRng802_16Timer mhRng_;
  BsUcd802_16Timer mhUcd_;
  BsSync802_16Timer mhSync_;
  BsTxPkt802_16Timer mhBsTxPkt_;
  //$A14
  BsServiceFlowSendTimer mhBsSend_;

  //$A15
  BsUplinkSchedWindowTimer mhWdw_;
  
  //#ifdef RATE_CONTROL//------------------------------------
  BsToken802_16Timer mhToken_;
  tkptr TokenList;
  //#endif//-------------------------------------------------
  
  /* Configuration parameters */
  struct bs_conf_param Conf_Table_;
  u_int16_t SizeSSTable;
  
  /* Simulation statistics variables */
  struct bs_statistics SSStatistics_;
  
  /*$A13 and $A14
  /* Allocation algorithm variables 
  struct job* job_list[10]; /*Uplink: 
                               job_list[0] -> UGS periodic (data), 
                               job_list[1] -> RT-VBR periodic (bw request), 
                               job_list[2] -> NRT-POLL periodic (bw request),
                               job_list[3] -> RT-VBR non periodic (data),
                               job_list[4] -> NRT-POLL non periodic (data), 
                               job_list[5]->  best effort (data), 
                              Downlink:
                               job_list[6] -> UGS periodic (data),     
                               job_list[7] -> RT-VBR non periodic (data), 
                               job_list[8] -> NRT-POLL non periodic (data), 
                               job_list[9] -> best effort (data),
                             */
  //$A15
  /*Now, I'm implementing a new scheduling algorithm just for uplink*/
  struct job* job_list[8]; /*Uplink: queues for the clients' (ss's) requests at the base station (bs)
                              job_list[0] -> high priority queue - reqs must be schedule in the next frame, 
                              job_list[1] -> intermediate queue - RT-POLL and NRT-POLL requests
                              job_list[2] -> low priority queue - best-effort,
                             Downlink: 
                              job_list[3] -> UGS periodic (data),     
                              job_list[4] -> RT-POLL non periodic (data), 
                              job_list[5] -> ERT-POLL non periodic (data)
                              job_list[6] -> NRT-POLL non periodic (data), 
                              job_list[7] -> best effort (data),
                            */
#define UP_HIGH_QUEUE 0
#define UP_INTERM_QUEUE 1
#define UP_LOW_QUEUE 2
#define DOWN_UGS_QUEUE 3
#define DOWN_RT_QUEUE 4
#define DOWN_ERT_QUEUE 5 //$A18
#define DOWN_NRT_QUEUE 6 
#define DOWN_BE_QUEUE 7

  /* MAP variables */
  mapptr mptr;         /* Pointer to the head of MAP list */

  bs_sptr BsSndList; /* Snd timer list header */

  double map_stime;
  double omap_stime;
  double map_etime;
  double omap_etime;

  double map_acktime;
  double AckTime; 
  double max_slots_pmap;
  double next_map;

  int numIE;
  int map_lookahead;
  int MAP_LOOKAHEAD; // Configurable from tcl script
  int max_burst_slots;  
  int rem_overhead;
//$A12 
  int MapPropDelay;
  
  /* Simulation output parameters */
  int size_rtqueue; /*Avg size of rtqueue per sec */
  int avg_szrtqueue;
  double last_mrqtime;

  int size_bfqueue;
  int avg_szbfqueue;
  double last_mbfqtime;
  
  int num_bfreq;
  int avg_bfreq;
  double last_mbfreq;
  
  int num_rtreq;
  int avg_rtreq;
  double last_mrtreq;
  
  double last_dmptime;
  
  u_int32_t num_dgrant;     /* Avg num of data grants per MAP */
  u_int32_t num_contention; /* Avg num of contention grants per MAP */
  u_int32_t num_req;        /* Avg num of Unicast req per MAP */
  u_int32_t num_gpend;      /* Avg num of grant pending per MAP */
  
  u_int32_t avg_dgrant;     /* Avg num of data grants per MAP */
  u_int32_t avg_contention; /* Avg num of contention grants per MAP */
  u_int32_t avg_req;        /* Avg num of Unicast req per MAP */
  u_int32_t avg_gpend;      /* Avg num of grant pending per MAP */
  
  u_int32_t dropped_tokenq; /* total packets dropped at the token 
                               queues of different flows*/
  u_int32_t dropped_dsq;    /* total packets dropped at the DS queue*/
  
  /* Tuning parameters */
  double proportion;        /* To control the proportion of allocation
                               between RT-POLL and Best-effort */

  u_char contention_thrhold;/* Indicates the tolerable threshhold
                               for percentage of collisions in 
                               contention slot.If this threshhold
                               is crossed , then number of 
                               contention-slots will be 
                               increased */
  
  u_char network_status;    /* 0 - underutilized, 1 - overloaded */
  
  u_int32_t rtpoll_ddlinemiss;  /* Number of ddline misses per 
                                   second of RT_POLL data grants */
  
  u_int32_t beffort_ddlinemiss; /* Number of ddline misses per 
                                   second of BEST_EFFORT data grants */
  int32_t num_rtslots;
  //$A13
  int32_t num_nrtslots;
  int32_t num_befslots;
  u_int32_t num_adjust_slots;
  
  Event intr;

  /* Events to be consumed on expiration of management messages*/
  Event uintr; 
  Event sintr;
  Event rintr;
  Event rxintr_; // Event to be consumed when SSMgmt timer expires..
  //$A21 - event to be consimed by the window for minimum bw provision timer
  Event wintr;
  
  static int next_flowid;
  
  /*
    DROP-TAIL
    Note: can also create a REDQueue ....
    Not that simple....
  */
  // PacketQueue * txq_; /* Packet queue for downstream channel */
  
  qlist   txq_; /* Packet queue for downstream channel */
  
  // DropTail * txq_; /* Packet queue for downstream channel */
  // Queue * txq_; /* Packet queue for downstream channel */
  
  int qnp_;                      /* same as len_ */
  int qnb_;                      /* no bytes in queue */
  int max_qnp_;                  /* Max # of pkts observed */
  int max_qnb_;                  /* Max # of bytes observed */
  int min_qnp_;                  /* Min # of pkts  observed */
  int min_qnb_;                  /* Min # of bytes observed */

  int queue_total_bytes_in, queue_total_bytes_out;  /*used for final 
                                                      utilization stats*/
  
  //$A0: switch to doubles
  double util_total_bytes_US;    /* used for final utilization stats*/
  double util_total_bytes_DS;    /* used for final utilization stats*/
  int util_total_pkts_US;        /* used for final utilization stats*/
  int util_total_pkts_DS;        /* used for final utilization stats*/
  
  //$A0
  double util_bytes_US;          /* used by dump802_16UtilStats*/
  double util_bytes_DS;          /* used by dump802_16UtilStats*/
  int  qlim_;                    /* max queue size in packets */
  double lastDumpTime;
  double lastUtilDumpTime;
  
  /* Methods */  
  inline void SSRngHandler(Event * e) {}
  inline void SSSndTimerHandler(Event * e) {}
  inline void SSReqTimerHandler(Event * e) {}
  inline void UnlockQueue() {}

  void BsMapHandler(Event *e);
  void BsSyncHandler(Event * e);
  void BsUcdHandler(Event * e);
  void BsRngHandler(Event * e);

  //$A15  
  void BsWindowTimerHandler(Event * e);

  
  //#ifdef RATE_CONTROL//-------------------------------------
  void RateControl(Packet*, int,int,int);
  double getupdatedtokens(int,int);
  void BsTokenHandler(Event*);
  void insert_tokenlist(double,int,int);
  //#endif//-------------------------------------------------
                
  void sendUp(Packet* p);
  void sendDown(Packet* p);
  void RecvFrame(Packet*,int);
  void PassDownstream(Packet*);
  void HandleInData(Packet*,int,int);
  void HandleInMgmt(Packet*);
  void HandleFrag(Packet*);
  void HandleConcat(Packet*,int,int);
  void ReleaseJobs();
  void fill_job(struct job*,char,char,double,u_int32_t,double,double,u_int16_t);
  void InsertJob(struct job*,int);
  //$A17
  //void HandleReq(u_int16_t,int,int);
  void HandleReq(u_int16_t,int,int,bool);
  void tune_parameters();
  void alloc_bw();
  void delete_joblist(int);
  void PhUnsupress(Packet*,int,int);
  void ApplyPhs(Packet*,int,int );
  void MakeAperiodicAlloc(struct job*,mapptr,int);
  void AllocMemSSrecord();
  void MakePeriodicAllocation(int,mapptr,double);
  void ReOrder(mapptr);
  void MarkOtherSlots(mapptr,u_int32_t,int);
  void jobdrop(mapptr);
  void MarkGrantPending(u_int32_t*,double);
  void SendMap();
  u_int32_t  MarkUnusedSlots(u_int32_t);
  void find_flowindex(u_int16_t,int*,int*);
  void SendFrame(Packet*,int);
  void BsSendHandler(Event *); 
  void dump_stats();
  void ParseExtHdr(Packet *);
  void dumpUGSJITTER(char *);
  void UpdateJitter(int,u_int16_t, double);
  
  //u_char find_size_map();
  
  int find_size_map();
  int NumContSlots(mapptr *);
  int ChkQoSJobs(double,double);
  int  classify(Packet*,char,int*);
  int insert_mapjob(int , jptr , u_int32_t *, int);
  int insert_mapjob(struct job*,u_int32_t*);
  int find_ss(int);
  u_int32_t MarkOtherAlloc(u_int32_t);
  u_int32_t FillMap(int,int,int,int,int); 
  mapptr find_best_hole(u_int32_t);
  mapptr find_next(mapptr);
  mapptr find_prv(mapptr);
  mapptr TryAlloc(double,u_int32_t);
  double determine_deadline(char, int,int);
  double FitMap(mapptr,double);
  double CalculateAckTime();
  
  /* De-bugging functions */
  void print_job_list(int);
  void print_map_list();
  
  //$A4
  void print_short_map_list(Packet* Pkt);
  void delete_maplist();
  void dumpBWBS(char *fileName);
  void dumpFinalBSStats(char *fileName, int DSBW, int USBW);
  void dumpFinalSIDStats(int cindex, int findex,char *fileName, int DSBW);
  void dumpFinalDSSIDS(char *fileName, int DSBW);
  void dump802_16QueueStats(char *fileName, int channelBW);
  void dump802_16UtilStats(char *fileName, int channelDSBW, int channelUSBW);
  
  /* Queue functions */

  //$A10
  void insert_pkt_at_Head(Packet*, int , int);

  int len_mgmtqueue();

  Packet* deque_pkt();
  int packetTrace(Packet *p, int direction);   

  //$A14
  void HandleOutData(Packet*, int, int);

  int down_idle(int, int, EventType, Packet*);
  int down_decision(int, int, EventType, Packet*); 
  int down_tosend(int, int, EventType, Packet*); 
  int down_waitformap(int, int, EventType, Packet*);
  int(Mac802_16BS::*DOWNswitch[DOWNSTATES])(int, int, EventType, Packet*) ;    

  void UpdateAllocationTable(int, int);
  void UpdateJitter(int, int);
  bool insert_pkt(Packet*,int, int);
  double timer_expiration(int, int, Packet*);
  Packet * deque_pkt(int, int);
  void insert_mgmtpkt(Packet*, int, int);
  void insert_sndlist(double, int, int);
  void BsSndTimerHandler(Event * e);
  //end $A14
  //$A15
  void alloc_ul_bw(double, double,u_int32_t);
  void alloc_dl_bw(double, double,u_int32_t);
  void checkDeadline(double, double, u_int32_t&);
  void checkMinimumBW(u_int32_t&, priority_array_p&, int&);
  void MakeAllocation(jptr, int, mapptr,char, int);

  int CanBeSent(aptr&, Packet*);

};

/*========================End BS class declaration====================*/

/*========================SS class declaration==========================*/

/*************************************************************************

*************************************************************************/
class Mac802_16SS : public Mac802_16 
{ 
  friend class SSRng802_16Timer;
  friend class SSServiceFlowSendTimer;
  friend class SSServiceFlowRequestTimer;
  
 public:
  Mac802_16SS();
  ~Mac802_16SS(){};
      
 protected:
  int  command(int argc, const char*const* argv);
 
 private:
  
  RNG* rng_; /* Object for generating random numbers */
    
  /* Timer variables */
  SSRng802_16Timer mhSSRng_;
  SSServiceFlowSendTimer mhSSSend_;
  SSServiceFlowRequestTimer mhReq_; 
  
  Packet* map_;            /* The latest MAP received */
                          
  /* Debug variables */
  char debug_ss;

  u_int32_t ss_id; /* SS id assigned via tcl script */
  
  u_char my_lan;   /* my_lan stores the lan number which 
                      will be used as index on array bs_arr 
                      to obtain pointer to bs object */
  
  u_char SizeUpFlowTable;
  struct upstream_sflow UpFlowTable[MAX_NUM_UPFLOWS_PERSS];
  
  u_char SizeDownFlowTable;
  struct downstream_sflow DownFlowTable[MAX_NUM_DOWNFLOWS_PERSS];
  
  u_char default_upstream_index_;
  u_char default_dstream_index_;

  u_int16_t priority; /* Used for best-effort flows only*/
  double rng_freq;    /* frequency of RNG-REQ msgs*/
  int bs_addr;
  double map_acktime; /*The ack-time in last MAP*/
  u_int32_t total_num_frag;
  u_int32_t total_num_collisions;
  u_int32_t total_num_bkoff;
  
  u_int32_t total_collision_drops; /* Total number of packets dropped due 
                                      to transmission attempt exceeding 16 */

  u_int32_t total_queue_drops;     /* Total number of packets dropped due 
                                      to service-flow queue overflow */
  
  sptr SndList; /* Snd timer list header */
  rptr ReqList; /* Req timer list header */
  //$A7
  rptr tempReqList; 
    
  /* 
     Array of function pointers to 
     implement the state machines 
  */
  int(Mac802_16SS::*UGSswitch[UGSSTATES])(char, EventType, Packet*) ;    
  int(Mac802_16SS::*RTPOLLswitch[RTPOLLSTATES])(char, EventType, Packet*);
  //$A16
  int(Mac802_16SS::*ERTPOLLswitch[ERTPOLLSTATES])(char, EventType, Packet*);
  //$A13
  int(Mac802_16SS::*NRTPOLLswitch[NRTPOLLSTATES])(char, EventType, Packet*);   
  int(Mac802_16SS::*BEFFORTswitch[BEFFORTSTATES])(char, EventType,Packet*);
  
  Event rintr; /* Event to be consumed when SSMgmt timer expires..*/
  
  double last_dmptime;
  
  /* Methods */  
  inline void BsMapHandler(Event * e) {}
  inline void BsSyncHandler(Event * e) {}
  inline void BsUcdHandler(Event * e) {}
  inline void BsRngHandler(Event * e) {}
  inline  void BsSendHandler(Event *e) {};

  //#ifdef RATE_CONTROL //-----------------------------------
  inline void BsTokenHandler(Event *e) {};
  //#endif //------------------------------------------------
  
  void SSRngHandler(Event * e);
  void SSSndTimerHandler(Event * e);
  void SSReqTimerHandler(Event * e);
  void sendUp(Packet* p);
  void sendDown(Packet* p);
  void Initialize_entry(char direction, char index);
  void HandleMap(Packet*);
  void HandleOutData(Packet*, char);
  void SendData(Packet*, char);
//$A7
//  void SendReq(char, Packet*);
  int  SendReq(char, Packet*);
  void decide_frag(Packet*,char);
  void send_frag_data(Packet*,char);
  void fill_extended_header(int, Packet*, char);
  void send_concat(Packet*, char);
  void RecvFrame(Packet*,int);
  void handle_indata(Packet*,char);
  void handle_inmgmt(Packet*,char);
  void SetDefaultFlow();
  void PhUnsupress(Packet*, char);
  void ApplyPhs(Packet*, char);


  void print_alloclist(char);
  
  //$A4
  void print_short_map_list(Packet* Pkt);
  void print_classifiers();
  void dump_stats();
  char classify(Packet*,char);
  int check_concat_req(char);
  int check_frag_req(u_int32_t,char);
  int fill_piggyback_req(char);
  void MarkUsedContentionSlots(int,char);
  void turn_off_contention(char);
  //void back_off(char,Packet*);
  int back_off(char,Packet*);
  void insert_sndlist(double,char);
  void insert_reqlist(double,char);
  void refresh_reqlist(char);

  //$A7
  void reinsert_reqlist(char); 

  void insert_pkt(Packet*,char);
  void UpdateAllocationTable(char);
  void HandleOtherMgmt(Packet*);
  /* $A14 - moved to Mac802_16 class, since it is also used by the bs
    void insert_alloclist(char,u_int16_t,double,double,u_int16_t,u_int32_t); */
  void print_ssalloclist();
  void HandleOutMgmt(Packet*,char);
  void FillPiggyReq(char, Packet*);
//  $A7
//  void FillPiggyExtHdr(char,Packet*, int);
  int FillPiggyExtHdr(char,Packet*, int);
  void UpdateJitter(char);

  /*$A14 - the method was moved to Mac802_16 class
    int CanBeSent(char,Packet*);*/

  int CanBeSent(aptr&, Packet*, char);

  int CanUnicastReqBeSent(char);
  int CanContentionReqBeSent(char);
  int DataGrantPending(char);   
  int MapSentAfterReq(char);
  int NumContentionSlots(char);

  void USRateMeasure(char, Packet*);
  void us_getupdatedtokens(char);

  /*$A14 - moved do Mac802_16 class
    int len_queue(char);*/
  
  //$A2
  int look_at_queue(char);
  int filterACKPackets(Packet *pkt, char tbindex);
  int packetMatch(Packet *pkt1, Packet *pkt2);
  
  double find_contention_slot(char,u_int32_t);
  double timer_expiration(char,Packet*,int);
  Packet * deque_pkt(char);
  Packet* pkt_lookup(char tbindex,int i);
  
  //Statistics
  void dumpBWSS(char *fileName);
  void dumpUGSJITTER(char,char *filename);
  void dumpFinalSSStats(char *fileName);
  void dump802_16QueueStats(char *fileName, int channelBW);
  void dump802_16UtilStats(char *fileName, int channelDSBW, int channelUSBW);   
//$A7
  int reqFlag, reqFlagCounter;
  int packetTrace(Packet *p, int direction);   
  //$A11
  int timingsTrace(Packet *p, int id);


  int ugs_idle(char, EventType, Packet*);
  int ugs_decision(char, EventType, Packet*); 
  int ugs_tosend(char, EventType, Packet*); 
  int ugs_waitformap(char, EventType, Packet*);
  int rtpoll_idle(char, EventType, Packet*);
  int rtpoll_decision(char, EventType, Packet*);
  int rtpoll_tosend(char, EventType, Packet*);
  int rtpoll_waitformap(char, EventType, Packet*);
  int rtpoll_tosendreq(char, EventType, Packet*);
  //$A19 int rtpoll_reqsent(char, EventType, Packet*);

  //A16
  int ertpoll_idle(char, EventType, Packet*);
  int ertpoll_decision(char, EventType, Packet*);
  int ertpoll_tosend(char, EventType, Packet*);
  int ertpoll_waitformap(char, EventType, Packet*);
  int ertpoll_tosendreq(char, EventType, Packet*);
  //$A13
  int nrtpoll_idle(char, EventType, Packet*);
  int nrtpoll_decision(char, EventType, Packet*);
  int nrtpoll_tosend(char, EventType, Packet*);
  int nrtpoll_waitformap(char, EventType, Packet*);
  int nrtpoll_tosendreq(char, EventType, Packet*);
  int nrtpoll_reqsent(char, EventType, Packet*);
  int nrtpoll_contention(char, EventType, Packet*);
  int beffort_idle(char, EventType, Packet*);
  int beffort_decision(char, EventType, Packet*);
  int beffort_tosend(char, EventType, Packet*);
  int beffort_waitformap(char, EventType, Packet*);
  int beffort_tosendreq(char, EventType, Packet*);
  int beffort_reqsent(char, EventType, Packet*);
  int beffort_contention(char, EventType, Packet*);
  //$A7
  int beffort_ratecheck(char, EventType, Packet*);

  //$A16
  void FillErtPSPiggyReq(char, Packet *);
  int  SendErtPSReq(char, Packet*);

};

/*======================== End SS class declaration========================*/

#endif /* __mac_802_16_h__ */

---