开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
bsscheduler.cc
资源名称：WiMAX_Protocol_Code.rar　[点击查看]
上传用户：hzie11
上传日期：2013-10-07
资源大小：1487k
文件大小：35k
源码类别：

网络

开发平台：

C/C++

bsscheduler.cc：源码内容
  1. /* This software was developed at the National Institute of Standards and
  2.  * Technology by employees of the Federal Government in the course of
  3.  * their official duties. Pursuant to title 17 Section 105 of the United
  4.  * States Code this software is not subject to copyright protection and
  5.  * is in the public domain.
  6.  * NIST assumes no responsibility whatsoever for its use by other parties,
  7.  * and makes no guarantees, expressed or implied, about its quality,
  8.  * reliability, or any other characteristic.
  9.  * <BR>
  10.  * We would appreciate acknowledgement if the software is used.
  11.  * <BR>
  12.  * NIST ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION AND
  13.  * DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING
  14.  * FROM THE USE OF THIS SOFTWARE.
  15.  * </PRE></P>
  16.  * @author  rouil
  17.  */
  19. #include "bsscheduler.h"
  20. #include "burst.h"
  21. #include "dlburst.h"
  22. #include "ulburst.h"
  23. #include "random.h"
  24. #include "wimaxctrlagent.h"
  26. /**
  27.  * Bridge to TCL for BSScheduler
  28.  */
  29. static class BSSchedulerClass : public TclClass {
  30. public:
  31.   BSSchedulerClass() : TclClass("WimaxScheduler/BS") {}
  32.   TclObject* create(int, const char*const*) {
  33.     return (new BSScheduler());
  34.     
  35.   }
  36. } class_bsscheduler;
  38. /*
  39.  * Create a scheduler
  40.  */
  41. BSScheduler::BSScheduler () : cl_head_(0), cl_tail_(0), ctrlagent_(0)
  42. {
  43.   debug2 ("BSScheduler createdn");
  44.   LIST_INIT (&t17_head_);
  45.   LIST_INIT (&scan_stations_);
  46.   LIST_INIT (&fast_ranging_head_);
  47.   bw_peer_ = NULL;
  48.   bw_node_index_ = 0;
  49.   default_mod_ = OFDM_BPSK_1_2;
  50.   contention_size_ = MIN_CONTENTION_SIZE;
  51.   sendDCD = false;
  52.   dlccc_ = 0;
  53.   sendUCD = false;
  54.   ulccc_ = 0;
  55. }
  56.  
  57. /*
  58.  * Interface with the TCL script
  59.  * @param argc The number of parameter
  60.  * @param argv The list of parameters
  61.  */
  62. int BSScheduler::command(int argc, const char*const* argv)
  63. {
  64.   if (argc == 3) {
  65.     if (strcmp(argv[1], "set-default-modulation") == 0) {
  66.       if (strcmp(argv[2], "OFDM_BPSK_1_2") == 0)
  67. default_mod_ = OFDM_BPSK_1_2;
  68.       else if (strcmp(argv[2], "OFDM_QPSK_1_2") == 0)
  69. default_mod_ = OFDM_QPSK_1_2;
  70.       else if (strcmp(argv[2], "OFDM_QPSK_3_4") == 0)
  71. default_mod_ = OFDM_QPSK_3_4;
  72.       else if (strcmp(argv[2], "OFDM_16QAM_1_2") == 0)
  73. default_mod_ = OFDM_16QAM_1_2;
  74.       else if (strcmp(argv[2], "OFDM_16QAM_3_4") == 0)
  75. default_mod_ = OFDM_16QAM_3_4;
  76.       else if (strcmp(argv[2], "OFDM_64QAM_2_3") == 0)
  77. default_mod_ = OFDM_64QAM_2_3;
  78.       else if (strcmp(argv[2], "OFDM_64QAM_3_4") == 0)
  79. default_mod_ = OFDM_64QAM_3_4;
  80.       else
  81. return TCL_ERROR;
  82.       return TCL_OK;
  83.     }
  84.     else if (strcmp(argv[1], "set-contention-size") == 0) {
  85.       contention_size_ = atoi (argv[2]);
  86.       assert (contention_size_>=0);
  87.       return TCL_OK;
  88.     }
  89.   }
  90.   return TCL_ERROR;
  91. }
  93. /**
  94.  * Initializes the scheduler
  95.  */
  96. void BSScheduler::init ()
  97. {
  98.   WimaxScheduler::init();
  100.   /*print debug information */
  101.   int nbPS = (int) round((mac_->getFrameDuration()/mac_->getPhy()->getPS()));
  102.   debug2 ("duration=%f, PStime=%f, nbPS=%d,Symbol time=%f, %d n",mac_->getFrameDuration(), mac_->getPhy()->getPS(), nbPS, mac_->getPhy()->getSymbolTime (), mac_->getPhy()->getSymbolPS());
  104.   //At initialization, allocate one DL burst 
  105.   //and contention windows
  106.   //1-create one profile to be used for broadcast 
  107.   //  packets (and DL_MAP...)
  108.   Profile *p = map_->getDlSubframe()->addProfile ((int)round((mac_->getPhy()->getFreq()/1000)), default_mod_);
  109.   p->setIUC (DIUC_PROFILE_1);
  110.   map_->getDlSubframe()->getPdu ()->setPreamble (DL_PREAMBLE); //preamble + fch
  111.   //2-add the burst to carry the broadcast message
  112.   DlBurst *b = (DlBurst*) map_->getDlSubframe()->getPdu ()->addBurst (0);
  113.   b->setCid ( BROADCAST_CID );
  114.   b->setIUC (p->getIUC());
  115.   b->setStarttime (0); //after preamble and fch
  116.   b->setDuration (INIT_DL_DURATION); //enough to send DL_MAP...
  117.   b->setPreamble(true); //this is the first burst after preamble
  118.   //3-Add the End of map element
  119.   b = (DlBurst*) map_->getDlSubframe()->getPdu ()->addBurst (1);
  120.   b->setIUC (DIUC_END_OF_MAP);
  121.   b->setStarttime (INIT_DL_DURATION);
  123.   //create uplink 
  124.   //start of UL subframe is after DL and TTG and unit is PS
  125.   int starttime = (INIT_DL_DURATION+DL_PREAMBLE)*mac_->getPhy()->getSymbolPS()+mac_->phymib_.ttg;
  126.   map_->getUlSubframe()->setStarttime (starttime);
  127.   int slotleft = nbPS - starttime - mac_->phymib_.rtg;
  128.   //duration is in unit of ofdm symbols
  129.   int rangingslot = slotleft/2;
  130.   int rangingduration =(int) round(((mac_->getPhy()->getPS()*rangingslot)/mac_->getPhy()->getSymbolTime()));
  131.   int bwduration = (int) round(((mac_->getPhy()->getPS()*(slotleft - rangingslot))/mac_->getPhy()->getSymbolTime()));
  133.   //we open the uplink to initial ranging and bw requests
  134.   //add profile for the ranging burst
  135.   p = map_->getUlSubframe()->addProfile (0, default_mod_);
  136.   p->setIUC (UIUC_INITIAL_RANGING);
  137.   ContentionSlot *slot = map_->getUlSubframe()->getRanging ();
  138.   slot->setSize (getInitRangingopportunity ());
  139.   slot->setBackoff_start (mac_->macmib_.rng_backoff_start);
  140.   slot->setBackoff_stop (mac_->macmib_.rng_backoff_stop);
  141.   //create burst to represent the contention slot
  142.   Burst* b2 = map_->getUlSubframe()->addPhyPdu (0,0)->addBurst (0);
  143.   b2->setIUC (UIUC_INITIAL_RANGING);
  144.   b2->setDuration (rangingduration);
  145.   b2->setStarttime (0); //we put the contention at the begining
  147.   //now the bw request
  148.   //add profile for the bw burst
  149.   p = map_->getUlSubframe()->addProfile (0, default_mod_);
  150.   p->setIUC (UIUC_REQ_REGION_FULL);  
  151.   slot = map_->getUlSubframe()->getBw_req ();
  152.   slot->setSize (getBWopportunity ());
  153.   slot->setBackoff_start (mac_->macmib_.bw_backoff_start);
  154.   slot->setBackoff_stop (mac_->macmib_.rng_backoff_stop);
  155.   b2 = map_->getUlSubframe()->addPhyPdu (1,0)->addBurst (0);
  156.   b2->setIUC (UIUC_REQ_REGION_FULL);
  157.   b2->setDuration (bwduration);
  158.   b2->setStarttime (rangingduration); //start after the ranging slot
  160.   //end of map
  161.   b2 = map_->getUlSubframe()->addPhyPdu (2,0)->addBurst (0);
  162.   b2->setIUC (UIUC_END_OF_MAP);
  163.   b2->setStarttime (rangingduration+bwduration);
  165.   //schedule the first frame by using a random backoff to avoid
  166.   //synchronization between BSs.
  167.   double stime = Random::uniform(0, mac_->getFrameDuration ());
  168.   dl_timer_->sched (stime);
  170.   ul_timer_->sched (stime+starttime*mac_->getPhy()->getPS());
  172.   //also start the DCD and UCD timer
  173.   dcdtimer_ = new WimaxDCDTimer (mac_);
  174.   ucdtimer_ = new WimaxUCDTimer (mac_);
  175.   nbradvtimer_ = new WimaxMobNbrAdvTimer (mac_);
  176.   dcdtimer_->start (mac_->macmib_.dcd_interval);
  177.   ucdtimer_->start (mac_->macmib_.ucd_interval);
  178.   nbradvtimer_->start (mac_->macmib_.nbr_adv_interval+stime);
  179. }
  181. /**
  182.  * Compute and return the bandwidth request opportunity size
  183.  * @return The bandwidth request opportunity size
  184.  */
  185. int BSScheduler::getBWopportunity ()
  186. {
  187.   int nbPS = BW_REQ_PREAMBLE * mac_->getPhy()->getSymbolPS();
  188.   //add PS for carrying header
  189.   nbPS += (int) round((mac_->getPhy()->getTrxTime (HDR_MAC802_16_SIZE, map_->getUlSubframe()->getProfile(UIUC_REQ_REGION_FULL)->getEncoding())/mac_->getPhy()->getPS ()));
  190.   //printf ("BWopportunity size=%dn", nbPS);
  191.   return nbPS;
  192. }
  194. /**
  195.  * Compute and return the initial ranging opportunity size
  196.  * @return The initial ranging opportunity size
  197.  */
  198. int BSScheduler::getInitRangingopportunity ()
  199. {
  200.   int nbPS = INIT_RNG_PREAMBLE * mac_->getPhy()->getSymbolPS();
  201.   //add PS for carrying header
  202.   nbPS += (int) round((mac_->getPhy()->getTrxTime (RNG_REQ_SIZE+HDR_MAC802_16_SIZE, map_->getUlSubframe()->getProfile(UIUC_INITIAL_RANGING)->getEncoding())/mac_->getPhy()->getPS ()));
  203.   //printf ("Init ranging opportunity size=%dn", nbPS);
  204.   return nbPS;  
  205. }
  207. /**
  208.  * Called when a timer expires
  209.  * @param The timer ID
  210.  */
  211. void BSScheduler::expire (timer_id id)
  212. {
  213.   switch (id) {
  214.   case WimaxDCDTimerID:
  215.     sendDCD = true;
  216.     mac_->debug ("At %f in Mac %d DCDtimer expiredn", NOW, mac_->addr());
  217.     dcdtimer_->start (mac_->macmib_.dcd_interval);
  218.     break;
  219.   case WimaxUCDTimerID:
  220.     sendUCD = true;
  221.     mac_->debug ("At %f in Mac %d UCDtimer expiredn", NOW, mac_->addr());
  222.     ucdtimer_->start (mac_->macmib_.ucd_interval);
  223.     break;
  224.   case WimaxMobNbrAdvTimerID:
  225.     send_nbr_adv();
  226.     nbradvtimer_->start (mac_->macmib_.nbr_adv_interval);
  227.     break;
  228.   default:
  229.     mac_->debug ("Warning: unknown timer expired in BSSchedulern");
  230.   }
  231. }
  233. /**
  234.  * Set the control agent
  235.  */
  236. void BSScheduler::setCtrlAgent (WimaxCtrlAgent *agent)
  237. {
  238.   assert (agent);
  239.   ctrlagent_ = agent;
  240. }
  242. /**
  243.  * Process a packet received by the Mac. Only scheduling related packets should be sent here (BW request, UL_MAP...)
  244.  * @param p The packet to process
  245.  */
  246. void BSScheduler::process (Packet * p)
  247. {
  248.   //assert (mac_);
  249.   //debug2 ("BSScheduler received packet to processn");
  251.   assert (mac_ && HDR_CMN(p)->ptype()==PT_MAC);
  252.   debug2 ("BSScheduler received packet to processn");
  253.   
  254.   hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(p);
  255.   gen_mac_header_t header = wimaxHdr->header;
  257.   //check if this is a bandwidth request
  258.   if (header.ht == 1) {
  259.     process_bw_req (p);
  260.     return;
  261.   }
  263.   //we cast to this frame because all management frame start with
  264.   //a type 
  265.   mac802_16_dl_map_frame *frame = (mac802_16_dl_map_frame*) p->accessdata();
  266.   
  267.   switch (frame->type) {
  268.   case MAC_RNG_REQ: 
  269.     process_ranging_req (p);
  270.     break;
  271.   case MAC_REG_REQ: 
  272.     process_reg_req (p);
  273.     break;
  274.   case MAC_MOB_SCN_REQ:
  275.     if (ctrlagent_) 
  276.       ctrlagent_->process_scan_request (p);
  277.     else
  278.       fprintf (stderr, "Warning: no controler to handle scan request in BS %dn", mac_->addr());
  279.     break;
  280.   case MAC_MOB_MSHO_REQ:
  281.     process_msho_req (p);
  282.     break;
  283.   case MAC_MOB_HO_IND:
  284.     process_ho_ind (p);
  285.     break;
  286.   default:
  287.     mac_->debug ("unknown packet in BSn");
  288.   }
  290.   Packet::free (p);
  291. }
  294. /**
  295.  * Return the type of STA this scheduler is good for
  296.  * @return STA_BS
  297.  */
  298. station_type_t BSScheduler::getNodeType ()
  299. {
  300.   return STA_BS;
  301. }
  303. /**
  304.  * Start a new frame
  305.  */
  306. void BSScheduler::start_ulsubframe ()
  307. {
  308.   //mac_->debug ("At %f in Mac %d BS scheduler ulsubframe expiresn", NOW, mac_->addr());
  310.   //change PHY state
  311.   mac_->getPhy()->setMode (OFDM_RECV);  
  313.   //start handler of ulsubframe
  314.   map_->getUlSubframe()->getTimer()->sched (0);
  316.   //reschedule for next frame
  317.   ul_timer_->resched (mac_->getFrameDuration());
  318. }
  320. /**
  321.  * Start a new frame
  322.  */
  323. void BSScheduler::start_dlsubframe ()
  324. {
  325.   debug2 ("At %f in Mac %d BS scheduler dlsubframe expires (frame=%d)n", 
  326.        NOW, mac_->addr(), mac_->frame_number_+1);
  328.   assert (map_);
  330.   Packet *p;
  331.   Burst *b;
  332.   struct hdr_cmn *ch;
  333.   double txtime;
  334.   int txtime_s;
  335.   OFDMPhy *phy = mac_->getPhy();
  337.   //increment frame number
  338.   mac_->frame_number_ ++;
  339.   
  340.   //adjust frame start information
  341.   map_->setStarttime(NOW);
  343.   /* First lets clear the peers we haven't heard of for long time */
  344.   for (PeerNode *pn = mac_->getPeerNode_head() ; pn ; ) {
  345.     PeerNode *tmp = pn->next_entry(); //next elem
  346.     if (isPeerScanning(pn->getPeerNode())) {
  347.       //since a scanning node cannot send data we push the 
  348.       //timeout while it is scanning
  349.       pn->setRxTime(NOW); 
  350.     } else if (NOW-pn->getRxTime()>mac_->macmib_.client_timeout) {
  351.       mac_->debug ("Client timeout for node %dn", pn->getPeerNode());
  352.       mac_->removePeerNode(pn);
  353.     }
  354.     pn = tmp;
  355.   }
  357.   /**** Step one : burst allocation ****/
  358.   int nbPS = (int) round((mac_->getFrameDuration()/phy->getPS()));
  359.   int nbPS_left = nbPS - mac_->phymib_.rtg - mac_->phymib_.ttg;
  360.   int nbSymbols = (int) ((phy->getPS()*nbPS_left)/phy->getSymbolTime());
  361.   int dlduration = INIT_DL_DURATION+DL_PREAMBLE;
  362.   int ulduration = 0;
  363.   debug2 ("Frame: duration=%f, PSduration=%e, symboltime=%e, nbPS=%d, rtg=%d, ttg=%d, PSleft=%d, nbSymbols=%d, ", 
  364.     mac_->getFrameDuration(), phy->getPS(), phy->getSymbolTime(), nbPS, mac_->phymib_.rtg, mac_->phymib_.ttg, nbPS_left, nbSymbols);
  366.   //remove control messages
  367.   nbSymbols -= INIT_DL_DURATION+DL_PREAMBLE;
  368.   
  369.   nbSymbols -=10;
  370.   for (Connection *c = mac_->getCManager()->get_down_connection (); c && nbSymbols>0 ; c=c->next_entry()) {
  371.     if (c->getPeerNode() && !isPeerScanning (c->getPeerNode()->getPeerNode())) {
  372.       int queuesize = c->queueByteLength();
  373.       int tmp = (int) round((phy->getTrxTime (queuesize, map_->getDlSubframe()->getProfile (DIUC_PROFILE_1)->getEncoding())/phy->getSymbolTime()));
  374.       if (tmp < nbSymbols) {
  375. dlduration += tmp;
  376. nbSymbols -= tmp;
  377.       }else{
  378. dlduration +=nbSymbols;
  379. nbSymbols -= nbSymbols;
  380. break;
  381.       }
  382.     }
  383.   }
  384.   nbSymbols +=10;
  386.   map_->getDlSubframe()->getPdu()->getBurst(0)->setDuration (dlduration);
  387.   map_->getUlSubframe()->setStarttime (dlduration*phy->getSymbolPS()+mac_->phymib_.rtg);
  388.   ul_timer_->resched (map_->getUlSubframe()->getStarttime()*mac_->getPhy()->getPS());
  390.   debug2 ("dlduration=%d, ", dlduration);
  391.   //update the END_OF_MAP start time
  392.   b = (DlBurst*) map_->getDlSubframe()->getPdu ()->getBurst (1);
  393.   b->setStarttime (dlduration);  
  395.   while (map_->getUlSubframe()->getNbPdu()>0) {
  396.     PhyPdu *pdu = map_->getUlSubframe()->getPhyPdu(0);
  397.     map_->getUlSubframe()->removePhyPdu(pdu);
  398.     delete (pdu);
  399.   }
  400.   
  401.   int rangingduration = 0;
  402.   int bwduration = 0;
  403.   int pduIndex = 0;
  404.   debug2 ("In Mac %d Nb symbols left before contention =%dn", mac_->addr(), nbSymbols);
  406.   int contentionslots = (int) round((contention_size_*((getBWopportunity()+getInitRangingopportunity())*mac_->getPhy()->getPS()/mac_->getPhy()->getSymbolTime())));
  407.   if (nbSymbols > contentionslots) {
  408.     int starttime, slotleft, rangingslot, bwslot;
  409.     //create uplink 
  410.     //start of UL subframe is after DL and TTG and unit is PS
  411.     starttime = map_->getUlSubframe()->getStarttime();
  412.     slotleft = nbPS - starttime - mac_->phymib_.rtg;
  413.     //if there is at least one peer, then use only contention_size_ symbols, 
  414.     //otherwise use all the bw
  415.     if (mac_->getPeerNode_head() || fast_ranging_head_.lh_first) {
  416.       rangingslot = contention_size_*getInitRangingopportunity();
  417.       bwslot = contention_size_*getBWopportunity();
  418.       nbSymbols -= contentionslots;
  419.       debug2 ("nbSymbols after contention=%dn", nbSymbols);
  420.     }
  421.     else {
  422.       rangingslot = (int) (floor (slotleft/(2.0*getInitRangingopportunity()))*getInitRangingopportunity());
  423.       bwslot = (int) (floor ((slotleft-rangingslot)/getBWopportunity())*getBWopportunity());
  424.       nbSymbols = 0;
  425.     }    
  426.     rangingduration =(int) round(((mac_->getPhy()->getPS()*rangingslot)/mac_->getPhy()->getSymbolTime()));
  427.     bwduration = (int) round (((mac_->getPhy()->getPS()*bwslot)/mac_->getPhy()->getSymbolTime()));
  428.     //we open the uplink to initial ranging and bw requests
  429.     ContentionSlot *slot = map_->getUlSubframe()->getRanging ();
  430.     //create burst to represent the contention slot
  431.     Burst* b2 = map_->getUlSubframe()->addPhyPdu (pduIndex,0)->addBurst (0);
  432.     pduIndex++;
  433.     b2->setIUC (UIUC_INITIAL_RANGING);
  434.     b2->setDuration (rangingduration);
  435.     b2->setStarttime (ulduration); //we put the contention at the begining
  436.     ulduration += rangingduration;
  437.     
  438.     //now the bw request
  439.     slot = map_->getUlSubframe()->getBw_req ();
  440.     b2 = map_->getUlSubframe()->addPhyPdu (pduIndex,0)->addBurst (0);
  441.     pduIndex++;
  442.     b2->setIUC (UIUC_REQ_REGION_FULL);
  443.     b2->setDuration (bwduration);
  444.     b2->setStarttime (ulduration); //start after the ranging slot
  445.     ulduration += bwduration;
  446.   }
  447.   
  448.   //check if there is Fast Ranging allocation to do
  449.   while (fast_ranging_head_.lh_first !=NULL 
  450.  && fast_ranging_head_.lh_first->frame() == mac_->getFrameNumber()) {
  451.     //we need to include a fast ranging allocation
  452.     b = map_->getUlSubframe()->addPhyPdu (pduIndex,0)->addBurst (0);
  453.     pduIndex++;
  454.     int tmp =(int) round(((mac_->getPhy()->getPS()*getInitRangingopportunity())/mac_->getPhy()->getSymbolTime()));    
  455.     b->setIUC (UIUC_EXT_UIUC);
  456.     b->setDuration (tmp);
  457.     b->setStarttime (ulduration); //start after previous slot
  458.     ((UlBurst*)b)->setFastRangingParam (fast_ranging_head_.lh_first->macAddr(), UIUC_INITIAL_RANGING);
  459.     ulduration += tmp;
  460.     mac_->debug ("At %f in Mac %d adding fast ranging for %dn", NOW, mac_->addr(), fast_ranging_head_.lh_first->macAddr());
  461.     fast_ranging_head_.lh_first->remove_entry();
  462.   }
  464.   //get the next node to allocate bw. 
  465.   //PB: the node may have been removed. We need to check that
  466.   PeerNode *peer = mac_->getPeerNode_head();
  467.   PeerNode *start_peer = mac_->getPeerNode_head(); 
  468.   int i=0;
  470.   if (start_peer != NULL) {
  471.     //we have at least one element in the list
  472.     for (peer = mac_->getPeerNode_head(); peer->next_entry() ; peer=peer->next_entry());
  473.     debug2 ("start_peer=%d, peer=%dn", start_peer->getPeerNode(), peer->getPeerNode());
  474.     while (start_peer != peer) {
  475.       if (!isPeerScanning(peer->getPeerNode())) {
  476. debug2 ("peer %d not scanning take itn", peer->getPeerNode());
  477. break; //we found next station
  478.       }
  479.       debug2 ("peer %d scanning move itn", peer->getPeerNode());
  480.       peer->remove_entry();
  481.       mac_->addPeerNode (peer); //we put it at head of the list
  482.       for (peer = mac_->getPeerNode_head(); peer->next_entry() ; peer=peer->next_entry());
  483.     }
  484.   }
  485.   if (peer)
  486.     debug2 ("final pick is %dn", peer->getPeerNode());
  488.   //update variables
  489.   bw_node_index_ = i;
  490.   bw_peer_ = peer;
  491.   
  492.   //the next peer node takes the rest of the bw
  493.   if (nbSymbols > 0 && peer && !isPeerScanning(peer->getPeerNode())) {
  494.     debug2 ("Allocate uplink for STA %dn", peer->getPeerNode());
  495.     peer->remove_entry();
  496.     mac_->addPeerNode (peer); //we put it at head of the list
  497.     //printf ("NbSymbols for node=%dn", nbSymbols);
  498.     //add burst
  499.     Burst *b3 = map_->getUlSubframe()->addPhyPdu (pduIndex,0)->addBurst (0);
  500.     pduIndex++;
  501.     b3->setIUC (UIUC_PROFILE_1);
  502.     b3->setCid (peer->getPrimary()->get_cid());
  503.     b3->setDuration (nbSymbols);
  504.     b3->setStarttime (ulduration); 
  505.     //add profile if not existing
  506.     Profile *p = map_->getUlSubframe()->getProfile (UIUC_PROFILE_1);
  507.     if (p==NULL) {
  508.       p = map_->getUlSubframe()->addProfile (0, default_mod_);
  509.       p->setIUC (UIUC_PROFILE_1);
  510.     }
  511.   }
  512.   
  513.   //end of map
  514.   Burst *b2 = map_->getUlSubframe()->addPhyPdu (pduIndex,0)->addBurst (0);
  515.   pduIndex++;
  516.   b2->setIUC (UIUC_END_OF_MAP);
  517.   b2->setStarttime (rangingduration+bwduration+nbSymbols);
  518.   
  521.   //we need to fill up the outgoing queues
  522.   for (int index = 0 ; index < map_->getDlSubframe()->getPdu ()->getNbBurst() ; index++) {
  523.     b = map_->getDlSubframe()->getPdu ()->getBurst (index);
  524.     int duration = 0; 
  526.     if (b->getIUC()==DIUC_END_OF_MAP) {
  527.       //consistency check..
  528.       assert (index == map_->getDlSubframe()->getPdu ()->getNbBurst()-1);
  529.       break;
  530.     }
  531.     
  532.     //we can get the next one after we check END_OF_MAP
  533.     //b2 = map_->getDlSubframe()->getPdu ()->getBurst (index+1);
  535.     //if this is the first buffer, add DL_MAP...messages
  536.     if (index==0) {
  537.       p = map_->getDL_MAP();
  538.       ch = HDR_CMN(p);
  539.       txtime = phy->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  540.       ch->txtime() = txtime;
  541.       txtime_s = (int) round(txtime/phy->getSymbolTime ()); //in units of symbol 
  542.       assert ((duration+txtime_s) <= b->getDuration());
  543.       b->enqueue(p);      //enqueue into burst
  544.       duration += txtime_s;
  545.       p = map_->getUL_MAP();
  546.       ch = HDR_CMN(p);
  547.       txtime = phy->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  548.       ch->txtime() = txtime;
  549.       txtime_s = (int) round(txtime/phy->getSymbolTime ()); //in units of symbol 
  550.       assert ((duration+txtime_s) <= b->getDuration());
  551.       b->enqueue(p);      //enqueue into burst
  552.       duration += txtime_s;
  554.       if (sendDCD || map_->getDlSubframe()->getCCC()!= dlccc_) {
  555. p = map_->getDCD();
  556. ch = HDR_CMN(p);
  557. txtime = phy->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  558. ch->txtime() = txtime;
  559. txtime_s = (int) round(txtime/phy->getSymbolTime ()); //in units of symbol 
  560. assert ((duration+txtime_s) <= b->getDuration());
  561. b->enqueue(p);      //enqueue into burst
  562. duration += txtime_s;
  563. sendDCD = false;
  564. dlccc_ = map_->getDlSubframe()->getCCC();
  565. //reschedule timer
  566. dcdtimer_->stop();
  567. dcdtimer_->start (mac_->macmib_.dcd_interval);
  568.       }
  569.       
  570.       if (sendUCD || map_->getUlSubframe()->getCCC()!= ulccc_) {
  571. p = map_->getUCD();
  572. ch = HDR_CMN(p);
  573. txtime = phy->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  574. ch->txtime() = txtime;
  575. txtime_s = (int) round(txtime/phy->getSymbolTime ()); //in units of symbol 
  576. assert ((duration+txtime_s) <= b->getDuration());
  577. b->enqueue(p);      //enqueue into burst
  578. duration += txtime_s;
  579. sendUCD = false;
  580. ulccc_ = map_->getUlSubframe()->getCCC();
  581. //reschedule timer
  582. ucdtimer_->stop();
  583. ucdtimer_->start (mac_->macmib_.ucd_interval);
  584.       }
  585.     }
  586.       
  587.     //get the packets from the connection with the same CID
  588.     //Connection *c=mac_->getCManager ()->get_connection (b->getCid());
  589.     int nb_down = 0;
  590.     for (Connection *c = mac_->getCManager()->get_down_connection (); c ; c=c->next_entry()){ nb_down++;}
  591.     Connection **tmp_con = (Connection **) malloc (nb_down*sizeof (Connection *));
  592.     int i=0;
  593.     for (Connection *c = mac_->getCManager()->get_down_connection (); c ; c=c->next_entry()){
  594.       tmp_con[i] = c;
  595.       i++;
  596.     }
  597.     //we randomly pick the connection we'll start serving first
  598.     int start_index = (int) round (Random::uniform(0, nb_down));
  599.     debug2 ("Picked connection %d as firstn", start_index);
  601.     //for (Connection *c = mac_->getCManager()->get_down_connection (); c ; c=c->next_entry()) {
  602.     for (i=0; i < nb_down ; i++) {
  603.       int index = (i+start_index)%nb_down;
  604.       Connection *c=tmp_con[index];
  606.       if (c->getPeerNode() && isPeerScanning (c->getPeerNode()->getPeerNode()))
  607. continue;
  609.       duration = transfer_packets (c, b, duration);
  610.     }
  611.   }
  613.   //change PHY state
  614.   mac_->getPhy()->setMode (OFDM_SEND);
  616.   //start handler of dlsubframe
  617.   map_->getDlSubframe()->getTimer()->sched (0);
  619.   //reschedule for next time (frame duration)
  620.   dl_timer_->resched (mac_->getFrameDuration());  
  621. }
  623. /** Add a new Fast Ranging allocation
  624.  * @param time The time when to allocate data
  625.  * @param macAddr The MN address
  626.  */
  627. void BSScheduler::addNewFastRanging (double time, int macAddr)
  628. {
  629.   //compute the frame where the allocation will be located
  630.   int frame = int ((time-NOW)/mac_->getFrameDuration()) +2 ;
  631.   frame += mac_->getFrameNumber();
  632.   //printf ("Added fast RA for frame %d (current=%d) for time (%f)n", 
  633.   //   frame, mac_->getFrameNumber(), time);
  634.   FastRangingInfo *info= new FastRangingInfo (frame, macAddr);
  635.   info->insert_entry(&fast_ranging_head_);
  636. }
  639. /**** Packet processing methods ****/
  641. /**
  642.  * Process a RNG-REQ message
  643.  * @param p The packet containing the ranging request information
  644.  */
  645. void BSScheduler::process_ranging_req (Packet *p)
  646. {
  647.   UlSubFrame *ulsubframe = map_->getUlSubframe();
  648.   mac802_16_rng_req_frame *req = (mac802_16_rng_req_frame *) p->accessdata();
  650.   if (HDR_MAC802_16(p)->header.cid != INITIAL_RANGING_CID) {
  651.     //process request for DIUC
  652.   } else {
  653.     //here we can make decision to accept the SS or not.
  654.     //for now, accept everybody
  655.     //check if CID already assigned for the SS
  656.     PeerNode *peer = mac_->getPeerNode (req->ss_mac_address);
  657.     if (peer==NULL) {
  658.       mac_->debug ("New peer node requesting ranging (%d)n",req->ss_mac_address);
  659.       //Assign Management CIDs
  660.       Connection *basic = new Connection (CONN_BASIC);
  661.       Connection *upbasic = new Connection (CONN_BASIC, basic->get_cid());
  662.       Connection *primary = new Connection (CONN_PRIMARY);
  663.       Connection *upprimary = new Connection (CONN_PRIMARY, primary->get_cid());
  664.       
  665.       //Create Peer information
  666.       peer = new PeerNode (req->ss_mac_address);
  667.       peer->setBasic (basic);
  668.       peer->setPrimary (primary);
  669.       upbasic->setPeerNode (peer);
  670.       upprimary->setPeerNode (peer);
  671.       mac_->addPeerNode (peer);
  672.       mac_->getCManager()->add_connection (upbasic, true);
  673.       mac_->getCManager()->add_connection (basic, false);
  674.       mac_->getCManager()->add_connection (upprimary, true);
  675.       mac_->getCManager()->add_connection (primary, false);
  676.       //schedule timer in case the node never register
  677.       addtimer17 (req->ss_mac_address);
  679.       //create packet for answers
  680.       Packet *rep = mac_->getPacket ();
  681.       struct hdr_cmn *ch = HDR_CMN(rep);
  682.       rep->allocdata (sizeof (struct mac802_16_rng_rsp_frame));
  683.       mac802_16_rng_rsp_frame *frame = (mac802_16_rng_rsp_frame*) rep->accessdata();
  684.       frame->type = MAC_RNG_RSP;
  685.       frame->uc_id = ulsubframe->getChannelID();
  686.       frame->rng_status = RNG_SUCCESS;
  687.       frame->ss_mac_address = req->ss_mac_address;
  688.       frame->basic_cid = basic->get_cid();
  689.       frame->primary_cid = primary->get_cid();
  690.       ch->size() = RNG_RSP_SIZE;
  691.       //compute transmission time
  692.       Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
  693.       double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  694.       ch->txtime() = txtime;
  695.       //enqueue packet
  696.       mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (rep);
  698.       if (cl_head_==NULL) {
  699. cl_head_ = (new_client_t*)malloc (sizeof (new_client_t));
  700. cl_tail_ = cl_head_;
  701.       } else {
  702. cl_tail_->next = (new_client_t*)malloc (sizeof (new_client_t));
  703. cl_tail_=cl_tail_->next;
  704.       }
  705.       cl_tail_->cid = primary->get_cid();
  706.       cl_tail_->next = NULL;
  708. #ifdef USE_802_21
  709.       mac_->send_link_detected (mac_->addr(), peer->getPeerNode(), 1);
  710. #endif
  712.     } else {
  713.       mac_->debug ("Received ranging for known station (%d)n", req->ss_mac_address);
  714.       //reset invited ranging retries for SS
  715.       //create packet for answers
  716.       Connection *basic = peer->getBasic();
  717.       Connection *primary = peer->getPrimary();
  718.       Packet *rep = mac_->getPacket ();
  719.       struct hdr_cmn *ch = HDR_CMN(rep);
  720.       rep->allocdata (sizeof (struct mac802_16_rng_rsp_frame));
  721.       mac802_16_rng_rsp_frame *frame = (mac802_16_rng_rsp_frame*) rep->accessdata();
  722.       frame->type = MAC_RNG_RSP;
  723.       frame->uc_id = ulsubframe->getChannelID();
  724.       frame->rng_status = RNG_SUCCESS;
  725.       frame->ss_mac_address = req->ss_mac_address;
  726.       frame->basic_cid = basic->get_cid();
  727.       frame->primary_cid = primary->get_cid();
  728.       ch->size() = RNG_RSP_SIZE;
  729.       //compute transmission time
  730.       Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
  731.       double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  732.       ch->txtime() = txtime;
  733.       //enqueue packet
  734.       mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (rep);
  735.     }
  736.   }
  737. }
  739. /**
  740.  * Add a new timer17 in the list. It also performs cleaning of the list
  741.  * @param index The client address
  742.  */
  743. void BSScheduler::addtimer17 (int index)
  744. {
  745.   //clean expired timers
  746.   T17Element *entry;
  747.   for (entry = t17_head_.lh_first; entry ; ) {
  748.     if (entry->paused ()) {
  749.       T17Element *tmp = entry;
  750.       entry = entry->next_entry();
  751.       tmp->remove_entry();
  752.       free (tmp);
  753.     }
  754.     entry = entry->next_entry();
  755.   }
  757.   entry = new T17Element (mac_, index);
  758.   entry->insert_entry (&t17_head_);
  759. }
  760. /**
  761.  * Cancel and remove the timer17 associated with the node
  762.  * @param index The client address
  763.  */
  764. void BSScheduler::removetimer17 (int index)
  765. {
  766.   //clean expired timers
  767.   T17Element *entry;
  768.   for (entry = t17_head_.lh_first; entry ; entry = entry->next_entry()) {
  769.     if (entry->index ()==index) {
  770.       entry->cancel();
  771.       entry->remove_entry();
  772.       delete (entry);
  773.       break;
  774.     }
  775.   }
  776. }
  778. /**
  779.  * Process bandwidth request
  780.  * @param p The request
  781.  */
  782. void BSScheduler::process_bw_req (Packet *p)
  783. { 
  784.   hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(p);
  785.   gen_mac_header_t header = wimaxHdr->header;
  787.   bw_req_header_t *req;
  788.   req = (bw_req_header_t *)&header;
  790.   mac_->debug ("received bandwidth request of %d bytes from %dn", req->br, req->cid); 
  791.   
  792. }
  794. /**
  795.  * Process registration request
  796.  * @param p The request
  797.  */
  798. void BSScheduler::process_reg_req (Packet *req)
  799. { 
  800.   hdr_mac802_16 *wimaxHdr_req = HDR_MAC802_16(req);
  801.   gen_mac_header_t header_req = wimaxHdr_req->header;
  802.   
  803.   mac_->debug ("received registration request from %dn", header_req.cid);
  805.   Packet *p;
  806.   struct hdr_cmn *ch;
  807.   hdr_mac802_16 *wimaxHdr;
  808.   mac802_16_reg_rsp_frame *reg_frame;
  809.   PeerNode *peer;
  811.   //create packet for request
  812.   p = mac_->getPacket ();
  813.   ch = HDR_CMN(p);
  814.   wimaxHdr = HDR_MAC802_16(p);
  815.   p->allocdata (sizeof (struct mac802_16_reg_rsp_frame));
  816.   reg_frame = (mac802_16_reg_rsp_frame*) p->accessdata();
  817.   reg_frame->type = MAC_REG_RSP;
  818.   reg_frame->response = 0; //OK
  819.   peer = mac_->getCManager()->get_connection (header_req.cid, false)->getPeerNode();
  820.   Connection *secondary = peer->getSecondary ();
  821.   if (secondary==NULL) {
  822.     //first time 
  823.     secondary = new Connection (CONN_SECONDARY);
  824.     Connection *upsecondary = new Connection (CONN_SECONDARY, secondary->get_cid());
  825.     mac_->getCManager()->add_connection (upsecondary, true);
  826.     mac_->getCManager()->add_connection (secondary, false);
  827.     peer->setSecondary (secondary);
  828.     upsecondary->setPeerNode (peer);
  829.   }
  830.   reg_frame->sec_mngmt_cid = secondary->get_cid();
  831.   wimaxHdr->header.cid = header_req.cid;
  832.   ch->size() = REG_RSP_SIZE;
  833.   
  834.   //compute transmission time
  835.   Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
  836.   double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  837.   ch->txtime() = txtime;
  838.   //enqueue packet
  839.   mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
  840.   //clear t17 timer for this node
  841.   removetimer17 (peer->getPeerNode());
  843. #ifdef USE_802_21
  844.   mac_->debug ("At %f in Mac %d, send link upn", NOW, mac_->addr());
  845.   mac_->send_link_up (peer->getPeerNode(),mac_->addr());
  846. #endif
  847. }
  849. /**
  850.  * Send a neighbor advertisement message
  851.  */
  852. void BSScheduler::send_nbr_adv ()
  853. {
  854.   mac_->debug ("At %f in BS %d send_nbr_adv (nb_neighbor=%d)n", NOW, mac_->addr(), nbr_db_->getNbNeighbor());
  855.   Packet *p;
  856.   struct hdr_cmn *ch;
  857.   hdr_mac802_16 *wimaxHdr;
  858.   mac802_16_mob_nbr_adv_frame *frame;
  859.   //PeerNode *peer;
  861.   //create packet for request
  862.   p = mac_->getPacket ();
  863.   ch = HDR_CMN(p);
  864.   wimaxHdr = HDR_MAC802_16(p);
  865.   p->allocdata (sizeof (struct mac802_16_mob_nbr_adv_frame));
  866.   frame = (mac802_16_mob_nbr_adv_frame*) p->accessdata();
  867.   frame->type = MAC_MOB_NBR_ADV;
  868.   frame->n_neighbors = nbr_db_->getNbNeighbor();
  869.   frame->skip_opt_field = 0;
  870.   for (int i = 0 ; i < frame->n_neighbors ; i++) {
  871.     frame->nbr_info[i].phy_profile_id.FAindex = 0;
  872.     frame->nbr_info[i].phy_profile_id.bs_eirp = 0;
  873.     frame->nbr_info[i].nbr_bsid= nbr_db_->getNeighbors()[i]->getID();
  874.     frame->nbr_info[i].dcd_included = true;
  875.     memcpy (&(frame->nbr_info[i].dcd_settings), nbr_db_->getNeighbors ()[i]->getDCD(), sizeof(mac802_16_dcd_frame));
  876.     frame->nbr_info[i].ucd_included = true;
  877.     memcpy (&(frame->nbr_info[i].ucd_settings), nbr_db_->getNeighbors ()[i]->getUCD(), sizeof(mac802_16_ucd_frame));
  878.     frame->nbr_info[i].phy_included = false;
  879.   }
  880.   ch->size() = Mac802_16pkt::getMOB_NBR_ADV_size(frame);
  881.   mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
  882.   
  883. }
  885. /** 
  886.  * Finds out if the given station is currently scanning
  887.  * @param nodeid The MS id
  888.  */
  889. bool BSScheduler::isPeerScanning (int nodeid)
  890. {
  891.   ScanningStation *sta;
  892.   for (sta = scan_stations_.lh_first; sta ; sta = sta->next_entry()) {
  893.     if (sta->getNodeId()==nodeid && sta->isScanning(mac_->frame_number_)) {
  894.       //printf ("station %d scanningn", nodeid);
  895.       return true;
  896.     }
  897.   }
  898.   return false;
  899. }
  901. /**
  902.  * Process handover request
  903.  * @param p The request
  904.  */
  905. void BSScheduler::process_msho_req (Packet *req)
  906. {
  907.   hdr_mac802_16 *wimaxHdr_req = HDR_MAC802_16(req);
  908.   gen_mac_header_t header_req = wimaxHdr_req->header;
  909.   mac802_16_mob_msho_req_frame *req_frame = 
  910.     (mac802_16_mob_msho_req_frame*) req->accessdata();
  911.   
  912.   mac_->debug ("At %f in Mac %d received handover request from %dn", NOW, mac_->addr(), header_req.cid);
  914.   //check the BS that has stronger power
  915.   int maxIndex = 0;
  916.   int maxRssi = 0; //max value
  917.   for (int i = 0; i < req_frame->n_new_bs_full ; i++) {
  918.     if (req_frame->bs_full[i].bs_rssi_mean >= maxRssi) {
  919.       maxIndex = i;
  920.       maxRssi = req_frame->bs_full[i].bs_rssi_mean;
  921.     }
  922.   }
  923.   //reply with one recommended BS
  924.   Packet *p;
  925.   struct hdr_cmn *ch;
  926.   hdr_mac802_16 *wimaxHdr;
  927.   mac802_16_mob_bsho_rsp_frame *rsp_frame;
  929.   send_nbr_adv (); //to force update with latest information
  931.   //create packet for request
  932.   p = mac_->getPacket ();
  933.   ch = HDR_CMN(p);
  934.   wimaxHdr = HDR_MAC802_16(p);
  935.   p->allocdata (sizeof (struct mac802_16_mob_bsho_rsp_frame)+sizeof (mac802_16_mob_bsho_rsp_rec));
  936.   rsp_frame = (mac802_16_mob_bsho_rsp_frame*) p->accessdata();
  937.   rsp_frame->type = MAC_MOB_BSHO_RSP;
  938.   
  939.   rsp_frame->mode = 0; //HO request
  940.   rsp_frame->ho_operation_mode = 1; //mandatory handover response
  941.   rsp_frame->n_recommended = 1;
  942.   rsp_frame->resource_retain_flag = 0; //release connection information
  943.   rsp_frame->n_rec[0].neighbor_bsid = req_frame->bs_full[maxIndex].neighbor_bs_index;
  944.   rsp_frame->n_rec[0].ho_process_optimization=0; //no optimization
  946.   ch->size() += Mac802_16pkt::getMOB_BSHO_RSP_size(rsp_frame);
  947.   wimaxHdr->header.cid = header_req.cid;
  948.   mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
  949. }
  950.  
  951. /**
  952.  * Process handover indication
  953.  * @param p The indication
  954.  */
  955. void BSScheduler::process_ho_ind (Packet *p)
  956. {
  957.   hdr_mac802_16 *wimaxHdr_req = HDR_MAC802_16(p);
  958.   gen_mac_header_t header_req = wimaxHdr_req->header;
  959.   //mac802_16_mob_ho_ind_frame *req_frame = 
  960.   //  (mac802_16_mob_ho_ind_frame*) p->accessdata();
  961.   
  962.   mac_->debug ("At %f in Mac %d received handover indication from %dn", NOW, mac_->addr(), header_req.cid);
  963.   
  965. }
  966.  
  967. /**
  968.  * Send a scan response to the MN
  969.  * @param rsp The response from the control
  970.  */
  971. void BSScheduler::send_scan_response (mac802_16_mob_scn_rsp_frame *rsp, int cid)
  972. {
  973.   //create packet for request
  974.   Packet *p = mac_->getPacket ();
  975.   struct hdr_cmn *ch = HDR_CMN(p);
  976.   hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(p);
  977.   p->allocdata (sizeof (struct mac802_16_mob_scn_rsp_frame));
  978.   mac802_16_mob_scn_rsp_frame* rsp_frame = (mac802_16_mob_scn_rsp_frame*) p->accessdata();
  979.   memcpy (rsp_frame, rsp, sizeof (mac802_16_mob_scn_rsp_frame));
  980.   rsp_frame->type = MAC_MOB_SCN_RSP;
  981.   
  982.   wimaxHdr->header.cid = cid;
  983.   ch->size() += Mac802_16pkt::getMOB_SCN_RSP_size(rsp_frame);
  984.   
  985.   //add scanning station to the list
  986.   PeerNode *peer = mac_->getCManager()->get_connection (cid, false)->getPeerNode();
  988.   /* The request is received in frame i, the reply is sent in frame i+1
  989.    * so the frame at which the scanning start is start_frame+2
  990.    */
  991.   ScanningStation *sta = new ScanningStation (peer->getPeerNode(), rsp_frame->scan_duration & 0xFF, 
  992.      rsp_frame->start_frame+mac_->frame_number_+2, 
  993.      rsp_frame->interleaving_interval & 0xFF,
  994.      rsp_frame->scan_iteration & 0xFF);
  995.   sta->insert_entry_head (&scan_stations_);
  997.   //compute transmission time
  998.   Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
  999.   double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  1000.   ch->txtime() = txtime;
  1001.   //enqueue packet
  1002.   mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
  1003. }