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

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

网络

开发平台：

C/C++

mac802_16.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 "mac802_16.h"
  20. #include "scheduling/wimaxscheduler.h"
  21. #include "scheduling/ssscheduler.h" //TBR
  22. //we use mac 802_11 for trace
  23. #include "mac-802_11.h"
  25. /* Defines frequencies for 3.5 GHz band and 7 Mhz freqency bandwidth */
  26. /* Will be removed when a dynamic way is added */
  27. static const int nbFreq = 5;
  28. static const double frequencies[] = { 3.486e+9, 3.493e+9, 3.5e+9, 3.507e+9, 3.514e+9};
  31. int hdr_mac802_16::offset_;
  32. /**
  33.  * TCL Hooks for the simulator for wimax packets
  34.  */
  35. static class Mac802_16HeaderClass : public PacketHeaderClass
  36. {
  37. public:
  38. Mac802_16HeaderClass() : PacketHeaderClass("PacketHeader/802_16",
  39.      sizeof(hdr_mac802_16))
  40. {
  41. bind_offset(&hdr_mac802_16::offset_);
  42. }
  43. } class_hdr_mac802_16;
  45. /**
  46.  * TCL Hooks for the simulator for wimax mac
  47.  */
  48. static class Mac802_16Class : public TclClass {
  49. public:
  50.   Mac802_16Class() : TclClass("Mac/802_16") {}
  51.   TclObject* create(int, const char*const*) {
  52.     return (new Mac802_16());
  53.     
  54.   }
  55. } class_mac802_16;
  57. Phy802_16MIB::Phy802_16MIB(Mac802_16 *parent)
  58. {
  59.   parent->bind ("channel_", &channel );
  60.   parent->bind ("fbandwidth_", &fbandwidth );
  61.   parent->bind ("ttg_", &ttg );
  62.   parent->bind ("rtg_", &rtg );
  63. }
  65. Mac802_16MIB::Mac802_16MIB(Mac802_16 *parent)
  66. {
  67.   parent->bind ("queue_length_", &queue_length );
  68.   parent->bind ("frame_duration_", &frame_duration );
  69.   parent->bind ("dcd_interval_", &dcd_interval );
  70.   parent->bind ("ucd_interval_", &ucd_interval );
  71.   parent->bind ("init_rng_interval_", &init_rng_interval );
  72.   parent->bind ("lost_dlmap_interval_", &lost_dlmap_interval );
  73.   parent->bind ("lost_ulmap_interval_", &lost_ulmap_interval );
  74.   parent->bind ("t1_timeout_", &t1_timeout );
  75.   parent->bind ("t2_timeout_", &t2_timeout );
  76.   parent->bind ("t3_timeout_", &t3_timeout );
  77.   parent->bind ("t6_timeout_", &t6_timeout );
  78.   parent->bind ("t12_timeout_", &t12_timeout );
  79.   parent->bind ("t16_timeout_", &t16_timeout );
  80.   parent->bind ("t17_timeout_", &t17_timeout );
  81.   parent->bind ("t21_timeout_", &t21_timeout );
  82.   parent->bind ("contention_rng_retry_", &contention_rng_retry );
  83.   parent->bind ("invited_rng_retry_", &invited_rng_retry );
  84.   parent->bind ("request_retry_", &request_retry );
  85.   parent->bind ("reg_req_retry_", &reg_req_retry );
  86.   parent->bind ("tproc_", &tproc );
  87.   parent->bind ("dsx_req_retry_", &dsx_req_retry );
  88.   parent->bind ("dsx_rsp_retry_", &dsx_rsp_retry );
  90.   parent->bind ("rng_backoff_start_", &rng_backoff_start);
  91.   parent->bind ("rng_backoff_stop_", &rng_backoff_stop);
  92.   parent->bind ("bw_backoff_start_", &bw_backoff_start);
  93.   parent->bind ("bw_backoff_stop_", &bw_backoff_stop);
  94.  
  95.   //mobility extension
  96.   parent->bind ("scan_duration_", &scan_duration );
  97.   parent->bind ("interleaving_interval_", &interleaving );
  98.   parent->bind ("scan_iteration_", &scan_iteration );
  99.   parent->bind ("t44_timeout_", &t44_timeout );
  100.   parent->bind ("max_dir_scan_time_", &max_dir_scan_time );
  101.   parent->bind ("nbr_adv_interval_", &nbr_adv_interval );
  102.   parent->bind ("scan_req_retry_", &scan_req_retry );
  104.   parent->bind ("client_timeout_", &client_timeout );
  105.   parent->bind ("rxp_avg_alpha_", &rxp_avg_alpha);
  106.   parent->bind ("lgd_factor_", &lgd_factor_);
  107. }
  109. /**
  110.  * Creates a Mac 802.16
  111.  */
  112. Mac802_16::Mac802_16() : Mac (), macmib_(this), phymib_(this), rxTimer_(this)
  113. {
  114.   //init variable
  115.   LIST_INIT(&classifier_list_);
  116.   peer_list_ = (struct peerNode *) malloc (sizeof(struct peerNode));
  117.   LIST_INIT(peer_list_);
  118.   
  119.   collision_ = false;
  120.   pktRx_ = NULL;
  121.   pktBuf_ = NULL;
  123.   connectionManager_ = new ConnectionManager (this);
  124.   scheduler_ = NULL;
  125.   /* the following will be replaced by dynamic adding of service flow */
  126.   serviceFlowHandler_ = new ServiceFlowHandler ();
  127.   serviceFlowHandler_->setMac (this);
  128.   bs_id_ = BS_NOT_CONNECTED;
  129.   type_ = STA_UNKNOWN;
  130.   frame_number_ = 0;
  131.   state_ = MAC802_16_DISCONNECTED;
  132.   notify_upper_ = true;
  134.   last_tx_time_ = 0;
  135.   last_tx_duration_ = 0;
  137.   Tcl& tcl = Tcl::instance();
  138.   tcl.evalf ("Phy/WirelessPhy set RXThresh_");
  139.   macmib_.RXThreshold_ = atof (tcl.result());
  142.   /* Initialize Stats variables */
  143.   bind_bool ("print_stats_", &print_stats_);
  144.   last_tx_delay_ = 0;
  145.   double tmp;
  146.   bind ("delay_avg_alpha_", &tmp);
  147.   delay_watch_.set_alpha(tmp);
  148.   bind ("jitter_avg_alpha_", &tmp);
  149.   jitter_watch_.set_alpha(tmp);
  150.   bind ("loss_avg_alpha_", &tmp);
  151.   loss_watch_.set_alpha(tmp);
  152.   bind ("throughput_avg_alpha_", &tmp);
  153.   rx_data_watch_.set_alpha(tmp);
  154.   rx_data_watch_.set_pos_gradient (false);
  155.   rx_traffic_watch_.set_alpha(tmp);
  156.   rx_traffic_watch_.set_pos_gradient (false);
  157.   tx_data_watch_.set_alpha(tmp);
  158.   tx_data_watch_.set_pos_gradient (false);
  159.   tx_traffic_watch_.set_alpha(tmp);
  160.   tx_traffic_watch_.set_pos_gradient (false);
  161.   bind ("throughput_delay_", &tmp);
  162.   rx_data_watch_.set_delay (tmp);
  163.   rx_traffic_watch_.set_delay (tmp);
  164.   tx_data_watch_.set_delay (tmp);
  165.   tx_traffic_watch_.set_delay (tmp);
  166.   //timers for stats
  167.   rx_data_timer_ = new StatTimer (this, &rx_data_watch_);
  168.   rx_traffic_timer_ = new StatTimer (this, &rx_traffic_watch_);
  169.   tx_data_timer_ = new StatTimer (this, &tx_data_watch_);
  170.   tx_traffic_timer_ = new StatTimer (this, &tx_traffic_watch_);
  172. }
  174. /*
  175.  * Interface with the TCL script
  176.  * @param argc The number of parameter
  177.  * @param argv The list of parameters
  178.  */
  179. int Mac802_16::command(int argc, const char*const* argv)
  180. {
  181.   if (argc == 2) {
  182.     if (strcmp(argv[1], "dump-classifiers") == 0) {
  183.       for (SDUClassifier *n=classifier_list_.lh_first;n;n=n->next_entry()) {
  184. //printf ("Classifier %x priority=%dn", (int)n, n->getPriority());
  185.       }
  186.       return TCL_OK;
  187.     }
  188.   }
  189.   else if (argc == 3) {
  190.     /*
  191.     if (strcmp(argv[1], "set-bs") == 0) {
  192.       bs_id_ = atoi (argv[2]);
  193.     }
  194.     else*/
  195.     if (strcmp(argv[1], "add-classifier") == 0) {
  196.       SDUClassifier *clas = (SDUClassifier*) TclObject::lookup(argv[2]);
  197.       if (clas == 0)
  198. return TCL_ERROR;
  199.       //add classifier to the list
  200.       addClassifier (clas);
  201.       return TCL_OK;
  202.     } else if (strcmp(argv[1], "set-scheduler") == 0) {
  203.       scheduler_ = (WimaxScheduler*) TclObject::lookup(argv[2]);
  204.       if (scheduler_ == 0)
  205. return TCL_ERROR;
  206.       scheduler_->setMac (this); //register the mac
  207.       setStationType (scheduler_->getNodeType()); //get the node type (BS or MN)
  208.       return TCL_OK;
  209.     } else if (strcmp(argv[1], "set-servicehandler") == 0) {
  210.       serviceFlowHandler_ = (ServiceFlowHandler*) TclObject::lookup(argv[2]);
  211.       if (serviceFlowHandler_ == 0)
  212. return TCL_ERROR;
  213.       serviceFlowHandler_->setMac (this);
  214.       return TCL_OK;
  215.     } else if (strcmp(argv[1], "set-channel") == 0) {
  216.       assert (netif_); //to make sure we can update the phy
  217.       phymib_.channel = atoi (argv[2]);
  218.       double tmp = frequencies[phymib_.channel];
  219.       getPhy ()->setFrequency (tmp);
  220.       return TCL_OK;
  221.     }
  222.   }
  223.   return Mac::command(argc, argv);
  224. }
  226. /**
  227.  * Set the type of STA. This will be called when adding the scheduler
  228.  * It is used to create the default connections
  229.  * @param type The station type
  230.  */
  231. void Mac802_16::setStationType (station_type_t type)
  232. {
  233.   assert (type_ == STA_UNKNOWN && type != STA_UNKNOWN);
  234.   type_ = type;
  236.   init_default_connections ();
  237. }
  239. /**
  240.  * Initialize default connections
  241.  */
  242. void Mac802_16::init_default_connections ()
  243. {
  244.   Connection * con;
  246.   //create initial ranging and padding connection
  247.   con = new Connection (CONN_INIT_RANGING);
  248.   connectionManager_->add_connection (con, true); //uplink
  249.   con = new Connection (CONN_INIT_RANGING);
  250.   connectionManager_->add_connection (con, false); //downlink
  251.   con = new Connection (CONN_PADDING);
  252.   connectionManager_->add_connection (con, true);
  253.   con = new Connection (CONN_PADDING);
  254.   connectionManager_->add_connection (con, false);
  256.   if (type_ == STA_BS) {
  257.     //the BS is always connected
  258.     setMacState (MAC802_16_CONNECTED);
  259.     //we need to create a Broadcast connection and AAS init ranging CIDs
  260.     con = new Connection (CONN_BROADCAST);
  261.     connectionManager_->add_connection (con, false);
  262.     con = new Connection (CONN_AAS_INIT_RANGING);
  263.     connectionManager_->add_connection (con, true);
  264.   } else if (type_ == STA_MN) {
  265.     //create connection to receive broadcast packets from BS
  266.     con = new Connection (CONN_BROADCAST);
  267.     connectionManager_->add_connection (con, false);
  268.   }
  269. }
  271. /**
  272.  * Return the peer node that has the given address
  273.  * @param index The address of the peer
  274.  * @return The peer node that has the given address
  275.  */
  276. PeerNode* Mac802_16::getPeerNode (int index)
  277. {
  278.   for (PeerNode *p=peer_list_->lh_first;p;p=p->next_entry()) {
  279.     if (p->getPeerNode ()==index)
  280.       return p;
  281.   }
  282.   return NULL;
  283. }
  285. /**
  286.  * Add the peer node
  287.  * @param The peer node to add
  288.  */
  289. void Mac802_16::addPeerNode (PeerNode *node)
  290. {
  291.   node->insert_entry (peer_list_);
  292.   //update Rx time so for default value
  293.   node->setRxTime(NOW);
  294.   node->getStatWatch()->set_alpha(macmib_.rxp_avg_alpha);
  295. }
  297. /**
  298.  * Remove the peer node
  299.  * @param The peer node to remove
  300.  */
  301. void Mac802_16::removePeerNode (PeerNode *peer)
  302. {
  303.   if (peer->getBasic()) {
  304.     getCManager()->remove_connection (peer->getBasic()->get_cid());
  305.     delete (peer->getBasic());
  306.   }
  307.   if (peer->getPrimary()) {
  308.     getCManager()->remove_connection (peer->getPrimary()->get_cid());
  309.     delete (peer->getPrimary());
  310.   }
  311.   if (peer->getSecondary()) {
  312.     getCManager()->remove_connection (peer->getSecondary()->get_cid());
  313.     delete (peer->getSecondary());
  314.   }
  315.   if (peer->getInData()) {
  316.     getCManager()->remove_connection (peer->getInData()->get_cid());
  317.     delete (peer->getInData());
  318.   }
  319.   if (peer->getOutData()) {
  320.     getCManager()->remove_connection (peer->getOutData()->get_cid());
  321.     delete (peer->getOutData());
  322.   }
  323.   peer->remove_entry ();
  324.   delete (peer);
  325. }
  327. /**
  328.  * Set the mac state
  329.  * @param state The new mac state
  330.  */  
  331. void Mac802_16::setMacState (Mac802_16State state)
  332. {
  333.   state_ = state;
  334. }
  336. /**
  337.  * Return the mac state
  338.  * @return The new mac state
  339.  */  
  340. Mac802_16State Mac802_16::getMacState ()
  341. {
  342.   return state_;
  343. }
  345. /**
  346.  * Return the PHY layer
  347.  * @return The PHY layer
  348.  */
  349. OFDMPhy* Mac802_16::getPhy () { 
  350.   return (OFDMPhy*) netif_;
  351. }
  353. /**
  354.  * Change the channel
  355.  * @param channel The new channel
  356.  */
  357. void Mac802_16::setChannel (int channel)
  358. {
  359.   assert (channel < nbFreq);
  360.   phymib_.channel = channel;
  361.   double tmp = frequencies[phymib_.channel];
  362.   getPhy ()->setFrequency (tmp);
  363. }
  365. /**
  366.  * Return the channel number for the given frequency
  367.  * @param freq The frequency
  368.  * @return The channel number of -1 if the frequency does not match
  369.  */
  370. int Mac802_16::getChannel (double freq)
  371. {
  372.   for (int i = 0 ; i < nbFreq ; i++) {
  373.     if (frequencies[i]==freq)
  374.       return i;
  375.   }
  376.   return -1;
  377. }
  379. /**
  380.  * Return the channel index
  381.  * @return The channel
  382.  */
  383. int Mac802_16::getChannel ()
  384. {
  385.   return phymib_.channel;
  386. }
  388. /**
  389.  * Set the channel to the next from the list
  390.  * Used at initialisation and when loosing signal
  391.  */
  392. void Mac802_16::nextChannel ()
  393. {
  394.   debug ("At %f in Mac %d Going to channel %dn", NOW, index_, (phymib_.channel+1)%nbFreq);
  395.   setChannel ((phymib_.channel+1)%nbFreq);
  396. }
  398. /**
  399.  * Add a flow
  400.  * @param qos The QoS required
  401.  * @param handler The entity that requires to add a flow
  402.  */
  403. void Mac802_16::addFlow (ServiceFlowQoS * qos, void * handler) 
  404. {
  406. }
  408. /**
  409.  * Backup the state of the Mac
  410.  */
  411. state_info* Mac802_16::backup_state ()
  412. {
  413.   state_info *backup_state = (state_info*) malloc (sizeof (state_info));
  414.   backup_state->bs_id = bs_id_;
  415.   backup_state->state = state_;
  416.   backup_state->frameduration = getFrameDuration();
  417.   backup_state->frame_number = frame_number_;
  418.   backup_state->channel = getChannel();
  419.   backup_state->connectionManager = connectionManager_;
  420.   connectionManager_ = new ConnectionManager (this);
  421.   init_default_connections ();
  422.   backup_state->serviceFlowHandler = serviceFlowHandler_;
  423.   serviceFlowHandler_ = new ServiceFlowHandler();
  424.   backup_state->peer_list = peer_list_;
  425.   peer_list_ = (struct peerNode *) malloc (sizeof(struct peerNode));
  426.   LIST_INIT(peer_list_);
  427.   return backup_state;
  428. }
  430. /**
  431.  * Restore the state of the Mac
  432.  */
  433. void Mac802_16::restore_state (state_info *backup_state)
  434. {
  435.   bs_id_ = backup_state->bs_id;
  436.   state_ = backup_state->state;
  437.   setFrameDuration(backup_state->frameduration);
  438.   frame_number_ = backup_state->frame_number;
  439.   setChannel (backup_state->channel);
  440.   delete (connectionManager_);
  441.   connectionManager_ = backup_state->connectionManager;
  442.   delete (serviceFlowHandler_);
  443.   serviceFlowHandler_ = backup_state->serviceFlowHandler;
  444.   while (getPeerNode_head()!=NULL) {
  445.     removePeerNode (getPeerNode_head());
  446.   }
  447.   peer_list_ = backup_state->peer_list;
  448. }
  449.   
  450. /**
  451.  * Set the variable used to find out if upper layers
  452.  * must be notified to send packets. During scanning we
  453.  * do not want upper layers to send packet to the mac.
  454.  */
  455. void Mac802_16::setNotify_upper (bool notify) { 
  456.   notify_upper_ = notify; 
  457.   if (notify_upper_ && pktBuf_) {
  458.     sendDown (pktBuf_);
  459.     pktBuf_ = NULL;
  460.   }
  461. }
  463. /**** Packet processing methods ****/
  465. /*
  466.  * Process packets going out
  467.  * @param p The packet to send out
  468.  */
  469. void Mac802_16::sendDown(Packet *p)
  470. {
  471.   //We first send it through the CS
  472.   int cid = -1;
  474.   if (!notify_upper_) {
  475.     assert (!pktBuf_);
  476.     pktBuf_ = p;
  477.     return;
  478.   } 
  480.   for (SDUClassifier *n=classifier_list_.lh_first; n && cid==-1; n=n->next_entry()) {
  481.     cid = n->classify (p);
  482.   }
  484.   if (cid == -1) {
  485.     debug ("At %f in Mac %d drop packet because no classification were foundn", 
  486.     NOW, index_);
  487.     drop(p, "CID");
  488.     //Packet::free (p);
  489.   } else {
  490.     //enqueue the packet 
  491.     Connection *connection = connectionManager_->get_connection (cid, type_ == STA_MN);
  492.     if (connection == NULL) {
  493.       debug ("Warning: At %f in Mac %d connection with cid = %d does not exist. Please check classifiersn",
  494.       NOW, index_, cid);
  495.       //Packet::free (p);
  496.       update_watch (&loss_watch_, 1);
  497.       drop(p, "CID");
  498.     }
  499.     else {
  500.       if (connection->queueLength ()==macmib_.queue_length) {
  501. //queue full 
  502. update_watch (&loss_watch_, 1);
  503. drop (p, "QWI");
  504.       } else {
  505. //update mac header information
  506. //set header information
  507. hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(p);
  508. wimaxHdr->header.ht = 0;
  509. wimaxHdr->header.ec = 1;
  510. wimaxHdr->header.type = 0; //no subheader
  511. wimaxHdr->header.ci = 0;
  512. wimaxHdr->header.eks = 0;
  513. wimaxHdr->header.cid = cid; //default
  514. wimaxHdr->header.hcs = 0;
  515. HDR_CMN(p)->size() += HDR_MAC802_16_SIZE;
  516. HDR_CMN(p)->timestamp() = NOW; //set timestamp for delay
  517. connection ->enqueue (p);
  518. //printf ("At %f in Mac %d Enqueue packet to cid=%d queue size=%d(max=%d)n", NOW, index_, cid,connection->queueLength (), macmib_.queue_length);
  519.       }
  520.     }
  521.   }
  523.   //inform upper layer that it can send another packet
  524.   //if (notify_upper_) 
  525.   resume (NULL);  
  526. }
  528. /*
  529.  * Transmit a packet to the physical layer
  530.  * @param p The packet to send out
  531.  */
  532. void Mac802_16::transmit(Packet *p)
  533. {
  534.   if (NOW < last_tx_time_+last_tx_duration_) {
  535.     //still sending
  536.     //printf ("MAC is already transmitting. Drop packet.n");
  537.     Packet::free (p);
  538.     return;
  539.   }
  541.   struct hdr_cmn *ch = HDR_CMN(p);
  542.   /*
  543.   debug ("At %f in Mac %d sending packet (type=%s, size=%d) ", NOW, index_, packet_info.name(ch->ptype()), ch->size());
  544.   if (ch->ptype()==PT_MAC) {
  545.     if (HDR_MAC802_16(p)->header.ht == 0)
  546.       debug ("mngt=%dn", ((mac802_16_dl_map_frame*) p->accessdata())->type);
  547.     else
  548.       debug ("bwreqn");
  549.   } else {
  550.     debug ("n");
  551.   }
  552.   */
  553.   //update stats for delay and jitter
  554.   double delay = NOW-ch->timestamp();
  555.   update_watch (&delay_watch_, delay);
  556.   double jitter = fabs (delay - last_tx_delay_);
  557.   update_watch (&jitter_watch_, jitter);
  558.   last_tx_delay_ = delay;
  559.   if (ch->ptype()!=PT_MAC) {
  560.     update_throughput (&tx_data_watch_, 8*ch->size());
  561.   } 
  562.   update_throughput (&tx_traffic_watch_, 8*ch->size());
  563.   
  564.   last_tx_time_ = NOW;
  565.   last_tx_duration_ = ch->txtime();
  566.   downtarget_->recv (p, (Handler*)NULL);
  567. }
  569. /*
  570.  * Process incoming packets
  571.  * @param p The incoming packet
  572.  */
  573. void Mac802_16::sendUp (Packet *p)
  574. {
  575.   struct hdr_cmn *ch = HDR_CMN(p);
  577. #ifdef DEBUG_WIMAX
  578.   debug ("At %f in Mac %d receive first bit..over at %f(txtime=%f) (type=%s) ", NOW, index_, NOW+ch->txtime(),ch->txtime(), packet_info.name(ch->ptype()));
  579.   if (ch->ptype()==PT_MAC) {
  580.     if (HDR_MAC802_16(p)->header.ht == 0)
  581.       debug ("mngt=%dn", ((mac802_16_dl_map_frame*) p->accessdata())->type);
  582.     else
  583.       debug ("bwreqn");
  584.   } else {
  585.     debug ("n");
  586.   }
  587. #endif
  589.   if (pktRx_ !=NULL) {
  590.     /*
  591.      *  If the power of the incoming packet is smaller than the
  592.      *  power of the packet currently being received by at least
  593.      *  the capture threshold, then we ignore the new packet.
  594.      */
  595.     if(pktRx_->txinfo_.RxPr / p->txinfo_.RxPr >= p->txinfo_.CPThresh) {
  596.       Packet::free(p);
  597.     } else {
  598.       /*
  599.        *  Since a collision has occurred, figure out
  600.        *  which packet that caused the collision will
  601.        *  "last" the longest.  Make this packet,
  602.        *  pktRx_ and reset the Recv Timer if necessary.
  603.        */
  604.       if(txtime(p) > rxTimer_.expire()) {
  605. rxTimer_.stop();
  606. //printf ("t drop pktRx..collisionn");
  607. drop(pktRx_, "COL");
  608. update_watch (&loss_watch_, 1);
  609. pktRx_ = p;
  610. //mark the packet with error
  611. ch->error() = 1;
  612. collision_ = true;
  613. rxTimer_.start(ch->txtime()-0.000000001);
  614.       }
  615.       else {
  616. //printf ("t drop new packet..collisionn");
  617. drop(p, "COL");
  618. //mark the packet with error
  619. HDR_CMN(pktRx_)->error() = 1;
  620. collision_ = true;
  621.       }
  622.     }
  623.     return;
  624.   }
  625.   assert (pktRx_==NULL);
  626.   assert (rxTimer_.busy()==0);
  627.   pktRx_ = p;
  628.   //create a timer to wait for the end of reception
  629.   //since the packets are received by burst, the beginning of the new packet 
  630.   //is the same time as the end of this packet..we process this packet 1ns 
  631.   //earlier to make room for the new packet.
  632.   rxTimer_.start(ch->txtime()-0.000000001);
  633. }
  635. /**
  636.  * Process the fully received packet
  637.  */
  638. void Mac802_16::receive ()
  639. {
  640.   assert (pktRx_);
  641.   struct hdr_cmn *ch = HDR_CMN(pktRx_);
  643. #ifdef DEBUG_WIMAX
  644.   printf ("At %f in Mac %d packet received (type=%s) ", NOW, index_, packet_info.name(ch->ptype()));
  645.   if (ch->ptype()==PT_MAC) {
  646.     if (HDR_MAC802_16(pktRx_)->header.ht == 0)
  647.       printf ("mngt=%dn", ((mac802_16_dl_map_frame*) pktRx_->accessdata())->type);
  648.     else
  649.       printf ("bwreqn");
  650.   } else {
  651.     printf ("n");
  652.   }
  653. #endif
  654.     
  656.   //drop the packet if corrupted
  657.   if (ch->error()) {
  658.     if (collision_) {
  659.       //printf ("t drop new pktRx..collisionn");
  660.       drop (pktRx_, "COL");
  661.       collision_ = false;
  662.     } else {
  663.       //error in the packet, the Mac does not process
  664.       Packet::free(pktRx_);
  665.     }
  666.     //update drop stat
  667.     update_watch (&loss_watch_, 1);
  668.     pktRx_ = NULL;
  669.     return;
  670.   }
  672.   //process packet
  673.   hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(pktRx_);
  674.   gen_mac_header_t header = wimaxHdr->header;
  675.   int cid = header.cid;
  676.   Connection *con = connectionManager_->get_connection (cid, type_==STA_BS);
  677.   mac802_16_dl_map_frame *frame;
  679.   if (con == NULL) {
  680.     //This packet is not for us
  681.     //printf ("At %f in Mac %d Connection nulln", NOW, index_);
  682.     update_watch (&loss_watch_, 1);
  683.     Packet::free(pktRx_);
  684.     pktRx_=NULL;
  685.     return;
  686.   }
  687.   //printf ("CID=%dn", cid);
  689.   //update rx time of last packet received
  690.   PeerNode *peer;
  691.   if (type_ == STA_MN)
  692.     peer = getPeerNode_head(); //MN only has one peer
  693.   else
  694.     peer = con->getPeerNode(); //BS can have multiple peers
  696.   if (peer) {
  697.     peer->setRxTime (NOW);
  698.     
  699.     //collect receive signal strength stats
  700.     peer->getStatWatch()->update(10*log10(pktRx_->txinfo_.RxPr*1e3));
  701.     //debug ("At %f in Mac %d weighted RXThresh: %e rxp average %en", NOW, index_, macmib_.lgd_factor_*macmib_.RXThreshold_, pow(10,peer->getStatWatch()->average()/10)/1e3);
  702.     double avg_w = pow(10,(peer->getStatWatch()->average()/10))/1e3;
  703.     
  704.     if ( avg_w < (macmib_.lgd_factor_*macmib_.RXThreshold_)) {
  705.       if (!peer->isGoingDown () && type_ == STA_MN && state_==MAC802_16_CONNECTED) {
  706. ((SSscheduler*) scheduler_)->send_scan_request ();
  707.       }
  708.       peer->setGoingDown (true);
  709.       debug ("At %f Mac %d link going down triggern", NOW, index_);
  710. #ifdef USE_802_21
  711.       double probability = 1;
  712.       if(type_ == STA_MN) {
  713. Mac::send_link_going_down (addr(), getPeerNode_head()->getPeerNode(), -1, (int)(100*probability), eventId_++);
  714.       } else {
  715. Mac::send_link_going_down (peer->getPeerNode(), addr(), -1, (int)(100*probability), eventId_++);
  716.       }
  717. #endif
  718.     }
  719.     else {
  720.       if (peer->isGoingDown()) {
  721. #ifdef USE_802_21
  722. Mac::send_link_rollback (addr(), eventId_-1);
  723. #endif
  724. peer->setGoingDown (false);
  725.       }
  726.     }
  727.   }
  728.   
  729.   //process reassembly
  730.   if (wimaxHdr->frag_subheader) {
  731.     bool drop_pkt = true;
  732.     //printf ("Frag type = %dn",wimaxHdr->fc & 0x3);
  733.     switch (wimaxHdr->fc & 0x3) {
  734.     case FRAG_NOFRAG: 
  735.       if (con->getFragmentationStatus()!=FRAG_NOFRAG)
  736. con->updateFragmentation (FRAG_NOFRAG, 0, 0); //reset
  737.       drop_pkt = false;
  738.       break; 
  739.     case FRAG_FIRST: 
  740.       //when it is the first fragment, it does not matter if we previously
  741.       //received other fragments, since we reset the information
  742.       assert (wimaxHdr->fsn == 0);
  743.       //printf ("tReceived first fragmentn");
  744.       con->updateFragmentation (FRAG_FIRST, 0, ch->size()-(HDR_MAC802_16_SIZE+HDR_MAC802_16_FRAGSUB_SIZE));
  745.       break; 
  746.     case FRAG_CONT: 
  747.       if ( (con->getFragmentationStatus()!=FRAG_FIRST
  748.     && con->getFragmentationStatus()!=FRAG_CONT)
  749.    || ((wimaxHdr->fsn&0x7) != (con->getFragmentNumber ()+1)%8) ) {
  750. con->updateFragmentation (FRAG_NOFRAG, 0, 0); //reset
  751.       } else {
  752. //printf ("tReceived cont fragmentn");
  753. con->updateFragmentation (FRAG_CONT, wimaxHdr->fsn&0x7, con->getFragmentBytes()+ch->size()-(HDR_MAC802_16_SIZE+HDR_MAC802_16_FRAGSUB_SIZE));
  754.       }
  755.       break; 
  756.     case FRAG_LAST: 
  757.       if ( (con->getFragmentationStatus()==FRAG_FIRST
  758.     || con->getFragmentationStatus()==FRAG_CONT)
  759.    && ((wimaxHdr->fsn&0x7) == (con->getFragmentNumber ()+1)%8) ) {
  760. //printf ("tReceived last fragmentn");
  761. ch->size() += con->getFragmentBytes()-HDR_MAC802_16_FRAGSUB_SIZE;
  762. drop_pkt = false;
  763.       } else {
  764. //printf ("Error with last frag seq=%d (expected=%d)n", wimaxHdr->fsn&0x7, (con->getFragmentNumber ()+1)%8);
  765.       }     
  766.       con->updateFragmentation (FRAG_NOFRAG, 0, 0); //reset
  767.       break; 
  768.     default:
  769.       fprintf (stderr,"Error, unknown fragmentation typen");
  770.       exit (-1);
  771.     }
  772.     //if we got an error, or it is a fragment that is not the last, free the packet
  773.     if (drop_pkt) {
  774.       //update drop stat
  775.       update_watch (&loss_watch_, 1);
  776.       Packet::free(pktRx_);
  777.       pktRx_=NULL;
  778.       return;
  779.     } 
  780.   }
  782.   switch (con->getType()) {
  783.   case CONN_INIT_RANGING:
  784.     scheduler_->process (pktRx_);
  785.     break;
  786.   case CONN_AAS_INIT_RANGING:
  787.     break;
  788.   case CONN_MULTICAST_POLLING: 
  789.     break;
  790.   case CONN_PADDING:
  791.     //padding is sent by a SS that does not have data
  792.     //to send is required to send a signal.
  793.     //TBD: Find the SS that sent the padding
  794.     scheduler_->process (pktRx_);
  795.     break; 
  796.   case CONN_BROADCAST:
  797.     if (HDR_CMN(pktRx_)->ptype()==PT_MAC)
  798.       scheduler_->process (pktRx_);
  799.     else {
  800.       //Richard: only send to upper layer if connected
  801.       if (state_ == MAC802_16_CONNECTED)
  802. goto send_upper;
  803.       else {
  804. //update drop stat, could be used to detect deconnection
  805. update_watch (&loss_watch_, 1);
  806. Packet::free(pktRx_);
  807. pktRx_=NULL;
  808. return;
  809.       }
  810.     }
  811.     break; 
  812.   case CONN_BASIC:
  813.     scheduler_->process (pktRx_);
  814.     break; 
  815.   case CONN_PRIMARY:
  816.     assert (HDR_CMN(pktRx_)->ptype()==PT_MAC);
  817.     //we cast to this frame because all management frame start with a type
  818.     if (wimaxHdr->header.ht==1) {
  819.       //bw request
  820.       scheduler_->process (pktRx_);
  821.     } else {
  822.       frame = (mac802_16_dl_map_frame*) pktRx_->accessdata();
  823.       switch (frame->type) {
  824.       case MAC_DSA_REQ: 
  825.       case MAC_DSA_RSP: 
  826.       case MAC_DSA_ACK: 
  827. serviceFlowHandler_->process (pktRx_);
  828. break;
  829.       default:
  830. scheduler_->process (pktRx_);
  831.       }
  832.     }
  833.     break;   
  834.   case CONN_SECONDARY:
  835.     //fall through
  836.   case CONN_DATA:
  837.     //send to upper layer
  838.     goto send_upper;
  839.     break; 
  840.   default:
  841.     fprintf (stderr,"Error: unknown connection typen");
  842.     exit (0);
  843.   }
  844.   goto sent_mac; //default jump
  846.  send_upper:
  847.   update_throughput (&rx_data_watch_, 8*ch->size());    
  848.   update_throughput (&rx_traffic_watch_, 8*ch->size());
  849.   ch->size() -= HDR_MAC802_16_SIZE;
  850.   uptarget_->recv(pktRx_, (Handler*) 0);
  851.   goto done;
  853.  sent_mac:
  854.   update_throughput (&rx_traffic_watch_, 8*ch->size());
  855.   //fall through
  857.   //should not free it here because we don't know if other modules
  858.   //kept a copy of it.
  859.   //Packet::free(pktRx_);
  860.   //update Rx stat
  861.  done:
  862.   update_watch (&loss_watch_, 0);
  863.   pktRx_=NULL;
  864. }
  866. /**** Helper methods ****/
  868. /**
  869.  * Return the frame number
  870.  * @return the frame number
  871.  */
  872. int Mac802_16::getFrameNumber () {
  873.   return frame_number_;
  874. }
  876. /*
  877.  * Return the code for the frame duration
  878.  * @return the code for the frame duration
  879.  */
  880. int Mac802_16::getFrameDurationCode () {
  881.   if (macmib_.frame_duration == 0.0025)
  882.     return 0;
  883.   else if (macmib_.frame_duration == 0.004)
  884.     return 1;
  885.   else if (macmib_.frame_duration == 0.005)
  886.     return 2;
  887.   else if (macmib_.frame_duration == 0.008)
  888.     return 3;
  889.   else if (macmib_.frame_duration == 0.01)
  890.     return 4;
  891.   else if (macmib_.frame_duration == 0.0125)
  892.     return 5;
  893.   else if (macmib_.frame_duration == 0.02)
  894.     return 6;
  895.   else {
  896.     fprintf (stderr, "Invalid frame duration %fn", macmib_.frame_duration);
  897.     exit (1);
  898.   }
  899. }
  901. /*
  902.  * Set the frame duration using code
  903.  * @param code The frame duration code
  904.  */
  905. void Mac802_16::setFrameDurationCode (int code) 
  906. {
  907.   switch (code) {
  908.   case 0:
  909.     macmib_.frame_duration = 0.0025;
  910.     break;
  911.   case 1:
  912.     macmib_.frame_duration = 0.004;
  913.     break;
  914.   case 2:
  915.     macmib_.frame_duration = 0.005;
  916.     break;
  917.   case 3:
  918.     macmib_.frame_duration = 0.008;
  919.     break;
  920.   case 4:
  921.     macmib_.frame_duration = 0.01;
  922.     break;
  923.   case 5:
  924.     macmib_.frame_duration = 0.0125;
  925.     break;
  926.   case 6:
  927.     macmib_.frame_duration = 0.02;
  928.     break;
  929.   default:
  930.   fprintf (stderr, "Invalid frame duration code %dn", code);
  931.     exit (1);
  932.   }
  933. }
  936. /**
  937.  * Return a packet 
  938.  * @return a new packet
  939.  */
  940. Packet *Mac802_16::getPacket ()
  941. {
  942.   Packet *p = Packet::alloc ();
  943.   
  944.   hdr_mac802_16 *wimaxHdr= HDR_MAC802_16(p);
  946.   //set header information
  947.   wimaxHdr->header.ht = 0;
  948.   wimaxHdr->header.ec = 1;
  949.   wimaxHdr->header.type = 0; //no subheader
  950.   wimaxHdr->header.ci = 0;
  951.   wimaxHdr->header.eks = 0;
  952.   wimaxHdr->header.cid = BROADCAST_CID; //default
  953.   wimaxHdr->header.hcs = 0;
  954.   HDR_CMN(p)->ptype() = PT_MAC;
  956.   HDR_CMN(p)->size() = HDR_MAC802_16_SIZE;
  958.   return p;
  959. }
  961. /**** Internal methods ****/
  964. /*
  965.  * Add a classifier
  966.  * @param clas The classifier to add
  967.  */
  968. void Mac802_16::addClassifier (SDUClassifier *clas) 
  969. {
  970.   SDUClassifier *n=classifier_list_.lh_first;
  971.   SDUClassifier *prev=NULL;
  972.   int i = 0;
  973.   if (!n || (n->getPriority () >= clas->getPriority ())) {
  974.     //the first element
  975.     //debug ("Add first classifiern");
  976.     clas->insert_entry_head (&classifier_list_);
  977.   } else {
  978.     while ( n && (n->getPriority () < clas->getPriority ()) ) {
  979.       prev=n;
  980.       n=n->next_entry();
  981.       i++;
  982.     }
  983.     //debug ("insert entry at position %dn", i);
  984.     clas->insert_entry (prev);
  985.   }
  986.   //Register this mac with the classifier
  987.   clas->setMac (this);
  988. }
  990. #ifdef USE_802_21
  992. /* 
  993.  * Configure/Request configuration
  994.  * The upper layer sends a config object with the required 
  995.  * new values for the parameters (or PARAMETER_UNKNOWN_VALUE).
  996.  * The MAC tries to set the values and return the new setting.
  997.  * For examples if a MAC does not support a parameter it will
  998.  * return  PARAMETER_UNKNOWN_VALUE
  999.  * @param config The configuration object
  1000.  */ 
  1001. void Mac802_16::link_configure (link_parameter_config_t* config)
  1002. {
  1003. assert (config);
  1004. config->bandwidth = 15000000; //TBD use phy (but depend on modulation)
  1005. config->type = LINK_802_16;
  1006. //we set the rest to PARAMETER_UNKNOWN_VALUE
  1007. config->ber = PARAMETER_UNKNOWN_VALUE;
  1008. config->delay = PARAMETER_UNKNOWN_VALUE;
  1009. config->macPoA = PARAMETER_UNKNOWN_VALUE;
  1010. }
  1012. /*
  1013.  * Disconnect from the PoA
  1014.  */
  1015. void Mac802_16::link_disconnect ()
  1016. {
  1017.   if (type_ == STA_MN) {
  1018.     //force losing synchronization
  1019.     ((SSscheduler*) scheduler_)->lost_synch ();
  1020.     getPhy()->node_off();
  1021.   }
  1022. }
  1024. /*
  1025.  * Connect to the PoA
  1026.  */
  1027. void Mac802_16::link_connect (int poa)
  1028. {
  1029.   if (type_ == STA_MN) {
  1030.     getPhy()->node_on();
  1031.   }
  1032. }
  1034. /* 
  1035.  * Configure the threshold values for the given parameters
  1036.  * @param numLinkParameter number of parameter configured
  1037.  * @param linkThresholds list of parameters and thresholds
  1038.  */
  1039. struct link_param_th_status * Mac802_16::link_configure_thresholds (int numLinkParameter, struct link_param_th *linkThresholds)
  1040. {
  1041.   struct link_param_th_status *result = (struct link_param_th_status *) malloc(numLinkParameter * sizeof (struct link_param_th_status));
  1042.   StatWatch *watch=NULL;
  1043.   for (int i=0 ; i < numLinkParameter ; i++) {
  1044.     result[i].parameter = linkThresholds[i].parameter;
  1045.     result[i].status = 1; //accepted..default
  1046.     switch (linkThresholds[i].parameter){
  1047.     case LINK_PACKET_LOSS: 
  1048.       watch = &loss_watch_;
  1049.       break;
  1050.     case LINK_PACKET_DELAY:
  1051.       watch = &delay_watch_;
  1052.       break;
  1053.     case LINK_PACKET_JITTER:
  1054.       watch = &jitter_watch_;
  1055.       break;
  1056.     case LINK_RX_DATA_THROUGHPUT:
  1057.       watch = &rx_data_watch_;
  1058.       break;
  1059.     case LINK_RX_TRAFFIC_THROUGHPUT:
  1060.       watch = &rx_traffic_watch_;
  1061.       break;
  1062.     case LINK_TX_DATA_THROUGHPUT:
  1063.       watch = &tx_data_watch_;
  1064.       break;
  1065.     case LINK_TX_TRAFFIC_THROUGHPUT:
  1066.       watch = &tx_traffic_watch_;
  1067.       break;
  1068.     default:
  1069.       fprintf (stderr, "Parameter type not supported %dn", linkThresholds[i].parameter);
  1070.       result[i].status = 0; //rejected
  1071.     }
  1072.     watch->set_thresholds (linkThresholds[i].initActionTh.data_d, 
  1073.    linkThresholds[i].rollbackActionTh.data_d ,
  1074.    linkThresholds[i].exectActionTh.data_d);
  1075.   }
  1076.   return result;
  1077. }
  1078.  
  1079. #endif
  1081. /**
  1082.  * Update the given timer and check if thresholds are crossed
  1083.  * @param watch the stat watch to update
  1084.  * @param value the stat value
  1085.  */
  1086. void Mac802_16::update_watch (StatWatch *watch, double value)
  1087. {
  1088.   char *name;
  1090. #ifdef USE_802_21 //Switch to activate when using 802.21 modules (external package)
  1091.   threshold_action_t action = watch->update (value);
  1093.   if (action != NO_ACTION_TH) {
  1094.     link_parameter_t param;
  1095.     union param_value old_value, new_value;
  1097.     if (watch == &loss_watch_) {
  1098.       param = LINK_PACKET_LOSS;
  1099.     } else if (watch == &delay_watch_) {
  1100.       param = LINK_PACKET_DELAY;
  1101.     } else if (watch == &jitter_watch_) {
  1102.       param = LINK_PACKET_JITTER;
  1103.     }
  1104.     old_value.data_d = watch->old_average();
  1105.     new_value.data_d = watch->average();
  1106.     send_link_parameter_change (addr(), param, old_value, new_value);      
  1107.   }
  1108. #endif
  1110.   if (watch == &loss_watch_) {
  1111.     name = "loss";
  1112.   } else if (watch == &delay_watch_) {
  1113.     name = "delay";
  1114.   } else if (watch == &jitter_watch_) {
  1115.     name = "jitter";
  1116.   } else {
  1117.     name = "other";
  1118.   }
  1119.   if (print_stats_)
  1120.     printf ("At %f in Mac %d, updating stats %s: %fn", NOW, addr(), name, watch->average());
  1121. }
  1123. /**
  1124.  * Update the given timer and check if thresholds are crossed
  1125.  * @param watch the stat watch to update
  1126.  * @param value the stat value
  1127.  */
  1128. void Mac802_16::update_throughput (ThroughputWatch *watch, double size)
  1129. {
  1130.   char *name;
  1132. #ifdef USE_802_21 //Switch to activate when using 802.21 modules (external package)
  1133.   threshold_action_t action = watch->update (size, NOW);
  1134.   if (action != NO_ACTION_TH) {
  1135.     link_parameter_t param;
  1136.     union param_value old_value, new_value;
  1137.     if (watch == &rx_data_watch_) {
  1138.       param = LINK_RX_DATA_THROUGHPUT;
  1139.     } else if (watch == &rx_traffic_watch_) {
  1140.       param = LINK_RX_TRAFFIC_THROUGHPUT;
  1141.     } else if (watch == &tx_data_watch_) {
  1142.       param = LINK_TX_DATA_THROUGHPUT;
  1143.     } else if (watch == &tx_traffic_watch_) {
  1144.       param = LINK_TX_TRAFFIC_THROUGHPUT;
  1145.     }
  1146.     old_value.data_d = watch->old_average();
  1147.     new_value.data_d = watch->average();
  1148.     send_link_parameter_change (addr(), param, old_value, new_value);      
  1149.   }
  1150. #endif 
  1152.   if (watch == &rx_data_watch_) {
  1153.     name = "rx_data";
  1154.     rx_data_timer_->resched (watch->get_timer_interval());
  1155.   } else if (watch == &rx_traffic_watch_) {
  1156.     rx_traffic_timer_->resched (watch->get_timer_interval());
  1157.     name = "rx_traffic";
  1158.   } else if (watch == &tx_data_watch_) {
  1159.     tx_data_timer_->resched (watch->get_timer_interval());
  1160.     name = "tx_data";
  1161.   } else if (watch == &tx_traffic_watch_) {
  1162.     tx_traffic_timer_->resched (watch->get_timer_interval());
  1163.     name = "tx_traffic";
  1164.   }
  1166.   if (print_stats_)
  1167.     printf ("At %f in Mac %d, updating stats %s: %fn", NOW, addr(), name, watch->average());
  1168. }