NS2.26SourcesOriginal: Channel class Reference

00090                  : TclObject()
00091 {
00092         index_ = ChannelIndex++;
00093         LIST_INIT(&ifhead_);
00094         bind_time("delay_", &delay_);
00095 }

00098 {
00099         
00100         if (argc == 3) {
00101                 TclObject *obj;
00102 
00103                 if( (obj = TclObject::lookup(argv[2])) == 0) {
00104                         fprintf(stderr, "%s lookup failed\n", argv[1]);
00105                         return TCL_ERROR;
00106                 }
00107                 if (strcmp(argv[1], "trace-target") == 0) {
00108                         trace_ = (Trace*) obj;
00109                         return (TCL_OK);
00110                 }
00111                 else if(strcmp(argv[1], "addif") == 0) {
00112                         ((Phy*) obj)->insertchnl(&ifhead_);
00113                         ((Phy*) obj)->setchnl(this);
00114                         return TCL_OK;
00115                 }
00116                 // add interface for grid_keeper_
00117                 /*else if(strncasecmp(argv[1], "grid_keeper", 5) == 0) {
00118                         grid_keeper_ = (GridKeeper*)obj;
00119                         return TCL_OK;
00120                         }*/
00121         } else if (argc == 2) {
00122                 Tcl& tcl = Tcl::instance();
00123                 if (strcmp(argv[1], "trace-target") == 0) {
00124                         tcl.resultf("%s", trace_->name());
00125                         return (TCL_OK);
00126                 }
00127                 else if(strcmp(argv[1], "id") == 0) {
00128                         tcl.resultf("%d", index_);
00129                         return TCL_OK;
00130                 }
00131         }
00132         return TclObject::command(argc, argv);
00133 }

00221 {
00222         Phy *n;
00223         
00224         fprintf(stdout, "Network Interface List\n");
00225         for(n = ifhead_.lh_first; n; n = n->nextchnl() )
00226                 n->dump();
00227         fprintf(stdout, "--------------------------------------------------\n");
00228 }

00213 {
00214         // Dummy function
00215         return delay_;
00216 }

00067 {return index_;}

00066 { return delay_; };

00137 {
00138 //      Scheduler& s = Scheduler::instance();
00139 //      hdr_cmn::access(p)->direction() = hdr_cmn::UP;
00140 //      s.schedule(target_, p, txstop_ + delay_ - s.clock());
00141         sendUp(p, (Phy*)h);
00142 }

00148 {
00149         Scheduler &s = Scheduler::instance();
00150         Phy *rifp = ifhead_.lh_first;
00151         Node *tnode = tifp->node();
00152         Node *rnode = 0;
00153         Packet *newp;
00154         double propdelay = 0.0;
00155         struct hdr_cmn *hdr = HDR_CMN(p);
00156         
00157         hdr->direction() = hdr_cmn::UP;
00158         
00159         if (GridKeeper::instance()) {
00160             int i;
00161             GridKeeper* gk = GridKeeper::instance();
00162             int size = gk->size_; 
00163             
00164             MobileNode **outlist = new MobileNode *[size];
00165          
00166             int out_index = gk->get_neighbors((MobileNode*)tnode,
00167                                                          outlist);
00168             for (i=0; i < out_index; i ++) {
00169                 
00170                   newp = p->copy();
00171                   rnode = outlist[i];
00172                   propdelay = get_pdelay(tnode, rnode);
00173 
00174                   rifp = (rnode->ifhead()).lh_first; 
00175                   for(; rifp; rifp = rifp->nextnode()){
00176                           if (rifp->channel() == this){
00177                                  s.schedule(rifp, newp, propdelay); 
00178                                  break;
00179                           }
00180                   }
00181             }
00182             delete [] outlist; 
00183         } else {
00184             for( ; rifp; rifp = rifp->nextchnl()) {
00185                 rnode = rifp->node();
00186                 if(rnode == tnode)
00187                         continue;
00188                 /*
00189                  * Each node needs to get their own copy of this packet.
00190                  * Since collisions occur at the receiver, we can have
00191                  * two nodes canceling and freeing the *same* simulation
00192                  * event.
00193                  *
00194                  */
00195                 newp = p->copy();
00196                 propdelay = get_pdelay(tnode, rnode);
00197                 
00198                 /*
00199                  * Each node on the channel receives a copy of the
00200                  * packet.  The propagation delay determines exactly
00201                  * when the receiver's interface detects the first
00202                  * bit of this packet.
00203                  */
00204                 s.schedule(rifp, newp, propdelay);
00205             }
00206         }
00207         Packet::free(p);
00208 }


Public Member Functions
	Channel (void)
virtual int	command (int argc, const char const argv)
virtual void	recv (Packet p, Handler )
double	maxdelay ()
int	index ()
Public Attributes
if_head	ifhead_
TclObject *	gridkeeper_
Protected Member Functions
virtual double	get_pdelay (Node tnode, Node rnode)
Protected Attributes
int	index_
double	delay_
Trace *	trace_
Private Member Functions
virtual void	sendUp (Packet p, Phy txif)
void	dump (void)

Channel Class Reference

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation