mac-802_16.h

OPNET 中的Wimax模块, 主要用于wimax 无线网络仿真,以及普通无线网络仿真.

  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==========================*/

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

*************************************************************************/
/*! Mac802_16SS class */
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__ */