NS2.26SourcesOriginal: VegasTcpAgent class Reference

00055                              : TcpAgent()
00056 {
00057         v_sendtime_ = NULL;
00058         v_transmits_ = NULL;
00059 }

00062 {
00063         if (v_sendtime_)
00064                 delete []v_sendtime_;
00065         if (v_transmits_)
00066                 delete []v_transmits_;
00067 }

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 }

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 }

00083 {
00084         /* init vegas var */
00085         if (delay_bind(varName, localName, "v_alpha_", &v_alpha_, tracer)) 
00086                 return TCL_OK;
00087         if (delay_bind(varName, localName, "v_beta_", &v_beta_, tracer)) 
00088                 return TCL_OK;
00089         if (delay_bind(varName, localName, "v_gamma_", &v_gamma_, tracer)) 
00090                 return TCL_OK;
00091         if (delay_bind(varName, localName, "v_rtt_", &v_rtt_, tracer)) 
00092                 return TCL_OK;
00093         return TcpAgent::delay_bind_dispatch(varName, localName, tracer);
00094 }

00071 {
00072         delay_bind_init_one("v_alpha_");
00073         delay_bind_init_one("v_beta_");
00074         delay_bind_init_one("v_gamma_");
00075         delay_bind_init_one("v_rtt_");
00076         TcpAgent::delay_bind_init_all();
00077         reset();
00078 }

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 }

01365 {
01366         int recovered = (highest_ack_ > recover_);
01367         if (recovered || (!bug_fix_ && !ecn_)) {
01368                 goto tahoe_action;
01369         }
01370 
01371         if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {
01372                 last_cwnd_action_ = CWND_ACTION_DUPACK;
01373                 slowdown(CLOSE_CWND_ONE);
01374                 reset_rtx_timer(0,0);
01375                 return;
01376         }
01377 
01378         if (bug_fix_) {
01379                 /*
01380                  * The line below, for "bug_fix_" true, avoids
01381                  * problems with multiple fast retransmits in one
01382                  * window of data. 
01383                  */
01384                 return;
01385         }
01386 
01387 tahoe_action:
01388         // we are now going to fast-retransmit and willtrace that event
01389         trace_event("FAST_RETX");
01390 
01391         recover_ = maxseq_;
01392         last_cwnd_action_ = CWND_ACTION_DUPACK;
01393         slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_ONE);
01394         reset_rtx_timer(0,0);
01395         return;
01396 }

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 }

00427 {
00428         Packet* p = allocpkt();
00429         hdr_tcp *tcph = hdr_tcp::access(p);
00430         double now = Scheduler::instance().clock();
00431         tcph->seqno() = seqno;
00432         tcph->ts() = now;
00433         tcph->reason() = reason;
00434 
00435         /* if this is the 1st pkt, setup senttime[] and transmits[]
00436          * I alloc mem here, instrad of in the constructor, to cover
00437          * cases which windows get set by each different tcp flows */
00438         if (seqno==0) {
00439                 v_maxwnd_ = int(wnd_);
00440                 if (v_sendtime_)
00441                         delete []v_sendtime_;
00442                 if (v_transmits_)
00443                         delete []v_transmits_;
00444                 v_sendtime_ = new double[v_maxwnd_];
00445                 v_transmits_ = new int[v_maxwnd_];
00446                 for(int i=0;i<v_maxwnd_;i++) {
00447                         v_sendtime_[i] = -1.;
00448                         v_transmits_[i] = 0;
00449                 }
00450         }
00451 
00452         // record a find grained send time and # of transmits 
00453         int index = seqno % v_maxwnd_;
00454         v_sendtime_[index] = vegastime();  
00455         ++v_transmits_[index];
00456 
00457         /* support ndatabytes_ in output - Lloyd Wood 14 March 2000 */
00458         int bytes = hdr_cmn::access(p)->size(); 
00459         ndatabytes_ += bytes; 
00460         ndatapack_++; // Added this - Debojyoti 12th Oct 2000
00461         send(p, 0);
00462         if (seqno == curseq_ && seqno > maxseq_)
00463                 idle();  // Tell application I have sent everything so far
00464 
00465         if (seqno > maxseq_) {
00466                 maxseq_ = seqno;
00467                 if (!rtt_active_) {
00468                         rtt_active_ = 1;
00469                         if (seqno > rtt_seq_) {
00470                                 rtt_seq_ = seqno;
00471                                 rtt_ts_ = now;
00472                         }
00473                 }
00474         } else {
00475                 ++nrexmitpack_;
00476                 nrexmitbytes_ += bytes;
00477         }
00478 
00479         if (!(rtx_timer_.status() == TIMER_PENDING))
00480                 /* No timer pending.  Schedule one. */
00481                 set_rtx_timer();
00482 }

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 }

00135 {
00136         double currentTime = vegastime();
00137         hdr_tcp *tcph = hdr_tcp::access(pkt);
00138         hdr_flags *flagh = hdr_flags::access(pkt);
00139 
00140 #if 0
00141         if (pkt->type_ != PT_ACK) {
00142                 Tcl::instance().evalf("%s error \"recieved non-ack\"",
00143                                       name());
00144                 Packet::free(pkt);
00145                 return;
00146         }
00147 #endif /* 0 */
00148         ++nackpack_;
00149 
00150         if(firstrecv_<0) { // init vegas rtt vars
00151                 firstrecv_ = currentTime;
00152                 v_baseRTT_ = v_rtt_ = firstrecv_;
00153                 v_sa_  = v_rtt_ * 8.;
00154                 v_sd_  = v_rtt_;
00155                 v_timeout_ = ((v_sa_/4.)+v_sd_)/2.;
00156         }
00157 
00158         if (flagh->ecnecho())
00159                 ecn(tcph->seqno());
00160         if (tcph->seqno() > last_ack_) {
00161                 if (last_ack_ == 0 && delay_growth_) {
00162                         cwnd_ = initial_window();
00163                 }
00164                 /* check if cwnd has been inflated */
00165                 if(dupacks_ > numdupacks_ &&  cwnd_ > v_newcwnd_) {
00166                         cwnd_ = v_newcwnd_;
00167                         // vegas ssthresh is used only during slow-start
00168                         ssthresh_ = 2;
00169                 }
00170                 int oldack = last_ack_;
00171 
00172                 recv_newack_helper(pkt);
00173                 
00174                 /*
00175                  * begin of once per-rtt actions
00176                  *      1. update path fine-grained rtt and baseRTT
00177                  *      2. decide what to do with cwnd_, inc/dec/unchanged
00178                  *         based on delta=expect - actual.
00179                  */
00180                 if(tcph->seqno() >= v_begseq_) {
00181                         double rtt;
00182                         if(v_cntRTT_ > 0)
00183                                 rtt = v_sumRTT_ / v_cntRTT_;
00184                         else 
00185                                 rtt = currentTime - v_begtime_;
00186 
00187                         v_sumRTT_ = 0.0;
00188                         v_cntRTT_ = 0;
00189 
00190                         // calc # of packets in transit
00191                         int rttLen = t_seqno_ - v_begseq_;
00192 
00193                         /*
00194                          * decide should we incr/decr cwnd_ by how much
00195                          */
00196                         if(rtt>0) {
00197                                 /* if there's only one pkt in transit, update 
00198                                  * baseRTT
00199                                  */
00200                                 if(rtt<v_baseRTT_ || rttLen<=1)
00201                                         v_baseRTT_ = rtt;
00202 
00203                                 double expect;   // in pkt/sec
00204                                 // actual = (# in transit)/(current rtt) 
00205                                 v_actual_ = double(rttLen)/rtt;
00206                                 // expect = (current window size)/baseRTT
00207                                 expect = double(t_seqno_-last_ack_)/v_baseRTT_;
00208 
00209                                 // calc actual and expect thruput diff, delta
00210                                 int delta=int((expect-v_actual_)*v_baseRTT_+0.5);
00211                                 if(cwnd_ < ssthresh_) { // slow-start
00212                                         // adj cwnd every other rtt
00213                                         v_inc_flag_ = !v_inc_flag_;
00214                                         if(!v_inc_flag_)
00215                                                 v_incr_ = 0;
00216                                         else {
00217                                             if(delta > v_gamma_) {
00218                                                 // slow-down a bit to ensure
00219                                                 // the net is not so congested
00220                                                 ssthresh_ = 2;
00221                                                 cwnd_-=(cwnd_/8);
00222                                                 if(cwnd_<2)
00223                                                         cwnd_ = 2.;
00224                                                 v_incr_ = 0;
00225                                             } else 
00226                                                 v_incr_ = 1;
00227                                         }
00228                                 } else { // congestion avoidance
00229                                         if(delta>v_beta_) {
00230                                                 /*
00231                                                  * slow down a bit, retrack
00232                                                  * back to prev. rtt's cwnd
00233                                                  * and dont incr in the nxt rtt
00234                                                  */
00235                                                 --cwnd_;
00236                                                 if(cwnd_<2) cwnd_ = 2;
00237                                                 v_incr_ = 0;
00238                                         } else if(delta<v_alpha_)
00239                                                 // delta<alpha, faster....
00240                                                 v_incr_ = 1/cwnd_;
00241                                         else // current rate is cool.
00242                                                 v_incr_ = 0;
00243                                 }
00244                         } // end of if(rtt > 0)
00245 
00246                         // tag the next packet 
00247                         v_begseq_ = t_seqno_; 
00248                         v_begtime_ = currentTime;
00249                 } // end of once per-rtt section
00250 
00251                 /* since we set how much to incr only once per rtt,
00252                  * need to check if we surpass ssthresh during slow-start
00253                  * before the rtt is over.
00254                  */             
00255                 if(v_incr_ == 1 && cwnd_ >= ssthresh_)
00256                         v_incr_ = 0;
00257                 
00258                 /*
00259                  * incr cwnd unless we havent been able to keep up with it
00260                  */
00261                 if(v_incr_>0 && (cwnd_-(t_seqno_-last_ack_))<=2)
00262                         cwnd_ = cwnd_+v_incr_;  
00263 
00264                 // Add to make Vegas obey maximum congestion window variable.
00265                 if (maxcwnd_ && (int(cwnd_) > maxcwnd_)) {
00266                         cwnd_ = maxcwnd_;
00267                 }
00268 
00269                 /*
00270                  * See if we need to update the fine grained timeout value,
00271                  * v_timeout_
00272                  */
00273 
00274                 // reset v_sendtime for acked pkts and incr v_transmits_
00275                 double sendTime = v_sendtime_[tcph->seqno()%v_maxwnd_];
00276                 int transmits = v_transmits_[tcph->seqno()% v_maxwnd_];
00277                 int range = tcph->seqno() - oldack;
00278                 for(int k=((oldack+1) %v_maxwnd_); \
00279                         k<=(tcph->seqno()%v_maxwnd_) && range >0 ; \
00280                         k=((++k) % v_maxwnd_), range--) {
00281                         v_sendtime_[k] = -1.0;
00282                         v_transmits_[k] = 0;
00283                 }
00284 
00285                 if((sendTime !=0.) && (transmits==1)) {
00286                          // update fine-grained timeout value, v_timeout_.
00287                         double rtt, n;
00288                         rtt = currentTime - sendTime;
00289                         v_sumRTT_ += rtt;
00290                         ++v_cntRTT_;
00291                         if(rtt>0) {
00292                                 v_rtt_ = rtt;
00293                                 if(v_rtt_ < v_baseRTT_)
00294                                         v_baseRTT_ = v_rtt_;
00295                                 n = v_rtt_ - v_sa_/8;
00296                                 v_sa_ += n;
00297                                 n = n<0 ? -n : n;
00298                                 n -= v_sd_ / 4;
00299                                 v_sd_ += n;
00300                                 v_timeout_ = ((v_sa_/4)+v_sd_)/2;
00301                                 v_timeout_ += (v_timeout_/16);
00302                         }
00303                 }
00304 
00305                 /* 
00306                  * check the 1st or 2nd acks after dup ack received 
00307                  */
00308                 if(v_worried_>0) {
00309                         /*
00310                          * check if any pkt has been timeout. if so, 
00311                          * retx it. no need to change cwnd since we
00312                          * already did.
00313                          */
00314                         --v_worried_;
00315                         int expired=vegas_expire(pkt);
00316                         if(expired>=0) {
00317                                 dupacks_ = numdupacks_;
00318                                 output(expired, TCP_REASON_DUPACK);
00319                         } else
00320                                 v_worried_ = 0;
00321                 }
00322         } else if (tcph->seqno() == last_ack_)  {
00323                 /* check if a timeout should happen */
00324                 ++dupacks_; 
00325                 int expired=vegas_expire(pkt);
00326                 if (expired>=0 || dupacks_ == numdupacks_) {
00327                         double sendTime=v_sendtime_[(last_ack_+1) % v_maxwnd_]; 
00328                         int transmits=v_transmits_[(last_ack_+1) % v_maxwnd_];
00329                         /* The line below, for "bug_fix_" true, avoids
00330                         * problems with multiple fast retransmits after
00331                         * a retransmit timeout.
00332                         */
00333                         if ( !bug_fix_ || (highest_ack_ > recover_) || \
00334                             ( last_cwnd_action_ != CWND_ACTION_TIMEOUT)) {
00335                                 int win = window();
00336                                 last_cwnd_action_ = CWND_ACTION_DUPACK;
00337                                 recover_ = maxseq_;
00338                                 /* check for timeout after recv a new ack */
00339                                 v_worried_ = MIN(2, t_seqno_ - last_ack_ );
00340                 
00341                                 /* v_rto expon. backoff */
00342                                 if(transmits > 1) 
00343                                         v_timeout_ *=2.; 
00344                                 else
00345                                         v_timeout_ += (v_timeout_/8.);
00346                                 /*
00347                                  * if cwnd hasnt changed since the pkt was sent
00348                                  * we need to decr it.
00349                                  */
00350                                 if(t_cwnd_changed_ < sendTime ) {
00351                                         if(win<=3)
00352                                                 win=2;
00353                                         else if(transmits > 1)
00354                                                 win >>=1;
00355                                         else 
00356                                                 win -= (win>>2);
00357 
00358                                         // record cwnd_
00359                                         v_newcwnd_ = double(win);
00360                                         // inflate cwnd_
00361                                         cwnd_ = v_newcwnd_ + dupacks_;
00362                                         t_cwnd_changed_ = currentTime;
00363                                 } 
00364 
00365                                 // update coarser grained rto
00366                                 reset_rtx_timer(1);
00367                                 if(expired>=0) 
00368                                         output(expired, TCP_REASON_DUPACK);
00369                                 else
00370                                         output(last_ack_ + 1, TCP_REASON_DUPACK);
00371                                          
00372                                 if(transmits==1) 
00373                                         dupacks_ = numdupacks_;
00374                         }
00375                 } else if (dupacks_ > numdupacks_) 
00376                         ++cwnd_;
00377         }
00378         Packet::free(pkt);
00379 
00380 #if 0
00381         if (trace_)
00382                 plot();
00383 #endif /* 0 */
00384 
00385         /*
00386          * Try to send more data
00387          */
00388         if (dupacks_ == 0 || dupacks_ > numdupacks_ - 1)
00389                 send_much(0, 0, maxburst_);
00390 }

00118 {
00119         newack(pkt);
00120 #if 0
00121         // like TcpAgent::recv_newack_helper, but without this
00122         if ( !hdr_flags::access(pkt)->ecnecho() || !ecn_ ) {
00123                 opencwnd();
00124         }
00125 #endif
00126         /* if the connection is done, call finish() */
00127         if ((highest_ack_ >= curseq_-1) && !closed_) {
00128                 closed_ = 1;
00129                 finish();
00130         }
00131 }

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

00098 {
00099         t_cwnd_changed_ = 0.;
00100         firstrecv_ = -1.0;
00101         v_slowstart_ = 2;
00102         v_sa_ = 0;
00103         v_sd_ = 0;
00104         v_timeout_ = 1000.;
00105         v_worried_ = 0;
00106         v_begseq_ = 0;
00107         v_begtime_ = 0.;
00108         v_cntRTT_ = 0; v_sumRTT_ = 0.;
00109         v_baseRTT_ = 1000000000.;
00110         v_incr_ = 0;
00111         v_inc_flag_ = 1;
00112 
00113         TcpAgent::reset();
00114 }

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

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 }

00394 {
00395         if (tno == TCP_TIMER_RTX) {
00396                 if (highest_ack_ == maxseq_ && !slow_start_restart_) {
00397                         /*
00398                          * TCP option:
00399                          * If no outstanding data, then don't do anything.
00400                          *
00401                          * Note:  in the USC implementation,
00402                          * slow_start_restart_ == 0.
00403                          * I don't know what the U. Arizona implementation
00404                          * defaults to.
00405                          */
00406                         return;
00407                 };
00408                 dupacks_ = 0;
00409                 recover_ = maxseq_;
00410                 last_cwnd_action_ = CWND_ACTION_TIMEOUT;
00411                 reset_rtx_timer(0);
00412                 ++nrexmit_;
00413                 slowdown(CLOSE_CWND_RESTART|CLOSE_SSTHRESH_HALF);
00414                 cwnd_ = double(v_slowstart_);
00415                 v_newcwnd_ = 0;
00416                 t_cwnd_changed_ = vegastime();
00417                 send_much(0, TCP_REASON_TIMEOUT);
00418         } else {
00419                 /* delayed-sent timer, with random overhead to avoid
00420                  * phase effect. */
00421                 send_much(1, TCP_REASON_TIMEOUT);
00422         };
00423 }

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 }

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 }

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 }

00490 {
00491         hdr_tcp *tcph = hdr_tcp::access(pkt);
00492         double elapse = vegastime() - v_sendtime_[(tcph->seqno()+1)%v_maxwnd_];
00493         if (elapse >= v_timeout_) {
00494                 return(tcph->seqno()+1);
00495         }
00496         return(-1);
00497 }

00473                            {
00474                 return(Scheduler::instance().clock() - firstsent_);
00475         }

00752 {
00753         return (cwnd_ < wnd_ ? (int)cwnd_ : (int)wnd_);
00754 }

00757 {
00758         return (cwnd_ < wnd_ ? (double)cwnd_ : (double)wnd_);
00759 }

VegasTcpAgent 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
	VegasTcpAgent ()
	~VegasTcpAgent ()
virtual void	recv (Packet pkt, Handler )
virtual void	timeout (int tno)
virtual void	recv (Packet p, const char s)
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,...)
Protected Member Functions
double	vegastime ()
virtual void	output (int seqno, int reason=0)
virtual void	recv_newack_helper (Packet *)
int	vegas_expire (Packet *)
void	reset ()
void	vegas_inflate_cwnd (int win, double current_time)
virtual void	delay_bind_init_all ()
virtual int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
virtual int	window ()
virtual double	windowd ()
void	print_if_needed (double memb_time)
void	traceAll ()
virtual void	traceVar (TracedVar *v)
virtual int	headersize ()
virtual void	rtt_init ()
virtual double	rtt_timeout ()
virtual void	rtt_update (double tao)
virtual void	rtt_backoff ()
virtual void	send_much (int force, int reason, int maxburst=0)
virtual void	newtimer (Packet *)
virtual void	dupack_action ()
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	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	output_helper (Packet *)
virtual void	send_helper (int)
virtual void	send_idle_helper ()
virtual void	recv_helper (Packet *)
virtual void	partialnewack_helper (Packet *)
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
double	t_cwnd_changed_
double	firstrecv_
int	v_alpha_
int	v_beta_
int	v_gamma_
int	v_slowstart_
int	v_worried_
double	v_timeout_
double	v_rtt_
double	v_sa_
double	v_sd_
int	v_cntRTT_
double	v_sumRTT_
double	v_begtime_
int	v_begseq_
double *	v_sendtime_
int *	v_transmits_
int	v_maxwnd_
double	v_newcwnd_
double	v_baseRTT_
double	v_incr_
int	v_inc_flag_
double	v_actual_
int	ns_vegas_fix_level_
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_
Static Protected Attributes
int	uidcnt_