NS2.26SourcesOriginal: MacCsmaCa class Reference

00190 { return index_; }

00141 {
00142         Scheduler& s = Scheduler::instance();
00143         double now = s.clock();
00144 
00145         // if retransmission time within limit, do exponential backoff
00146         // else drop the packet and resume
00147         if (++rtx_ < rtxLimit_) {
00148                 delay += max(channel_->txstop() + ifs_ - now, 0.0);
00149                 int slot = Random::integer(cw_);
00150                 s.schedule(h, p, delay + slotTime_ * slot);
00151                 cw_ = min(2 * cw_, cwmax_);
00152         }
00153         else
00154                 resume(p);
00155 }

00188 { return bandwidth_; }

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 }

00159 {
00160         Scheduler& s = Scheduler::instance();
00161         double txt = txtime(p) - (s.clock() - txstart_);
00162         hdr_mac::access(p)->txtime() = txt;
00163         channel_->send(p, txt);
00164         s.schedule(&hRes_, &eEoc_, txt);
00165         rtx_ = 0;
00166         cw_ = cwmin_;
00167 }

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_; }

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

00132 {
00133         if (hdr_cmn::access(p)->direction() == hdr_cmn::UP) {
00134                 sendUp(p);
00135                 return;
00136         }
00137 
00138         callback_ = h;
00139         hdr_mac* mh = HDR_MAC(p);
00140         mh->set(MF_DATA, index_);
00141         state(MAC_SEND);
00142         sendDown(p);
00143 }

00092 {
00093         Scheduler& s = Scheduler::instance();
00094         s.schedule(callback_, &intr_, ifs_ + slotTime_ * cwmin_);
00095         if (p != 0)
00096                 drop(p);
00097         callback_ = 0;
00098         state(MAC_IDLE);
00099         rtx_ = 0;
00100         cw_ = cwmin_;
00101 }

00183 {
00184         Scheduler& s = Scheduler::instance();
00185         double delay = channel_->txstop() + ifs_ - s.clock();
00186 
00187         if (csense_ && delay > 0)
00188                 backoff(&hSend_, p);
00189         else {
00190                 txstart_ = s.clock();
00191                 channel_->contention(p, &hEoc_);
00192         }
00193 }

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_; }

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
virtual void	send (Packet *)
virtual void	resume (Packet *p=0)
virtual void	endofContention (Packet *p)
virtual void	recv (Packet p, Handler h)
virtual void	recv (Packet p, const char s)
virtual void	sendDown (Packet *p)
virtual void	sendUp (Packet *p)
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	backoff (Handler h, Packet p, double delay=0)
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
double	txstart_
double	ifs_
double	slotTime_
int	cw_
int	cwmin_
int	cwmax_
int	rtx_
int	rtxLimit_
int	csense_
Event	eEoc_
MacHandlerEoc	hEoc_
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_

MacCsmaCa Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Member Function Documentation

Member Data Documentation