Snoop Class Reference

#include <snoop.h>

Inheritance diagram for Snoop:

[legend]Collaboration diagram for Snoop:

[legend]List of all members.

Public Member Functions
	Snoop ()
void	recv (Packet *, Handler *)
void	handle (Event *)
int	snoop_rxmit (Packet *)
int	next (int i)
int	prev (int i)
int	wl_next (int i)
int	wl_prev (int i)
virtual void	recv (Packet *p, const char *s)
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
int	command (int argc, const char *const *argv)
void	reset ()
void	wlreset ()
void	snoop_data (Packet *)
int	snoop_ack (Packet *)
void	snoop_wless_data (Packet *)
void	snoop_wired_ack (Packet *)
int	snoop_wlessloss (int)
double	snoop_cleanbufs_ (int)
void	snoop_rtt (double)
int	snoop_qlong ()
int	snoop_insert (Packet *)
int	empty_ ()
void	savepkt_ (Packet *, int, int)
void	update_state_ ()
double	timeout ()
void	snoop_cleanup ()
Protected Attributes
LLSnoop *	parent_
NsObject *	recvtarget_
Handler *	callback_
SnoopRxmitHandler *	rxmitHandler_
SnoopPersistHandler *	persistHandler_
int	snoopDisable_
u_short	fstate_
int	lastSeen_
int	lastAck_
int	expNextAck_
short	expDupacks_
double	srtt_
double	rttvar_
double	tailTime_
int	rxmitStatus_
short	bufhead_
Event *	toutPending_
short	buftail_
Packet *	pkts_ [SNOOP_MAXWIND]
int	wl_state_
int	wl_lastSeen_
int	wl_lastAck_
int	wl_bufhead_
int	wl_buftail_
hdr_seq *	wlseqs_ [SNOOP_WLSEQS]
int	maxbufs_
double	snoopTick_
double	g_
int	integrate_
int	lru_
int	debug_
Friends
class	SnoopRxmitHandler
class	SnoopPersistHandler

---

Constructor & Destructor Documentation

Snoop::Snoop (   )

Definition at line 68 of file snoop.cc. References g_, lru_, maxbufs_, hdr_seq::num, pkts_, rttvar_, rxmitHandler_, rxmitStatus_, hdr_seq::seq, SNOOP_MAXWIND, SNOOP_WLEMPTY, SNOOP_WLSEQS, snoopDisable_, SnoopRxmitHandler, snoopTick_, srtt_, tailTime_, and wlseqs_. : NsObject(), fstate_(0), lastSeen_(-1), lastAck_(-1), expNextAck_(0), expDupacks_(0), bufhead_(0), toutPending_(0), buftail_(0), wl_state_(SNOOP_WLEMPTY), wl_lastSeen_(-1), wl_lastAck_(-1), wl_bufhead_(0), wl_buftail_(0) { bind("snoopDisable_", &snoopDisable_); bind_time("srtt_", &srtt_); bind_time("rttvar_", &rttvar_); bind("maxbufs_", &maxbufs_); bind("snoopTick_", &snoopTick_); bind("g_", &g_); bind("tailTime_", &tailTime_); bind("rxmitStatus_", &rxmitStatus_); bind("lru_", &lru_); rxmitHandler_ = new SnoopRxmitHandler(this); int i; for (i = 0; i < SNOOP_MAXWIND; i++) /* data from wired->wireless */ pkts_[i] = 0; for (i = 0; i < SNOOP_WLSEQS; i++) {/* data from wireless->wired */ wlseqs_[i] = (hdr_seq *) malloc(sizeof(hdr_seq)); wlseqs_[i]->seq = wlseqs_[i]->num = 0; } if (maxbufs_ == 0) maxbufs_ = SNOOP_MAXWIND; }

---

Member Function Documentation

int Snoop::command (  int  argc, const char *const *  argv )  [protected, virtual]

Reimplemented from NsObject. Definition at line 133 of file snoop.cc. References hdr_snoop::access(), buftail_, NsObject::command(), empty_(), parent_, pkts_, recvtarget_, rxmitStatus_, sh, SNOOP_PROPAGATE, snoop_rxmit(), and LL::uptarget(). { //Tcl& tcl = Tcl::instance(); if (argc == 3) { if (strcmp(argv[1], "llsnoop") == 0) { parent_ = (LLSnoop *) TclObject::lookup(argv[2]); if (parent_) recvtarget_ = parent_->uptarget(); return (TCL_OK); } if (strcmp(argv[1], "check-rxmit") == 0) { if (empty_()) { rxmitStatus_ = SNOOP_PROPAGATE; return (TCL_OK); } Packet *p = pkts_[buftail_]; hdr_snoop *sh = hdr_snoop::access(p); if (sh->sndTime()!=-1 && sh->sndTime()<atoi(argv[2]) && sh->numRxmit() == 0) /* candidate for retransmission */ rxmitStatus_ = snoop_rxmit(p); else rxmitStatus_ = SNOOP_PROPAGATE; return (TCL_OK); } } return NsObject::command(argc, argv); }

Here is the call graph for this function:

void NsObject::debug (  const char *  fmt, ...  )  [virtual, inherited]

Definition at line 102 of file object.cc. References NsObject::debug_. { if (!debug_) return; va_list ap; va_start(ap, fmt); vprintf(fmt, ap); }

int NsObject::delay_bind_dispatch (  const char *  varName, const char *  localName, TclObject *  tracer )  [virtual, inherited]

Reimplemented in BayFullTcpAgent, Agent, MPLSAddressClassifier, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent. Definition at line 63 of file object.cc. References NsObject::debug_. Referenced by MPLSAddressClassifier::delay_bind_dispatch(), and Agent::delay_bind_dispatch(). { if (delay_bind_bool(varName, localName, "debug_", &debug_, tracer)) return TCL_OK; return TclObject::delay_bind_dispatch(varName, localName, tracer); }

void NsObject::delay_bind_init_all (   )  [virtual, inherited]

Reimplemented in BayFullTcpAgent, Agent, MPLSAddressClassifier, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent. Definition at line 57 of file object.cc. Referenced by MPLSAddressClassifier::delay_bind_init_all(), and Agent::delay_bind_init_all(). { delay_bind_init_one("debug_"); }

int Snoop::empty_ (   )  [inline, protected]

Definition at line 139 of file snoop.h. References bufhead_, buftail_, fstate_, and SNOOP_FULL. Referenced by command(), snoop_cleanbufs_(), and snoop_data(). {return (bufhead_==buftail_ &&!(fstate_&SNOOP_FULL));}

void Snoop::handle (  Event *   )  [virtual]

Reimplemented from NsObject. Definition at line 227 of file snoop.cc. References hdr_cmn::access(), LinkDelay::delay(), Connector::drop(), hdr_cmn::error(), Packet::free(), Scheduler::instance(), packet_t, parent_, PT_ACK, PT_TCP, hdr_cmn::ptype(), recvtarget_, Scheduler::schedule(), snoop_ack(), SNOOP_PROPAGATE, and snoop_wless_data(). Referenced by recv(). { Packet *p = (Packet *) e; packet_t type = hdr_cmn::access(p)->ptype(); //int seq = hdr_tcp::access(p)->seqno(); int prop = SNOOP_PROPAGATE; // by default; propagate ack or packet Scheduler& s = Scheduler::instance(); //hdr_ll *llh = hdr_ll::access(p); if (hdr_cmn::access(p)->error()) { parent_->drop(p); // drop packet if it's been corrupted return; } if (type == PT_ACK) prop = snoop_ack(p); else if (type == PT_TCP) /* XXX what about TELNET? */ snoop_wless_data(p); if (prop == SNOOP_PROPAGATE) s.schedule(recvtarget_, e, parent_->delay()); else { // suppress ack /* printf("---- %f suppressing ack %d\n", s.clock(), seq);*/ Packet::free(p); } }

Here is the call graph for this function:

int NsObject::isdebug (   )  const [inline, inherited]

Definition at line 61 of file object.h. References NsObject::debug_. { return debug_; }

int Snoop::next (  int  i  )  [inline]

Definition at line 121 of file snoop.h. References maxbufs_. Referenced by SnoopRxmitHandler::handle(), snoop_ack(), snoop_cleanbufs_(), and snoop_insert(). { return (i+1) % maxbufs_; }

int Snoop::prev (  int  i  )  [inline]

Definition at line 122 of file snoop.h. References maxbufs_. Referenced by snoop_insert(). { return ((i == 0) ? maxbufs_-1 : i-1); };

void NsObject::recv (  Packet *  p, const char *  s )  [virtual, inherited]

Reimplemented in CMUTrace. Definition at line 96 of file object.cc. References Packet::free(). { Packet::free(p); }

Here is the call graph for this function:

void Snoop::recv (  Packet *  , Handler *  )  [virtual]

Implements NsObject. Definition at line 200 of file snoop.cc. References hdr_cmn::access(), hdr_cmn::direction(), hdr_cmn::DOWN, handle(), HDR_CMN, packet_t, parent_, PT_ACK, PT_TCP, hdr_cmn::ptype(), LL::sendDown(), snoop_data(), snoop_wired_ack(), and hdr_cmn::UP. Referenced by LLSnoop::recv(). { hdr_cmn *ch = HDR_CMN(p); if(ch->direction() == hdr_cmn::UP) { handle((Event *) p); return; } packet_t type = hdr_cmn::access(p)->ptype(); /* Put packet (if not ack) in cache after checking, and send it on */ if (type == PT_TCP) snoop_data(p); else if (type == PT_ACK) snoop_wired_ack(p); ch->direction() = hdr_cmn::DOWN; // Ben added parent_->sendDown(p); /* vector to LLSnoop's sendto() */ }

Here is the call graph for this function:

virtual void NsObject::recvOnly (  Packet *   )  [inline, virtual, inherited]

Reimplemented in Agent, and Trace. Definition at line 56 of file object.h. Referenced by Trace::recvOnly(). {};

void Snoop::reset (   )  [protected, virtual]

Reimplemented from NsObject. Definition at line 99 of file snoop.cc. References bufhead_, buftail_, Scheduler::cancel(), expDupacks_, expNextAck_, Packet::free(), fstate_, Scheduler::instance(), lastAck_, lastSeen_, pkts_, SNOOP_MAXWIND, and toutPending_. Referenced by snoop_data(). { // printf("%x resetting\n", this); fstate_ = 0; lastSeen_ = -1; lastAck_ = -1; expNextAck_ = 0; expDupacks_ = 0; bufhead_ = buftail_ = 0; if (toutPending_) { Scheduler::instance().cancel(toutPending_); // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure). toutPending_ = 0; }; for (int i = 0; i < SNOOP_MAXWIND; i++) { if (pkts_[i]) { Packet::free(pkts_[i]); pkts_[i] = 0; } } }

Here is the call graph for this function:

void Snoop::savepkt_ (  Packet *  , int  , int  )  [protected]

Definition at line 391 of file snoop.cc. References hdr_snoop::access(), Scheduler::clock(), Packet::copy(), Scheduler::instance(), pkts_, and sh. Referenced by snoop_insert(). { pkts_[i] = p->copy(); Packet *pkt = pkts_[i]; hdr_snoop *sh = hdr_snoop::access(pkt); sh->seqno() = seq; sh->numRxmit() = 0; sh->senderRxmit() = 0; sh->sndTime() = Scheduler::instance().clock(); }

Here is the call graph for this function:

int Snoop::snoop_ack (  Packet *   )  [protected]

Definition at line 407 of file snoop.cc. References hdr_snoop::access(), hdr_tcp::access(), bufhead_, buftail_, expDupacks_, expNextAck_, fstate_, lastAck_, next(), pkts_, hdr_tcp::seqno(), sh, snoop_cleanbufs_(), SNOOP_CLOSED, SNOOP_MAXWIND, SNOOP_NOACK, SNOOP_PROPAGATE, snoop_rtt(), snoop_rxmit(), and SNOOP_SUPPRESS. Referenced by handle(). { Packet *pkt; int ack = hdr_tcp::access(p)->seqno(); /* * There are 3 cases: * 1. lastAck_ > ack. In this case what has happened is * that the acks have come out of order, so we don't * do any local processing but forward it on. * 2. lastAck_ == ack. This is a duplicate ack. If we have * the packet we resend it, and drop the dupack. * Otherwise we never got it from the fixed host, so we * need to let the dupack get through. * Set expDupacks_ to number of packets already sent * This is the number of dup acks to ignore. * 3. lastAck_ < ack. Set lastAck_ = ack, and update * the head of the buffer queue. Also clean up ack'd packets. */ if (fstate_ & SNOOP_CLOSED || lastAck_ > ack) return SNOOP_PROPAGATE; // send ack onward if (lastAck_ == ack) { /* A duplicate ack; pure window updates don't occur in ns. */ pkt = pkts_[buftail_]; if (pkt == 0) return SNOOP_PROPAGATE; hdr_snoop *sh = hdr_snoop::access(pkt); if (pkt == 0 || sh->seqno() > ack + 1) /* don't have packet, letting thru' */ return SNOOP_PROPAGATE; /* * We have the packet: one of 3 possibilities: * 1. We are not expecting any dupacks (expDupacks_ == 0) * 2. We are expecting dupacks (expDupacks_ > 0) * 3. We are in an inconsistent state (expDupacks_ == -1) */ if (expDupacks_ == 0) { // not expecting it #define RTX_THRESH 1 static int thresh = 0; if (thresh++ < RTX_THRESH) /* no action if under RTX_THRESH */ return SNOOP_PROPAGATE; thresh = 0; // if the packet is a sender retransmission, pass on if (sh->senderRxmit()) return SNOOP_PROPAGATE; /* * Otherwise, not triggered by sender. If this is * the first dupack recd., we must determine how many * dupacks will arrive that must be ignored, and also * rexmit the desired packet. Note that expDupacks_ * will be -1 if we miscount for some reason. */ expDupacks_ = bufhead_ - expNextAck_; if (expDupacks_ < 0) expDupacks_ += SNOOP_MAXWIND; expDupacks_ -= RTX_THRESH + 1; expNextAck_ = next(buftail_); if (sh->numRxmit() == 0) return snoop_rxmit(pkt); } else if (expDupacks_ > 0) { expDupacks_--; return SNOOP_SUPPRESS; } else if (expDupacks_ == -1) { if (sh->numRxmit() < 2) { return snoop_rxmit(pkt); } } else // let sender deal with it return SNOOP_PROPAGATE; } else { // a new ack fstate_ &= ~SNOOP_NOACK; // have seen at least 1 new ack /* free buffers */ double sndTime = snoop_cleanbufs_(ack); if (sndTime != -1) snoop_rtt(sndTime); expDupacks_ = 0; expNextAck_ = buftail_; lastAck_ = ack; } return SNOOP_PROPAGATE; }

Here is the call graph for this function:

double Snoop::snoop_cleanbufs_ (  int   )  [protected]

Definition at line 611 of file snoop.cc. References hdr_tcp::access(), hdr_snoop::access(), bufhead_, buftail_, Scheduler::cancel(), empty_(), Packet::free(), fstate_, Scheduler::instance(), next(), pkts_, rxmitHandler_, Scheduler::schedule(), hdr_tcp::seqno(), sh, SNOOP_FULL, tailTime_, timeout(), and toutPending_. Referenced by snoop_ack(). { Scheduler &s = Scheduler::instance(); double sndTime = -1; if (toutPending_) { s.cancel(toutPending_); // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure). toutPending_ = 0; }; if (empty_()) return sndTime; int i = buftail_; do { hdr_snoop *sh = hdr_snoop::access(pkts_[i]); int seq = hdr_tcp::access(pkts_[i])->seqno(); if (seq <= ack) { sndTime = sh->sndTime(); Packet::free(pkts_[i]); pkts_[i] = 0; fstate_ &= ~SNOOP_FULL; /* XXX redundant? */ } else if (seq > ack) break; i = next(i); } while (i != bufhead_); if ((i != buftail_) || (bufhead_ != buftail_)) { fstate_ &= ~SNOOP_FULL; buftail_ = i; } if (!empty_()) { toutPending_ = (Event *) (pkts_[buftail_]); s.schedule(rxmitHandler_, toutPending_, timeout()); hdr_snoop *sh = hdr_snoop::access(pkts_[buftail_]); tailTime_ = sh->sndTime(); } return sndTime; }

Here is the call graph for this function:

void Snoop::snoop_cleanup (   )  [protected]

Definition at line 751 of file snoop.cc. { }

void Snoop::snoop_data (  Packet *   )  [protected]

Definition at line 261 of file snoop.cc. References hdr_tcp::access(), buftail_, Scheduler::cancel(), empty_(), fstate_, LL::ifq(), Scheduler::instance(), lastSeen_, Queue< T >::length(), Queue< T >::limit(), lru_, parent_, pkts_, reset(), rxmitHandler_, Scheduler::schedule(), hdr_tcp::seqno(), SNOOP_ALIVE, SNOOP_FULL, snoop_insert(), SNOOP_TAIL, timeout(), and toutPending_. Referenced by recv(). { Scheduler &s = Scheduler::instance(); int seq = hdr_tcp::access(p)->seqno(); int resetPending = 0; // printf("%x snoop_data: %f sending packet %d\n", this, s.clock(), seq); if (fstate_ & SNOOP_ALIVE && seq == 0) reset(); fstate_ |= SNOOP_ALIVE; if ((fstate_ & SNOOP_FULL) && !lru_) { // printf("snoop full, fwd'ing\n t %d h %d", buftail_, bufhead_); if (seq > lastSeen_) lastSeen_ = seq; return; } /* * Only if the ifq is NOT full do we insert, since otherwise we want * congestion control to kick in. */ if (parent_->ifq()->length() < parent_->ifq()->limit()-1) resetPending = snoop_insert(p); if (toutPending_ && resetPending == SNOOP_TAIL) { s.cancel(toutPending_); // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure). toutPending_ = 0; } if (!toutPending_ && !empty_()) { toutPending_ = (Event *) (pkts_[buftail_]); s.schedule(rxmitHandler_, toutPending_, timeout()); } return; }

Here is the call graph for this function:

int Snoop::snoop_insert (  Packet *   )  [protected]

Definition at line 306 of file snoop.cc. References hdr_snoop::access(), hdr_tcp::access(), bufhead_, buftail_, Scheduler::clock(), expNextAck_, Packet::free(), fstate_, Scheduler::instance(), lastAck_, lastSeen_, next(), pkts_, prev(), savepkt_(), hdr_snoop::seqno(), hdr_tcp::seqno(), sh, SNOOP_FULL, and SNOOP_TAIL. Referenced by snoop_data(). { int i, seq = hdr_tcp::access(p)->seqno(), retval=0; if (seq <= lastAck_) return retval; if (fstate_ & SNOOP_FULL) { /* free tail and go on */ printf("snoop full, making room\n"); Packet::free(pkts_[buftail_]); pkts_[buftail_] = 0; buftail_ = next(buftail_); fstate_ |= ~SNOOP_FULL; } if (seq > lastSeen_ || pkts_[buftail_] == 0) { // in-seq or empty cache i = bufhead_; bufhead_ = next(bufhead_); } else if (seq < hdr_snoop::access(pkts_[buftail_])->seqno()) { buftail_ = prev(buftail_); i = buftail_; } else { for (i = buftail_; i != bufhead_; i = next(i)) { hdr_snoop *sh = hdr_snoop::access(pkts_[i]); if (sh->seqno() == seq) { // cached before sh->numRxmit() = 0; sh->senderRxmit() = 1; //must be a sender retr sh->sndTime() = Scheduler::instance().clock(); return SNOOP_TAIL; } else if (sh->seqno() > seq) { //not cached before, should insert in the middle // find the position it should be: prev(i) Packet *temp = pkts_[prev(buftail_)]; for (int j = buftail_; j != i; j = next(j)) pkts_[prev(j)] = pkts_[j]; i = prev(i); pkts_[i] = temp; // seems not necessary. Ben comments buftail_ = prev(buftail_); break; } } // This should not happen, since seq must be > lastSeen, which is // handled before in the first if. Ben comments if (i == bufhead_) bufhead_ = next(bufhead_); } // save in the buffer savepkt_(p, seq, i); if (bufhead_ == buftail_) fstate_ |= SNOOP_FULL; /* * If we have one of the following packets: * 1. a network-out-of-order packet, or * 2. a fast rxmit packet, or 3. a sender retransmission * AND it hasn't already been buffered, * then seq will be < lastSeen_. * We mark this packet as having been due to a sender rexmit * and use this information in snoop_ack(). We let the dupacks * for this packet go through according to expDupacks_. */ if (seq < lastSeen_) { /* not in-order -- XXX should it be <= ? */ if (buftail_ == i) { hdr_snoop *sh = hdr_snoop::access(pkts_[i]); sh->senderRxmit() = 1; sh->numRxmit() = 0; } expNextAck_ = buftail_; retval = SNOOP_TAIL; } else lastSeen_ = seq; return retval; }

Here is the call graph for this function:

int Snoop::snoop_qlong (   )  [protected]

Definition at line 703 of file snoop.cc. Referenced by snoop_rxmit(). { /* For now only instantaneous lengths */ // if (parent_->ifq()->length() <= 3*parent_->ifq()->limit()/4) return 1; // return 0; }

void Snoop::snoop_rtt (  double   )  [protected]

Definition at line 658 of file snoop.cc. References Scheduler::clock(), g_, Scheduler::instance(), LLSnoop::integrate(), parent_, rttvar_, LLSnoop::snoop_rtt(), and srtt_. Referenced by snoop_ack(). { double rtt = Scheduler::instance().clock() - sndTime; if (parent_->integrate()) { parent_->snoop_rtt(sndTime); return; } if (rtt > 0) { srtt_ = g_*srtt_ + (1-g_)*rtt; double delta = rtt - srtt_; if (delta < 0) delta = -delta; if (rttvar_ != 0) rttvar_ = g_*delta + (1-g_)*rttvar_; else rttvar_ = delta; } }

Here is the call graph for this function:

int Snoop::snoop_rxmit (  Packet *   )

Definition at line 716 of file snoop.cc. References hdr_tcp::access(), hdr_snoop::access(), Scheduler::cancel(), Scheduler::clock(), Packet::copy(), hdr_cmn::direction(), hdr_cmn::DOWN, HDR_CMN, Scheduler::instance(), parent_, rxmitHandler_, Scheduler::schedule(), LL::sendDown(), hdr_tcp::seqno(), sh, SNOOP_MAX_RXMIT, SNOOP_PROPAGATE, snoop_qlong(), SNOOP_SUPPRESS, timeout(), and toutPending_. Referenced by command(), SnoopRxmitHandler::handle(), and snoop_ack(). { Scheduler& s = Scheduler::instance(); if (pkt != 0) { hdr_snoop *sh = hdr_snoop::access(pkt); if (sh->numRxmit() < SNOOP_MAX_RXMIT && snoop_qlong()) { /* && sh->seqno() == lastAck_+1) */ #if 0 printf("%f Rxmitting packet %d\n", s.clock(), hdr_tcp::access(pkt)->seqno()); #endif // need to specify direction, in this case, down hdr_cmn *ch = HDR_CMN(pkt); ch->direction() = hdr_cmn::DOWN; // Ben added sh->sndTime() = s.clock(); sh->numRxmit() = sh->numRxmit() + 1; Packet *p = pkt->copy(); parent_->sendDown(p); } else return SNOOP_PROPAGATE; } /* Reset timeout for later time. */ if (toutPending_) { s.cancel(toutPending_); // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure). }; toutPending_ = (Event *)pkt; s.schedule(rxmitHandler_, toutPending_, timeout()); return SNOOP_SUPPRESS; }

Here is the call graph for this function:

void Snoop::snoop_wired_ack (  Packet *   )  [protected]

Definition at line 560 of file snoop.cc. References hdr_flags::access(), hdr_tcp::access(), hdr_flags::eln_, hdr_seq::num, hdr_seq::seq, hdr_tcp::seqno(), SNOOP_WLEMPTY, snoop_wlessloss(), wl_bufhead_, wl_buftail_, wl_lastAck_, wl_next(), wl_state_, and wlseqs_. Referenced by recv(). { hdr_tcp *th = hdr_tcp::access(p); int ack = th->seqno(); int i; if (ack == wl_lastAck_ && snoop_wlessloss(ack)) { hdr_flags::access(p)->eln_ = 1; } else if (ack > wl_lastAck_) { /* update info about unack'd data */ for (i = wl_buftail_; i != wl_bufhead_; i = wl_next(i)) { hdr_seq *t = wlseqs_[i]; if (t->seq + t->num - 1 <= ack) { t->seq = t->num = 0; } else if (ack < t->seq) { break; } else if (ack < t->seq + t->num - 1) { /* ack for part of a block */ t->num -= ack - t->seq +1; t->seq = ack + 1; break; } } wl_buftail_ = i; if (wl_buftail_ == wl_bufhead_) wl_state_ |= SNOOP_WLEMPTY; wl_lastAck_ = ack; /* Even a new ack could cause an ELN to be set. */ if (wl_bufhead_ != wl_buftail_ && snoop_wlessloss(ack)) hdr_flags::access(p)->eln_ = 1; } }

Here is the call graph for this function:

void Snoop::snoop_wless_data (  Packet *   )  [protected]

Definition at line 517 of file snoop.cc. References hdr_tcp::access(), hdr_seq::num, hdr_seq::seq, hdr_tcp::seqno(), SNOOP_WLALIVE, SNOOP_WLEMPTY, wl_bufhead_, wl_buftail_, wl_lastAck_, wl_lastSeen_, wl_next(), wl_prev(), wl_state_, wlreset(), and wlseqs_. Referenced by handle(). { hdr_tcp *th = hdr_tcp::access(p); int i, seq = th->seqno(); if (wl_state_ & SNOOP_WLALIVE && seq == 0) wlreset(); wl_state_ |= SNOOP_WLALIVE; if (wl_state_ & SNOOP_WLEMPTY && seq >= wl_lastAck_) { wlseqs_[wl_bufhead_]->seq = seq; wlseqs_[wl_bufhead_]->num = 1; wl_buftail_ = wl_bufhead_; wl_bufhead_ = wl_next(wl_bufhead_); wl_lastSeen_ = seq; wl_state_ &= ~SNOOP_WLEMPTY; return; } /* WL data list definitely not empty at this point. */ if (seq >= wl_lastSeen_) { wl_lastSeen_ = seq; i = wl_prev(wl_bufhead_); if (wlseqs_[i]->seq + wlseqs_[i]->num == seq) { wlseqs_[i]->num++; return; } i = wl_bufhead_; wl_bufhead_ = wl_next(wl_bufhead_); } else if (seq == wlseqs_[i = wl_buftail_]->seq - 1) { } else return; wlseqs_[i]->seq = seq; wlseqs_[i]->num++; /* Ignore network out-of-ordering and retransmissions for now */ return; }

Here is the call graph for this function:

int Snoop::snoop_wlessloss (  int   )  [protected]

Definition at line 600 of file snoop.cc. References wl_bufhead_, wl_buftail_, and wlseqs_. Referenced by snoop_wired_ack(). { if ((wl_bufhead_ == wl_buftail_) || wlseqs_[wl_buftail_]->seq > ack+1) return 1; return 0; }

double Snoop::timeout (   )  [inline, protected]

Definition at line 143 of file snoop.h. References LLSnoop::integrate(), max, parent_, rttvar_, snoopTick_, srtt_, and LLSnoop::timeout(). Referenced by snoop_cleanbufs_(), snoop_data(), and snoop_rxmit(). { if (!parent_->integrate()) return max(srtt_+4*rttvar_, snoopTick_); else return parent_->timeout(); }

Here is the call graph for this function:

void Snoop::update_state_ (   )  [protected]

int Snoop::wl_next (  int  i  )  [inline]

Definition at line 123 of file snoop.h. References SNOOP_WLSEQS. Referenced by snoop_wired_ack(), and snoop_wless_data(). { return (i+1) % SNOOP_WLSEQS; }

int Snoop::wl_prev (  int  i  )  [inline]

Definition at line 124 of file snoop.h. References SNOOP_WLSEQS. Referenced by snoop_wless_data(). { return ((i == 0) ? SNOOP_WLSEQS-1 : i-1);};

void Snoop::wlreset (   )  [protected]

Definition at line 122 of file snoop.cc. References hdr_seq::num, hdr_seq::seq, SNOOP_WLEMPTY, SNOOP_WLSEQS, wl_bufhead_, wl_buftail_, wl_state_, and wlseqs_. Referenced by snoop_wless_data(). { wl_state_ = SNOOP_WLEMPTY; wl_bufhead_ = wl_buftail_ = 0; for (int i = 0; i < SNOOP_WLSEQS; i++) { wlseqs_[i]->seq = wlseqs_[i]->num = 0; } }

---

Friends And Related Function Documentation

friend class SnoopPersistHandler [friend]

Definition at line 115 of file snoop.h.

friend class SnoopRxmitHandler [friend]

Definition at line 114 of file snoop.h. Referenced by Snoop().

---

Member Data Documentation

short Snoop::bufhead_ [protected]

Definition at line 166 of file snoop.h. Referenced by empty_(), SnoopRxmitHandler::handle(), reset(), snoop_ack(), snoop_cleanbufs_(), and snoop_insert().

short Snoop::buftail_ [protected]

Definition at line 168 of file snoop.h. Referenced by command(), empty_(), SnoopRxmitHandler::handle(), reset(), snoop_ack(), snoop_cleanbufs_(), snoop_data(), and snoop_insert().

Handler* Snoop::callback_ [protected]

Definition at line 153 of file snoop.h.

int NsObject::debug_ [protected, inherited]

Reimplemented in FECModel, FloodAgent, and LandmarkAgent. Definition at line 66 of file object.h. Referenced by REDQueue::command(), RedPDQueue::command(), PushbackQueue::command(), NsObject::debug(), NsObject::delay_bind_dispatch(), RedPDQueue::enque(), PushbackQueue::enque(), NsObject::isdebug(), NsObject::NsObject(), TfrcAgent::recv(), PushbackQueue::reportDrop(), and REDQueue::reset().

short Snoop::expDupacks_ [protected]

Definition at line 161 of file snoop.h. Referenced by reset(), and snoop_ack().

int Snoop::expNextAck_ [protected]

Definition at line 160 of file snoop.h. Referenced by SnoopRxmitHandler::handle(), reset(), snoop_ack(), and snoop_insert().

u_short Snoop::fstate_ [protected]

Definition at line 157 of file snoop.h. Referenced by empty_(), SnoopRxmitHandler::handle(), reset(), snoop_ack(), snoop_cleanbufs_(), snoop_data(), and snoop_insert().

double Snoop::g_ [protected]

Definition at line 180 of file snoop.h. Referenced by Snoop(), and snoop_rtt().

int Snoop::integrate_ [protected]

Definition at line 181 of file snoop.h.

int Snoop::lastAck_ [protected]

Definition at line 159 of file snoop.h. Referenced by SnoopRxmitHandler::handle(), reset(), snoop_ack(), and snoop_insert().

int Snoop::lastSeen_ [protected]

Definition at line 158 of file snoop.h. Referenced by reset(), snoop_data(), and snoop_insert().

int Snoop::lru_ [protected]

Definition at line 182 of file snoop.h. Referenced by Snoop(), and snoop_data().

int Snoop::maxbufs_ [protected]

Definition at line 178 of file snoop.h. Referenced by next(), prev(), and Snoop().

LLSnoop* Snoop::parent_ [protected]

Definition at line 151 of file snoop.h. Referenced by command(), handle(), recv(), snoop_data(), snoop_rtt(), snoop_rxmit(), and timeout().

SnoopPersistHandler* Snoop::persistHandler_ [protected]

Definition at line 155 of file snoop.h.

Packet* Snoop::pkts_[SNOOP_MAXWIND] [protected]

Definition at line 169 of file snoop.h. Referenced by command(), SnoopRxmitHandler::handle(), reset(), savepkt_(), Snoop(), snoop_ack(), snoop_cleanbufs_(), snoop_data(), and snoop_insert().

NsObject* Snoop::recvtarget_ [protected]

Definition at line 152 of file snoop.h. Referenced by command(), and handle().

double Snoop::rttvar_ [protected]

Definition at line 163 of file snoop.h. Referenced by Snoop(), snoop_rtt(), and timeout().

SnoopRxmitHandler* Snoop::rxmitHandler_ [protected]

Definition at line 154 of file snoop.h. Referenced by Snoop(), snoop_cleanbufs_(), snoop_data(), and snoop_rxmit().

int Snoop::rxmitStatus_ [protected]

Definition at line 165 of file snoop.h. Referenced by command(), and Snoop().

int Snoop::snoopDisable_ [protected]

Definition at line 156 of file snoop.h. Referenced by Snoop().

double Snoop::snoopTick_ [protected]

Definition at line 179 of file snoop.h. Referenced by Snoop(), and timeout().

double Snoop::srtt_ [protected]

Definition at line 162 of file snoop.h. Referenced by Snoop(), snoop_rtt(), and timeout().

double Snoop::tailTime_ [protected]

Definition at line 164 of file snoop.h. Referenced by Snoop(), and snoop_cleanbufs_().

Event* Snoop::toutPending_ [protected]

Definition at line 167 of file snoop.h. Referenced by SnoopRxmitHandler::handle(), reset(), snoop_cleanbufs_(), snoop_data(), and snoop_rxmit().

int Snoop::wl_bufhead_ [protected]

Definition at line 174 of file snoop.h. Referenced by snoop_wired_ack(), snoop_wless_data(), snoop_wlessloss(), and wlreset().

int Snoop::wl_buftail_ [protected]

Definition at line 175 of file snoop.h. Referenced by snoop_wired_ack(), snoop_wless_data(), snoop_wlessloss(), and wlreset().

int Snoop::wl_lastAck_ [protected]

Definition at line 173 of file snoop.h. Referenced by snoop_wired_ack(), and snoop_wless_data().

int Snoop::wl_lastSeen_ [protected]

Definition at line 172 of file snoop.h. Referenced by snoop_wless_data().

int Snoop::wl_state_ [protected]

Definition at line 171 of file snoop.h. Referenced by snoop_wired_ack(), snoop_wless_data(), and wlreset().

hdr_seq* Snoop::wlseqs_[SNOOP_WLSEQS] [protected]

Definition at line 176 of file snoop.h. Referenced by Snoop(), snoop_wired_ack(), snoop_wless_data(), snoop_wlessloss(), and wlreset().

---

The documentation for this class was generated from the following files:

• snoop.h
• snoop.cc

---