bsscheduler.cc

This documentation is based on the following versions:- pre-release of the wimax model developed by

      mac_->addPeerNode (peer);
      mac_->getCManager()->add_connection (upbasic, true);
      mac_->getCManager()->add_connection (basic, false);
      mac_->getCManager()->add_connection (upprimary, true);
      mac_->getCManager()->add_connection (primary, false);
      //schedule timer in case the node never register
      addtimer17 (req->ss_mac_address);

      //create packet for answers
      Packet *rep = mac_->getPacket ();
      struct hdr_cmn *ch = HDR_CMN(rep);
      rep->allocdata (sizeof (struct mac802_16_rng_rsp_frame));
      mac802_16_rng_rsp_frame *frame = (mac802_16_rng_rsp_frame*) rep->accessdata();
      frame->type = MAC_RNG_RSP;
      frame->uc_id = ulsubframe->getChannelID();
      frame->rng_status = RNG_SUCCESS;
      frame->ss_mac_address = req->ss_mac_address;
      frame->basic_cid = basic->get_cid();
      frame->primary_cid = primary->get_cid();
      ch->size() = RNG_RSP_SIZE;
      //compute transmission time
      Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
      double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
      ch->txtime() = txtime;
      //enqueue packet
      mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (rep);

      if (cl_head_==NULL) {
	cl_head_ = (new_client_t*)malloc (sizeof (new_client_t));
	cl_tail_ = cl_head_;
      } else {
	cl_tail_->next = (new_client_t*)malloc (sizeof (new_client_t));
	cl_tail_=cl_tail_->next;
      }
      cl_tail_->cid = primary->get_cid();
      cl_tail_->next = NULL;

#ifdef USE_802_21
      mac_->send_link_detected (mac_->addr(), peer->getPeerNode(), 1);
#endif

    } else {
      mac_->debug ("Received ranging for known station (%d)\n", req->ss_mac_address);
      //reset invited ranging retries for SS
      //create packet for answers
      Connection *basic = peer->getBasic();
      Connection *primary = peer->getPrimary();
      Packet *rep = mac_->getPacket ();
      struct hdr_cmn *ch = HDR_CMN(rep);
      rep->allocdata (sizeof (struct mac802_16_rng_rsp_frame));
      mac802_16_rng_rsp_frame *frame = (mac802_16_rng_rsp_frame*) rep->accessdata();
      frame->type = MAC_RNG_RSP;
      frame->uc_id = ulsubframe->getChannelID();
      frame->rng_status = RNG_SUCCESS;
      frame->ss_mac_address = req->ss_mac_address;
      frame->basic_cid = basic->get_cid();
      frame->primary_cid = primary->get_cid();
      ch->size() = RNG_RSP_SIZE;
      //compute transmission time
      Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
      double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
      ch->txtime() = txtime;
      //enqueue packet
      mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (rep);
    }
  }
}

/**
 * Add a new timer17 in the list. It also performs cleaning of the list
 * @param index The client address
 */
void BSScheduler::addtimer17 (int index)
{
  //clean expired timers
  T17Element *entry;
  for (entry = t17_head_.lh_first; entry ; ) {
    if (entry->paused ()) {
      T17Element *tmp = entry;
      entry = entry->next_entry();
      tmp->remove_entry();
      free (tmp);
    }
    entry = entry->next_entry();
  }

  entry = new T17Element (mac_, index);
  entry->insert_entry (&t17_head_);
}
/**
 * Cancel and remove the timer17 associated with the node
 * @param index The client address
 */
void BSScheduler::removetimer17 (int index)
{
  //clean expired timers
  T17Element *entry;
  for (entry = t17_head_.lh_first; entry ; entry = entry->next_entry()) {
    if (entry->index ()==index) {
      entry->cancel();
      entry->remove_entry();
      delete (entry);
      break;
    }
  }
}

/**
 * Process bandwidth request
 * @param p The request
 */
void BSScheduler::process_bw_req (Packet *p)
{ 
  hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(p);
  gen_mac_header_t header = wimaxHdr->header;

  bw_req_header_t *req;
  req = (bw_req_header_t *)&header;

  mac_->debug ("received bandwidth request of %d bytes from %d\n", req->br, req->cid); 
  
}

/**
 * Process registration request
 * @param p The request
 */
void BSScheduler::process_reg_req (Packet *req)
{ 
  hdr_mac802_16 *wimaxHdr_req = HDR_MAC802_16(req);
  gen_mac_header_t header_req = wimaxHdr_req->header;
  
  mac_->debug ("received registration request from %d\n", header_req.cid);

  Packet *p;
  struct hdr_cmn *ch;
  hdr_mac802_16 *wimaxHdr;
  mac802_16_reg_rsp_frame *reg_frame;
  PeerNode *peer;

  //create packet for request
  p = mac_->getPacket ();
  ch = HDR_CMN(p);
  wimaxHdr = HDR_MAC802_16(p);
  p->allocdata (sizeof (struct mac802_16_reg_rsp_frame));
  reg_frame = (mac802_16_reg_rsp_frame*) p->accessdata();
  reg_frame->type = MAC_REG_RSP;
  reg_frame->response = 0; //OK
  peer = mac_->getCManager()->get_connection (header_req.cid, false)->getPeerNode();
  Connection *secondary = peer->getSecondary ();
  if (secondary==NULL) {
    //first time 
    secondary = new Connection (CONN_SECONDARY);
    Connection *upsecondary = new Connection (CONN_SECONDARY, secondary->get_cid());
    mac_->getCManager()->add_connection (upsecondary, true);
    mac_->getCManager()->add_connection (secondary, false);
    peer->setSecondary (secondary);
    upsecondary->setPeerNode (peer);
  }
  reg_frame->sec_mngmt_cid = secondary->get_cid();
  wimaxHdr->header.cid = header_req.cid;
  ch->size() = REG_RSP_SIZE;
  
  //compute transmission time
  Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
  double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  ch->txtime() = txtime;
  //enqueue packet
  mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
  //clear t17 timer for this node
  removetimer17 (peer->getPeerNode());

#ifdef USE_802_21
  mac_->debug ("At %f in Mac %d, send link up\n", NOW, mac_->addr());
  mac_->send_link_up (peer->getPeerNode(),mac_->addr());
#endif
}

/**
 * Send a neighbor advertisement message
 */
void BSScheduler::send_nbr_adv ()
{
  mac_->debug ("At %f in BS %d send_nbr_adv (nb_neighbor=%d)\n", NOW, mac_->addr(), nbr_db_->getNbNeighbor());
  Packet *p;
  struct hdr_cmn *ch;
  hdr_mac802_16 *wimaxHdr;
  mac802_16_mob_nbr_adv_frame *frame;
  //PeerNode *peer;

  //create packet for request
  p = mac_->getPacket ();
  ch = HDR_CMN(p);
  wimaxHdr = HDR_MAC802_16(p);
  p->allocdata (sizeof (struct mac802_16_mob_nbr_adv_frame));
  frame = (mac802_16_mob_nbr_adv_frame*) p->accessdata();
  frame->type = MAC_MOB_NBR_ADV;
  frame->n_neighbors = nbr_db_->getNbNeighbor();
  frame->skip_opt_field = 0;
  for (int i = 0 ; i < frame->n_neighbors ; i++) {
    frame->nbr_info[i].phy_profile_id.FAindex = 0;
    frame->nbr_info[i].phy_profile_id.bs_eirp = 0;
    frame->nbr_info[i].nbr_bsid= nbr_db_->getNeighbors()[i]->getID();
    frame->nbr_info[i].dcd_included = true;
    memcpy (&(frame->nbr_info[i].dcd_settings), nbr_db_->getNeighbors ()[i]->getDCD(), sizeof(mac802_16_dcd_frame));
    frame->nbr_info[i].ucd_included = true;
    memcpy (&(frame->nbr_info[i].ucd_settings), nbr_db_->getNeighbors ()[i]->getUCD(), sizeof(mac802_16_ucd_frame));
    frame->nbr_info[i].phy_included = false;
  }
  ch->size() = Mac802_16pkt::getMOB_NBR_ADV_size(frame);
  mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
  
}

/** 
 * Finds out if the given station is currently scanning
 * @param nodeid The MS id
 */
bool BSScheduler::isPeerScanning (int nodeid)
{
  ScanningStation *sta;
  for (sta = scan_stations_.lh_first; sta ; sta = sta->next_entry()) {
    if (sta->getNodeId()==nodeid && sta->isScanning(mac_->frame_number_)) {
      //printf ("station %d scanning\n", nodeid);
      return true;
    }
  }
  return false;
}

/**
 * Process handover request
 * @param p The request
 */
