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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
channel.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：20k
源码类别：

通讯编程

开发平台：

Visual C++

channel.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1996 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  * This product includes software developed by the Computer Systems
  17.  * Engineering Group at Lawrence Berkeley Laboratory and the Daedalus
  18.  * research group at UC Berkeley.
  19.  * 4. Neither the name of the University nor of the Laboratory may be used
  20.  *    to endorse or promote products derived from this software without
  21.  *    specific prior written permission.
  22.  *
  23.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33.  * SUCH DAMAGE.
  34.  *
  35.  * Contributed by Giao Nguyen, http://daedalus.cs.berkeley.edu/~gnguyen
  36.  */
  38. #ifndef lint
  39. static const char rcsid[] =
  40.     "@(#) $Header: /cvsroot/nsnam/ns-2/mac/channel.cc,v 1.46 2008/02/01 21:39:39 tom_henderson Exp $ (UCB)";
  41. #endif
  43. // Time interval for updating a position of a node in the X-List
  44. // (can be adjusted by the user, depending on the nodes mobility). /* VAL NAUMOV */
  45. #define XLIST_POSITION_UPDATE_INTERVAL 1.0 //seconds
  49. //#include "template.h"
  50. #include <float.h>
  52. #include "trace.h"
  53. #include "delay.h"
  54. #include "object.h"
  55. #include "packet.h"
  56. #include "mac.h"
  57. #include "channel.h"
  58. #include "lib/bsd-list.h"
  59. #include "phy.h"
  60. #include "wireless-phy.h"
  61. #include "mobilenode.h"
  62. #include "ip.h"
  63. #include "dsr/hdr_sr.h"
  64. #include "gridkeeper.h"
  65. #include "tworayground.h"
  66. #include "wireless-phyExt.h"
  68. static class ChannelClass : public TclClass {
  69. public:
  70. ChannelClass() : TclClass("Channel") {}
  71. TclObject* create(int, const char*const*) {
  72. return (new Channel);
  73. }
  74. } class_channel;
  76. /*static class DuplexChannelClass : public TclClass {
  77. public:
  78. DuplexChannelClass() : TclClass("Channel/Duplex") {}
  79. TclObject* create(int, const char*const*) {
  80. return (new DuplexChannel);
  81. }
  82. } class_channel_duplex; */
  84. static class WirelessChannelClass : public TclClass {
  85. public:
  86.         WirelessChannelClass() : TclClass("Channel/WirelessChannel") {}
  87.         TclObject* create(int, const char*const*) {
  88.                 return (new WirelessChannel);
  89.         }
  90. } class_Wireless_channel;
  94. /* ==================================================================
  95.    NS Initialization Functions
  96.    =================================================================*/
  97. static int ChannelIndex = 0;
  98. Channel::Channel() : TclObject()
  99. {
  100. index_ = ChannelIndex++;
  101. LIST_INIT(&ifhead_);
  102. bind_time("delay_", &delay_);
  103. }
  105. int Channel::command(int argc, const char*const* argv)
  106. {
  108. if (argc == 3) {
  109. TclObject *obj;
  111. if( (obj = TclObject::lookup(argv[2])) == 0) {
  112. fprintf(stderr, "%s lookup failedn", argv[1]);
  113. return TCL_ERROR;
  114. }
  115. if (strcmp(argv[1], "trace-target") == 0) {
  116. trace_ = (Trace*) obj;
  117. return (TCL_OK);
  118. }
  119. else if(strcmp(argv[1], "addif") == 0) {
  120. ((Phy*) obj)->insertchnl(&ifhead_);
  121. ((Phy*) obj)->setchnl(this);
  122. return TCL_OK;
  123. }
  125. // add interface for grid_keeper_
  126. /*else if(strncasecmp(argv[1], "grid_keeper", 5) == 0) {
  127. grid_keeper_ = (GridKeeper*)obj;
  128. return TCL_OK;
  129. }*/
  130. } else if (argc == 2) {
  131. Tcl& tcl = Tcl::instance();
  132. if (strcmp(argv[1], "trace-target") == 0) {
  133. tcl.resultf("%s", trace_->name());
  134. return (TCL_OK);
  135. }
  136. else if(strcmp(argv[1], "id") == 0) {
  137. tcl.resultf("%d", index_);
  138. return TCL_OK;
  139. }
  140. }
  141. return TclObject::command(argc, argv);
  142. }
  145. void Channel::recv(Packet* p, Handler* h)
  146. {
  147. sendUp(p, (Phy*)h);
  148. }
  152. void
  153. Channel::sendUp(Packet* p, Phy *tifp)
  154. {
  155. Scheduler &s = Scheduler::instance();
  156. Phy *rifp = ifhead_.lh_first;
  157. Node *tnode = tifp->node();
  158. Node *rnode = 0;
  159. Packet *newp;
  160. double propdelay = 0.0;
  161. struct hdr_cmn *hdr = HDR_CMN(p);
  163. hdr->direction() = hdr_cmn::UP;
  164. for( ; rifp; rifp = rifp->nextchnl()) {
  165. rnode = rifp->node();
  166. if(rnode == tnode)
  167. continue;
  168. /*
  169.  * Each node needs to get their own copy of this packet.
  170.  * Since collisions occur at the receiver, we can have
  171.  * two nodes canceling and freeing the *same* simulation
  172.  * event.
  173.  *
  174.  */
  175. newp = p->copy();
  176. propdelay = get_pdelay(tnode, rnode);
  178. /*
  179.  * Each node on the channel receives a copy of the
  180.  * packet.  The propagation delay determines exactly
  181.  * when the receiver's interface detects the first
  182.  * bit of this packet.
  183.  */
  184. s.schedule(rifp, newp, propdelay);
  185. }
  187. Packet::free(p);
  188. }
  193. double 
  194. Channel::get_pdelay(Node* /*tnode*/, Node* /*rnode*/)
  195. {
  196. // Dummy function
  197. return delay_;
  198. }
  201. void
  202. Channel::dump(void)
  203. {
  204. Phy *n;
  206. fprintf(stdout, "Network Interface Listn");
  207.   for(n = ifhead_.lh_first; n; n = n->nextchnl() )
  208. n->dump();
  209. fprintf(stdout, "--------------------------------------------------n");
  210. }
  212. /* NoDupChannel------------------------------------------------------------
  213.  * NoDupChannel is currently acting the same as Channel but with one
  214.  * important difference: it uses reference-copying of the packet,
  215.  * thus, a lot of time is saved (e.g. for 49 senders and 1 receiver
  216.  * overflowing mac802.3 and running for 10 seconds sim time, factors
  217.  * of 60 and more of savings in actual running time have been
  218.  * observed).
  219.  *
  220.  * DRAWBACKS: 
  221.  *
  222.  * - No propagation model supported (uses constant prop delay for 
  223.  *        all nodes), although it should be easy to change that.
  224.  * - Macs should be EXTREMELY careful handling these reference 
  225.  *        copies: essentially they all are expected not to modify them 
  226.  *   in any way (including scheduling!) while reference counter is
  227.  *        positive.  802.3 seems to work with it, other macs may need
  228.  *   some changes.
  229.  */
  231. struct ChannelDelayEvent : public Event {
  232. public:
  233. ChannelDelayEvent(Packet *p, Phy *txphy) : p_(p), txphy_(txphy) {};
  234. Packet *p_;
  235. Phy *txphy_;
  236. };
  238. class NoDupChannel : public Channel, public Handler {
  239. public:
  240. void recv(Packet* p, Handler*);
  241. void handle(Event*);
  242. protected:
  243. int phy_counter_;
  244. private:
  245. void sendUp(Packet *p, Phy *txif);
  247. };
  249. void NoDupChannel::recv(Packet* p, Handler* h) {
  250. assert(hdr_cmn::access(p)->direction() == hdr_cmn::DOWN);
  251. // Delay this packet
  252. Scheduler &s = Scheduler::instance();
  253. ChannelDelayEvent *de = new ChannelDelayEvent(p, (Phy *)h);
  254. s.schedule(this, de, delay_);
  255. }
  256. void NoDupChannel::handle(Event *e) {
  257. ChannelDelayEvent *cde = (ChannelDelayEvent *)e;
  258. sendUp(cde->p_, cde->txphy_);
  259. delete cde;
  260. }
  262. void NoDupChannel::sendUp(Packet *p, Phy *txif) {
  263. struct hdr_cmn *hdr = HDR_CMN(p);
  264. hdr->direction() = hdr_cmn::UP;
  266. for(Phy *rifp = ifhead_.lh_first; rifp; rifp = rifp->nextchnl()) {
  267. if(rifp == txif)
  268. continue;
  269. rifp->recv(p->refcopy(), 0);
  270. }
  271. Packet::free(p);
  272. }
  274. static class NoDupChannelClass : public TclClass {
  275. public:
  276. NoDupChannelClass() : TclClass("Channel/NoDup") {}
  277. TclObject* create(int, const char*const*) {
  278. return (new NoDupChannel);
  279. }
  280. } class_nodupchannel;
  284. // Wireless extensions
  285. class MobileNode;
  287. double WirelessChannel::highestAntennaZ_ = -1; // i.e., uninitialized
  288. double WirelessChannel::distCST_ = -1;
  290. WirelessChannel::WirelessChannel(void) : Channel(), numNodes_(0), 
  291.  xListHead_(NULL), sorted_(0) {}
  293. int WirelessChannel::command(int argc, const char*const* argv)
  294. {
  296. if (argc == 3) {
  297. TclObject *obj;
  299. if( (obj = TclObject::lookup(argv[2])) == 0) {
  300. fprintf(stderr, "%s lookup failedn", argv[1]);
  301. return TCL_ERROR;
  302. }
  303. if (strcmp(argv[1], "add-node") == 0) {
  304. addNodeToList((MobileNode*) obj);
  305. return TCL_OK;
  306. }
  307. else if (strcmp(argv[1], "remove-node") == 0) {
  308. removeNodeFromList((MobileNode*) obj);
  309. return TCL_OK;
  310. }
  311. }
  312. return Channel::command(argc, argv);
  313. }
  316. void
  317. WirelessChannel::sendUp(Packet* p, Phy *tifp)
  318. {
  319. Scheduler &s = Scheduler::instance();
  320. Phy *rifp = ifhead_.lh_first;
  321. Node *tnode = tifp->node();
  322. Node *rnode = 0;
  323. Packet *newp;
  324. double propdelay = 0.0;
  325. struct hdr_cmn *hdr = HDR_CMN(p);
  327.          /* list-based improvement */
  328.          if(highestAntennaZ_ == -1) {
  329.                  fprintf(stdout, "channel.cc:sendUp - Calc highestAntennaZ_ and distCST_n");
  330.                  calcHighestAntennaZ(tifp);
  331.                  fprintf(stdout, "highestAntennaZ_ = %0.1f,  distCST_ = %0.1fn", highestAntennaZ_, distCST_);
  332.          }
  334.  hdr->direction() = hdr_cmn::UP;
  336.  // still keep grid-keeper around ??
  337.  if (GridKeeper::instance()) {
  338.     int i;
  339.     GridKeeper* gk = GridKeeper::instance();
  340.     int size = gk->size_; 
  341.     
  342.     MobileNode **outlist = new MobileNode *[size];
  343.  
  344.             int out_index = gk->get_neighbors((MobileNode*)tnode,
  345.          outlist);
  346.     for (i=0; i < out_index; i ++) {
  348.   newp = p->copy();
  349.   rnode = outlist[i];
  350.   propdelay = get_pdelay(tnode, rnode);
  352.   rifp = (rnode->ifhead()).lh_first; 
  353.   for(; rifp; rifp = rifp->nextnode()){
  354.   if (rifp->channel() == this){
  355.  s.schedule(rifp, newp, propdelay); 
  356.  break;
  357.   }
  358.   }
  359.       }
  360.     delete [] outlist; 
  361.  
  362.  } else { // use list-based improvement
  363.  
  364.  MobileNode *mtnode = (MobileNode *) tnode;
  365.  MobileNode **affectedNodes;// **aN;
  366.  int numAffectedNodes = -1, i;
  367.  
  368.  if(!sorted_){
  369.  sortLists();
  370.  }
  371.  
  372.  affectedNodes = getAffectedNodes(mtnode, distCST_ + /* safety */ 5, &numAffectedNodes);
  373.  for (i=0; i < numAffectedNodes; i++) {
  374.  rnode = affectedNodes[i];
  375.  
  376.  if(rnode == tnode)
  377.  continue;
  378.  
  379.  newp = p->copy();
  380.  
  381.  propdelay = get_pdelay(tnode, rnode);
  382.  
  383.  rifp = (rnode->ifhead()).lh_first;
  384.  for(; rifp; rifp = rifp->nextnode()){
  385.  s.schedule(rifp, newp, propdelay);
  386.  }
  387.  }
  388.  delete [] affectedNodes;
  389.  }
  390.  Packet::free(p);
  391. }
  394. void
  395. WirelessChannel::addNodeToList(MobileNode *mn)
  396. {
  397. MobileNode *tmp;
  399. // create list of mobilenodes for this channel
  400. if (xListHead_ == NULL) {
  401. fprintf(stderr, "INITIALIZE THE LIST xListHeadn");
  402. xListHead_ = mn;
  403. xListHead_->nextX_ = NULL;
  404. xListHead_->prevX_ = NULL;
  405. } else {
  406. for (tmp = xListHead_; tmp->nextX_ != NULL; tmp=tmp->nextX_);
  407. tmp->nextX_ = mn;
  408. mn->prevX_ = tmp;
  409. mn->nextX_ = NULL;
  410. }
  411. numNodes_++;
  412. }
  414. void
  415. WirelessChannel::removeNodeFromList(MobileNode *mn) {
  417. MobileNode *tmp;
  418. // Find node in list
  419. for (tmp = xListHead_; tmp->nextX_ != NULL; tmp=tmp->nextX_) {
  420. if (tmp == mn) {
  421. if (tmp == xListHead_) {
  422. xListHead_ = tmp->nextX_;
  423. if (tmp->nextX_ != NULL)
  424. tmp->nextX_->prevX_ = NULL;
  425. } else if (tmp->nextX_ == NULL) 
  426. tmp->prevX_->nextX_ = NULL;
  427. else {
  428. tmp->prevX_->nextX_ = tmp->nextX_;
  429. tmp->nextX_->prevX_ = tmp->prevX_;
  430. }
  431. numNodes_--;
  432. return;
  433. }
  434. }
  435. fprintf(stderr, "Channel: node not found in listn");
  436. }
  438. void
  439. WirelessChannel::sortLists(void) {
  440. bool flag = true;
  441. MobileNode *m, *q;
  443. sorted_ = true;
  445. fprintf(stderr, "SORTING LISTS ...");
  446. /* Buble sort algorithm */
  447. // SORT x-list
  448. while(flag) {
  449. flag = false;
  450. m = xListHead_;
  451. while (m != NULL){
  452. if(m->nextX_ != NULL)
  453. if ( m->X() > m->nextX_->X() ){
  454. flag = true;
  455. //delete_after m;
  456. q = m->nextX_;
  457. m->nextX_ = q->nextX_;
  458. if (q->nextX_ != NULL)
  459. q->nextX_->prevX_ = m;
  460.     
  461. //insert_before m;
  462. q->nextX_ = m;
  463. q->prevX_ = m->prevX_;
  464. m->prevX_ = q;
  465. if (q->prevX_ != NULL)
  466. q->prevX_->nextX_ = q;
  468. // adjust Head of List
  469. if(m == xListHead_) 
  470. xListHead_ = m->prevX_;
  471. }
  472. m = m -> nextX_;
  473. }
  474. }
  476. fprintf(stderr, "DONE!n");
  477. }
  479. void
  480. WirelessChannel::updateNodesList(class MobileNode *mn, double oldX) {
  482. MobileNode* tmp;
  483. double X = mn->X();
  484. bool skipX=false;
  486. if(!sorted_) {
  487. sortLists();
  488. return;
  489. }
  491. /* xListHead cannot be NULL here (they are created during creation of mobilenode) */
  493. /***  DELETE ***/
  494. // deleting mn from x-list
  495. if(mn->nextX_ != NULL) {
  496. if(mn->prevX_ != NULL){
  497. if((mn->nextX_->X() >= X) && (mn->prevX_->X() <= X)) skipX = true; // the node doesn't change its position in the list
  498. else{
  499. mn->nextX_->prevX_ = mn->prevX_;
  500. mn->prevX_->nextX_ = mn->nextX_;
  501. }
  502. }
  504. else{
  505. if(mn->nextX_->X() >= X) skipX = true; // skip updating the first element
  506. else{
  507. mn->nextX_->prevX_ = NULL;
  508. xListHead_ = mn->nextX_;
  509. }
  510. }
  511. }
  513. else if(mn->prevX_ !=NULL){
  514. if(mn->prevX_->X() <= X) skipX = true; // skip updating the last element
  515. else mn->prevX_->nextX_ = NULL;
  516. }
  518. if ((mn->prevX_ == NULL) && (mn->nextX_ == NULL)) skipX = true; //skip updating if only one element in list
  520. /*** INSERT ***/
  521. //inserting mn in x-list
  522. if(!skipX){
  523. if(X > oldX){
  524. for(tmp = mn; tmp->nextX_ != NULL && tmp->nextX_->X() < X; tmp = tmp->nextX_);
  525. //fprintf(stdout,"Scanning the element addr %d X=%0.f, next addr %d X=%0.fn", tmp, tmp->X(), tmp->nextX_, tmp->nextX_->X());
  526. if(tmp->nextX_ == NULL) { 
  527. //fprintf(stdout, "tmp->nextX_ is NULLn");
  528. tmp->nextX_ = mn;
  529. mn->prevX_ = tmp;
  530. mn->nextX_ = NULL;
  531. } 
  532. else{ 
  533. //fprintf(stdout, "tmp->nextX_ is not NULL, tmp->nextX_->X()=%0.fn", tmp->nextX_->X());
  534. mn->prevX_ = tmp->nextX_->prevX_;
  535. mn->nextX_ = tmp->nextX_;
  536. tmp->nextX_->prevX_ = mn;  
  537. tmp->nextX_ = mn;
  538. } 
  539. }
  540. else{
  541. for(tmp = mn; tmp->prevX_ != NULL && tmp->prevX_->X() > X; tmp = tmp->prevX_);
  542. //fprintf(stdout,"Scanning the element addr %d X=%0.f, prev addr %d X=%0.fn", tmp, tmp->X(), tmp->prevX_, tmp->prevX_->X());
  543. if(tmp->prevX_ == NULL) {
  544. //fprintf(stdout, "tmp->prevX_ is NULLn");
  545. tmp->prevX_ = mn;
  546. mn->nextX_ = tmp;
  547. mn->prevX_ = NULL;
  548. xListHead_ = mn;
  549. } 
  550. else{
  551. //fprintf(stdout, "tmp->prevX_ is not NULL, tmp->prevX_->X()=%0.fn", tmp->prevX_->X());
  552. mn->nextX_ = tmp->prevX_->nextX_;
  553. mn->prevX_ = tmp->prevX_;
  554. tmp->prevX_->nextX_ = mn;  
  555. tmp->prevX_ = mn;
  556. }
  557. }
  558. }
  559. }
  562. MobileNode **
  563. WirelessChannel::getAffectedNodes(MobileNode *mn, double radius,
  564.   int *numAffectedNodes)
  565. {
  566. double xmin, xmax, ymin, ymax;
  567. int n = 0;
  568. MobileNode *tmp, **list, **tmpList;
  570. if (xListHead_ == NULL) {
  571. *numAffectedNodes=-1;
  572. fprintf(stderr, "xListHead_ is NULL when trying to send!!!n");
  573. return NULL;
  574. }
  576. xmin = mn->X() - radius;
  577. xmax = mn->X() + radius;
  578. ymin = mn->Y() - radius;
  579. ymax = mn->Y() + radius;
  581. // First allocate as much as possibly needed
  582. tmpList = new MobileNode*[numNodes_];
  584. for(tmp = xListHead_; tmp != NULL; tmp = tmp->nextX_) tmpList[n++] = tmp;
  585. for(int i = 0; i < n; ++i)
  586. if(tmpList[i]->speed()!=0.0 && (Scheduler::instance().clock() -
  587. tmpList[i]->getUpdateTime()) > XLIST_POSITION_UPDATE_INTERVAL )
  588. tmpList[i]->update_position();
  589. n=0;
  591. for(tmp = mn; tmp != NULL && tmp->X() >= xmin; tmp=tmp->prevX_)
  592. if(tmp->Y() >= ymin && tmp->Y() <= ymax){
  593. tmpList[n++] = tmp;
  594. }
  595. for(tmp = mn->nextX_; tmp != NULL && tmp->X() <= xmax; tmp=tmp->nextX_){
  596. if(tmp->Y() >= ymin && tmp->Y() <= ymax){
  597. tmpList[n++] = tmp;
  598. }
  599. }
  601. list = new MobileNode*[n];
  602. memcpy(list, tmpList, n * sizeof(MobileNode *));
  603. delete [] tmpList;
  604.          
  605. *numAffectedNodes = n;
  606. return list;
  607. }
  608.  
  611. /* Only to be used with mobile nodes (WirelessPhy).
  612.  * NS-2 at its current state support only a flat (non 3D) movement of nodes,
  613.  * so we assume antenna heights do not change for the dureation of
  614.  * a simulation.
  615.  * Another assumption - all nodes have the same wireless interface, so that
  616.  * the maximum distance, corresponding to CST (at max transmission power 
  617.  * level) stays the same for all nodes.
  618.  */
  619. void
  620. WirelessChannel::calcHighestAntennaZ(Phy *tifp)
  621. {
  622.        double highestZ = 0;
  623.        Phy *n;
  624.  
  625.        // HACK: the dynamic_cast is a workaround only!
  626.        for(n = ifhead_.lh_first; n; n = n->nextchnl()) {
  627.         if(dynamic_cast<WirelessPhyExt*>(n)) {
  628.         if(((WirelessPhyExt *)n)->getAntennaZ() > highestZ)
  629.         highestZ = ((WirelessPhyExt *)n)->getAntennaZ();
  630.         } else if (dynamic_cast<WirelessPhy*>(n)) {
  631.         if(((WirelessPhy *)n)->getAntennaZ() > highestZ)
  632.         highestZ = ((WirelessPhy *)n)->getAntennaZ();
  633.         } else highestZ = 0;
  634.        }
  635.  
  636.        highestAntennaZ_ = highestZ;
  638.        if (dynamic_cast<WirelessPhyExt*>(tifp)) {
  639.         WirelessPhyExt *wifp = (WirelessPhyExt *)tifp;
  640.         distCST_ = wifp->getDist(wifp->getCSThresh(), wifp->getPt(), 1.0, 1.0, 
  641.    highestZ , highestZ, wifp->getL(),
  642.    wifp->getLambda());
  643.        } else if (dynamic_cast<WirelessPhy*>(tifp)) {
  644.         WirelessPhy *wifp = (WirelessPhy *)tifp;
  645.         distCST_ = wifp->getDist(wifp->getCSThresh(), wifp->getPt(), 1.0, 1.0,
  646.         highestZ , highestZ, wifp->getL(),
  647.         wifp->getLambda());       
  648.        } else distCST_ = DBL_MAX;
  649. }
  652. double
  653. WirelessChannel::get_pdelay(Node* tnode, Node* rnode)
  654. {
  655. // Scheduler &s = Scheduler::instance();
  656. MobileNode* tmnode = (MobileNode*)tnode;
  657. MobileNode* rmnode = (MobileNode*)rnode;
  658. double propdelay = 0;
  660. propdelay = tmnode->propdelay(rmnode);
  662. assert(propdelay >= 0.0);
  663. if (propdelay == 0.0) {
  664. /* if the propdelay is 0 b/c two nodes are on top of 
  665.    each other, move them slightly apart -dam 7/28/98 */
  666. propdelay = 2 * DBL_EPSILON;
  667. //printf ("propdelay 0: %d->%d at %fn",
  668. // tmnode->address(), rmnode->address(), s.clock());
  669. }
  670. return propdelay;
  671. }
  675. // send():
  676. //  The packet occupies the channel for the transmission time, txtime
  677. //  If collision occur (>1 pkts overlap), corrupt all pkts involved
  678. // by setting the error bit or discard them
  680. // int Channel::send(Packet* p, Phy *tifp)
  681. // {
  682. //  // without collision, return 0
  683. //  Scheduler& s = Scheduler::instance();
  684. //  double now = s.clock();
  686. //  // busy = time when the channel are still busy with earlier tx
  687. //  double busy = max(txstop_, cwstop_);
  689. //  // txstop = when the channel is no longer busy from this tx
  690. //  txstop_ = max(busy, now + txtime);
  692. //  // now < busy => collision
  693. //  // mark the pkt error bit, EF_COLLISION
  694. //  // drop if there is a drop target, drop_
  695. //  if (now < busy) {
  696. //  // if still transmit earlier packet, pkt_, then corrupt it
  697. //  if (pkt_ && pkt_->time_ > now) {
  698. //  hdr_cmn::access(pkt_)->error() |= EF_COLLISION;
  699. //  if (drop_) {
  700. //  s.cancel(pkt_);
  701. //  drop(pkt_);
  702. //  pkt_ = 0;
  703. //  }
  704. //  }
  706. //  // corrupts the current packet p, and drop if drop_ exists
  707. //  hdr_cmn::access(p)->error() |= EF_COLLISION;
  708. //  if (drop_) {
  709. //  drop(p);
  710. //  return 1;
  711. //  }
  712. //  }
  714. //  // if p was not dropped, call recv() or hand it to trace_ if present
  715. //  pkt_ = p;
  716. //  trace_ ? trace_->recv(p, 0) : recv(p, 0);
  717. //  return 0;
  718. // }
  721. // contention():
  722. //  The MAC calls this Channel::contention() to enter contention period
  723. //  It determines when the contention window is over, cwstop_,
  724. // and schedule a callback to the MAC for the actual send()
  726. // void Channel::contention(Packet* p, Handler* h)
  727. // {
  728. //  Scheduler& s = Scheduler::instance();
  729. //  double now = s.clock();
  730. //  if (now > cwstop_) {
  731. //  cwstop_ = now + delay_;
  732. //  numtx_ = 0;
  733. //  }
  734. //  numtx_++;
  735. //  s.schedule(h, p, cwstop_ - now);
  736. // }
  739. // jam():
  740. //  Jam the channel for a period txtime
  741. //  Some MAC protocols use this to let other MAC detect collisions
  743. // int Channel::jam(double txtime)
  744. // {
  745. //  // without collision, return 0
  746. //  double now = Scheduler::instance().clock();
  747. //  if (txstop_ > now) {
  748. //  txstop_ = max(txstop_, now + txtime);
  749. //  return 1;
  750. //  }
  751. //  txstop_ = now + txtime;
  752. //  return (now < cwstop_);
  753. // }
  756. // int DuplexChannel::send(Packet* p, double txtime)
  757. // {
  758. //  double now = Scheduler::instance().clock();
  759. //  txstop_ = now + txtime;
  760. //  trace_ ? trace_->recv(p, 0) : recv(p, 0);
  761. //  return 0;
  762. // }
  765. // void DuplexChannel::contention(Packet* p, Handler* h)
  766. // {
  767. //  Scheduler::instance().schedule(h, p, delay_);
  768. //  numtx_ = 1;
  769. // }