Snoop Class Reference

#include <snoop.h>

Inheritance diagram for Snoop:

Collaboration diagram for Snoop:

[legend]

---

Detailed Description

Definition at line 113 of file snoop.h.

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

---

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_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, HbAfterRtoSctpAgent, MfrHbAfterRtoSctpAgent, MfrTimestampSctpAgent, MultipleFastRtxSctpAgent, NewRenoSctpAgent, TimestampSctpAgent, SctpAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, VegasTcpAgent, XcpAgent, and XcpSink. 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, HbAfterRtoSctpAgent, MfrHbAfterRtoSctpAgent, MfrTimestampSctpAgent, MultipleFastRtxSctpAgent, NewRenoSctpAgent, TimestampSctpAgent, SctpAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, VegasTcpAgent, XcpAgent, and XcpSink. 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(), Packet::free(), Scheduler::instance(), 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::direction(), handle(), HDR_CMN, 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. { 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_, RTX_THRESH, hdr_tcp::seqno(), sh, SNOOP_CLOSED, SNOOP_MAXWIND, SNOOP_PROPAGATE, 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_. { 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_. { 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(), Packet::free(), fstate_, Scheduler::instance(), lastAck_, lastSeen_, next(), pkts_, prev(), 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(), Scheduler::instance(), LLSnoop::integrate(), parent_, and LLSnoop::snoop_rtt(). { 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::clock(), Packet::copy(), hdr_cmn::direction(), hdr_cmn::DOWN, HDR_CMN, Scheduler::instance(), parent_, LL::sendDown(), hdr_tcp::seqno(), sh, SNOOP_MAX_RXMIT, SNOOP_PROPAGATE, and snoop_qlong(). 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::seq, hdr_tcp::seqno(), SNOOP_WLEMPTY, snoop_wlessloss(), wl_bufhead_, wl_buftail_, wl_lastAck_, wl_next(), wl_state_, and wlseqs_. { 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(), num, 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_(), and snoop_data(). { 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 num, 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().

---

Field 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(), PushbackQueue::enque(), NsObject::isdebug(), NsObject::NsObject(), TfrcAgent::recv(), PushbackQueue::reportDrop(), SctpAgent::Reset(), REDQueue::reset(), DropTail::shrink_queue(), and Delayer::try_send().

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(), and snoop_ack().

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().

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(), 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(), and timeout().

SnoopRxmitHandler* Snoop::rxmitHandler_ [protected]

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

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(), 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_(), and snoop_data().

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

---