NS2.26SourcesOriginal: NewRenoTcpAsymAgent class Reference

00110 : NewRenoTcpAgent(), TcpAsymAgent() { }

00327 {
00328         char wrk[256];
00329         int n;
00330         double curTime = (&Scheduler::instance() == NULL ? 0 : 
00331                           Scheduler::instance().clock());
00332         
00333         sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s",
00334                 curTime, here_.addr_, dst_.addr_, name);
00335         n = strlen(wrk);
00336         wrk[n] = '\n';
00337         wrk[n+1] = 0;
00338         if (channel_)
00339                 (void)Tcl_Write(channel_, wrk, n+1);
00340         // keep agent trace name
00341         if (traceName_ != NULL)
00342                 delete[] traceName_;
00343         traceName_ = new char[strlen(name)+1];
00344         strcpy(traceName_, name);
00345 }

00096 { return here_.addr_; }

00684 {
00685   curseq_ += delta;
00686         if (delta > 0)
00687                 closed_ = 0;
00688         send_much(0, 0, maxburst_); 
00689 }

00518 {
00519         Packet* p = allocpkt();
00520 
00521         if (n > 0)
00522                 p->allocdata(n);
00523 
00524         return(p);
00525 }

00507 {
00508         Packet* p = Packet::alloc();
00509         initpkt(p);
00510         return (p);
00511 }

00109 {
00110         return 0;
00111 }

00373 {
00374         app_ = app;
00375 }

00242                                         {
00243                 rtx_timer_.force_cancel();
00244         }

01650 {   
01651         static int first_time = 1;
01652         if (first_time == 1) {
01653                 fprintf(stderr, "the TcpAgent::closecwnd() function is now deprecated, please use the function slowdown() instead\n");
01654         }
01655         switch (how) {
01656         case 0:
01657                 /* timeouts */
01658                 ssthresh_ = int( window() / 2 );
01659                 if (ssthresh_ < 2)
01660                         ssthresh_ = 2;
01661                 cwnd_ = int(wnd_restart_);
01662                 break;
01663 
01664         case 1:
01665                 /* Reno dup acks, or after a recent congestion indication. */
01666                 // cwnd_ = window()/2;
01667                 cwnd_ = decrease_num_ * window();
01668                 ssthresh_ = int(cwnd_);
01669                 if (ssthresh_ < 2)
01670                         ssthresh_ = 2;          
01671                 break;
01672 
01673         case 2:
01674                 /* Tahoe dup acks               
01675                  * after a recent congestion indication */
01676                 cwnd_ = wnd_init_;
01677                 break;
01678 
01679         case 3:
01680                 /* Retransmit timeout, but no outstanding data. */ 
01681                 cwnd_ = int(wnd_init_);
01682                 break;
01683         case 4:
01684                 /* Tahoe dup acks */
01685                 ssthresh_ = int( window() / 2 );
01686                 if (ssthresh_ < 2)
01687                         ssthresh_ = 2;
01688                 cwnd_ = 1;
01689                 break;
01690 
01691         default:
01692                 abort();
01693         }
01694         fcnt_ = 0.;
01695         count_ = 0;
01696 }

00693 {
00694         if (argc == 3) {
00695                 if (strcmp(argv[1], "advance") == 0) {
00696                         int newseq = atoi(argv[2]);
00697                         if (newseq > maxseq_)
00698                                 advanceby(newseq - curseq_);
00699                         else
00700                                 advanceby(maxseq_ - curseq_);
00701                         return (TCL_OK);
00702                 }
00703                 if (strcmp(argv[1], "advanceby") == 0) {
00704                         advanceby(atoi(argv[2]));
00705                         return (TCL_OK);
00706                 }
00707                 if (strcmp(argv[1], "eventtrace") == 0) {
00708                         et_ = (EventTrace *)TclObject::lookup(argv[2]);
00709                         return (TCL_OK);
00710                 }
00711                 /*
00712                  * Curtis Villamizar's trick to transfer tcp connection
00713                  * parameters to emulate http persistent connections.
00714                  *
00715                  * Another way to do the same thing is to open one tcp
00716                  * object and use start/stop/maxpkts_ or advanceby to control
00717                  * how much data is sent in each burst.
00718                  * With a single connection, slow_start_restart_
00719                  * should be configured as desired.
00720                  *
00721                  * This implementation (persist) may not correctly
00722                  * emulate pure-BSD-based systems which close cwnd
00723                  * after the connection goes idle (slow-start
00724                  * restart).  See appendix C in
00725                  * Jacobson and Karels ``Congestion
00726                  * Avoidance and Control'' at
00727                  * <ftp://ftp.ee.lbl.gov/papers/congavoid.ps.Z>
00728                  * (*not* the original
00729                  * '88 paper) for why BSD does this.  See
00730                  * ``Performance Interactions Between P-HTTP and TCP
00731                  * Implementations'' in CCR 27(2) for descriptions of
00732                  * what other systems do the same.
00733                  *
00734                  */
00735                 if (strcmp(argv[1], "persist") == 0) {
00736                         TcpAgent *other
00737                           = (TcpAgent*)TclObject::lookup(argv[2]);
00738                         cwnd_ = other->cwnd_;
00739                         awnd_ = other->awnd_;
00740                         ssthresh_ = other->ssthresh_;
00741                         t_rtt_ = other->t_rtt_;
00742                         t_srtt_ = other->t_srtt_;
00743                         t_rttvar_ = other->t_rttvar_;
00744                         t_backoff_ = other->t_backoff_;
00745                         return (TCL_OK);
00746                 }
00747         }
00748         return (Agent::command(argc, argv));
00749 }

00898 {
00899         double p;
00900         double low_p = 1.5/(low_window_*low_window_);
00901         p = exp(linear(log(cwnd_), log(low_window_), log(low_p), log(high_window_), log(high_p_)));
00902         return p;
00903 }

00390 {
00391 /*
00392         dst_ = dst;
00393 */
00394 }

00098 { return dst_.addr_; }

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

00909 {
00910         double decrease;
00911         decrease = linear(log(cwnd_), log(low_window_), 0.5, log(high_window_), high_decrease_);
00912         return decrease;
00913 }

00203 {
00204         if (delay_bind(varName, localName, "window_", &wnd_, tracer)) return TCL_OK;
00205         if (delay_bind(varName, localName, "windowInit_", &wnd_init_, tracer)) return TCL_OK;
00206         if (delay_bind(varName, localName, "windowInitOption_", &wnd_init_option_, tracer)) return TCL_OK;
00207         if (delay_bind_bool(varName, localName, "syn_", &syn_, tracer)) return TCL_OK;
00208         if (delay_bind(varName, localName, "windowOption_", &wnd_option_ , tracer)) return TCL_OK;
00209         if (delay_bind(varName, localName, "windowConstant_",  &wnd_const_, tracer)) return TCL_OK;
00210         if (delay_bind(varName, localName, "windowThresh_", &wnd_th_ , tracer)) return TCL_OK;
00211         if (delay_bind_bool(varName, localName, "delay_growth_", &delay_growth_ , tracer)) return TCL_OK;
00212         if (delay_bind(varName, localName, "overhead_", &overhead_, tracer)) return TCL_OK;
00213         if (delay_bind(varName, localName, "tcpTick_", &tcp_tick_, tracer)) return TCL_OK;
00214         if (delay_bind_bool(varName, localName, "ecn_", &ecn_, tracer)) return TCL_OK;
00215         if (delay_bind_bool(varName, localName, "old_ecn_", &old_ecn_ , tracer)) return TCL_OK;
00216         if (delay_bind(varName, localName, "eln_", &eln_ , tracer)) return TCL_OK;
00217         if (delay_bind(varName, localName, "eln_rxmit_thresh_", &eln_rxmit_thresh_ , tracer)) return TCL_OK;
00218         if (delay_bind(varName, localName, "packetSize_", &size_ , tracer)) return TCL_OK;
00219         if (delay_bind(varName, localName, "tcpip_base_hdr_size_", &tcpip_base_hdr_size_, tracer)) return TCL_OK;
00220         if (delay_bind(varName, localName, "ts_option_size_", &ts_option_size_, tracer)) return TCL_OK;
00221         if (delay_bind_bool(varName, localName, "bugFix_", &bug_fix_ , tracer)) return TCL_OK;
00222         if (delay_bind_bool(varName, localName, "lessCareful_", &less_careful_ , tracer)) return TCL_OK;
00223         if (delay_bind_bool(varName, localName, "timestamps_", &ts_option_ , tracer)) return TCL_OK;
00224         if (delay_bind_bool(varName, localName, "slow_start_restart_", &slow_start_restart_ , tracer)) return TCL_OK;
00225         if (delay_bind_bool(varName, localName, "restart_bugfix_", &restart_bugfix_ , tracer)) return TCL_OK;
00226         if (delay_bind(varName, localName, "maxburst_", &maxburst_ , tracer)) return TCL_OK;
00227         if (delay_bind(varName, localName, "maxcwnd_", &maxcwnd_ , tracer)) return TCL_OK;
00228         if (delay_bind(varName, localName, "numdupacks_", &numdupacks_, tracer)) return TCL_OK;
00229         if (delay_bind(varName, localName, "numdupacksFrac_", &numdupacksFrac_, tracer)) return TCL_OK;
00230         if (delay_bind(varName, localName, "maxrto_", &maxrto_ , tracer)) return TCL_OK;
00231         if (delay_bind(varName, localName, "minrto_", &minrto_ , tracer)) return TCL_OK;
00232         if (delay_bind(varName, localName, "srtt_init_", &srtt_init_ , tracer)) return TCL_OK;
00233         if (delay_bind(varName, localName, "rttvar_init_", &rttvar_init_ , tracer)) return TCL_OK;
00234         if (delay_bind(varName, localName, "rtxcur_init_", &rtxcur_init_ , tracer)) return TCL_OK;
00235         if (delay_bind(varName, localName, "T_SRTT_BITS", &T_SRTT_BITS , tracer)) return TCL_OK;
00236         if (delay_bind(varName, localName, "T_RTTVAR_BITS", &T_RTTVAR_BITS , tracer)) return TCL_OK;
00237         if (delay_bind(varName, localName, "rttvar_exp_", &rttvar_exp_ , tracer)) return TCL_OK;
00238         if (delay_bind(varName, localName, "awnd_", &awnd_ , tracer)) return TCL_OK;
00239         if (delay_bind(varName, localName, "decrease_num_", &decrease_num_, tracer)) return TCL_OK;
00240         if (delay_bind(varName, localName, "increase_num_", &increase_num_, tracer)) return TCL_OK;
00241         if (delay_bind(varName, localName, "k_parameter_", &k_parameter_, tracer)) return TCL_OK;
00242         if (delay_bind(varName, localName, "l_parameter_", &l_parameter_, tracer)) return TCL_OK;
00243 
00244 
00245         if (delay_bind_bool(varName, localName, "trace_all_oneline_", &trace_all_oneline_ , tracer)) return TCL_OK;
00246         if (delay_bind_bool(varName, localName, "nam_tracevar_", &nam_tracevar_ , tracer)) return TCL_OK;
00247         if (delay_bind(varName, localName, "QOption_", &QOption_ , tracer)) return TCL_OK;
00248         if (delay_bind(varName, localName, "EnblRTTCtr_", &EnblRTTCtr_ , tracer)) return TCL_OK;
00249         if (delay_bind(varName, localName, "control_increase_", &control_increase_ , tracer)) return TCL_OK;
00250         if (delay_bind_bool(varName, localName, "noFastRetrans_", &noFastRetrans_, tracer)) return TCL_OK;
00251         if (delay_bind_bool(varName, localName, "precisionReduce_", &precision_reduce_, tracer)) return TCL_OK;
00252         if (delay_bind_bool(varName, localName, "oldCode_", &oldCode_, tracer)) return TCL_OK;
00253         if (delay_bind_bool(varName, localName, "useHeaders_", &useHeaders_, tracer)) return TCL_OK;
00254         if (delay_bind(varName, localName, "low_window_", &low_window_, tracer)) return TCL_OK;
00255         if (delay_bind(varName, localName, "high_window_", &high_window_, tracer)) return TCL_OK;
00256         if (delay_bind(varName, localName, "high_p_", &high_p_, tracer)) return TCL_OK;
00257         if (delay_bind(varName, localName, "high_decrease_", &high_decrease_, tracer)) return TCL_OK;
00258         if (delay_bind(varName, localName, "max_ssthresh_", &max_ssthresh_, tracer)) return TCL_OK;
00259         if (delay_bind(varName, localName, "cwnd_frac_", &cwnd_frac_, tracer)) return TCL_OK;
00260         if (delay_bind_bool(varName, localName, "timerfix_", &timerfix_, tracer)) return TCL_OK;
00261         if (delay_bind_bool(varName, localName, "rfc2988_", &rfc2988_, tracer)) return TCL_OK;
00262         if (delay_bind(varName, localName, "singledup_", &singledup_ , tracer)) return TCL_OK;
00263         if (delay_bind(varName, localName, "rate_request_", &rate_request_ , tracer)) return TCL_OK;
00264         if (delay_bind_bool(varName, localName, "qs_enabled_", &qs_enabled_, tracer)) return TCL_OK;
00265 
00266 
00267 #ifdef TCP_DELAY_BIND_ALL
00268         // not if (delay-bound delay-bound tracevars aren't yet supported
00269         if (delay_bind(varName, localName, "t_seqno_", &t_seqno_ , tracer)) return TCL_OK;
00270         if (delay_bind(varName, localName, "rtt_", &t_rtt_ , tracer)) return TCL_OK;
00271         if (delay_bind(varName, localName, "srtt_", &t_srtt_ , tracer)) return TCL_OK;
00272         if (delay_bind(varName, localName, "rttvar_", &t_rttvar_ , tracer)) return TCL_OK;
00273         if (delay_bind(varName, localName, "backoff_", &t_backoff_ , tracer)) return TCL_OK;
00274 
00275         if (delay_bind(varName, localName, "dupacks_", &dupacks_ , tracer)) return TCL_OK;
00276         if (delay_bind(varName, localName, "seqno_", &curseq_ , tracer)) return TCL_OK;
00277         if (delay_bind(varName, localName, "ack_", &highest_ack_ , tracer)) return TCL_OK;
00278         if (delay_bind(varName, localName, "cwnd_", &cwnd_ , tracer)) return TCL_OK;
00279         if (delay_bind(varName, localName, "ssthresh_", &ssthresh_ , tracer)) return TCL_OK;
00280         if (delay_bind(varName, localName, "maxseq_", &maxseq_ , tracer)) return TCL_OK;
00281         if (delay_bind(varName, localName, "ndatapack_", &ndatapack_ , tracer)) return TCL_OK;
00282         if (delay_bind(varName, localName, "ndatabytes_", &ndatabytes_ , tracer)) return TCL_OK;
00283         if (delay_bind(varName, localName, "nackpack_", &nackpack_ , tracer)) return TCL_OK;
00284         if (delay_bind(varName, localName, "nrexmit_", &nrexmit_ , tracer)) return TCL_OK;
00285         if (delay_bind(varName, localName, "nrexmitpack_", &nrexmitpack_ , tracer)) return TCL_OK;
00286         if (delay_bind(varName, localName, "nrexmitbytes_", &nrexmitbytes_ , tracer)) return TCL_OK;
00287         if (delay_bind(varName, localName, "necnresponses_", &necnresponses_ , tracer)) return TCL_OK;
00288         if (delay_bind(varName, localName, "ncwndcuts_", &ncwndcuts_ , tracer)) return TCL_OK;
00289 #endif
00290 
00291         return Agent::delay_bind_dispatch(varName, localName, tracer);
00292 }

00108 {
00109 
00110         // Defaults for bound variables should be set in ns-default.tcl.
00111         delay_bind_init_one("window_");
00112         delay_bind_init_one("windowInit_");
00113         delay_bind_init_one("windowInitOption_");
00114 
00115         delay_bind_init_one("syn_");
00116         delay_bind_init_one("windowOption_");
00117         delay_bind_init_one("windowConstant_");
00118         delay_bind_init_one("windowThresh_");
00119         delay_bind_init_one("delay_growth_");
00120         delay_bind_init_one("overhead_");
00121         delay_bind_init_one("tcpTick_");
00122         delay_bind_init_one("ecn_");
00123         delay_bind_init_one("old_ecn_");
00124         delay_bind_init_one("eln_");
00125         delay_bind_init_one("eln_rxmit_thresh_");
00126         delay_bind_init_one("packetSize_");
00127         delay_bind_init_one("tcpip_base_hdr_size_");
00128         delay_bind_init_one("ts_option_size_");
00129         delay_bind_init_one("bugFix_");
00130         delay_bind_init_one("lessCareful_");
00131         delay_bind_init_one("slow_start_restart_");
00132         delay_bind_init_one("restart_bugfix_");
00133         delay_bind_init_one("timestamps_");
00134         delay_bind_init_one("maxburst_");
00135         delay_bind_init_one("maxcwnd_");
00136         delay_bind_init_one("numdupacks_");
00137         delay_bind_init_one("numdupacksFrac_");
00138         delay_bind_init_one("maxrto_");
00139         delay_bind_init_one("minrto_");
00140         delay_bind_init_one("srtt_init_");
00141         delay_bind_init_one("rttvar_init_");
00142         delay_bind_init_one("rtxcur_init_");
00143         delay_bind_init_one("T_SRTT_BITS");
00144         delay_bind_init_one("T_RTTVAR_BITS");
00145         delay_bind_init_one("rttvar_exp_");
00146         delay_bind_init_one("awnd_");
00147         delay_bind_init_one("decrease_num_");
00148         delay_bind_init_one("increase_num_");
00149         delay_bind_init_one("k_parameter_");
00150         delay_bind_init_one("l_parameter_");
00151         delay_bind_init_one("trace_all_oneline_");
00152         delay_bind_init_one("nam_tracevar_");
00153 
00154         delay_bind_init_one("QOption_");
00155         delay_bind_init_one("EnblRTTCtr_");
00156         delay_bind_init_one("control_increase_");
00157         delay_bind_init_one("noFastRetrans_");
00158         delay_bind_init_one("precisionReduce_");
00159         delay_bind_init_one("oldCode_");
00160         delay_bind_init_one("useHeaders_");
00161         delay_bind_init_one("low_window_");
00162         delay_bind_init_one("high_window_");
00163         delay_bind_init_one("high_p_");
00164         delay_bind_init_one("high_decrease_");
00165         delay_bind_init_one("max_ssthresh_");
00166         delay_bind_init_one("cwnd_frac_");
00167         delay_bind_init_one("timerfix_");
00168         delay_bind_init_one("rfc2988_");
00169         delay_bind_init_one("singledup_");
00170         delay_bind_init_one("rate_request_");
00171         delay_bind_init_one("qs_enabled_");
00172 
00173 #ifdef TCP_DELAY_BIND_ALL
00174         // out because delay-bound tracevars aren't yet supported
00175         delay_bind_init_one("t_seqno_");
00176         delay_bind_init_one("rtt_");
00177         delay_bind_init_one("srtt_");
00178         delay_bind_init_one("rttvar_");
00179         delay_bind_init_one("backoff_");
00180         delay_bind_init_one("dupacks_");
00181         delay_bind_init_one("seqno_");
00182         delay_bind_init_one("ack_");
00183         delay_bind_init_one("cwnd_");
00184         delay_bind_init_one("ssthresh_");
00185         delay_bind_init_one("maxseq_");
00186         delay_bind_init_one("ndatapack_");
00187         delay_bind_init_one("ndatabytes_");
00188         delay_bind_init_one("nackpack_");
00189         delay_bind_init_one("nrexmit_");
00190         delay_bind_init_one("nrexmitpack_");
00191         delay_bind_init_one("nrexmitbytes_");
00192         delay_bind_init_one("necnresponses_");
00193         delay_bind_init_one("ncwndcuts_");
00194 #endif /* TCP_DELAY_BIND_ALL */
00195 
00196         Agent::delay_bind_init_all();
00197 
00198         reset();
00199 }

00223 {
00224         char wrk[256];
00225 
00226         // XXX we don't know InstVar outside of Tcl! Is there any
00227         // tracedvars hidden in InstVar? If so, shall we have a tclclInt.h?
00228         TracedVar* var = tracedvar_;
00229         for ( ;  var != 0;  var = var->next_) 
00230                 flushAVar(var);
00231 
00232         // we need to flush all var values to trace file, 
00233         // so nam can do backtracing
00234         sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s -x",
00235                 Scheduler::instance().clock(), here_.addr_,
00236                 dst_.addr_, traceName_); 
00237         if (traceName_ != NULL)
00238                 delete[] traceName_;
00239         traceName_ = NULL;
00240 }

00099 { return dst_.port_; }

00115 {
00116         if (drop_ != 0)
00117                 drop_->recv(p, s);
00118         else
00119                 Packet::free(p);
00120 }

00107 {
00108         if (drop_ != 0)
00109                 drop_->recv(p);
00110         else
00111                 Packet::free(p);
00112 }

00115 {
00116         int recovered = (highest_ack_ > recover_);
00117         int recovered1 = (highest_ack_ == recover_);
00118         int allowFastRetransmit = allow_fast_retransmit(last_cwnd_action_);
00119         if (recovered || (!bug_fix_ && !ecn_) || allowFastRetransmit) {
00120                 goto reno_action;
00121         }
00122         if (bug_fix_ && less_careful_ && recovered1) {
00123                 /*
00124                  * For the Less Careful variant, allow a Fast Retransmit
00125                  *  if highest_ack_ == recover.
00126                  * RFC 2582 recommends the Careful variant, not the 
00127                  *  Less Careful one.
00128                  */
00129                 goto reno_action;
00130         }
00131 
00132         if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {
00133                 last_cwnd_action_ = CWND_ACTION_DUPACK;
00134                 /*
00135                  * What if there is a DUPACK action followed closely by ECN
00136                  * followed closely by a DUPACK action?
00137                  * The optimal thing to do would be to remember all
00138                  * congestion actions from the most recent window
00139                  * of data.  Otherwise "bugfix" might not prevent
00140                  * all unnecessary Fast Retransmits.
00141                  */
00142                 reset_rtx_timer(1,0);
00143                 output(last_ack_ + 1, TCP_REASON_DUPACK);
00144                 return;
00145         }
00146 
00147         if (bug_fix_) {
00148                 /*
00149                  * The line below, for "bug_fix_" true, avoids
00150                  * problems with multiple fast retransmits in one
00151                  * window of data.
00152                  */
00153                 return;
00154         }
00155 
00156 reno_action:
00157         trace_event("NEWRENO_FAST_RETX");
00158         recover_ = maxseq_;
00159         last_cwnd_action_ = CWND_ACTION_DUPACK;
00160         slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF);
00161         reset_rtx_timer(1,0);
00162         output(last_ack_ + 1, TCP_REASON_DUPACK);       // from top
00163         return;
00164 }

01233 {
01234         if (seqno > recover_ || 
01235               last_cwnd_action_ == CWND_ACTION_TIMEOUT) {
01236                 recover_ =  maxseq_;
01237                 last_cwnd_action_ = CWND_ACTION_ECN;
01238                 if (cwnd_ <= 1.0) {
01239                         if (ecn_backoff_) 
01240                                 rtt_backoff();
01241                         else ecn_backoff_ = 1;
01242                 } else ecn_backoff_ = 0;
01243                 slowdown(CLOSE_CWND_HALF|CLOSE_SSTHRESH_HALF);
01244                 ++necnresponses_ ;
01245                 // added by sylvia to count number of ecn responses 
01246         }
01247 }

01403 {
01404         qs_approved_ = 0;
01405         int new_cwnd = maxseq_ - last_ack_;
01406         if (new_cwnd > 1 && new_cwnd < cwnd_) {
01407                 cwnd_ = new_cwnd;
01408                 if (cwnd_ < initial_window()) 
01409                         cwnd_ = initial_window();
01410         }
01411 }

01604 {
01605         Tcl::instance().evalf("%s done", this->name());
01606 }

00101 { return type_; }

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

00574 {
00575         int total = tcpip_base_hdr_size_;
00576         if (total < 1) {
00577                 fprintf(stderr,
00578                   "TcpAgent(%s): warning: tcpip hdr size is only %d bytes\n",
00579                   name(), tcpip_base_hdr_size_);
00580         }
00581         if (ts_option_)
00582                 total += ts_option_size_;
00583         return (total);
00584 }

00364 {
00365         if (app_)
00366                 app_->resume();
00367 }

00919 {
00920         double increase, decrease, p, answer;
00921         /* extending the slow-start for high-speed TCP */
00922 
00923         /* for highspeed TCP -- from Sylvia Ratnasamy, */
00924         /* modifications by Sally Floyd and Evandro de Souza */
00925         // p ranges from 1.5/W^2 at congestion window low_window_, to
00926         //    high_p_ at congestion window high_window_, on a log-log scale.
00927         // The decrease factor ranges from 0.5 to high_decrease
00928         //  as the window ranges from low_window to high_window, 
00929         //  as the log of the window. 
00930         // For an efficient implementation, this would just be looked up
00931         //   in a table, with the increase and decrease being a function of the
00932         //   congestion window.
00933 
00934        if (cwnd_ <= low_window_) { 
00935                 answer = 1 / cwnd_;
00936                 return answer; 
00937        } else if (cwnd_ >= cwnd_last_ && cwnd_ < cwnd_frac_ * cwnd_last_ ) {
00938                 answer = increase_last_ / cwnd_;
00939                 return answer;
00940        } else { 
00941                 p = compute_p();
00942                 decrease = decrease_param();
00943                 increase = (cwnd_ * cwnd_ *2.0* decrease * p)/(2.0 - decrease); 
00944                 //      double max_increase = 157.8;
00945                 //      if (increase > max_increase) { 
00946                 //              increase = max_increase;
00947                 //      } 
00948                 answer = increase / cwnd_;
00949                 cwnd_last_ = cwnd_;
00950                 increase_last_ = increase;
00951                 return answer;
00952         }       
00953 }

01302 {
01303         //
01304         // init_option = 1: static iw of wnd_init_
01305         //
01306         if (wnd_init_option_ == 1) {
01307                 return (wnd_init_);
01308         }
01309         else if (wnd_init_option_ == 2) {
01310                 // do iw according to Internet draft
01311                 if (size_ <= 1095) {
01312                         return (4.0);
01313                 } else if (size_ < 2190) {
01314                         return (3.0);
01315                 } else {
01316                         return (2.0);
01317                 }
01318         }
01319         // XXX what should we return here???
01320         fprintf(stderr, "Wrong number of wnd_init_option_ %d\n", 
01321                 wnd_init_option_);
01322         abort();
01323         return (2.0); // XXX make msvc happy.
01324 }

00447 {
00448         hdr_cmn* ch = hdr_cmn::access(p);
00449         ch->uid() = uidcnt_++;
00450         ch->ptype() = type_;
00451         ch->size() = size_;
00452         ch->timestamp() = Scheduler::instance().clock();
00453         ch->iface() = UNKN_IFACE.value(); // from packet.h (agent is local)
00454         ch->direction() = hdr_cmn::NONE;
00455 
00456         ch->error() = 0;        /* pkt not corrupt to start with */
00457 
00458         hdr_ip* iph = hdr_ip::access(p);
00459         iph->saddr() = here_.addr_;
00460         iph->sport() = here_.port_;
00461         iph->daddr() = dst_.addr_;
00462         iph->dport() = dst_.port_;
00463         
00464         //DEBUG
00465         //if (dst_ != -1)
00466         //  printf("pl break\n");
00467         
00468         iph->flowid() = fid_;
00469         iph->prio() = prio_;
00470         iph->ttl() = defttl_;
00471 
00472         hdr_flags* hf = hdr_flags::access(p);
00473         hf->ecn_capable_ = 0;
00474         hf->ecn_ = 0;
00475         hf->eln_ = 0;
00476         hf->ecn_to_echo_ = 0;
00477         hf->fs_ = 0;
00478         hf->no_ts_ = 0;
00479         hf->pri_ = 0;
00480         hf->cong_action_ = 0;
00481 #ifdef HAVE_STL
00482 
00483         hdr_nv* nv = hdr_nv::access(p);
00484         if (0)
00485                 printf("Off hdr_nv %d, ip_hdr %d myaddr %ld\n",
00486                        hdr_nv::offset(), hdr_ip::offset(), here_.addr_);
00487         NixNode* pNixNode = NixNode::GetNodeObject(here_.addr_);
00488         if (0)
00489                 printf("Node Object %p\n", pNixNode);
00490         if (pNixNode) { 
00491                 // If we get non-null, indicates nixvector routing in use
00492                 // Delete any left over nv in the packet
00493                 // Get a nixvector to the target (may create new)
00494                 NixVec* pNv = pNixNode->GetNixVector(dst_.addr_);
00495                 pNv->Reset();
00496                 nv->nv() = pNv; // And set the nixvec in the packet
00497                 nv->h_used = 0; // And reset used portion to 0
00498         }
00499 #endif //HAVE_STL
00500 }

00251 {
00252         OldValue *p = new OldValue;
00253         assert(p != NULL);
00254         strncpy(p->val_, value, min(strlen(value)+1, TRACEVAR_MAXVALUELENGTH));
00255         p->var_ = v;
00256         p->next_ = NULL;
00257         if (oldValueList_ == NULL) 
00258                 oldValueList_ = p;
00259         else {
00260                 p->next_ = oldValueList_;
00261                 oldValueList_ = p;
00262         }
00263 }

00061 { return debug_; }

00873 {
00874         int round = int(cwnd / (double(max_ssthresh)/2.0));
00875         double increment1 = 1.0/(double(round)); 
00876         if (increment < increment1)
00877                 increment = increment1;
00878         return increment;
00879 }

00861 {
00862         // The y coordinate factor ranges from y_1 to y_2
00863         //  as the x coordinate ranges from x_1 to x_2.
00864         double y = y_1 + ((y_2 - y_1) * ((x - x_1)/(x_2-x_1)));
00865         return y;
00866 }

00243 {
00244         OldValue *p = oldValueList_;
00245         while ((p != NULL) && (p->var_ != v))
00246                 p = p->next_;
00247         return p;
00248 }

00311 {
00312         char wrk[256];
00313         int n;
00314         double curTime = (&Scheduler::instance() == NULL ? 0 : 
00315                           Scheduler::instance().clock());
00316         
00317         sprintf(wrk, "v -t "TIME_FORMAT" -e monitor_agent %d %s",
00318                 curTime, here_.addr_, traceName_);
00319         n = strlen(wrk);
00320         wrk[n] = '\n';
00321         wrk[n+1] = 0;
00322         if (channel_)
00323                 (void)Tcl_Write(channel_, wrk, n+1);
00324 }

01253                               {
01254         int win = window () ;
01255         if (t_seqno_ > (prev_highest_ack_ + win))
01256                 return 1;
01257         else
01258                 return 0;
01259 }

01175 {
01176         double now = Scheduler::instance().clock();
01177         hdr_tcp *tcph = hdr_tcp::access(pkt);
01178         /* 
01179          * Wouldn't it be better to set the timer *after*
01180          * updating the RTT, instead of *before*? 
01181          */
01182         if (!timerfix_) newtimer(pkt);
01183         dupacks_ = 0;
01184         last_ack_ = tcph->seqno();
01185         prev_highest_ack_ = highest_ack_ ;
01186         highest_ack_ = last_ack_;
01187 
01188         if (t_seqno_ < last_ack_ + 1)
01189                 t_seqno_ = last_ack_ + 1;
01190         /* 
01191          * Update RTT only if it's OK to do so from info in the flags header.
01192          * This is needed for protocols in which intermediate agents
01193          * in the network intersperse acks (e.g., ack-reconstructors) for
01194          * various reasons (without violating e2e semantics).
01195          */     
01196         hdr_flags *fh = hdr_flags::access(pkt);
01197         if (!fh->no_ts_) {
01198                 if (ts_option_)
01199                         rtt_update(now - tcph->ts_echo());
01200 
01201                 if (rtt_active_ && tcph->seqno() >= rtt_seq_) {
01202                         if (!ect_ || !ecn_backoff_ || 
01203                                 !hdr_flags::access(pkt)->ecnecho()) {
01204                                 /* 
01205                                  * Don't end backoff if still in ECN-Echo with
01206                                  * a congestion window of 1 packet. 
01207                                  */
01208                                 t_backoff_ = 1;
01209                                 ecn_backoff_ = 0;
01210                         }
01211                         rtt_active_ = 0;
01212                         if (!ts_option_)
01213                                 rtt_update(now - rtt_ts_);
01214                 }
01215         }
01216         if (timerfix_) newtimer(pkt);
01217         /* update average window */
01218         awnd_ *= 1.0 - wnd_th_;
01219         awnd_ += wnd_th_ * cwnd_;
01220 }

00839 {
00840         hdr_tcp *tcph = hdr_tcp::access(pkt);
00841         /*
00842          * t_seqno_, the next packet to send, is reset (decreased) 
00843          *   to highest_ack_ + 1 after a timeout,
00844          *   so we also have to check maxseq_, the highest seqno sent.
00845          * In addition, if the packet sent after the timeout has
00846          *   the ECN bit set, then the returning ACK caused cwnd_ to
00847          *   be decreased to less than one, and we can't send another
00848          *   packet until the retransmit timer again expires.
00849          *   So we have to check for "cwnd_ < 1" as well.
00850          */
00851         if (t_seqno_ > tcph->seqno() || tcph->seqno() < maxseq_ || cwnd_ < 1) 
00852                 set_rtx_timer();
00853         else
00854                 cancel_rtx_timer();
00855 }

00885 {
00886         int cwndfraction = (int) cwnd/numdupacksFrac_;
00887         if (numdupacks_ > cwndfraction) {
00888                 return numdupacks_;
00889         } else {
00890                 return cwndfraction;
00891         }
00892 }

00959 {
00960         double increment;
00961         if (cwnd_ < ssthresh_) {
00962                 /* slow-start (exponential) */
00963                 cwnd_ += 1;
00964         } else {
00965                 /* linear */
00966                 double f;
00967                 switch (wnd_option_) {
00968                 case 0:
00969                         if (++count_ >= cwnd_) {
00970                                 count_ = 0;
00971                                 ++cwnd_;
00972                         }
00973                         break;
00974 
00975                 case 1:
00976                         /* This is the standard algorithm. */
00977                         increment = increase_num_ / cwnd_;
00978                         if ((last_cwnd_action_ == 0 ||
00979                           last_cwnd_action_ == CWND_ACTION_TIMEOUT) 
00980                           && max_ssthresh_ > 0) {
00981                                 increment = limited_slow_start(cwnd_,
00982                                   max_ssthresh_, increment);
00983                         }
00984                         cwnd_ += increment;
00985                         break;
00986 
00987                 case 2:
00988                         /* These are window increase algorithms
00989                          * for experimental purposes only. */
00990                         f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
00991                         f *= f;
00992                         f *= wnd_const_;
00993                         f += fcnt_;
00994                         if (f > cwnd_) {
00995                                 fcnt_ = 0;
00996                                 ++cwnd_;
00997                         } else
00998                                 fcnt_ = f;
00999                         break;
01000 
01001                 case 3:
01002                         f = awnd_;
01003                         f *= f;
01004                         f *= wnd_const_;
01005                         f += fcnt_;
01006                         if (f > cwnd_) {
01007                                 fcnt_ = 0;
01008                                 ++cwnd_;
01009                         } else
01010                                 fcnt_ = f;
01011                         break;
01012 
01013                 case 4:
01014                         f = awnd_;
01015                         f *= wnd_const_;
01016                         f += fcnt_;
01017                         if (f > cwnd_) {
01018                                 fcnt_ = 0;
01019                                 ++cwnd_;
01020                         } else
01021                                 fcnt_ = f;
01022                         break;
01023                 case 5:
01024                         f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
01025                         f *= wnd_const_;
01026                         f += fcnt_;
01027                         if (f > cwnd_) {
01028                                 fcnt_ = 0;
01029                                 ++cwnd_;
01030                         } else
01031                                 fcnt_ = f;
01032                         break;
01033                 case 6:
01034                         /* binomial controls */ 
01035                         cwnd_ += increase_num_ / (cwnd_*pow(cwnd_,k_parameter_));                
01036                         break; 
01037                 case 8: 
01038                         /* high-speed TCP */
01039                         increment = increase_param();
01040                         if ((last_cwnd_action_ == 0 ||
01041                           last_cwnd_action_ == CWND_ACTION_TIMEOUT) 
01042                           && max_ssthresh_ > 0) {
01043                                 increment = limited_slow_start(cwnd_,
01044                                   max_ssthresh_, increment);
01045                         }
01046                         cwnd_ += increment;
01047                         break;
01048                 default:
01049 #ifdef notdef
01050                         /*XXX*/
01051                         error("illegal window option %d", wnd_option_);
01052 #endif
01053                         abort();
01054                 }
01055         }
01056         // if maxcwnd_ is set (nonzero), make it the cwnd limit
01057         if (maxcwnd_ && (int(cwnd_) > maxcwnd_))
01058                 cwnd_ = maxcwnd_;
01059 
01060         return;
01061 }

00587 {
00588         int force_set_rtx_timer = 0;
00589         Packet* p = allocpkt();
00590         hdr_tcp *tcph = hdr_tcp::access(p);
00591         hdr_flags* hf = hdr_flags::access(p);
00592         hdr_ip *iph = hdr_ip::access(p);
00593         int databytes = hdr_cmn::access(p)->size();
00594         tcph->seqno() = seqno;
00595         tcph->ts() = Scheduler::instance().clock();
00596         tcph->ts_echo() = ts_peer_;
00597         tcph->reason() = reason;
00598         tcph->last_rtt() = int(int(t_rtt_)*tcp_tick_*1000);
00599 
00600         if (ecn_) {
00601                 hf->ect() = 1;  // ECN-capable transport
00602         }
00603         if (cong_action_) {
00604                 hf->cong_action() = TRUE;  // Congestion action.
00605                 cong_action_ = FALSE;
00606         }
00607         /* Check if this is the initial SYN packet. */
00608         if (seqno == 0) {
00609                 if (syn_) {
00610                         databytes = 0;
00611                         curseq_ += 1;
00612                         hdr_cmn::access(p)->size() = tcpip_base_hdr_size_;
00613                 }
00614                 if (ecn_) {
00615                         hf->ecnecho() = 1;
00616 //                      hf->cong_action() = 1;
00617                         hf->ect() = 0;
00618                 }
00619                 if (qs_enabled_) {
00620                         hdr_qs *qsh = hdr_qs::access(p);
00621                         if (rate_request_ > 0) {
00622                                 // QuickStart code from Srikanth Sundarrajan.
00623                                 qsh->flag() = QS_REQUEST;
00624                                 Random::seed_heuristically();
00625                                 qsh->ttl() = Random::integer(256);
00626                                 ttl_diff_ = (iph->ttl() - qsh->ttl()) % 256;
00627                                 qsh->rate() = rate_request_;
00628                                 qs_requested_ = 1;
00629                         } else {
00630                                 qsh->flag() = QS_DISABLE;
00631                         }
00632                 }
00633         }
00634         else if (useHeaders_ == true) {
00635                 hdr_cmn::access(p)->size() += headersize();
00636         }
00637         hdr_cmn::access(p)->size();
00638 
00639         /* if no outstanding data, be sure to set rtx timer again */
00640         if (highest_ack_ == maxseq_)
00641                 force_set_rtx_timer = 1;
00642         /* call helper function to fill in additional fields */
00643         output_helper(p);
00644 
00645         ++ndatapack_;
00646         ndatabytes_ += databytes;
00647         send(p, 0);
00648         if (seqno == curseq_ && seqno > maxseq_)
00649                 idle();  // Tell application I have sent everything so far
00650         if (seqno > maxseq_) {
00651                 maxseq_ = seqno;
00652                 if (!rtt_active_) {
00653                         rtt_active_ = 1;
00654                         if (seqno > rtt_seq_) {
00655                                 rtt_seq_ = seqno;
00656                                 rtt_ts_ = Scheduler::instance().clock();
00657                         }
00658                                         
00659                 }
00660         } else {
00661                 ++nrexmitpack_;
00662                 nrexmitbytes_ += databytes;
00663         }
00664         if (!(rtx_timer_.status() == TIMER_PENDING) || force_set_rtx_timer)
00665                 /* No timer pending.  Schedule one. */
00666                 set_rtx_timer();
00667 }

00062 {
00063         hdr_tcp *tcph = hdr_tcp::access(pkt);
00064         if (partial_window_deflation_) {
00065                 // Do partial window deflation before resetting last_ack_
00066                 unsigned int deflate = 0; // Should initialize it?? - haoboy
00067                 if (tcph->seqno() > last_ack_) // assertion
00068                         deflate = tcph->seqno() - last_ack_;
00069                 else 
00070                         printf("False call to partialnewack:  deflate %u \
00071 last_ack_ %d\n", deflate, last_ack_);
00072                 if (dupwnd_ > deflate)
00073                         dupwnd_ -= (deflate - 1);
00074                 else {
00075                         cwnd_ -= (deflate - dupwnd_);
00076                         // Leave dupwnd_ > 0 to flag "fast recovery" phase
00077                         dupwnd_ = 1; 
00078                 }
00079                 if (cwnd_ < 1) {cwnd_ = 1;}
00080         }
00081         last_ack_ = tcph->seqno();
00082         highest_ack_ = last_ack_;
00083         if (t_seqno_ < last_ack_ + 1)
00084                 t_seqno_ = last_ack_ + 1;
00085         if (rtt_active_ && tcph->seqno() >= rtt_seq_) {
00086                 rtt_active_ = 0;
00087                 t_backoff_ = 1;
00088         }
00089 }

00092 {
00093         if (!newreno_changes1_ || firstpartial_ == 0) {
00094                 firstpartial_ = 1;
00095                 /* For newreno_changes1_, 
00096                  * only reset the retransmit timer for the first
00097                  * partial ACK, so that, in the worst case, we
00098                  * don't have to wait for one packet retransmitted
00099                  * per RTT.
00100                  */
00101                 newtimer(pkt);
00102         }
00103         partialnewack(pkt);
00104         output(last_ack_ + 1, 0);
00105 }

00097 { return here_.port_; }

01807 {
01808         if (F_counting == 1) {
01809                 if (seqno >= W_timed) {
01810                         RTT_count ++ ; 
01811                         F_counting = 0 ; 
01812                 }
01813                 else {
01814                         if (dupacks_ == numdupacks_)
01815                                 RTT_count ++ ;
01816                 }
01817         }
01818 }

01703 {
01704         int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
01705         int rto = (int)(t_rtxcur_/tcp_tick_) ; 
01706         /*double ct = Scheduler::instance().clock();*/
01707 
01708         if (!EnblRTTCtr_) {
01709                 if (tcp_now - T_last >= rto) {
01710                         // The sender has been idle.
01711                         slowdown(THREE_QUARTER_SSTHRESH) ;
01712                         for (int i = 0 ; i < (tcp_now - T_last)/rto; i ++) {
01713                                 slowdown(CWND_HALF_WITH_MIN);
01714                         }
01715                         T_prev = tcp_now ;
01716                         W_used = 0 ;
01717                 }
01718                 T_last = tcp_now ;
01719                 if (t_seqno_ == highest_ack_+ window()) {
01720                         T_prev = tcp_now ; 
01721                         W_used = 0 ; 
01722                 }
01723                 else if (t_seqno_ == curseq_-1) {
01724                         // The sender has no more data to send.
01725                         int tmp = t_seqno_ - highest_ack_ ;
01726                         if (tmp > W_used)
01727                                 W_used = tmp ;
01728                         if (tcp_now - T_prev >= rto) {
01729                                 // The sender has been application-limited.
01730                                 slowdown(THREE_QUARTER_SSTHRESH);
01731                                 slowdown(CLOSE_CWND_HALF_WAY);
01732                                 T_prev = tcp_now ;
01733                                 W_used = 0 ;
01734                         }
01735                 }
01736         } else {
01737                 rtt_counting();
01738         }
01739 }

01414 {
01415         // QuickStart code from Srikanth Sundarrajan.
01416         hdr_tcp *tcph = hdr_tcp::access(pkt);
01417         hdr_qs *qsh = hdr_qs::access(pkt);
01418         double now = Scheduler::instance().clock();
01419         int app_rate;
01420 
01421         // printf("flag: %d ttl: %d ttl_diff: %d rate: %d\n", qsh->flag(),
01422         //     qsh->ttl(), ttl_diff_, qsh->rate());
01423         qs_requested_ = 0;
01424         qs_approved_ = 0;
01425         if (qsh->flag() == QS_RESPONSE && qsh->ttl() == ttl_diff_ && 
01426             qsh->rate() > 0) {
01427                 app_rate = (int) (qsh->rate() * (now - tcph->ts_echo())) ;
01428                 printf("Quick Start approved, rate %d, window %d\n", 
01429                                      qsh->rate(), app_rate);
01430                 if (app_rate > initial_window()) {
01431                         wnd_init_option_ = 1;
01432                         wnd_init_ = app_rate;
01433                         qs_approved_ = 1;
01434                 }
01435         } else { // Quick Start rejected
01436                 printf("Quick Start rejected\n");
01437         }
01438 
01439 }

01638 {
01639         if (highest_ack_ >= recover_) {
01640                 recover_ =  maxseq_;
01641                 last_cwnd_action_ = CWND_ACTION_ECN;
01642                 closecwnd(how);
01643         }
01644 }

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

00168 {
00169         hdr_tcp *tcph = hdr_tcp::access(pkt);
00170 
00171         /* Use first packet to calculate the RTT  --contributed by Allman */
00172 
00173         if (qs_approved_ == 1 && tcph->seqno() > last_ack_)
00174                 endQuickStart();
00175         if (qs_requested_ == 1)
00176                 processQuickStart(pkt);
00177         if (++acked_ == 1) 
00178                 basertt_ = Scheduler::instance().clock() - firstsent_;
00179 
00180         /* Estimate ssthresh based on the calculated RTT and the estimated
00181            bandwidth (using ACKs 2 and 3).  */
00182 
00183         else if (acked_ == 2)
00184                 ack2_ = Scheduler::instance().clock();
00185         else if (acked_ == 3) {
00186                 ack3_ = Scheduler::instance().clock();
00187                 new_ssthresh_ = int((basertt_ * (size_ / (ack3_ - ack2_))) / size_);
00188                 if (newreno_changes_ > 0 && new_ssthresh_ < ssthresh_)
00189                         ssthresh_ = new_ssthresh_;
00190         }
00191 
00192 #ifdef notdef
00193         if (pkt->type_ != PT_ACK) {
00194                 fprintf(stderr,
00195                         "ns: confiuration error: tcp received non-ack\n");
00196                 exit(1);
00197         }
00198 #endif
00199         /* W.N.: check if this is from a previous incarnation */
00200         if (tcph->ts() < lastreset_) {
00201                 // Remove packet and do nothing
00202                 Packet::free(pkt);
00203                 return;
00204         }
00205         ++nackpack_;
00206         ts_peer_ = tcph->ts();
00207 
00208         if (hdr_flags::access(pkt)->ecnecho() && ecn_)
00209                 ecn(tcph->seqno());
00210         recv_helper(pkt);
00211         if (tcph->seqno() > last_ack_) {
00212                 if (tcph->seqno() >= recover_ 
00213                     || (last_cwnd_action_ != CWND_ACTION_DUPACK &&
00214                         tcph->seqno() > last_ack_)) {
00215                         if (dupwnd_ > 0 && exit_recovery_fix_) {
00216                                 int outstanding = maxseq_ - tcph->seqno() + 1;
00217                                 if (ssthresh_ < outstanding)
00218                                         cwnd_ = ssthresh_;
00219                                 else
00220                                         cwnd_ = outstanding;
00221                         }
00222                         dupwnd_ = 0;
00223                         firstpartial_ = 0;
00224                         recv_newack_helper(pkt);
00225                         if (last_ack_ == 0 && delay_growth_) {
00226                                 cwnd_ = initial_window();
00227                         }
00228                 } else {
00229                         /* received new ack for a packet sent during Fast
00230                          *  Recovery, but sender stays in Fast Recovery */
00231                         if (partial_window_deflation_ == 0)
00232                                 dupwnd_ = 0;
00233                         partialnewack_helper(pkt);
00234                 }
00235         } else if (tcph->seqno() == last_ack_) {
00236                 if (hdr_flags::access(pkt)->eln_ && eln_) {
00237                         tcp_eln(pkt);
00238                         return;
00239                 }
00240                 if (++dupacks_ == numdupacks_) {
00241                         dupack_action();
00242                         dupwnd_ = numdupacks_;
00243                 } else if (dupacks_ > numdupacks_) {
00244                         trace_event("NEWRENO_FAST_RECOVERY");
00245                         ++dupwnd_;      // fast recovery
00246 
00247                         /* For every two duplicate ACKs we receive (in the
00248                          * "fast retransmit phase"), send one entirely new
00249                          * data packet "to keep the flywheel going".  --Allman
00250                          */
00251                         if (newreno_changes_ > 0 && (dupacks_ % 2) == 1)
00252                                 output (t_seqno_++,0);
00253                 } else if (dupacks_ < numdupacks_ && singledup_ ) {
00254                         send_one();
00255                 }
00256         }
00257         Packet::free(pkt);
00258 #ifdef notyet
00259         if (trace_)
00260                 plot();
00261 #endif
00262 
00263         /*
00264          * Try to send more data
00265          */
00266 
00267         if (dupacks_ == 0) 
00268                 /*
00269                  * Maxburst is really only needed for the first
00270                  *  window of data on exiting Fast Recovery.
00271                  */
00272                 send_much(0, 0, maxburst_);
00273         else if (dupacks_ > numdupacks_ - 1 && newreno_changes_ == 0)
00274                 send_much(0, 0, 2);
00275 }

00355 {
00356         if (app_)
00357                 app_->recv(nbytes);     
00358 }

00411 {
00412         rtt_init();
00413         rtt_seq_ = -1;
00414         /*XXX lookup variables */
00415         dupacks_ = 0;
00416         curseq_ = 0;
00417         set_initial_window();
00418 
00419         t_seqno_ = 0;
00420         maxseq_ = -1;
00421         last_ack_ = -1;
00422         highest_ack_ = -1;
00423         ssthresh_ = int(wnd_);
00424         if (max_ssthresh_ > 0 && max_ssthresh_ < ssthresh_) 
00425                 ssthresh_ = max_ssthresh_;
00426         wnd_restart_ = 1.;
00427         awnd_ = wnd_init_ / 2.0;
00428         recover_ = 0;
00429         closed_ = 0;
00430         last_cwnd_action_ = 0;
00431         boot_time_ = Random::uniform(tcp_tick_);
00432         first_decrease_ = 1;
00433         /* W.N.: for removing packets from previous incarnations */
00434         lastreset_ = Scheduler::instance().clock();
00435 
00436         /* Now these variables will be reset 
00437            - Debojyoti Dutta 12th Oct'2000 */
00438  
00439         ndatapack_ = 0;
00440         ndatabytes_ = 0;
00441         nackpack_ = 0;
00442         nrexmitbytes_ = 0;
00443         nrexmit_ = 0;
00444         nrexmitpack_ = 0;
00445         necnresponses_ = 0;
00446         ncwndcuts_ = 0;
00447 
00448         cwnd_last_ = 0.0;
00449 
00450         if (control_increase_) {
00451                 prev_highest_ack_ = highest_ack_ ; 
00452         }
00453 
00454         if (QOption_) {
00455                 int now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
00456                 T_last = now ; 
00457                 T_prev = now ; 
00458                 W_used = 0 ;
00459                 if (EnblRTTCtr_) {
00460                         reset_qoption();
00461                 }
00462         }
00463 }

00396 {
00397         int now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
00398 
00399         T_start = now ; 
00400         RTT_count = 0 ; 
00401         RTT_prev = 0 ; 
00402         RTT_goodcount = 1 ; 
00403         F_counting = 0 ; 
00404         W_timed = -1 ; 
00405         F_full = 0 ;
00406         Backoffs = 0 ; 
00407 }

00814 {
00815         if (backoff)
00816                 rtt_backoff();
00817         set_rtx_timer();
00818         if (!mild)
00819                 t_seqno_ = highest_ack_ + 1;
00820         rtt_active_ = 0;
00821 }

00553 {
00554         if (t_backoff_ < 64)
00555                 t_backoff_ <<= 1;
00556 
00557         if (t_backoff_ > 8) {
00558                 /*
00559                  * If backed off this far, clobber the srtt
00560                  * value, storing it in the mean deviation
00561                  * instead.
00562                  */
00563                 t_rttvar_ += (t_srtt_ >> T_SRTT_BITS);
00564                 t_srtt_ = 0;
00565         }
00566 }

01749 {
01750         int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
01751         int rtt = (int(t_srtt_) >> T_SRTT_BITS) ;
01752 
01753         if (rtt < 1) 
01754                 rtt = 1 ;
01755         if (tcp_now - T_last >= 2*rtt) {
01756                 // The sender has been idle.
01757                 int RTTs ; 
01758                 RTTs = (tcp_now -T_last)*RTT_goodcount/(rtt*2) ; 
01759                 RTTs = RTTs - Backoffs ; 
01760                 Backoffs = 0 ; 
01761                 if (RTTs > 0) {
01762                         slowdown(THREE_QUARTER_SSTHRESH) ;
01763                         for (int i = 0 ; i < RTTs ; i ++) {
01764                                 slowdown(CWND_HALF_WITH_MIN);
01765                                 RTT_prev = RTT_count ; 
01766                                 W_used = 0 ;
01767                         }
01768                 }
01769         }
01770         T_last = tcp_now ;
01771         if (tcp_now - T_start >= 2*rtt) {
01772                 if ((RTT_count > RTT_goodcount) || (F_full == 1)) {
01773                         RTT_goodcount = RTT_count ; 
01774                         if (RTT_goodcount < 1) RTT_goodcount = 1 ; 
01775                 }
01776                 RTT_prev = RTT_prev - RTT_count ;
01777                 RTT_count = 0 ; 
01778                 T_start  = tcp_now ;
01779                 F_full = 0;
01780         }
01781         if (t_seqno_ == highest_ack_ + window()) {
01782                 W_used = 0 ; 
01783                 F_full = 1 ; 
01784                 RTT_prev = RTT_count ;
01785         }
01786         else if (t_seqno_ == curseq_-1) {
01787                 // The sender has no more data to send.
01788                 int tmp = t_seqno_ - highest_ack_ ;
01789                 if (tmp > W_used)
01790                         W_used = tmp ;
01791                 if (RTT_count - RTT_prev >= 2) {
01792                         // The sender has been application-limited.
01793                         slowdown(THREE_QUARTER_SSTHRESH) ;
01794                         slowdown(CLOSE_CWND_HALF_WAY);
01795                         RTT_prev = RTT_count ; 
01796                         Backoffs ++ ; 
01797                         W_used = 0;
01798                 }
01799         }
01800         if (F_counting == 0) {
01801                 W_timed = t_seqno_  ;
01802                 F_counting = 1 ;
01803         }
01804 }

00469 {
00470         t_rtt_ = 0;
00471         t_srtt_ = int(srtt_init_ / tcp_tick_) << T_SRTT_BITS;
00472         t_rttvar_ = int(rttvar_init_ / tcp_tick_) << T_RTTVAR_BITS;
00473         t_rtxcur_ = rtxcur_init_;
00474         t_backoff_ = 1;
00475 }

00478 {
00479         double timeout;
00480         if (rfc2988_) {
00481         // Correction from Tom Kelly to be RFC2988-compliant, by
00482         // clamping minrto_ before applying t_backoff_.
00483                 if (t_rtxcur_ < minrto_)
00484                         timeout = minrto_ * t_backoff_;
00485                 else
00486                         timeout = t_rtxcur_ * t_backoff_;
00487         } else {
00488                 timeout = t_rtxcur_ * t_backoff_;
00489                 if (timeout < minrto_)
00490                         timeout = minrto_;
00491         }
00492 
00493         if (timeout > maxrto_)
00494                 timeout = maxrto_;
00495 
00496         if (timeout < 2.0 * tcp_tick_) {
00497                 if (timeout < 0) {
00498                         fprintf(stderr, "TcpAgent: negative RTO!  (%f)\n",
00499                                 timeout);
00500                         exit(1);
00501                 }
00502                 timeout = 2.0 * tcp_tick_;
00503         }
00504         return (timeout);
00505 }

00510 {
00511         double now = Scheduler::instance().clock();
00512         if (ts_option_)
00513                 t_rtt_ = int(tao /tcp_tick_ + 0.5);
00514         else {
00515                 double sendtime = now - tao;
00516                 sendtime += boot_time_;
00517                 double tickoff = fmod(sendtime, tcp_tick_);
00518                 t_rtt_ = int((tao + tickoff) / tcp_tick_);
00519         }
00520         if (t_rtt_ < 1)
00521                 t_rtt_ = 1;
00522 
00523         //
00524         // srtt has 3 bits to the right of the binary point
00525         // rttvar has 2
00526         //
00527         if (t_srtt_ != 0) {
00528                 register short delta;
00529                 delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS);      // d = (m - a0)
00530                 if ((t_srtt_ += delta) <= 0)    // a1 = 7/8 a0 + 1/8 m
00531                         t_srtt_ = 1;
00532                 if (delta < 0)
00533                         delta = -delta;
00534                 delta -= (t_rttvar_ >> T_RTTVAR_BITS);
00535                 if ((t_rttvar_ += delta) <= 0)  // var1 = 3/4 var0 + 1/4 |d|
00536                         t_rttvar_ = 1;
00537         } else {
00538                 t_srtt_ = t_rtt_ << T_SRTT_BITS;                // srtt = rtt
00539                 t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1);        // rttvar = rtt / 2
00540         }
00541         //
00542         // Current retransmit value is 
00543         //    (unscaled) smoothed round trip estimate
00544         //    plus 2^rttvar_exp_ times (unscaled) rttvar. 
00545         //
00546         t_rtxcur_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS))) +
00547                 t_srtt_)  >> T_SRTT_BITS ) * tcp_tick_;
00548 
00549         return;
00550 }

00089 { sendmsg(nbytes); }

00084 { sendmsg(sz, data, 0); }

00080 { target_->recv(p, h); }

00114 { TcpAsymAgent::send_helper(maxburst); }

00766 {
00767         send_idle_helper();
00768         int win = window();
00769         int npackets = 0;
00770 
00771         if (!force && delsnd_timer_.status() == TIMER_PENDING)
00772                 return;
00773         /* Save time when first packet was sent, for newreno  --Allman */
00774         if (t_seqno_ == 0)
00775                 firstsent_ = Scheduler::instance().clock();
00776 
00777         if (burstsnd_timer_.status() == TIMER_PENDING)
00778                 return;
00779         while (t_seqno_ <= highest_ack_ + win && t_seqno_ < curseq_) {
00780                 if (overhead_ == 0 || force) {
00781                         output(t_seqno_, reason);
00782                         npackets++;
00783                         if (QOption_)
00784                                 process_qoption_after_send () ; 
00785                         t_seqno_ ++ ;
00786                         if (qs_approved_ == 1) {
00787                                 // delay = effective RTT / window
00788                                 double delay = (double) t_rtt_ * tcp_tick_ / win;
00789                                 delsnd_timer_.resched(delay);
00790                                 return;
00791                         }
00792                 } else if (!(delsnd_timer_.status() == TIMER_PENDING)) {
00793                         /*
00794                          * Set a delayed send timeout.
00795                          */
00796                         delsnd_timer_.resched(Random::uniform(overhead_));
00797                         return;
00798                 }
00799                 win = window();
00800                 if (maxburst && npackets == maxburst)
00801                         break;
00802         }
00803         /* call helper function */
00804         send_helper(maxburst);
00805 }

01351 {
01352         if (t_seqno_ <= highest_ack_ + wnd_ && t_seqno_ < curseq_ &&
01353                 t_seqno_ <= highest_ack_ + cwnd_ + dupacks_ ) {
01354                 output(t_seqno_, 0);
01355                 if (QOption_)
01356                         process_qoption_after_send () ;
01357                 t_seqno_ ++ ;
01358                 // send_helper(); ??
01359         }
01360         return;
01361 }

00401 {
00402         fprintf(stderr, 
00403         "Agent::sendmsg(int, AppData*, const char*) not implemented\n");
00404         abort();
00405 }

00675 {
00676         if (nbytes == -1 && curseq_ <= TCP_MAXSEQ)
00677                 curseq_ = TCP_MAXSEQ; 
00678         else
00679                 curseq_ += (nbytes/size_ + (nbytes%size_ ? 1 : 0));
00680         send_much(0, 0, maxburst_);
00681 }

00409 {
00410         fprintf(stderr, 
00411         "Agent::sendmsg(int, AppData*, const char*) not implemented\n");
00412         abort();
00413 }

00387 {
00388         if (syn_ && delay_growth_)
00389                 cwnd_ = 1.0; 
00390         else
00391                 cwnd_ = initial_window();
00392 }

00100 { type_ = pkttype; }

00828 {
00829         rtx_timer_.resched(rtt_timeout());
00830 }

00095 { return size_; }

01065 {
01066         double decrease;  /* added for highspeed - sylvia */
01067         double win, halfwin, decreasewin;
01068         int slowstart = 0;
01069         ++ncwndcuts_; 
01070         // we are in slowstart for sure if cwnd < ssthresh
01071         if (cwnd_ < ssthresh_) 
01072                 slowstart = 1;
01073         if (precision_reduce_) {
01074                 halfwin = windowd() / 2;
01075                 if (wnd_option_ == 6) {         
01076                         /* binomial controls */
01077                         decreasewin = windowd() - (1.0-decrease_num_)*pow(windowd(),l_parameter_);
01078                 } else if (wnd_option_ == 8 && (cwnd_ > low_window_)) { 
01079                         /* experimental highspeed TCP */
01080                         decrease = decrease_param();
01081                         //if (decrease < 0.1) 
01082                         //      decrease = 0.1;
01083                         decrease_num_ = decrease;
01084                         decreasewin = windowd() - (decrease * windowd());
01085                 } else {
01086                         decreasewin = decrease_num_ * windowd();
01087                 }
01088                 win = windowd();
01089         } else  {
01090                 int temp;
01091                 temp = (int)(window() / 2);
01092                 halfwin = (double) temp;
01093                 if (wnd_option_ == 6) {
01094                         /* binomial controls */
01095                         temp = (int)(window() - (1.0-decrease_num_)*pow(window(),l_parameter_));
01096                 } else if ((wnd_option_ == 8) && (cwnd_ > low_window_)) { 
01097                         /* experimental highspeed TCP */
01098                         decrease = decrease_param();
01099                         //if (decrease < 0.1)
01100                         //       decrease = 0.1;                
01101                         decrease_num_ = decrease;
01102                         temp = (int)(windowd() - (decrease * windowd()));
01103                 } else {
01104                         temp = (int)(decrease_num_ * window());
01105                 }
01106                 decreasewin = (double) temp;
01107                 win = (double) window();
01108         }
01109         if (how & CLOSE_SSTHRESH_HALF)
01110                 // For the first decrease, decrease by half
01111                 // even for non-standard values of decrease_num_.
01112                 if (first_decrease_ == 1 || slowstart ||
01113                         last_cwnd_action_ == CWND_ACTION_TIMEOUT) {
01114                         // Do we really want halfwin instead of decreasewin
01115                 // after a timeout?
01116                         ssthresh_ = (int) halfwin;
01117                 } else {
01118                         ssthresh_ = (int) decreasewin;
01119                 }
01120         else if (how & THREE_QUARTER_SSTHRESH)
01121                 if (ssthresh_ < 3*cwnd_/4)
01122                         ssthresh_  = (int)(3*cwnd_/4);
01123         if (how & CLOSE_CWND_HALF)
01124                 // For the first decrease, decrease by half
01125                 // even for non-standard values of decrease_num_.
01126                 if (first_decrease_ == 1 || slowstart || decrease_num_ == 0.5) {
01127                         cwnd_ = halfwin;
01128                 } else cwnd_ = decreasewin;
01129         else if (how & CWND_HALF_WITH_MIN) {
01130                 // We have not thought about how non-standard TCPs, with
01131                 // non-standard values of decrease_num_, should respond
01132                 // after quiescent periods.
01133                 cwnd_ = decreasewin;
01134                 if (cwnd_ < 1)
01135                         cwnd_ = 1;
01136         }
01137         else if (how & CLOSE_CWND_RESTART) 
01138                 cwnd_ = int(wnd_restart_);
01139         else if (how & CLOSE_CWND_INIT)
01140                 cwnd_ = int(wnd_init_);
01141         else if (how & CLOSE_CWND_ONE)
01142                 cwnd_ = 1;
01143         else if (how & CLOSE_CWND_HALF_WAY) {
01144                 // cwnd_ = win - (win - W_used)/2 ;
01145                 cwnd_ = W_used + decrease_num_ * (win - W_used);
01146                 if (cwnd_ < 1)
01147                         cwnd_ = 1;
01148         }
01149         if (ssthresh_ < 2)
01150                 ssthresh_ = 2;
01151         if (how & (CLOSE_CWND_HALF|CLOSE_CWND_RESTART|CLOSE_CWND_INIT|CLOSE_CWND_ONE))
01152                 cong_action_ = TRUE;
01153 
01154         fcnt_ = count_ = 0;
01155         if (first_decrease_ == 1)
01156                 first_decrease_ = 0;
01157         // for event tracing slow start
01158         if (cwnd_ == 1 || slowstart) 
01159                 // Not sure if this is best way to capture slow_start
01160                 // This is probably tracing a superset of slowdowns of
01161                 // which all may not be slow_start's --Padma, 07/'01.
01162                 trace_event("SLOW_START");
01163         
01164 
01165 
01166         
01167 }

00048 { return target_; }

01583 {
01584         //int eln_rxmit;
01585         hdr_tcp *tcph = hdr_tcp::access(pkt);
01586         int ack = tcph->seqno();
01587 
01588         if (++dupacks_ == eln_rxmit_thresh_ && ack > eln_last_rxmit_) {
01589                 /* Retransmit this packet */
01590                 output(last_ack_ + 1, TCP_REASON_DUPACK);
01591                 eln_last_rxmit_ = last_ack_+1;
01592         } else
01593                 send_much(0, 0, maxburst_);
01594 
01595         Packet::free(pkt);
01596         return;
01597 }

00200 {
00201         if (tno == TCP_TIMER_RTX) {
00202                 dupwnd_ = 0;
00203                 dupacks_ = 0;
00204                 if (bug_fix_) recover_ = maxseq_;
00205                 TcpAgent::timeout(tno);
00206         } else {
00207                 timeout_nonrtx(tno);
00208         }
00209 }

01506 {
01507         if (tno == TCP_TIMER_DELSND)  {
01508          /*
01509                 * delayed-send timer, with random overhead
01510                 * to avoid phase effects
01511                 */
01512                 send_much(1, TCP_REASON_TIMEOUT, maxburst_);
01513         }
01514 }

00368 {
00369         if (nam_tracevar_) {
00370                 Agent::trace(v);
00371         } else if (trace_all_oneline_)
00372                 traceAll();
00373         else 
00374                 traceVar(v);
00375 }

01821 {
01822         if (et_ == NULL) return;
01823         int seqno = t_seqno_;
01824         char *wrk = et_->buffer();
01825         char *nwrk = et_->nbuffer();
01826         if (wrk != 0)
01827                 sprintf(wrk,
01828                         "E "TIME_FORMAT" %d %d TCP %s %d %d %d",
01829                         et_->round(Scheduler::instance().clock()),   // time
01830                         addr(),                       // owner (src) node id
01831                         daddr(),                      // dst node id
01832                         eventtype,                    // event type
01833                         fid_,                         // flow-id
01834                         seqno,                        // current seqno
01835                         int(cwnd_)                         //cong. window
01836                         );
01837         
01838         if (nwrk != 0)
01839                 sprintf(nwrk,
01840                         "E -t "TIME_FORMAT" -o TCP -e %s -s %d.%d -d %d.%d",
01841                         et_->round(Scheduler::instance().clock()),   // time
01842                         eventtype,                    // event type
01843                         addr(),                       // owner (src) node id
01844                         port(),                       // owner (src) port id
01845                         daddr(),                      // dst node id
01846                         dport()                       // dst port id
01847                         );
01848         et_->trace();
01849 }

00208                        {
00209         double curtime;
00210         Scheduler& s = Scheduler::instance();
00211         char wrk[500];
00212         int n;
00213 
00214         TcpAgent::traceAll();
00215         curtime = &s ? s.clock() : 0;
00216         sprintf(wrk, "time: %-8.5f saddr: %-2d sport: %-2d daddr: %-2d dport:"
00217                 " %-2d exact_srtt %d", curtime, addr(), port(),
00218                 daddr(), dport(), (int(t_exact_srtt_)));
00219         n = strlen(wrk);
00220         wrk[n] = '\n';
00221         wrk[n+1] = 0;
00222         if (channel_)
00223                 (void)Tcl_Write(channel_, wrk, n+1);
00224         wrk[n] = 0;
00225         return;
00226 }

00296                    {
00297         double curtime;
00298         Scheduler& s = Scheduler::instance();
00299         char wrk[500];
00300         int n;
00301 
00302         curtime = &s ? s.clock() : 0;
00303         sprintf(wrk,"time: %-8.5f saddr: %-2d sport: %-2d daddr: %-2d dport:"
00304                 " %-2d maxseq: %-4d hiack: %-4d seqno: %-4d cwnd: %-6.3f"
00305                 " ssthresh: %-3d dupacks: %-2d rtt: %-6.3f srtt: %-6.3f"
00306                 " rttvar: %-6.3f bkoff: %-d", curtime, addr(), port(),
00307                 daddr(), dport(), int(maxseq_), int(highest_ack_),
00308                 int(t_seqno_), double(cwnd_), int(ssthresh_),
00309                 int(dupacks_), int(t_rtt_)*tcp_tick_, 
00310                 (int(t_srtt_) >> T_SRTT_BITS)*tcp_tick_, 
00311                 int(t_rttvar_)*tcp_tick_/4.0, int(t_backoff_)); 
00312         n = strlen(wrk);
00313         wrk[n] = '\n';
00314         wrk[n+1] = 0;
00315         if (channel_)
00316                 (void)Tcl_Write(channel_, wrk, n+1);
00317         wrk[n] = 0;
00318         return;
00319 }

00179                                         {
00180         Scheduler& s = Scheduler::instance();
00181         char wrk[500];
00182 
00183         double curtime = &s ? s.clock() : 0;
00184         if (!strcmp(v->name(), "exact_srtt_"))
00185                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f", 
00186                         curtime, addr(), port(), daddr(), dport(),
00187                         v->name(), double(*((TracedDouble*) v)));
00188         else if (!strcmp(v->name(), "avg_win_"))
00189                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f", 
00190                         curtime, addr(), port(), daddr(), dport(), 
00191                         v->name(), double(*((TracedDouble*) v)));
00192         else {
00193                 TcpAgent::traceVar(v);
00194                 return;
00195         }
00196 
00197         int n = strlen(wrk);
00198         wrk[n] = '\n';
00199         wrk[n+1] = 0;
00200         if (channel_)
00201                 (void)Tcl_Write(channel_, wrk, n+1);
00202         wrk[n] = 0;
00203         return;
00204 }

00324 {
00325         double curtime;
00326         Scheduler& s = Scheduler::instance();
00327         char wrk[500];
00328         int n;
00329 
00330         curtime = &s ? s.clock() : 0;
00331         if (!strcmp(v->name(), "cwnd_") || !strcmp(v->name(), "maxrto_")) 
00332                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00333                         curtime, addr(), port(), daddr(), dport(),
00334                         v->name(), double(*((TracedDouble*) v))); 
00335         else if (!strcmp(v->name(), "minrto_")) 
00336                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00337                         curtime, addr(), port(), daddr(), dport(),
00338                         v->name(), double(*((TracedDouble*) v))); 
00339         else if (!strcmp(v->name(), "rtt_"))
00340                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00341                         curtime, addr(), port(), daddr(), dport(),
00342                         v->name(), int(*((TracedInt*) v))*tcp_tick_); 
00343         else if (!strcmp(v->name(), "srtt_")) 
00344                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00345                         curtime, addr(), port(), daddr(), dport(),
00346                         v->name(), 
00347                         (int(*((TracedInt*) v)) >> T_SRTT_BITS)*tcp_tick_); 
00348         else if (!strcmp(v->name(), "rttvar_"))
00349                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00350                         curtime, addr(), port(), daddr(), dport(),
00351                         v->name(), 
00352                         int(*((TracedInt*) v))*tcp_tick_/4.0); 
00353         else
00354                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %d",
00355                         curtime, addr(), port(), daddr(), dport(),
00356                         v->name(), int(*((TracedInt*) v))); 
00357         n = strlen(wrk);
00358         wrk[n] = '\n';
00359         wrk[n+1] = 0;
00360         if (channel_)
00361                 (void)Tcl_Write(channel_, wrk, n+1);
00362         wrk[n] = 0;
00363         return;
00364 }

00043 {
00044         //
00045         // reno: inflate the window by dupwnd_
00046         //      dupwnd_ will be non-zero during fast recovery,
00047         //      at which time it contains the number of dup acks
00048         //
00049         int win = int(cwnd_) + dupwnd_;
00050         if (win > int(wnd_))
00051                 win = int(wnd_);
00052         return (win);
00053 }

00056 {
00057         //
00058         // reno: inflate the window by dupwnd_
00059         //      dupwnd_ will be non-zero during fast recovery,
00060         //      at which time it contains the number of dup acks
00061         //
00062         double win = cwnd_ + dupwnd_;
00063         if (win > wnd_)
00064                 win = wnd_;
00065         return (win);
00066 }

NewRenoTcpAsymAgent Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	NewRenoTcpAsymAgent ()
virtual void	output_helper (Packet *p)
virtual void	send_helper (int maxburst)
virtual void	recv_helper (Packet *p)
virtual void	recv_newack_helper (Packet *pkt)
virtual void	recv (Packet pkt, Handler )
virtual void	recv (Packet p, const char s)
virtual void	partialnewack_helper (Packet *pkt)
virtual void	dupack_action ()
virtual int	window ()
virtual double	windowd ()
virtual void	timeout (int tno)
virtual void	timeout_nonrtx (int tno)
int	command (int argc, const char const argv)
virtual void	sendmsg (int nbytes, const char *flags=0)
virtual void	sendmsg (int sz, AppData , const char flags=0)
void	trace (TracedVar *v)
virtual void	advanceby (int delta)
void	recvOnly (Packet *)
void	send (Packet p, Handler h)
virtual void	send (int sz, AppData *data)
virtual void	send (int nbytes)
virtual void	sendto (int sz, AppData , const char flags, nsaddr_t dst)
virtual void	sendto (int nbytes, const char *flags, nsaddr_t dst)
virtual void	connect (nsaddr_t dst)
virtual void	close ()
virtual void	listen ()
virtual void	attachApp (Application *app)
virtual int &	size ()
nsaddr_t &	addr ()
nsaddr_t &	port ()
nsaddr_t &	daddr ()
nsaddr_t &	dport ()
void	set_pkttype (packet_t pkttype)
packet_t	get_pkttype ()
NsObject *	target ()
virtual void	drop (Packet *p)
int	isdebug () const
virtual void	debug (const char *fmt,...)
virtual void	traceAll ()
virtual void	traceVar (TracedVar *v)
Protected Member Functions
void	partialnewack (Packet *pkt)
int	allow_fast_retransmit (int last_cwnd_action_)
void	print_if_needed (double memb_time)
void	traceAll ()
virtual void	traceVar (TracedVar *v)
virtual int	headersize ()
virtual void	delay_bind_init_all ()
virtual int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
virtual void	rtt_init ()
virtual double	rtt_timeout ()
virtual void	rtt_update (double tao)
virtual void	rtt_backoff ()
virtual void	output (int seqno, int reason=0)
virtual void	send_much (int force, int reason, int maxburst=0)
virtual void	newtimer (Packet *)
virtual void	send_one ()
double	linear (double x, double x_1, double y_1, double x_2, double y_2)
void	opencwnd ()
void	slowdown (int how)
void	ecn (int seqno)
virtual void	set_initial_window ()
double	initial_window ()
void	reset ()
void	newack (Packet *)
void	tcp_eln (Packet *pkt)
void	finish ()
void	reset_qoption ()
void	rtt_counting ()
int	network_limited ()
double	limited_slow_start (double cwnd, double max_ssthresh, double increment)
virtual int	numdupacks (double cwnd)
virtual void	processQuickStart (Packet *pkt)
virtual void	endQuickStart ()
virtual void	send_idle_helper ()
virtual void	cancel_timers ()
virtual void	cancel_rtx_timer ()
virtual void	set_rtx_timer ()
void	reset_rtx_timer (int mild, int backoff=1)
double	increase_param ()
double	decrease_param ()
double	compute_p ()
void	trace_event (char *eventtype)
void	closecwnd (int how)
void	quench (int how)
void	process_qoption_after_send ()
void	process_qoption_after_ack (int seqno)
virtual void	recvBytes (int bytes)
virtual void	idle ()
Packet *	allocpkt () const
Packet *	allocpkt (int) const
void	initpkt (Packet *) const
void	deleteAgentTrace ()
void	addAgentTrace (const char *name)
void	monitorAgentTrace ()
OldValue *	lookupOldValue (TracedVar *v)
void	insertOldValue (TracedVar v, const char value)
void	dumpTracedVars ()
virtual void	drop (Packet p, const char s)
void	handle (Event *)
Protected Attributes
int	newreno_changes_
int	newreno_changes1_
int	acked_
int	new_ssthresh_
double	ack2_
double	ack3_
double	basertt_
int	firstpartial_
int	partial_window_deflation_
int	exit_recovery_fix_
unsigned int	dupwnd_
TracedInt	t_seqno_
TracedInt	t_rtt_
int	T_SRTT_BITS
TracedInt	t_srtt_
int	srtt_init_
int	T_RTTVAR_BITS
int	rttvar_exp_
TracedInt	t_rttvar_
int	rttvar_init_
double	t_rtxcur_
double	rtxcur_init_
TracedInt	t_backoff_
double	ts_peer_
RtxTimer	rtx_timer_
DelSndTimer	delsnd_timer_
BurstSndTimer	burstsnd_timer_
int	timerfix_
int	rfc2988_
double	boot_time_
double	overhead_
double	wnd_
double	wnd_const_
double	wnd_th_
double	wnd_init_
double	wnd_restart_
double	tcp_tick_
int	wnd_option_
int	wnd_init_option_
double	decrease_num_
double	increase_num_
double	k_parameter_
double	l_parameter_
int	precision_reduce_
int	syn_
int	delay_growth_
int	tcpip_base_hdr_size_
int	ts_option_size_
int	bug_fix_
int	less_careful_
int	ts_option_
int	maxburst_
int	maxcwnd_
int	numdupacks_
int	numdupacksFrac_
double	maxrto_
double	minrto_
int	old_ecn_
FILE *	plotfile_
TracedInt	dupacks_
TracedInt	curseq_
int	last_ack_
TracedInt	highest_ack_
int	recover_
int	last_cwnd_action_
TracedDouble	cwnd_
double	base_cwnd_
double	awnd_
TracedInt	ssthresh_
int	count_
double	fcnt_
int	rtt_active_
int	rtt_seq_
double	rtt_ts_
TracedInt	maxseq_
int	ecn_
int	cong_action_
int	ecn_burst_
int	ecn_backoff_
int	ect_
int	eln_
int	eln_rxmit_thresh_
int	eln_last_rxmit_
double	firstsent_
double	lastreset_
int	slow_start_restart_
int	restart_bugfix_
int	closed_
TracedInt	ndatapack_
TracedInt	ndatabytes_
TracedInt	nackpack_
TracedInt	nrexmit_
TracedInt	nrexmitpack_
TracedInt	nrexmitbytes_
TracedInt	necnresponses_
TracedInt	ncwndcuts_
int	trace_all_oneline_
int	nam_tracevar_
int	first_decrease_
TracedInt	singledup_
int	noFastRetrans_
int	oldCode_
int	useHeaders_
int	low_window_
int	high_window_
double	high_p_
double	high_decrease_
int	max_ssthresh_
double	cwnd_last_
double	increase_last_
double	cwnd_frac_
int	rate_request_
int	qs_enabled_
int	qs_requested_
int	qs_approved_
int	ttl_diff_
int	QOption_
int	EnblRTTCtr_
int	T_full
int	T_last
int	T_prev
int	T_start
int	RTT_count
int	RTT_prev
int	RTT_goodcount
int	F_counting
int	W_used
int	W_timed
int	F_full
int	Backoffs
int	control_increase_
int	prev_highest_ack_
ns_addr_t	here_
ns_addr_t	dst_
int	size_
packet_t	type_
int	fid_
int	prio_
int	flags_
int	defttl_
Tcl_Channel	channel_
char *	traceName_
OldValue *	oldValueList_
Application *	app_
EventTrace *	et_
NsObject *	target_
NsObject *	drop_
int	debug_
int	ecn_to_echo_
TracedDouble	t_exact_srtt_
double	g_
int	damp_
Static Protected Attributes
int	uidcnt_