NS2.26SourcesOriginal: MultihopMac class Reference

00061                          : mode_(MAC_IDLE), peer_(0),
00062         pendingPollEvent_(0), pkt_(0),
00063         ph_(this), pah_(this), pnh_(this), pth_(this), bh_(this)
00064 {
00065         /* Bind a bunch of variables to access from Tcl */
00066         bind_time("tx_rx_", &tx_rx_);
00067         bind_time("rx_tx_", &rx_tx_);
00068         bind_time("rx_rx_", &rx_rx_);
00069         bind_time("backoffBase_", &backoffBase_);
00070         backoffTime_ = backoffBase_;
00071 }

00190 { return index_; }

00152 { return backoffBase_; }

00154 { return backoffTime_ = bt; }

00153 { return backoffTime_; }

00188 { return bandwidth_; }

00162 { return &bh_; }

00078 {
00079         MultihopMac *p;
00080         
00081         if (!(mode_ & state))
00082                 return 0;
00083         else if (macList_ == 0)
00084                 return 1;
00085         for (p = (MultihopMac *)macList_; p != this && p != NULL; 
00086              p = (MultihopMac *)(p->macList())) {
00087                 if (p->mode() != MAC_IDLE) {
00088                         return 0;
00089                 }
00090         }
00091         return 1;
00092 }

00098 {
00099         if(argc == 2) {
00100                 Tcl& tcl = Tcl::instance();
00101                 
00102                 if(strcmp(argv[1], "id") == 0) {
00103                         tcl.resultf("%d", addr());
00104                         return TCL_OK;
00105                 } else if (strcmp(argv[1], "channel") == 0) {
00106                         tcl.resultf("%s", channel_->name());
00107                         return (TCL_OK);
00108                 }
00109                 
00110         } else if (argc == 3) {
00111                 TclObject *obj;
00112                 if( (obj = TclObject::lookup(argv[2])) == 0) {
00113                         fprintf(stderr, "%s lookup failed\n", argv[1]);
00114                         return TCL_ERROR;
00115                 }
00116                 else if (strcmp(argv[1], "netif") == 0) {
00117                         netif_ = (Phy*) obj;
00118                         return TCL_OK;
00119                 }
00120                 else if (strcmp(argv[1], "log-target") == 0) {
00121                         logtarget_ = (NsObject*) obj;
00122                         if(logtarget_ == 0)
00123                                 return TCL_ERROR;
00124                         return TCL_OK;
00125                 }
00126         }
00127         
00128         return BiConnector::command(argc, argv);
00129 }

00103 {
00104         if (!debug_)
00105                 return;
00106         va_list ap;
00107         va_start(ap, fmt);
00108         vprintf(fmt, ap);
00109 }

00064 {
00065         if (delay_bind_bool(varName, localName, "debug_", &debug_, tracer)) 
00066                 return TCL_OK;
00067         return TclObject::delay_bind_dispatch(varName, localName, tracer);
00068 }

00058 {
00059         delay_bind_init_one("debug_");
00060 }

00049 { return downtarget_; }

00145 {
00146         if (drop_ != 0)
00147                 drop_->recv(p, s);
00148         else
00149                 Packet::free(p);
00150 }

00136 {
00137         if (drop_ != 0)
00138                 drop_->recv(p);
00139         else
00140                 Packet::free(p);
00141 }

00092 {
00093         recv((Packet*)e);
00094 }

00196                                                             {
00197                 struct hdr_mac *dh = (struct hdr_mac*) hdr;
00198                 if(dst > -2)
00199                         dh->macDA_ = dst;
00200                 return dh->macDA();
00201         }

00202                                                             {
00203                 struct hdr_mac *dh = (struct hdr_mac*) hdr;
00204                 if(src > -2)
00205                         dh->macSA_ = src;
00206                 return dh->macSA();
00207         }

00208                                                                    {
00209                 struct hdr_mac *dh = (struct hdr_mac*) hdr;
00210                 if (type)
00211                         dh->hdr_type_ = type;
00212                 return dh->hdr_type();
00213         }

00223                                   { 
00224                 return (netif_ && uptarget_ && downtarget_); 
00225         }

00061 { return debug_; }

00146 { return mode_ = m; }

00145 { return mode_; }

00159 { return &pah_; }

00148 { return peer_ = p; }

00147 { return peer_; }

00156 { return pendingPollEvent_ = pe; }

00155 { return pendingPollEvent_; }

00158 { return &ph_; } /* access poll handler */

00157 { return pkt_; }

00160 { return &pnh_; }

00100 {
00101         Scheduler& s = Scheduler::instance();
00102         MultihopMac *pm = (MultihopMac*) getPeerMac(p);
00103         PollEvent *pe = new PollEvent(pm, this);
00104 
00105         pendingPollEvent_ = new PollEvent(pm, this);
00106         pkt_ = p->copy();       /* local copy for poll retries */
00107         double timeout = max(pm->rx_tx(), tx_rx_) + 4*pollTxtime(MAC_POLLSIZE);
00108         s.schedule(&bh_, pendingPollEvent_, timeout);
00109 
00110         /*  If the other interfaces are idle, then go ahead, else not. */
00111         if (checkInterfaces(MAC_IDLE)) { 
00112                 mode_ = MAC_POLLING;
00113                 peer_ = pm;
00114                 s.schedule(pm->ph(), (Event *)pe, pollTxtime(MAC_POLLSIZE));
00115         }
00116 }

00164 { return (double) s*8.0/bandwidth(); }

00161 { return &pth_; }

