1 /* 2 * Copyright (c) 1991-1997 Regents of the University of California. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the Computer Systems 16 * Engineering Group at Lawrence Berkeley Laboratory. 17 * 4. Neither the name of the University nor of the Laboratory may be used 18 * to endorse or promote products derived from this software without 19 * specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#) $Header: /cvsroot/nsnam/ns-2/tcp/tcp.h,v 1.132 2011/08/26 19:29:57 tom_henderson Exp $ (LBL) 34 */ 35 #ifndef ns_tcp_h 36 #define ns_tcp_h 37 38 #include "agent.h" 39 #include "packet.h" 40 41 //class EventTrace; 42 43 struct hdr_tcp { 44 #define NSA 3 45 double ts_; /* time packet generated (at source) */ 46 double ts_echo_; /* the echoed timestamp (originally sent by 47 the peer) */ 48 int seqno_; /* sequence number */ 49 int reason_; /* reason for a retransmit */ 50 int sack_area_[NSA+1][2]; /* sack blocks: start, end of block */ 51 int sa_length_; /* Indicate the number of SACKs in this * 52 * packet. Adds 2+sack_length*8 bytes */ 53 int ackno_; /* ACK number for FullTcp */ 54 int hlen_; /* header len (bytes) for FullTcp */ 55 int tcp_flags_; /* TCP flags for FullTcp */ 56 int last_rtt_; /* more recent RTT measurement in ms, */ 57 /* for statistics only */ 58 // Advertised Window, Shigeyuki Osada 2012/01/08 59 double wnd_; 60 61 static int offset_; // offset for this header 62 inline static int& offset() { return offset_; } 63 inline static hdr_tcp* access(Packet* p) { 64 return (hdr_tcp*) p->access(offset_); 65 } 66 67 /* per-field member functions */ 68 double& ts() { return (ts_); } 69 double& ts_echo() { return (ts_echo_); } 70 int& seqno() { return (seqno_); } 71 int& reason() { return (reason_); } 72 int& sa_left(int n) { return (sack_area_[n][0]); } 73 int& sa_right(int n) { return (sack_area_[n][1]); } 74 int& sa_length() { return (sa_length_); } 75 int& hlen() { return (hlen_); } 76 int& ackno() { return (ackno_); } 77 int& flags() { return (tcp_flags_); } 78 int& last_rtt() { return (last_rtt_); } 79 double& wnd() {return (wnd_);} // Shigeyuki Osada 80 }; 81 82 /* these are used to mark packets as to why we xmitted them */ 83 #define TCP_REASON_TIMEOUT 0x01 84 #define TCP_REASON_DUPACK 0x02 85 #define TCP_REASON_RBP 0x03 // used only in tcp-rbp.cc 86 #define TCP_REASON_PARTIALACK 0x04 87 88 /* these are reasons we adjusted our congestion window */ 89 90 #define CWND_ACTION_DUPACK 1 // dup acks/fast retransmit 91 #define CWND_ACTION_TIMEOUT 2 // retransmission timeout 92 #define CWND_ACTION_ECN 3 // ECN bit [src quench if supported] 93 #define CWND_ACTION_EXITED 4 // congestion recovery has ended 94 // (when previously CWND_ACTION_DUPACK) 95 96 /* these are bits for how to change the cwnd and ssthresh values */ 97 98 #define CLOSE_SSTHRESH_HALF 0x00000001 99 #define CLOSE_CWND_HALF 0x00000002 100 #define CLOSE_CWND_RESTART 0x00000004 101 #define CLOSE_CWND_INIT 0x00000008 102 #define CLOSE_CWND_ONE 0x00000010 103 #define CLOSE_SSTHRESH_HALVE 0x00000020 104 #define CLOSE_CWND_HALVE 0x00000040 105 #define THREE_QUARTER_SSTHRESH 0x00000080 106 #define CLOSE_CWND_HALF_WAY 0x00000100 107 #define CWND_HALF_WITH_MIN 0x00000200 108 #define TCP_IDLE 0x00000400 109 #define NO_OUTSTANDING_DATA 0x00000800 110 111 /* 112 * tcp_tick_: 113 * default 0.1, 114 * 0.3 for 4.3 BSD, 115 * 0.01 for new window algorithms, 116 */ 117 118 #define NUMDUPACKS 3 /* This is no longer used. The variable */ 119 /* numdupacks_ is used instead. */ 120 #define TCP_MAXSEQ 1073741824 /* Number that curseq_ is set to for */ 121 /* "infinite send" (2^30) */ 122 123 #define TCP_TIMER_RTX 0 124 #define TCP_TIMER_DELSND 1 125 #define TCP_TIMER_BURSTSND 2 126 #define TCP_TIMER_DELACK 3 127 #define TCP_TIMER_Q 4 128 #define TCP_TIMER_RESET 5 129 130 class TcpAgent; 131 132 class RtxTimer : public TimerHandler { 133 public: 134 RtxTimer(TcpAgent *a) : TimerHandler() { a_ = a; } 135 protected: 136 virtual void expire(Event *e); 137 TcpAgent *a_; 138 }; 139 140 class DelSndTimer : public TimerHandler { 141 public: 142 DelSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; } 143 protected: 144 virtual void expire(Event *e); 145 TcpAgent *a_; 146 }; 147 148 class BurstSndTimer : public TimerHandler { 149 public: 150 BurstSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; } 151 protected: 152 virtual void expire(Event *e); 153 TcpAgent *a_; 154 }; 155 156 /* 157 * Variables for HighSpeed TCP. 158 */ 159 //int *hs_win_; // array of cwnd values 160 //int *hs_increase_; // array of increase values 161 //double *hs_decrease_; // array of decrease values 162 struct hstcp { 163 double low_p; // low_p 164 double dec1; // for computing the decrease parameter 165 double dec2; // for computing the decrease parameter 166 double p1; // for computing p 167 double p2; // for computing p 168 /* The next three parameters are for CPU overhead, for computing */ 169 /* the HighSpeed parameters less frequently. A better solution */ 170 /* might be just to have a look-up array. */ 171 double cwnd_last_; /* last cwnd for computed parameters */ 172 double increase_last_; /* increase param for cwnd_last_ */ 173 hstcp() : low_p(0.0), dec1(0.0), dec2(0.0), p1(0.0), p2(0.0), 174 cwnd_last_(0.0), increase_last_(0.0) { } 175 }; 176 177 class TcpAgent : public Agent { 178 friend class XcpEndsys; 179 public: 180 TcpAgent(); 181 virtual ~TcpAgent() {free(tss);} 182 virtual void recv(Packet*, Handler*); 183 virtual void timeout(int tno); 184 virtual void timeout_nonrtx(int tno); 185 int command(int argc, const char*const* argv); 186 virtual void sendmsg(int nbytes, const char *flags = 0); 187 188 void trace(TracedVar* v); 189 virtual void advanceby(int delta); 190 191 virtual void reset(); 192 193 /* These two functions aid Tmix one-way TCP agents */ 194 int is_closed() {return closed_;} 195 void clr_closed() {closed_ = 0;} 196 protected: 197 virtual int window(); 198 virtual double windowd(); 199 void print_if_needed(double memb_time); 200 void traceAll(); 201 virtual void traceVar(TracedVar* v); 202 virtual int headersize(); // a tcp header 203 204 virtual void delay_bind_init_all(); 205 virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer); 206 207 double boot_time_; /* where between 'ticks' this sytem came up */ 208 double overhead_; 209 double wnd_; 210 double wnd_const_; 211 double wnd_th_; /* window "threshold" */ 212 double wnd_init_; 213 double wnd_restart_; 214 double tcp_tick_; /* clock granularity */ 215 int wnd_option_; 216 int wnd_init_option_; /* 1 for using wnd_init_ */ 217 /* 2 for using large initial windows */ 218 double decrease_num_; /* factor for multiplicative decrease */ 219 double increase_num_; /* factor for additive increase */ 220 int tcpip_base_hdr_size_; /* size of base TCP/IP header */ 221 int maxcwnd_; /* max # cwnd can ever be */ 222 int numdupacks_; /* dup ACKs before fast retransmit */ 223 int numdupacksFrac_; /* for a larger numdupacks_ with large */ 224 /* windows */ 225 226 /* connection and packet dynamics */ 227 virtual void output(int seqno, int reason = 0); 228 virtual void send_much(int force, int reason, int maxburst = 0); 229 virtual void newtimer(Packet*); 230 virtual void dupack_action(); /* do this on dupacks */ 231 virtual void send_one(); /* do this on 1-2 dupacks */ 232 virtual void opencwnd(); 233 void update_window(Packet*); // Shigeyuki Osada 2012/01/08 234 235 void slowdown(int how); /* reduce cwnd/ssthresh */ 236 void ecn(int seqno); /* react to quench */ 237 virtual void set_initial_window(); /* set IW */ 238 double initial_window(); /* what is IW? */ 239 void newack(Packet*); 240 void finish(); /* called when the connection is terminated */ 241 int network_limited(); /* Sending limited by network? */ 242 double limited_slow_start(double cwnd, int max_ssthresh, double increment); 243 /* Limited slow-start for high windows */ 244 virtual int numdupacks(double cwnd); /* for getting numdupacks_ */ 245 /* End of section of connection and packet dynamics. */ 246 247 /* General dynamic state. */ 248 TracedInt t_seqno_; /* sequence number */ 249 TracedInt dupacks_; /* number of duplicate acks */ 250 TracedInt curseq_; /* highest seqno "produced by app" */ 251 TracedInt highest_ack_; /* not frozen during Fast Recovery */ 252 TracedDouble cwnd_; /* current window */ 253 TracedInt ssthresh_; /* slow start threshold */ 254 TracedInt maxseq_; /* used for Karn algorithm */ 255 /* highest seqno sent so far */ 256 int last_ack_; /* largest consecutive ACK, frozen during 257 * Fast Recovery */ 258 int recover_; /* highest pkt sent before dup acks, */ 259 /* timeout, or source quench/ecn */ 260 int last_cwnd_action_; /* CWND_ACTION_{TIMEOUT,DUPACK,ECN} */ 261 int count_; /* used in window increment algorithms */ 262 int rtt_active_; /* 1 if a rtt sample is pending */ 263 int rtt_seq_; /* seq # of timed seg if rtt_active_ is 1 */ 264 double rtt_ts_; /* time at which rtt_seq_ was sent */ 265 double firstsent_; /* When first packet was sent --Allman */ 266 double lastreset_; /* W.N. Last time connection was reset - for */ 267 /* detecting pkts from previous incarnations */ 268 int closed_; /* whether this connection has closed */ 269 /* End of general dynamic state. */ 270 271 /* 272 * State encompassing the round-trip-time estimate. 273 * srtt and rttvar are stored as fixed point; 274 * srtt has 3 bits to the right of the binary point, rttvar has 2. 275 */ 276 TracedInt t_rtt_; /* round trip time */ 277 TracedInt t_srtt_; /* smoothed round-trip time */ 278 TracedInt t_rttvar_; /* variance in round-trip time */ 279 TracedInt t_backoff_; /* current multiplier of RTO, */ 280 /* 1 if not backed off */ 281 #define T_RTT_BITS 0 282 int T_SRTT_BITS; /* exponent of weight for updating t_srtt_ */ 283 int srtt_init_; /* initial value for computing t_srtt_ */ 284 int T_RTTVAR_BITS; /* exponent of weight for updating t_rttvar_ */ 285 int rttvar_exp_; /* exponent of multiple for t_rtxcur_ */ 286 int rttvar_init_; /* initial value for computing t_rttvar_ */ 287 double t_rtxcur_; /* current retransmit value */ 288 double rtxcur_init_; /* initial value for t_rtxcur_ */ 289 virtual void rtt_init(); 290 virtual double rtt_timeout(); /* provide RTO based on RTT estimates */ 291 virtual void rtt_update(double tao); /* update RTT estimate */ 292 virtual void rtt_backoff(); /* double multiplier */ 293 /* End of state for the round-trip-time estimate. */ 294 295 /* RTOs: */ 296 double maxrto_; /* max value of an RTO */ 297 double minrto_; /* min value of an RTO */ 298 int ts_resetRTO_; /* Un-backoff RTO after any valid RTT, */ 299 /* including from a retransmitted pkt? */ 300 /* The old version was "false". */ 301 /* But "true" gives better performance, and */ 302 /* seems conformant with RFC 2988. */ 303 /* End of section for RTOs. */ 304 305 /* Timestamps. */ 306 double ts_peer_; /* the most recent timestamp the peer sent */ 307 double ts_echo_; /* the most recent timestamp the peer echoed */ 308 int ts_option_size_; // header bytes in a ts option 309 double *tss; // To store sent timestamps, with bugfix_ts_ 310 int tss_size_; // Current capacity of tss 311 int ts_option_; /* use RFC1323-like timestamps? */ 312 /* End of timestamps. */ 313 314 /* Helper functions. Used by tcp-asym */ 315 virtual void output_helper(Packet*) { return; } 316 virtual void send_helper(int) { return; } 317 virtual void send_idle_helper() { return; } 318 virtual void recv_helper(Packet*); 319 virtual void recv_frto_helper(Packet*); 320 virtual void recv_newack_helper(Packet*); 321 virtual void partialnewack_helper(Packet*) {}; 322 /* End of helper functions. */ 323 324 int force_wnd(int num); 325 void spurious_timeout(); 326 327 /* Timers */ 328 RtxTimer rtx_timer_; 329 DelSndTimer delsnd_timer_; 330 BurstSndTimer burstsnd_timer_; 331 virtual void cancel_timers() { 332 rtx_timer_.force_cancel(); 333 burstsnd_timer_.force_cancel(); 334 delsnd_timer_.force_cancel(); 335 } 336 virtual void cancel_rtx_timer() { 337 rtx_timer_.force_cancel(); 338 } 339 virtual void set_rtx_timer(); 340 void reset_rtx_timer(int mild, int backoff = 1); 341 int timerfix_; /* set to true to update timer *after* */ 342 /* update the RTT, instead of before */ 343 int rfc2988_; /* Use updated RFC 2988 timers */ 344 /* End of timers. */ 345 346 347 /* For modeling SYN and SYN/ACK packets. */ 348 int syn_; /* 1 for modeling SYN/ACK exchange */ 349 int delay_growth_; /* delay opening cwnd until 1st data recv'd */ 350 int max_connects_; /* max number of transmits for syn packet */ 351 /* -1 to allow infinite number of transmits */ 352 /* End of modeling SYN and SYN/ACK packets. */ 353 354 /* Dynamic state for SYN packet retransmissions. */ 355 int syn_connects_; /* number of transmits of syn packet */ 356 /* End of dynamic state for SYN packet retransmissions. */ 357 358 /* F-RTO */ 359 int frto_enabled_; /* != 0 to enable F-RTO */ 360 int sfrto_enabled_; /* != 0 to enabled SACK-based F-RTO */ 361 int spurious_response_; /* Response variant to spurious RTO */ 362 /* End of R-RTO */ 363 364 /* Parameters for backwards compatility with old code. */ 365 int bug_fix_; /* 1 for multiple-fast-retransmit fix */ 366 int less_careful_; /* 1 for Less Careful variant of bug_fix_, */ 367 /* for illustration only */ 368 int exitFastRetrans_; /* True to clean exits of Fast Retransmit */ 369 /* False for buggy old behavior */ 370 int bugfix_ack_; // 1 to enable ACK heuristic, to allow 371 // multiple-fast-retransmits in special cases. 372 // From Andrei Gurtov 373 int bugfix_ts_; // 1 to enable timestamp heuristic, to allow 374 // multiple-fast-retransmits in special cases. 375 // From Andrei Gurtov 376 // Not implemented yet. 377 int old_ecn_; /* For backwards compatibility with the 378 * old ECN implementation, which never 379 * reduced the congestion window below 380 * one packet. */ 381 int bugfix_ss_; // 1 to use window of one when SYN 382 // packet is dropped 383 /* End of parameters for backwards compatility. */ 384 385 /* Parameters for alternate congestion control mechanisms. */ 386 double k_parameter_; /* k parameter in binomial controls */ 387 double l_parameter_; /* l parameter in binomial controls */ 388 int precision_reduce_; /* non-integer reduction of cwnd */ 389 int maxburst_; /* max # packets can send back-2-back */ 390 int aggressive_maxburst_; /* Send on a non-valid ack? */ 391 /* End of parameters for alternate congestion control mechanisms. */ 392 393 FILE *plotfile_; 394 395 /* Dynamic state used for alternate congestion control mechanisms */ 396 double awnd_; /* averaged window */ 397 int first_decrease_; /* First decrease of congestion window. */ 398 /* Used for decrease_num_ != 0.5. */ 399 double fcnt_; /* used in window increment algorithms */ 400 double base_cwnd_; /* base window (for experimental purposes) */ 401 /* End of state for alternate congestion control mechanisms */ 402 403 /* Dynamic state only used for monitoring */ 404 int trace_all_oneline_; /* TCP tracing vars all in one line or not? */ 405 int nam_tracevar_; /* Output nam's variable trace or just plain 406 text variable trace? */ 407 TracedInt ndatapack_; /* number of data packets sent */ 408 TracedInt ndatabytes_; /* number of data bytes sent */ 409 TracedInt nackpack_; /* number of ack packets received */ 410 TracedInt nrexmit_; /* number of retransmit timeouts 411 when there was data outstanding */ 412 TracedInt nrexmitpack_; /* number of retransmited packets */ 413 TracedInt nrexmitbytes_; /* number of retransmited bytes */ 414 TracedInt necnresponses_; /* number of times cwnd was reduced 415 in response to an ecn packet -- sylvia */ 416 TracedInt ncwndcuts_; /* number of times cwnd was reduced 417 for any reason -- sylvia */ 418 TracedInt ncwndcuts1_; /* number of times cwnd was reduced 419 due to congestion (as opposed to idle 420 periods */ 421 /* end of dynamic state for monitoring */ 422 423 /* Specifying variants in TCP algorithms. */ 424 int slow_start_restart_; /* boolean: re-init cwnd after connection 425 goes idle. On by default. */ 426 int restart_bugfix_; /* ssthresh is cut down because of 427 timeouts during a connection's idle period. 428 Setting this boolean fixes this problem. 429 For now, it is off by default. */ 430 TracedInt singledup_; /* Send on a single dup ack. */ 431 int LimTransmitFix_; /* To fix a bug in Limited Transmit. */ 432 int noFastRetrans_; /* No Fast Retransmit option. */ 433 int oldCode_; /* Use old code. */ 434 int useHeaders_; /* boolean: Add TCP/IP header sizes */ 435 /* end of specifying variants */ 436 437 /* Used for ECN */ 438 int ecn_; /* Explicit Congestion Notification */ 439 int cong_action_; /* Congestion Action. True to indicate 440 that the sender responded to congestion. */ 441 int ecn_burst_; /* True when the previous ACK packet 442 * carried ECN-Echo. */ 443 int ecn_backoff_; /* True when retransmit timer should begin 444 to be backed off. */ 445 int ect_; /* turn on ect bit now? */ 446 int SetCWRonRetransmit_; /* True to allow setting CWR on */ 447 /* retransmitted packets. Affects */ 448 /* performance for Reno with ECN. */ 449 int use_rtt_; /* Use RTT for timeout for ECN-marked SYN-ACK */ 450 /* end of ECN */ 451 452 /* used for Explicit Loss Notification */ 453 void tcp_eln(Packet *pkt); /* reaction to ELN (usually wireless) */ 454 int eln_; /* Explicit Loss Notification (wireless) */ 455 int eln_rxmit_thresh_; /* Threshold for ELN-triggered rxmissions */ 456 int eln_last_rxmit_; /* Last packet rxmitted due to ELN info */ 457 /* end of Explicit Loss Notification */ 458 459 /* for High-Speed TCP, RFC 3649 */ 460 double linear(double x, double x_1, double y_1, double x_2, double y_2); 461 /* the "linear" function is for experimental highspeed TCP */ 462 /* These four parameters define the HighSpeed response function. */ 463 int low_window_; /* window for turning on high-speed TCP */ 464 int high_window_; /* target window for new response function */ 465 double high_p_; /* target drop rate for new response function */ 466 double high_decrease_; /* decrease rate at target window */ 467 /* The next parameter is for Limited Slow-Start. */ 468 int max_ssthresh_; /* max value for ssthresh_ */ 469 470 /* These two functions are just an easy structuring of the code. */ 471 double increase_param(); /* get increase parameter for current cwnd */ 472 double decrease_param(); /* get decrease parameter for current cwnd */ 473 int cwnd_range_; /* for determining when to recompute params. */ 474 hstcp hstcp_; /* HighSpeed TCP variables */ 475 /* end of section for experimental high-speed TCP */ 476 477 /* for Quick-Start, RFC 4782 */ 478 virtual void processQuickStart(Packet *pkt); 479 virtual void endQuickStart(); 480 int lossQuickStart(); 481 int rate_request_; /* Rate request in KBps, for QuickStart. */ 482 int qs_enabled_; /* to enable QuickStart. */ 483 int qs_requested_; 484 int qs_approved_; 485 int qs_window_; /* >0: there are outstanding non-acked segments 486 from QS window */ 487 int qs_cwnd_; /* Initial window for Quick-Start */ 488 int tcp_qs_recovery_; /* != 0 if we apply slow start on packet 489 losses during QS window */ 490 int qs_request_mode_; /* 1 = Try to avoid unnecessary QS requests 491 for short flows. Use qs_rtt_ as the RTT 492 used in window calculation. 493 Other: Always request 'rate_request_' bytes, 494 regardless of flow size */ 495 int qs_thresh_; /* Do not use QS if there are less data to send 496 than this. Applies only if 497 qs_request_mode_ == 1 */ 498 int qs_rtt_; /* QS needs some assumption of the RTT in 499 in order to be able to determine how much 500 it needs for rate request with given amount 501 of data to send. milliseconds. */ 502 int print_request_; /* true to print Quick-Start request */ 503 int ttl_diff_; 504 /* end of section for Quick-Start. */ 505 506 /* F-RTO: !=0 when F-RTO recovery is underway, N:th round-trip 507 * since RTO. Can have values between 0-2 */ 508 int frto_; 509 int pipe_prev_; /* window size when timeout last occurred */ 510 511 /* support for event-tracing */ 512 //EventTrace *et_; 513 void trace_event(char *eventtype); 514 515 /* these function are now obsolete, see other above */ 516 void closecwnd(int how); 517 void quench(int how); 518 519 /* TCP quiescence, reducing cwnd after an idle period */ 520 void process_qoption_after_send() ; 521 void process_qoption_after_ack(int seqno) ; 522 void reset_qoption(); /* for QOption with EnblRTTCtr_ */ 523 void rtt_counting(); /* for QOption with EnblRTTCtr_ */ 524 int QOption_ ; /* TCP quiescence option */ 525 int EnblRTTCtr_ ; /* are we using a corase grained timer? */ 526 int T_full ; /* last time the window was full */ 527 int T_last ; 528 int T_prev ; 529 int T_start ; 530 int RTT_count ; 531 int RTT_prev ; 532 int RTT_goodcount ; 533 int F_counting ; 534 int W_used ; 535 int W_timed ; 536 int F_full ; 537 int Backoffs ; 538 int control_increase_ ; /* If true, don't increase cwnd if sender */ 539 /* is not window-limited. */ 540 int prev_highest_ack_ ; /* Used to determine if sender is */ 541 /* window-limited. */ 542 /* end of TCP quiescence */ 543 }; 544 545 /* TCP Reno */ 546 class RenoTcpAgent : public virtual TcpAgent { 547 public: 548 RenoTcpAgent(); 549 virtual int window(); 550 virtual double windowd(); 551 virtual void recv(Packet *pkt, Handler*); 552 virtual void timeout(int tno); 553 virtual void dupack_action(); 554 protected: 555 int allow_fast_retransmit(int last_cwnd_action_); 556 unsigned int dupwnd_; 557 }; 558 559 /* TCP New Reno */ 560 class NewRenoTcpAgent : public virtual RenoTcpAgent { 561 public: 562 NewRenoTcpAgent(); 563 virtual void recv(Packet *pkt, Handler*); 564 virtual void partialnewack_helper(Packet* pkt); 565 virtual void dupack_action(); 566 protected: 567 int newreno_changes_; /* 0 for fixing unnecessary fast retransmits */ 568 /* 1 for additional code from Allman, */ 569 /* to implement other algorithms from */ 570 /* Hoe's paper, including sending a new */ 571 /* packet for every two duplicate ACKs. */ 572 /* The default is set to 0. */ 573 int newreno_changes1_; /* Newreno_changes1_ set to 0 gives the */ 574 /* Slow-but-Steady variant of NewReno from */ 575 /* RFC 2582, with the retransmit timer reset */ 576 /* after each partial new ack. */ 577 /* Newreno_changes1_ set to 1 gives the */ 578 /* Impatient variant of NewReno from */ 579 /* RFC 2582, with the retransmit timer reset */ 580 /* only for the first partial new ack. */ 581 /* The default is set to 0 */ 582 void partialnewack(Packet *pkt); 583 int allow_fast_retransmit(int last_cwnd_action_); 584 int acked_, new_ssthresh_; /* used if newreno_changes_ == 1 */ 585 double ack2_, ack3_, basertt_; /* used if newreno_changes_ == 1 */ 586 int firstpartial_; /* For the first partial ACK. */ 587 int partial_window_deflation_; /* 0 if set cwnd to ssthresh upon */ 588 /* partial new ack (default) */ 589 /* 1 if deflate (cwnd + dupwnd) by */ 590 /* amount of data acked */ 591 /* "Partial window deflation" is */ 592 /* discussed in RFC 2582. */ 593 int exit_recovery_fix_; /* 0 for setting cwnd to ssthresh upon */ 594 /* leaving fast recovery (default) */ 595 /* 1 for setting cwnd to min(ssthresh, */ 596 /* amnt. of data in network) when leaving */ 597 }; 598 599 /* TCP vegas (VegasTcpAgent) */ 600 class VegasTcpAgent : public virtual TcpAgent { 601 public: 602 VegasTcpAgent(); 603 ~VegasTcpAgent(); 604 virtual void recv(Packet *pkt, Handler *); 605 virtual void timeout(int tno); 606 protected: 607 double vegastime() { 608 return(Scheduler::instance().clock() - firstsent_); 609 } 610 virtual void output(int seqno, int reason = 0); 611 virtual void recv_newack_helper(Packet*); 612 int vegas_expire(Packet*); 613 void reset(); 614 void vegas_inflate_cwnd(int win, double current_time); 615 616 virtual void delay_bind_init_all(); 617 virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer); 618 619 double t_cwnd_changed_; // last time cwnd changed 620 double firstrecv_; // time recv the 1st ack 621 622 int v_alpha_; // vegas thruput thresholds in pkts 623 int v_beta_; 624 625 int v_gamma_; // threshold to change from slow-start to 626 // congestion avoidance, in pkts 627 628 int v_slowstart_; // # of pkts to send after slow-start, deflt(2) 629 int v_worried_; // # of pkts to chk after dup ack (1 or 2) 630 631 double v_timeout_; // based on fine-grained timer 632 double v_rtt_; 633 double v_sa_; 634 double v_sd_; 635 636 int v_cntRTT_; // # of rtt measured within one rtt 637 double v_sumRTT_; // sum of rtt measured within one rtt 638 639 double v_begtime_; // tagged pkt sent 640 int v_begseq_; // tagged pkt seqno 641 642 double* v_sendtime_; // each unacked pkt's sendtime is recorded. 643 int* v_transmits_; // # of retx for an unacked pkt 644 645 int v_maxwnd_; // maxwnd size for v_sendtime_[] 646 double v_newcwnd_; // record un-inflated cwnd 647 648 double v_baseRTT_; // min of all rtt 649 650 double v_incr_; // amount cwnd is increased in the next rtt 651 int v_inc_flag_; // if cwnd is allowed to incr for this rtt 652 653 double v_actual_; // actual send rate (pkt/s; needed for tcp-rbp) 654 655 int ns_vegas_fix_level_; // see comment at end of tcp-vegas.cc for details of fixes 656 }; 657 658 // Local Variables: 659 // mode:c++ 660 // c-basic-offset: 8 661 // End: 662 663 #endif