void BSScheduler::process_msho_req (Packet *req)
{
  hdr_mac802_16 *wimaxHdr_req = HDR_MAC802_16(req);
  gen_mac_header_t header_req = wimaxHdr_req->header;
  mac802_16_mob_msho_req_frame *req_frame = 
    (mac802_16_mob_msho_req_frame*) req->accessdata();
  
  mac_->debug ("At %f in Mac %d received handover request from %d\n", NOW, mac_->addr(), header_req.cid);

  //check the BS that has stronger power
  int maxIndex = 0;
  int maxRssi = 0; //max value
  for (int i = 0; i < req_frame->n_new_bs_full ; i++) {
    if (req_frame->bs_full[i].bs_rssi_mean >= maxRssi) {
      maxIndex = i;
      maxRssi = req_frame->bs_full[i].bs_rssi_mean;
    }
  }
  //reply with one recommended BS
  Packet *p;
  struct hdr_cmn *ch;
  hdr_mac802_16 *wimaxHdr;
  mac802_16_mob_bsho_rsp_frame *rsp_frame;

  send_nbr_adv (); //to force update with latest information

  //create packet for request
  p = mac_->getPacket ();
  ch = HDR_CMN(p);
  wimaxHdr = HDR_MAC802_16(p);
  p->allocdata (sizeof (struct mac802_16_mob_bsho_rsp_frame)+sizeof (mac802_16_mob_bsho_rsp_rec));
  rsp_frame = (mac802_16_mob_bsho_rsp_frame*) p->accessdata();
  rsp_frame->type = MAC_MOB_BSHO_RSP;
  
  rsp_frame->mode = 0; //HO request
  rsp_frame->ho_operation_mode = 1; //mandatory handover response
  rsp_frame->n_recommended = 1;
  rsp_frame->resource_retain_flag = 0; //release connection information
  rsp_frame->n_rec[0].neighbor_bsid = req_frame->bs_full[maxIndex].neighbor_bs_index;
  rsp_frame->n_rec[0].ho_process_optimization=0; //no optimization

  ch->size() += Mac802_16pkt::getMOB_BSHO_RSP_size(rsp_frame);
  wimaxHdr->header.cid = header_req.cid;
  mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
}
 
/**
 * Process handover indication
 * @param p The indication
 */
void BSScheduler::process_ho_ind (Packet *p)
{
  hdr_mac802_16 *wimaxHdr_req = HDR_MAC802_16(p);
  gen_mac_header_t header_req = wimaxHdr_req->header;
  //mac802_16_mob_ho_ind_frame *req_frame = 
  //  (mac802_16_mob_ho_ind_frame*) p->accessdata();
  
  mac_->debug ("At %f in Mac %d received handover indication from %d\n", NOW, mac_->addr(), header_req.cid);
  

}
 
/**
 * Send a scan response to the MN
 * @param rsp The response from the control
 */
void BSScheduler::send_scan_response (mac802_16_mob_scn_rsp_frame *rsp, int cid)
{
  //create packet for request
  Packet *p = mac_->getPacket ();
  struct hdr_cmn *ch = HDR_CMN(p);
  hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(p);
  p->allocdata (sizeof (struct mac802_16_mob_scn_rsp_frame));
  mac802_16_mob_scn_rsp_frame* rsp_frame = (mac802_16_mob_scn_rsp_frame*) p->accessdata();
  memcpy (rsp_frame, rsp, sizeof (mac802_16_mob_scn_rsp_frame));
  rsp_frame->type = MAC_MOB_SCN_RSP;
  
  wimaxHdr->header.cid = cid;
  ch->size() += Mac802_16pkt::getMOB_SCN_RSP_size(rsp_frame);
  
  //add scanning station to the list
  PeerNode *peer = mac_->getCManager()->get_connection (cid, false)->getPeerNode();

  /* The request is received in frame i, the reply is sent in frame i+1
   * so the frame at which the scanning start is start_frame+2
   */
  ScanningStation *sta = new ScanningStation (peer->getPeerNode(), rsp_frame->scan_duration & 0xFF, 
					     rsp_frame->start_frame+mac_->frame_number_+2, 
					     rsp_frame->interleaving_interval & 0xFF,
					     rsp_frame->scan_iteration & 0xFF);
  sta->insert_entry_head (&scan_stations_);

  //compute transmission time
  Burst *b = map_->getDlSubframe()->getPdu ()->getBurst (0);
  double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getDlSubframe()->getProfile (b->getIUC())->getEncoding());
  ch->txtime() = txtime;
  //enqueue packet
  mac_->getCManager()->get_connection (BROADCAST_CID, false)->enqueue (p);
}