00097 {
00098         Packet::free(p);
00099 }

00212 {
00213         if (h == 0) {           /* from MAC classifier (pass pkt to LL) */
00214                 mode_ = MAC_IDLE;
00215                 Scheduler::instance().schedule(target_, p, delay_);
00216                 return;
00217         }
00218         callback_ = h;
00219         hdr_mac* mh = hdr_mac::access(p);
00220         mh->macSA() = addr_;
00221         if (mh->ftype() == MF_ACK) {
00222                 mode_ = MAC_SND;
00223                 send(p);
00224         } else {
00225                 mh->ftype() = MF_DATA;
00226                 poll(p);                /* poll first */
00227         }
00228 }

00174 {
00175         if (p != 0)
00176                 drop(p);
00177         state(MAC_IDLE);
00178         callback_->handle(&intr_);
00179 }

00151 { return rx_rx_; } /* access rx_rx time */

00150 { return rx_tx_; } /* access rx_tx time */

00196 {
00197         Scheduler& s = Scheduler::instance();
00198         if (mode_ != MAC_SND)
00199                 return;
00200 
00201         double txt = txtime(p);
00202         hdr_mac::access(p)->txtime() = txt;
00203         channel_->send(p, txt); // target is peer's mac handler
00204         s.schedule(callback_, &intr_, txt); // callback to higher layer (LL)
00205         mode_ = MAC_IDLE;
00206 }

00056                 { downtarget_->recv(p, h); }

00164 {
00165         Scheduler& s = Scheduler::instance();
00166         double txt = txtime(p);
00167         downtarget_->recv(p, this);
00168         if(!abstract_)
00169                 s.schedule(&hRes_, &intr_, txt);
00170 }

00058                 { uptarget_->recv(p, h); }

00146 {
00147         char* mh = (char*)p->access(hdr_mac::offset_);
00148         int dst = this->hdr_dst(mh);
00149 
00150         state(MAC_IDLE);
00151         if (((u_int32_t)dst != MAC_BROADCAST) && (dst != index_)) {
00152                 if(!abstract_){
00153                         drop(p);
00154                 }else {
00155                         //Dont want to creat a trace
00156                         Packet::free(p);
00157                 }
00158                 return;
00159         }
00160         Scheduler::instance().schedule(uptarget_, p, delay_);
00161 }

00192 { return state_ = (MacState) m; }

00191 { return state_; }

00149 { return tx_rx_; } /* access tx_rx time */

00184                                         {
00185                 return 8. * (MAC_HDR_LEN + \
00186                              (HDR_CMN(p))->size()) / bandwidth_;
00187         }

00181                                         {
00182                 return (8. * bytes / bandwidth_);
00183         }

00048 { return uptarget_; }


Public Member Functions
	MultihopMac ()
void	send (Packet *)
void	recv (Packet , Handler )
void	poll (Packet *)
int	checkInterfaces (int)
void	schedulePoll (MultihopMac *)
int	mode ()
int	mode (int m)
MultihopMac *	peer ()
MultihopMac *	peer (MultihopMac *p)
double	tx_rx ()
double	rx_tx ()
double	rx_rx ()
double	backoffBase ()
double	backoffTime ()
double	backoffTime (double bt)
PollEvent *	pendingPE ()
PollEvent *	pendingPE (PollEvent *pe)
Packet *	pkt ()
PollHandler *	ph ()
PollAckHandler *	pah ()
PollNackHandler *	pnh ()
PollTimeoutHandler *	pth ()
BackoffHandler *	bh ()
double	pollTxtime (int s)
virtual void	recv (Packet p, const char s)
virtual void	sendDown (Packet *p)
virtual void	sendUp (Packet *p)
virtual void	resume (Packet *p=0)
virtual void	installTap (Tap *t)
double	txtime (int bytes)
double	txtime (Packet *p)
double	bandwidth () const
int	addr ()
MacState	state ()
MacState	state (int m)
virtual int	hdr_dst (char *hdr, int dst=-2)
virtual int	hdr_src (char *hdr, int src=-2)
virtual int	hdr_type (char *hdr, u_int16_t type=0)
NsObject *	uptarget ()
NsObject *	downtarget ()
virtual void	drop (Packet *p)
virtual void	recvOnly (Packet *)
virtual void	delay_bind_init_all ()
virtual int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
int	isdebug () const
virtual void	debug (const char *fmt,...)
Protected Member Functions
virtual void	sendDown (Packet p, Handler h)
virtual void	sendUp (Packet p, Handler h)
int	command (int argc, const char const argv)
virtual int	initialized ()
virtual void	drop (Packet p, const char s)
virtual void	reset ()
void	handle (Event *)
Protected Attributes
int	mode_
MultihopMac *	peer_
double	tx_rx_
double	rx_tx_
double	rx_rx_
double	backoffTime_
double	backoffBase_
PollEvent *	pendingPollEvent_
Packet *	pkt_
PollHandler	ph_
PollAckHandler	pah_
PollNackHandler	pnh_
PollTimeoutHandler	pth_
BackoffHandler	bh_
int	index_
double	bandwidth_
double	delay_
int	abstract_
Phy *	netif_
Tap *	tap_
LL *	ll_
Channel *	channel_
Handler *	callback_
MacHandlerResume	hRes_
MacHandlerSend	hSend_
Event	intr_
MacState	state_
Packet *	pktRx_
Packet *	pktTx_
NsObject *	uptarget_
NsObject *	downtarget_
NsObject *	drop_
int	debug_

MultihopMac Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation