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

Go to the documentation of this file.

/*******************************************************************
 * This file contains:
 *   -the 802_16 frame formats (i.e., headers)
 *   -the map structure
 *   -the upstream flow table structure
 *   -All global enum and #defines needed by the code
 *
 * Revisions:
 *   $A1   :10/2004 : Ack filtering
 *   $A0:  2/17/2005:  Added upstream rate control (Viraj )  
 *   $A1:  3/10/05:  Fixed support of max_concat_thresh
 *   $A2:  Add stat to track avg number IP packets per concat packet
 *   $A3:  Fixed jitter calculation
 *   $A4:  9/13/05: (J. Freitag) sgrant_limit and lgrant_limit are not being used in any function of any class!
 *   $A5:  3/15/06: (J. Freitag) included non-real-time service
 *   $A6:  3/31/06: (J. Freitag) included downlink QoS services  
 *   $A7:  8/29/06: (J. Freitag) QoS parameters (latency and minimum bandwidth) for scheduling services 
 *   $A8:  8/30/06: (J. Freitag) included a new uplink scheduling algorithm
 *   $A9:  9/15/06: (J. Freitag) included incremental bandwidth request
 *   $A10: 11/13/06: (J. Freitag) included aggregate bandwidth request
 *   $A11: 11/22/06: (J. Freitag) replaced u_char mac_param; by u_int16_t mac_param; in 802_16_frame_hdr 
 *                                in order to permit bw requests greater than 255 slots 
 *   $A12: 04/27/07: (J. Freitag) included extended-real-time service
 *   $A13: 08/13/07: (J. Freitag) included the T16 timeout defined in the 802.16 standard. 
 ******************************************************************/
#ifndef ns_hdr_mac802_16_h
#define ns_hdr_mac802_16_h    

#define EPSILON 0.0000000000005

/*===============INCLUDE HEADER FILES====================*/

#include <arp.h>
#include <connector.h>
#include <delay.h>      
#include <ll.h>
#include <mac.h>
#include "mac-802_16-timers.h"
#include <marshall.h>   
#include <packet.h>     
#include <queue.h>
#include <random.h>

/*===============END INCLUDE HEADER FILES====================*/


/*================ENUM & CONSTANT DEFINITIONS================*/

enum SchedType 
  {
    UGS         = 0x0000,
    RT_POLL     = 0x0001,
    ERT_POLL    = 0x0002, //$A12
    NRT_POLL    = 0x0003, //$A5
    BEST_EFFORT = 0x0004
  };

enum PhsType 
  {
    SUPRESS_ALL   = 0x0000,
    SUPRESS_TCPIP = 0x0001,
    SUPRESS_UDPIP = 0x0002,
    SUPRESS_MAC   = 0x0003,
    NO_SUPRESSION = 0x0004
  };

enum EventType 
  {
    PKT_ARRIVAL      = 0x0000,
    MAP_ARRIVAL      = 0x0001,
    SEND_TIMER       = 0x0002,
    REQ_TIMER        = 0x0003,
    SEND_PKT         = 0x0004,
    SEND_UREQ        = 0x0006,
    CONTENTION_ON    = 0x0007,
    CONTENTION_SLOTS = 0x0008,
    CONTENTION_BKOFF = 0x0009,
    UNLOCK_QUEUE     = 0x00010,
//$A0
    PIGGYBACK_REQ  =   0x00011

  };

#define UPSTREAM           0    
#define DOWNSTREAM         1
#define OFF                0
#define ON                 1
#define BROADCAST_SID      1

#define DATA_PKT           0 /* Packet passed from IFQ(Upper layers) */
#define MGMT_PKT           1 /* Packet generated at 802_16 layer */

/* Need to redefine it later */
#define SUPRESS_ALL_SIZE          100
#define SUPRESS_TCPIP_SIZE         40
#define SUPRESS_UDPIP_SIZE         28
#define SUPRESS_MAC_SIZE           28

#define DATA_GRANT                  0
#define UREQ_GRANT                  1
#define CONTENTION_GRANT            2
#define SM_GRANT                    3
#define ETHER_HDR_LEN               ((ETHER_ADDR_LEN << 1) + ETHER_TYPE_LEN)
#define MAC802_16_HDR_LEN           6
#define MAX_NUM_IE                240 /* Max num of IEs in a MAP */
#define MAX_GRANT                 255 /* Max num of mini-slots that 
                                         can be assigned per service-flow */

#define MAX_RETRY                  10
#define SIZE_MGMT_HDR              24
#define SIZE_MAP_HDR                4
#define MANAGEMENT_MSG_PAYLOAD_SIZE 5 /*Size of payload of mgmt msgs */
#define NUM_EXTENDED_HDR_ELEMENTS   2 /* Max num of EH elements in EH */
#define MAX_NUM_DOWNFLOWS_PERSS    10 /* Max num of downstream flows 
                                         a SS can create */

#define MAX_NUM_UPFLOWS_PERSS            10 /* Max num of upstream flows 
                                               a SS can create */
#define NUM_802_16_LANS                   5
#define MAX_NUM_SS_NODES                500 /* Max num of SSs in a mac-domain*/
#define MAX_NUM_RETRIES                  15
#define FRAG_ENABLE_BIT                   8
#define CONCAT_ENABLE_BIT                 7
#define FRAG_ON_BIT                       6
#define CONCAT_ON_BIT                     5
#define PIGGY_ENABLE_BIT                  4
#define NO_PIGGY_BIT                      3
#define PIGGY_NOT_SEND                    2
#define CONCAT_THRESHHOLD                 1
#define QUEUE_THRESHOLD                  25
#define UGSSTATES                         4
#define RTPOLLSTATES                      6
//$A12
#define ERTPOLLSTATES                     5
//$A5
#define NRTPOLLSTATES                     7
//$A0
//#define BEFFORTSTATES                   7
#define BEFFORTSTATES                     8
//$A6
#define DOWNSTATES                        4

#define UGS_IDLE                          0
#define UGS_DECISION                      1
#define UGS_TOSEND                        2
#define UGS_WAITFORMAP                    3
#define RTPOLL_IDLE                       0
#define RTPOLL_DECISION                   1
#define RTPOLL_TOSEND                     2
#define RTPOLL_WAITFORMAP                 3
#define RTPOLL_TOSENDREQ                  4
#define RTPOLL_REQSENT                    5
//$A12
#define ERTPOLL_IDLE                      0
#define ERTPOLL_DECISION                  1
#define ERTPOLL_TOSEND                    2
#define ERTPOLL_WAITFORMAP                3
#define ERTPOLL_TOSENDREQ                 4
//$A5
#define NRTPOLL_IDLE                      0
#define NRTPOLL_DECISION                  1
#define NRTPOLL_TOSEND                    2
#define NRTPOLL_WAITFORMAP                3
#define NRTPOLL_TOSENDREQ                 4
#define NRTPOLL_REQSENT                   5
#define NRTPOLL_CONTENTION                6

#define BEFFORT_IDLE                      0
#define BEFFORT_DECISION                  1
#define BEFFORT_TOSEND                    2
#define BEFFORT_WAITFORMAP                3
#define BEFFORT_TOSENDREQ                 4
#define BEFFORT_REQSENT                   5
#define BEFFORT_CONTENTION                6
//$A0
#define BEFFORT_RATECHECK                 7

//$A6
#define DOWN_IDLE                         0
#define DOWN_DECISION                     1
#define DOWN_TOSEND                       2
#define DOWN_WAITFORMAP                   3

//$A13
#define T16_TIMER                         1 //in seconds

/*================END ENUM  & CONSTANT DEFINITIONS===================== */       


/* ==================================================================          
   FRAME STRUCTURE DECLARATIONS. 
   ==================================================================*/

/*************************************************************************
802_16 header format
*************************************************************************/
struct mac802_16_frame_hdr 
{
  u_char    fc_type    : 2;
  u_char    fc_parm    : 5;
  u_char    ehdr_on    : 1;
  //$A11
  //u_char    mac_param;
  u_int16_t mac_param;          
  u_int16_t len;
};  

/*************************************************************************
802_16 Extended header element
*************************************************************************/
struct mac802_16_extended_header_element 
{
  u_char     eh_type     : 4;
  u_char     eh_len      : 4;
  u_int16_t  eh_data[6];
};

/*=====================END FRAME STRUCTURE DECLARATIONS==================*/


/*===============NEW PACKET HEADERS FOR NS============*/

/*************************************************************************
 802_16 packet header
*************************************************************************/
struct hdr_mac802_16 
{
  struct mac802_16_frame_hdr dshdr_;
  int dt_conv_overhead_; /* Overhead added to
                            802_16 pkt to account 
                            for data convergence layer*/
  
  static int offset_;
  
  inline static int& offset() 
  {
    return offset_;
  }
  
  inline static hdr_mac802_16* access(const Packet * p) 
  {
    return (hdr_mac802_16*) p->access(offset_);
  }    
  
  /* per-field member functions */  
  struct mac802_16_frame_hdr& dshdr() 
  { 
    return dshdr_;
  }
  
  int& dt_conv_overhead() 
  { 
    return dt_conv_overhead_;
  }
};

/*************************************************************************
802_16 extended packet header
*************************************************************************/
struct hdr_mac802_16extd 
{  
  struct mac802_16_extended_header_element exthdr_[NUM_EXTENDED_HDR_ELEMENTS];
  
  int num_hdr;         /* Num of extended headers on */
  static int offset_;
  
  inline static int& offset()   
  { 
    return offset_; 
  }
  
  inline static hdr_mac802_16extd*      access(const Packet * p) 
  {
    return (hdr_mac802_16extd*) p->access(offset_);
  } 
  
  /* per-field member functions */
  inline int& num_hdr_() 
  { 
    return num_hdr;
  }
  
  struct mac802_16_extended_header_element* exthdr() 
  { 
    return exthdr_;
  } 
};

/*************************************************************************
802_16 management packet header
*************************************************************************/
struct hdr_mac802_16mgmt 
{
  int dstaddr;
  int srcaddr;
  u_char msg_payload_[MANAGEMENT_MSG_PAYLOAD_SIZE];
  
  /* 
     The last field will be used to carry          
     either SYNC or RNG or REG msg 
  */
  u_char type; /* To distinguish between MAP & non-MAP messages */

  static int offset_;
  
  inline static int& offset()   
  { 
    return offset_; 
  }
  
  inline static hdr_mac802_16mgmt*      access(const Packet * p) 
  {
    return (hdr_mac802_16mgmt*) p->access(offset_);
  }
  
  /* per-field member functions */
  inline int& dstaddr_() 
  { 
    return dstaddr;
  }
        
  inline int& srcaddr_() 
  { 
    return srcaddr;
  }
        
  inline u_char& type_() 
  { 
    return type;
  }     
};

/*************************************************************************
802_16 map packet header
The information elements will be send in DATA portion of packet
*************************************************************************/
struct hdr_mac802_16map 
{
  double allocstarttime;
  double allocendtime;
  double acktime;
  u_char numIE; 
  u_char bkoff_start;
  u_char bkoff_end;
  
  static int offset_;
 
  inline static int& offset()
  {
    return offset_;
  }
  
  inline static hdr_mac802_16map*       access(const Packet * p) 
  {
    return (hdr_mac802_16map*) p->access(offset_);
  }
  
  /* per-field member functions */
  
  inline double& allocstarttime_()
  {
    return allocstarttime;
  }
  
  inline double& allocendtime_()
  {
    return allocendtime;
  }
  
  inline double& acktime_()   
  {
    return acktime;
  } 
  
  inline u_char& numIE_()   
  {
    return numIE;
  }
  
  inline u_char& bkoff_start_()
  {
    return bkoff_start;
  }
  
  inline u_char& bkoff_end_()      
  {
    return bkoff_end;
  }
};


/*=======================END PACKET HEADER DECLARATIONS================*/


/*========================DATA STRUCTURES DECLARATIONS=================*/

/*=======================Common data structures=========================*/

/************************************************************************/
typedef struct pnode * plist;

struct pnode 
{
  Packet * pkt;
  double enq_time; /* Time at which this pkt was enqued */
  plist next;
};

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

/*************************************************************************
This defines the classifier to be used for matching packets to 
upstream/downstream flows 
*************************************************************************/
struct flow_classifier 
{
  int32_t  src_ip;
  int32_t  dst_ip;
  packet_t pkt_type;
};

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

*************************************************************************/
typedef struct allocation_time * aptr;

struct allocation_time 
{
  double start_time;
  double end_time;
  u_int32_t num_slots;
  aptr next;
  u_char type; /* 0- Data, 1 - Unicast Req, 2- Contention-req */
  u_char used; /* Indicates whether this slot has already been 
                  allocated/used to some one */   
};

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

/*************************************************************************
 This structure defines attributes of downstream service flow of a SS 
*************************************************************************/
struct downstream_flow_record 
{
  struct flow_classifier classifier;

  //$A6
  SchedType sched_type; /* UGS, RT-VBR, NRT-POLL
                             BEST-EFFORT*/
  plist packet_list; /* The bs must have one queue for each QoS service. 
                       Will not be used in SS code */

  u_int16_t max_qsize;       /* variable indicates the maximum
                                queue size */

  u_char state;     /* The current state for this service flow.
                       Will not be used in SS code*/
  Packet* pkt;

  u_char    pending;           /* Denotes whether any data grant 
                                  is pending for this flow */  
  struct allocation_time* alloc_list;

  double ugsjitter;         /* The jitter in the grant, 
                                  valid only for UGS flows */
  int    jitterSamples;
  double last_granttime;    /* Last grant observed at this time
                               (to make sure that we do not use the 
                               same data grant again in the calculation) */
  
  double nominal_alloctime;    /* Grant should have ben allocated at this time */
  double last_jittercaltime;   /* Last time avg jitter was calculated */

  double ginterval;       /* Grant interval for UGS flow */
  
  u_int16_t gsize;        /* Grant size(bytes) for UGS flow */

  //$A7
  double latency;         /*maximum latency requested by the connection*/

  u_int32_t min_bw;       /*minimum bandwidth requested by the connection*/
  
   
  //end $A6

  u_int16_t flow_id; /* Downstream service flow id */
  PhsType PHS_profile; /* PHS to be applied */

  //#ifdef RATE_CONTROL//-------------------------------------------------
  PacketQueue *tokenq_; /* Token bucket queue */
  /* Will not be used in SS code as of now */

  double tokens_;
  double rate_;
  int bucket_;
  int tokenqlen_;
  double lastupdatetime_;
  int init_;
  Event intr;
  char ratecontrol; /* To indicate whether rate-control is ON or not */
  //#endif //-------------------------------------------------------------
  
  /* Per SID stats */
  double util_total_bytes_DS;
  int util_total_pkts_DS;
  int total_pkts_dropped;
  int dropped_tokenq;
  
  double dsq_delay; /* Queuing delay in DS queue */
  int num_qsamples; /* Num of samples used to calculate dsq queuing delay */
  int dropped_dsq;  /* Number of packets dropped in DS queue for this SID */
};

/*************************************************************************
This structure defines attributes of an upstream service flow of a SS node
*************************************************************************/
struct upstream_flow_record 
{
  struct flow_classifier classifier;
  SchedType sched_type; /* UGS, RT-VBR, NRT-POLL
                             BEST-EFFORT*/
  PhsType PHS_profile;    /* PHS to be applied */
  
  double ginterval;       /* Grant interval for UGS flow */
  
  //$A7
  double latency;         /*maximum latency requested by the connection*/

  u_int32_t min_bw;       /*minimum bandwidth requested by the connection*/

  u_int16_t flow_id;      /* Upstream service flow id */
  u_int16_t gsize;        /* Grant size(bytes) for UGS flow */
  u_char flag;
};

/*************************************************************************
 This structure defines all the user-configurable 
paramters for upstream channel
*************************************************************************/
struct upstream_channel 
{
  double data_rate;       /* (bits/sec) */
  double prop_delay;
  u_int32_t max_burst_size;
  u_int32_t overhead_bytes;
  u_char physlots_p_minislot;
};

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

*************************************************************************/
struct  downstream_channel 
{
  double data_rate;       /* (bits/sec) */
  double prop_delay;
  u_int32_t overhead_bytes;
};

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

/*======================= End Common data structures====================*/


/*=========================BS DATA STRUCTURES=========================*/

/*************************************************************************
This structure contains all the information excluding scheduling algorithm 
information   about a SS  at the BS node
*************************************************************************/
struct up_flow_record 
{
  struct flow_classifier classifier;
  Packet* frag_pkt;
  SchedType sched_type;    /* UGS, RT-VBR, BEST-EFFORT*/
  PhsType PHS_profile;     /* PHS to be applied */
  
  double ginterval;        /* Grant interval for UGS flow */
  
  u_int32_t frag_data;
  u_int16_t flow_id;       /* Upstream service flow id */
  u_int16_t gsize;         /* Grant size(bytes) for UGS flow */
  u_int16_t seq_num;       /* The next seq_num for fragmentation*/
  u_char flag;             /* last 4 bit positions are used as
                             flags for concatenation/fragmentation */    
  //$A7
  double latency;          /*maximum latency requested by the connection*/
  u_int32_t min_bw;        /*minimum bandwidth requested by the connection*/
  double last_granttime;   /*for UGS and rt-pool/nrt-pool periodic grants*/
  u_int16_t backlogged;    /*number of slots backlogged for this flow*/
  int16_t granted_bw;      /*number of slots granted for this flow during a time window T*/
};

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

*************************************************************************/
struct ss_record 
{
  struct downstream_flow_record d_rec[MAX_NUM_DOWNFLOWS_PERSS];
  struct up_flow_record         u_rec[MAX_NUM_UPFLOWS_PERSS];
  
  int ss_macaddr;
  u_int16_t priority; /* Priority for best-effort flow */ 
  
  u_char SizeDnFlTable;
  u_char SizeUpFlTable;
  u_char default_upstream_index_;
  u_char default_downstream_index_;
};


/*************************************************************************
 The frequency of generation of management messages 
*************************************************************************/
struct mgmt_conf_param 
{
  double sync_msg_interval;
  double rng_msg_interval;
  double ucd_msg_interval;
};

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

*************************************************************************/
struct map_conf_param 
{
  double time_covered;            /* Time covered by MAP(in ms), 
                                     0 inidcates varying, >0 indicates 
                                     the actual time to be covered by MAP */
  
  double map_interval;            /* Interval between two maps(in s)*/
  
  u_int32_t num_contention_slots; /* Number of contention slots per map */  
  u_int32_t num_sm_slots;         /* Number of station maintainence 
                                     slots per map */  
  //$A4
  //u_int32_t sgrant_limit;         /* Max number of bytes that can be
                                     //sent in short grant IE */  
  //  u_int32_t lgrant_limit;         /* Max number of bytes that can be
                                        // sent in long grant IE */  
  u_char bkoff_start;             /* Initial back-off window for 
                                     contention data and request */
  u_char bkoff_end;               /* Final back-off window for 
                                     contention data and request */
};

/*************************************************************************
This structure contains all the configurable parameters of the BS node
*************************************************************************/
struct bs_conf_param 
{
  struct mgmt_conf_param mgtparam;
  struct map_conf_param mapparam;  
};

/*************************************************************************
Simulation output statistics variable
*************************************************************************/
struct bs_statistics 
{
  double avg_interdpr_map;       /* Avg interdeparture between MAPs*/  
  u_int32_t avg_datagrants;      /* per MAP*/  
  u_int32_t num_req;             /* Number of requests for bandwidth per sec*/ 
  u_int32_t avg_contentionslots; /* Per map*/  
  u_int32_t data_sent;           /* bytes sent per sec*/  
  u_int32_t fragmented_count;    /* Number of fragmented frames received*/  
  u_int32_t concatenation_count; /* Number of concatenated frames received*/  
  u_char num_IE;                 /* per MAP */  
  u_int32_t num_creq;            /* Num of contention request received */
  u_int32_t num_piggyreq;        /* Num of piggy request received */
  u_int32_t num_creqgrant;       /* Num of contention request granted*/
  u_int32_t num_creqdenied;      /* Num of contention request denied*/
  u_int32_t total_num_cslots;    /* Total number of contention slots that 
                                    were assigned over the simulation */
  u_int32_t total_num_mgmtslots; /* Total number of management slots that 
                                    were assigned over the simualtion */  
};

/*************************************************************************
Scheduling algorithm data structures
*************************************************************************/
typedef struct job* jptr;

struct job 
{
  double release_time;       /* The time after which the job can be processed*/
  double period;             /* For periodic jobs*/
  double deadline;           /* Request should be satisfied by this time */
  u_int32_t mini_slots;      /* Number of minislots requested */
  jptr next;                 /* Next job in the queue */
  u_int16_t flow_id;         /* Flow id of requesting SS */
  SchedType sclass;          /* UGS or RT-VBR or BEST-EFFORT */
  u_char type;               /* Type of request, DATA or Unicast req slots */
  u_char flag;               /* To delete or not..*/
  u_char retry_count; 
  double ugsjitter;          /* The jitter in the grant, valid only 
                                for UGS flows */
  //$A3
  int    jitterSamples;
  double last_jittercaltime; /* Last time avg jitter was calculated */
};

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

*************************************************************************/
typedef struct map_list * mapptr;

struct map_list 
{
  double alloc_stime;   /* When can the allocation be started in MAP*/
  double alloc_etime;   /* When can the allocation be ended in MAP*/
  double release_time;  /* The time after which the job can be processed*/
  double deadline;      /* Request should be satisfied by this time */
  u_int32_t nslots;
  mapptr next;
  u_int16_t flow_id;
  u_int16_t  flag;      /* To indicate whether this is hole or not 
                           This is the IUC*/
};

/*************************************************************************
List of token timer requests 
*************************************************************************/
//#ifdef RATE_CONTROL //-------------------------------------------------
typedef struct token_timer_list* tkptr;

struct token_timer_list 
{
  double expiration_time; /*stime + rtime */
  tkptr next;
  int cindex;   /* ssindex of the DownFlowTable for which 
                   Token timer has been set */
  
  int findex;   /* flindex of the DownFlowTable for which 
                   Token timer has been set */
};

/*************************************************************************
Packet queue structure 
*************************************************************************/
typedef struct bsqnode * qlist;

struct bsqnode 
{
  Packet *pkt;
  double enq_time; /* Time at which this pkt was enqued */
  int cindex;
  int findex;
  qlist next;
};
//#endif //--------------------------------------------------------------

/*************************************************************************
 $A6
*************************************************************************/
typedef struct bs_snd_timer_list* bs_sptr;

struct bs_snd_timer_list 
{
  double expiration_time; /* stime + rtime */
  bs_sptr next;
  int cindex; /* index of the SSRecord for which 
                    SEND timer has been set */
  int findex; /*flow index of the SSRecord[tindex].d_rec*/
};

/*************************************************************************
 $A8 - auxiliar struct to compute the priority of the rtPS and nrtPS in
       the intermediate queue
*************************************************************************/
typedef struct active_flows* acflows_ptr;

struct active_flows
{
  acflows_ptr next;          /*Next flow */
  u_int16_t flow_id;         /*Flow id of requesting SS */
  u_int16_t backlogged_tmp;  /*number of slots backlogged for this flow*/
  int16_t granted_bw_tmp;  /*number of slots granted for this flow during a time window T*/
};

/*************************************************************************
 $A8 - auxiliar struct to compute the priority of the rtPS and nrtPS in
       the intermediate queue
*************************************************************************/
struct priority_array
{
  int priority;
  jptr job_pointer;
};

typedef struct priority_array* priority_array_p;

/*=======================END BS data structures=========================*/


/*=======================SS data structures=========================*/

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

*************************************************************************/
typedef struct snd_timer_list* sptr;

struct snd_timer_list 
{
  double expiration_time; /* stime + rtime */
  sptr next;
  u_char tindex; /* index of the UpFlowTable for which 
                    SEND timer has been set */
};

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

*************************************************************************/
typedef struct req_timer_list* rptr;

struct req_timer_list 
{
  double expiration_time; /* stime + rtime */
  rptr next;
  u_char rindex; /* index of the UpFlowTable for which 
                    REQ timer has been set */
};

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

*************************************************************************/
struct upstream_sflow 
{
  struct upstream_flow_record upstream_record;
  struct allocation_time* alloc_list;
  //PacketQueue  *q_;
  plist packet_list;
  u_int16_t max_qsize;       /* variable indicates the maximum
                                queue size */
  Packet* pkt;
  Packet* frag_pkt;
  
  char debug;                /* To debug the flow */
  
  double map_acktime;
  double req_time;           /* Time when a request for 
                                bandwidth has been sent */
  
  double avg_queuing_delay;  /* Avg queuing delay 
                                per packet for this service flow*/
  u_int32_t queuing_samples; /* Num of samples used to compute the 
                                avg queuing delay */
  
  double avg_req_stime;      /* Avg time for
                                a request to be serviced*/
  
  double enque_time;         /* Time at which the packet being sent now 
                                was enqued, used to compute access delay */
  
  u_int32_t  num_delay_samples; /* Num of delay samples, used to 
                                   compute the avg access delay */
  
  u_int32_t curr_gsize;      /* This denotes how much data(in bytes) could be 
                                sent when the SEND timer expires */
  
  u_int32_t num_pkt_snt; /* Number of packets for
                            which request for banwidth
                            has to be sent */
  u_int32_t drop_count;
  
  u_int32_t seq_num;
  u_int32_t frag_data;
  double    last_mfrtime;
  u_int32_t avg_pkts;    /* Avg number of frames
                            sent per sec */
  u_int32_t avg_bytes;   /* Avg number of bytes/s */ 
  u_int32_t num_bytes; 
  u_int32_t num_pkts;  
  
  /* STATISTICS */
  u_int32_t SID_num_sent_bytes; 
  u_int32_t SID_num_sent_pkts;  
  
  u_int32_t avg_slotspermap;     /* Avg number of slots
                                        per map */
  //$A0 : to support ACK filtering....
  u_int32_t totalACKs;         /* Total num of TCP acks that arrived to be sent */
  u_int32_t totalACKsFiltered; /* Total num of TCP acks that were filtered/removed */
  
  u_int32_t total_piggyreq;      /* Total num of piggy req sent */
  u_int32_t total_creq;          /* Total num of contention req sent */
  
  u_int32_t total_fcoll;         /* Total num of first collisions */
  u_int32_t avg_fcont;           /* avg num of slots skipped during first 
                                    contention back-off */
  u_int32_t fcont_count;         /* Number of first contentions done */
  
  u_int32_t total_collision_drops; /* Total number of packets droppeddue to 
                                        transmission attempt exceeding 16 */
  u_int32_t total_queue_drops;     /* Total number of packets dropped due to 
                                        service-flow queue overflow */

  int bs_addr;
  u_int16_t max_concat_threshhold;
  
  u_char state;                /* The current state for this service flow */
  
  u_int32_t bk_offwin;         /* Current bk-off window */
  u_int32_t bk_offcounter; 
  u_int32_t bk_offend; 
  u_int32_t bk_offstart;
  u_char    num_retries;
  u_char    max_retries; 
  u_char    contention_on;     /* (For best-effort flows only), 
                                        Indicates whether a req 
                                        has been sent in contention-slots */ 

  u_char    pending;           /* Denotes whether any data grant 
                                  is pending for this flow */  
  Event intr;
  Event rintr;

  double ugsjitter;         /* The jitter in the grant, 
                                  valid only for UGS flows */
  //$A3
  int    jitterSamples;
  double last_granttime;    /* Last grant observed at this time
                               (to make sure that we do not use the 
                               same data grant again in the calculation) */
  
  double nominal_alloctime;    /* Grant shud have ben allocated at this time */
  double last_jittercaltime;   /* Last time avg jitter was calculated */
//$A0
//#ifdef US_RATE_CONTROL
  double   acceptance_rate;
  double   prev_acceptance_rate;
  float    wt_factor;
  u_int32_t  num_slots_req;
  double     tokens_;
  double     rate_;
  int        bucket_;
  double     lastupdatetime_;
  int        init_;
  char  ratecontrol; /* To indicate whether rate-control is ON or not */
//#endif
  //$A8
  int totalPacketsInConcatFrames;
  int totalConcatFrames;

  //$A9
  int not_requested_pkts; /*To indicate for how many bytes BW was not requested yet*/
  
  //$A10
  u_int16_t aggreqinterval; /*aggregate bw request interval (in number of reqs)*/
  u_int16_t req_counter;    /*request counter used to define when to send aggregate requests*/
  

};

/*************************************************************************
To store the Upstream flow information so that it could be sent to BS 
during the Registration Phase
*************************************************************************/
struct downstream_sflow 
{
  struct downstream_flow_record downstream_record;

};

/*=======================END SS data structures=========================*/

/*======================END DATA STRUCTURES DECLARATIONS==================*/

#endif /* end __hdr_mac802_16_h */

---