/* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /* * Copyright (c) 1991-1997 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Computer Systems * Engineering Group at Lawrence Berkeley Laboratory. * 4. Neither the name of the University nor of the Laboratory may be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#) $Header: /cvsroot/nsnam/ns-2/tcp/tcp.h,v 1.126 2006/06/14 01:12:28 sallyfloyd Exp $ (LBL) */ #ifndef ns_tcp_h #define ns_tcp_h #include "agent.h" #include "packet.h" //class EventTrace; struct hdr_tcp { #define NSA 3 double ts_; /* time packet generated (at source) */ double ts_echo_; /* the echoed timestamp (originally sent by the peer) */ int seqno_; /* sequence number */ int reason_; /* reason for a retransmit */ int sack_area_[NSA+1][2]; /* sack blocks: start, end of block */ int sa_length_; /* Indicate the number of SACKs in this * * packet. Adds 2+sack_length*8 bytes */ int ackno_; /* ACK number for FullTcp */ int hlen_; /* header len (bytes) for FullTcp */ int tcp_flags_; /* TCP flags for FullTcp */ int last_rtt_; /* more recent RTT measurement in ms, */ /* for statistics only */ static int offset_; // offset for this header inline static int& offset() { return offset_; } inline static hdr_tcp* access(Packet* p) { return (hdr_tcp*) p->access(offset_); } /* per-field member functions */ double& ts() { return (ts_); } double& ts_echo() { return (ts_echo_); } int& seqno() { return (seqno_); } int& reason() { return (reason_); } int& sa_left(int n) { return (sack_area_[n][0]); } int& sa_right(int n) { return (sack_area_[n][1]); } int& sa_length() { return (sa_length_); } int& hlen() { return (hlen_); } int& ackno() { return (ackno_); } int& flags() { return (tcp_flags_); } int& last_rtt() { return (last_rtt_); } }; /* these are used to mark packets as to why we xmitted them */ #define TCP_REASON_TIMEOUT 0x01 #define TCP_REASON_DUPACK 0x02 #define TCP_REASON_RBP 0x03 // used only in tcp-rbp.cc #define TCP_REASON_PARTIALACK 0x04 /* these are reasons we adjusted our congestion window */ #define CWND_ACTION_DUPACK 1 // dup acks/fast retransmit #define CWND_ACTION_TIMEOUT 2 // retransmission timeout #define CWND_ACTION_ECN 3 // ECN bit [src quench if supported] #define CWND_ACTION_EXITED 4 // congestion recovery has ended // (when previously CWND_ACTION_DUPACK) /* these are bits for how to change the cwnd and ssthresh values */ #define CLOSE_SSTHRESH_HALF 0x00000001 #define CLOSE_CWND_HALF 0x00000002 #define CLOSE_CWND_RESTART 0x00000004 #define CLOSE_CWND_INIT 0x00000008 #define CLOSE_CWND_ONE 0x00000010 #define CLOSE_SSTHRESH_HALVE 0x00000020 #define CLOSE_CWND_HALVE 0x00000040 #define THREE_QUARTER_SSTHRESH 0x00000080 #define CLOSE_CWND_HALF_WAY 0x00000100 #define CWND_HALF_WITH_MIN 0x00000200 #define TCP_IDLE 0x00000400 #define NO_OUTSTANDING_DATA 0x00000800 /* * tcp_tick_: * default 0.1, * 0.3 for 4.3 BSD, * 0.01 for new window algorithms, */ #define NUMDUPACKS 3 /* This is no longer used. The variable */ /* numdupacks_ is used instead. */ #define TCP_MAXSEQ 1073741824 /* Number that curseq_ is set to for */ /* "infinite send" (2^30) */ #define TCP_TIMER_RTX 0 #define TCP_TIMER_DELSND 1 #define TCP_TIMER_BURSTSND 2 #define TCP_TIMER_DELACK 3 #define TCP_TIMER_Q 4 #define TCP_TIMER_RESET 5 class TcpAgent; class RtxTimer : public TimerHandler { public: RtxTimer(TcpAgent *a) : TimerHandler() { a_ = a; } protected: virtual void expire(Event *e); TcpAgent *a_; }; class DelSndTimer : public TimerHandler { public: DelSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; } protected: virtual void expire(Event *e); TcpAgent *a_; }; class BurstSndTimer : public TimerHandler { public: BurstSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; } protected: virtual void expire(Event *e); TcpAgent *a_; }; /* * Variables for HighSpeed TCP. */ //int *hs_win_; // array of cwnd values //int *hs_increase_; // array of increase values //double *hs_decrease_; // array of decrease values struct hstcp { double low_p; // low_p double dec1; // for computing the decrease parameter double dec2; // for computing the decrease parameter double p1; // for computing p double p2; // for computing p /* The next three parameters are for CPU overhead, for computing */ /* the HighSpeed parameters less frequently. A better solution */ /* might be just to have a look-up array. */ double cwnd_last_; /* last cwnd for computed parameters */ double increase_last_; /* increase param for cwnd_last_ */ hstcp() : low_p(0.0), dec1(0.0), dec2(0.0), p1(0.0), p2(0.0), cwnd_last_(0.0), increase_last_(0.0) { } }; class TcpAgent : public Agent { friend class XcpEndsys; public: TcpAgent(); virtual ~TcpAgent() {free(tss);} virtual void recv(Packet*, Handler*); virtual void timeout(int tno); virtual void timeout_nonrtx(int tno); int command(int argc, const char*const* argv); virtual void sendmsg(int nbytes, const char *flags = 0); void trace(TracedVar* v); virtual void advanceby(int delta); /* ------------------------------------------ Cheung: my new variables ------------------------------------------ */ int FixedWindowSize; // used by child class protected: virtual int window(); virtual double windowd(); void print_if_needed(double memb_time); void traceAll(); virtual void traceVar(TracedVar* v); virtual int headersize(); // a tcp header virtual void delay_bind_init_all(); virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer); TracedInt t_seqno_; /* sequence number */ /* * State encompassing the round-trip-time estimate. * srtt and rttvar are stored as fixed point; * srtt has 3 bits to the right of the binary point, rttvar has 2. */ TracedInt t_rtt_; /* round trip time */ TracedInt t_srtt_; /* smoothed round-trip time */ TracedInt t_rttvar_; /* variance in round-trip time */ TracedInt t_backoff_; /* current multiplier, 1 if not backed off */ #define T_RTT_BITS 0 int T_SRTT_BITS; /* exponent of weight for updating t_srtt_ */ int srtt_init_; /* initial value for computing t_srtt_ */ int T_RTTVAR_BITS; /* exponent of weight for updating t_rttvar_ */ int rttvar_exp_; /* exponent of multiple for t_rtxcur_ */ int rttvar_init_; /* initial value for computing t_rttvar_ */ double t_rtxcur_; /* current retransmit value */ double rtxcur_init_; /* initial value for t_rtxcur_ */ virtual void rtt_init(); virtual double rtt_timeout(); /* provide RTO based on RTT estimates */ virtual void rtt_update(double tao); /* update RTT estimate */ virtual void rtt_backoff(); /* double multiplier */ /* End of state for the round-trip-time estimate. */ /* Timestamps. */ double ts_peer_; /* the most recent timestamp the peer sent */ double ts_echo_; /* the most recent timestamp the peer echoed */ int ts_option_size_; // header bytes in a ts option double *tss; // To store sent timestamps, with bugfix_ts_ int tss_size_; // Current capacity of tss int ts_option_; /* use RFC1323-like timestamps? */ /* End of timestamps. */ /* connection and packet dynamics */ virtual void output(int seqno, int reason = 0); virtual void send_much(int force, int reason, int maxburst = 0); virtual void newtimer(Packet*); virtual void dupack_action(); /* do this on dupacks */ virtual void send_one(); /* do this on 1-2 dupacks */ double linear(double x, double x_1, double y_1, double x_2, double y_2); /* the "linear" function is for experimental highspeed TCP */ virtual void opencwnd(); void slowdown(int how); /* reduce cwnd/ssthresh */ void ecn(int seqno); /* react to quench */ virtual void set_initial_window(); /* set IW */ double initial_window(); /* what is IW? */ void reset(); void newack(Packet*); void tcp_eln(Packet *pkt); /* reaction to ELN (usually wireless) */ void finish(); /* called when the connection is terminated */ void reset_qoption(); /* for QOption with EnblRTTCtr_ */ void rtt_counting(); /* for QOption with EnblRTTCtr_ */ int network_limited(); /* Sending limited by network? */ double limited_slow_start(double cwnd, int max_ssthresh, double increment); /* Limited slow-start for high windows */ virtual int numdupacks(double cwnd); /* for getting numdupacks_ */ virtual void processQuickStart(Packet *pkt); virtual void endQuickStart(); int lossQuickStart(); /* Helper functions. Currently used by tcp-asym */ virtual void output_helper(Packet*) { return; } virtual void send_helper(int) { return; } virtual void send_idle_helper() { return; } virtual void recv_helper(Packet*) { return; } virtual void recv_frto_helper(Packet*); virtual void recv_newack_helper(Packet*); virtual void partialnewack_helper(Packet*) {}; /* End of helper functions. */ int force_wnd(int num); void spurious_timeout(); /* Timers */ RtxTimer rtx_timer_; DelSndTimer delsnd_timer_; BurstSndTimer burstsnd_timer_; virtual void cancel_timers() { rtx_timer_.force_cancel(); burstsnd_timer_.force_cancel(); delsnd_timer_.force_cancel(); } virtual void cancel_rtx_timer() { rtx_timer_.force_cancel(); } virtual void set_rtx_timer(); void reset_rtx_timer(int mild, int backoff = 1); int timerfix_; /* set to true to update timer *after* */ /* update the RTT, instead of before */ int rfc2988_; /* Use updated RFC 2988 timers */ /* End of timers. */ double boot_time_; /* where between 'ticks' this sytem came up */ double overhead_; double wnd_; double wnd_const_; double wnd_th_; /* window "threshold" */ double wnd_init_; double wnd_restart_; double tcp_tick_; /* clock granularity */ int wnd_option_; int wnd_init_option_; /* 1 for using wnd_init_ */ /* 2 for using large initial windows */ double decrease_num_; /* factor for multiplicative decrease */ double increase_num_; /* factor for additive increase */ int tcpip_base_hdr_size_; /* size of base TCP/IP header */ int ts_resetRTO_; /* Un-backoff RTO after any valid RTT, */ /* including from a retransmitted pkt? */ /* The old version was "false". */ /* But "true" gives better performance, and */ /* seems conformant with RFC 2988. */ int maxcwnd_; /* max # cwnd can ever be */ int numdupacks_; /* dup ACKs before fast retransmit */ int numdupacksFrac_; /* for a larger numdupacks_ with large */ /* windows */ double maxrto_; /* max value of an RTO */ double minrto_; /* min value of an RTO */ /* For modeling SYN and SYN/ACK packets. */ int syn_; /* 1 for modeling SYN/ACK exchange */ int delay_growth_; /* delay opening cwnd until 1st data recv'd */ /* End of modeling SYN and SYN/ACK packets. */ /* F-RTO */ int frto_enabled_; /* != 0 to enable F-RTO */ int sfrto_enabled_; /* != 0 to enabled SACK-based F-RTO */ int spurious_response_; /* Response variant to spurious RTO */ /* End of R-RTO */ /* Parameters for backwards compatility with old code. */ int bug_fix_; /* 1 for multiple-fast-retransmit fix */ int less_careful_; /* 1 for Less Careful variant of bug_fix_, */ /* for illustration only */ int exitFastRetrans_; /* True to clean exits of Fast Retransmit */ /* False for buggy old behavior */ int bugfix_ack_; // 1 to enable ACK heuristic, to allow // multiple-fast-retransmits in special cases. // From Andrei Gurtov int bugfix_ts_; // 1 to enable timestamp heuristic, to allow // multiple-fast-retransmits in special cases. // From Andrei Gurtov // Not implemented yet. int old_ecn_; /* For backwards compatibility with the * old ECN implementation, which never * reduced the congestion window below * one packet. */ int bugfix_ss_; // 1 to use window of one when SYN // packet is dropped /* End of parameters for backwards compatility. */ /* Parameters for alternate congestion control mechanisms. */ double k_parameter_; /* k parameter in binomial controls */ double l_parameter_; /* l parameter in binomial controls */ int precision_reduce_; /* non-integer reduction of cwnd */ int maxburst_; /* max # packets can send back-2-back */ int aggressive_maxburst_; /* Send on a non-valid ack? */ /* End of parameters for alternate congestion control mechanisms. */ FILE *plotfile_; /* * Dynamic state. */ TracedInt dupacks_; /* number of duplicate acks */ TracedInt curseq_; /* highest seqno "produced by app" */ TracedInt highest_ack_; /* not frozen during Fast Recovery */ TracedDouble cwnd_; /* current window */ TracedInt ssthresh_; /* slow start threshold */ TracedInt maxseq_; /* used for Karn algorithm */ /* highest seqno sent so far */ int last_ack_; /* largest consecutive ACK, frozen during * Fast Recovery */ int recover_; /* highest pkt sent before dup acks, */ /* timeout, or source quench/ecn */ int last_cwnd_action_; /* CWND_ACTION_{TIMEOUT,DUPACK,ECN} */ int count_; /* used in window increment algorithms */ int rtt_active_; /* 1 if a rtt sample is pending */ int rtt_seq_; /* seq # of timed seg if rtt_active_ is 1 */ double rtt_ts_; /* time at which rtt_seq_ was sent */ double firstsent_; /* When first packet was sent --Allman */ double lastreset_; /* W.N. Last time connection was reset - for */ /* detecting pkts from previous incarnations */ int closed_; /* whether this connection has closed */ int use_rtt_; /* Use RTT for timeout, for ECN-marked SYN-ACK */ /* Dynamic state used for alternate congestion control mechanisms */ double awnd_; /* averaged window */ int first_decrease_; /* First decrease of congestion window. */ /* Used for decrease_num_ != 0.5. */ double fcnt_; /* used in window increment algorithms */ double base_cwnd_; /* base window (for experimental purposes) */ /* End of state for alternate congestion control mechanisms */ /* Dynamic state only used for monitoring */ int trace_all_oneline_; /* TCP tracing vars all in one line or not? */ int nam_tracevar_; /* Output nam's variable trace or just plain text variable trace? */ TracedInt ndatapack_; /* number of data packets sent */ TracedInt ndatabytes_; /* number of data bytes sent */ TracedInt nackpack_; /* number of ack packets received */ TracedInt nrexmit_; /* number of retransmit timeouts when there was data outstanding */ TracedInt nrexmitpack_; /* number of retransmited packets */ TracedInt nrexmitbytes_; /* number of retransmited bytes */ TracedInt necnresponses_; /* number of times cwnd was reduced in response to an ecn packet -- sylvia */ TracedInt ncwndcuts_; /* number of times cwnd was reduced for any reason -- sylvia */ TracedInt ncwndcuts1_; /* number of times cwnd was reduced due to congestion (as opposed to idle periods */ /* end of dynamic state for monitoring */ /* Specifying variants in TCP algorithms. */ int slow_start_restart_; /* boolean: re-init cwnd after connection goes idle. On by default. */ int restart_bugfix_; /* ssthresh is cut down because of timeouts during a connection's idle period. Setting this boolean fixes this problem. For now, it is off by default. */ TracedInt singledup_; /* Send on a single dup ack. */ int LimTransmitFix_; /* To fix a bug in Limited Transmit. */ int noFastRetrans_; /* No Fast Retransmit option. */ int oldCode_; /* Use old code. */ int useHeaders_; /* boolean: Add TCP/IP header sizes */ /* end of specifying variants */ /* Used for ECN */ int ecn_; /* Explicit Congestion Notification */ int cong_action_; /* Congestion Action. True to indicate that the sender responded to congestion. */ int ecn_burst_; /* True when the previous ACK packet * carried ECN-Echo. */ int ecn_backoff_; /* True when retransmit timer should begin to be backed off. */ int ect_; /* turn on ect bit now? */ int SetCWRonRetransmit_; /* True to allow setting CWR on */ /* retransmitted packets. Affects */ /* performance for Reno with ECN. */ /* end of ECN */ /* used for Explicit Loss Notification */ int eln_; /* Explicit Loss Notification (wireless) */ int eln_rxmit_thresh_; /* Threshold for ELN-triggered rxmissions */ int eln_last_rxmit_; /* Last packet rxmitted due to ELN info */ /* end of Explicit Loss Notification */ /* for experimental high-speed TCP */ /* These four parameters define the HighSpeed response function. */ int low_window_; /* window for turning on high-speed TCP */ int high_window_; /* target window for new response function */ double high_p_; /* target drop rate for new response function */ double high_decrease_; /* decrease rate at target window */ /* The next parameter is for Limited Slow-Start. */ int max_ssthresh_; /* max value for ssthresh_ */ /* These two functions are just an easy structuring of the code. */ double increase_param(); /* get increase parameter for current cwnd */ double decrease_param(); /* get decrease parameter for current cwnd */ int cwnd_range_; /* for determining when to recompute params. */ hstcp hstcp_; /* HighSpeed TCP variables */ /* end of section for experimental high-speed TCP */ /* for Quick-Start, experimental. */ int rate_request_; /* Rate request in KBps, for QuickStart. */ int qs_enabled_; /* to enable QuickStart. */ int qs_requested_; int qs_approved_; int qs_window_; /* >0: there are outstanding non-acked segments from QS window */ int qs_cwnd_; /* Initial window for Quick-Start */ int tcp_qs_recovery_; /* != 0 if we apply slow start on packet losses during QS window */ int qs_request_mode_; /* 1 = Try to avoid unnecessary QS requests for short flows. Use qs_rtt_ as the RTT used in window calculation. Other: Always request 'rate_request_' bytes, regardless of flow size */ int qs_thresh_; /* Do not use QS if there are less data to send than this. Applies only if qs_request_mode_ == 1 */ int qs_rtt_; /* QS needs some assumption of the RTT in in order to be able to determine how much it needs for rate request with given amount of data to send. milliseconds. */ int print_request_; /* true to print Quick-Start request */ int ttl_diff_; /* end of section for Quick-Start. */ /* F-RTO: !=0 when F-RTO recovery is underway, N:th round-trip * since RTO. Can have values between 0-2 */ int frto_; int pipe_prev_; /* window size when timeout last occurred */ /* support for event-tracing */ //EventTrace *et_; void trace_event(char *eventtype); /* these function are now obsolete, see other above */ void closecwnd(int how); void quench(int how); /* TCP quiescence, reducing cwnd after an idle period */ void process_qoption_after_send() ; void process_qoption_after_ack(int seqno) ; int QOption_ ; /* TCP quiescence option */ int EnblRTTCtr_ ; /* are we using a corase grained timer? */ int T_full ; /* last time the window was 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_ ; /* If true, don't increase cwnd if sender */ /* is not window-limited. */ int prev_highest_ack_ ; /* Used to determine if sender is */ /* window-limited. */ /* end of TCP quiescence */ }; /* TCP Reno */ class RenoTcpAgent : public virtual TcpAgent { public: RenoTcpAgent(); virtual int window(); virtual double windowd(); virtual void recv(Packet *pkt, Handler*); virtual void timeout(int tno); virtual void dupack_action(); protected: int allow_fast_retransmit(int last_cwnd_action_); unsigned int dupwnd_; }; /* TCP New Reno */ class NewRenoTcpAgent : public virtual RenoTcpAgent { public: NewRenoTcpAgent(); virtual void recv(Packet *pkt, Handler*); virtual void partialnewack_helper(Packet* pkt); virtual void dupack_action(); protected: int newreno_changes_; /* 0 for fixing unnecessary fast retransmits */ /* 1 for additional code from Allman, */ /* to implement other algorithms from */ /* Hoe's paper, including sending a new */ /* packet for every two duplicate ACKs. */ /* The default is set to 0. */ int newreno_changes1_; /* Newreno_changes1_ set to 0 gives the */ /* Slow-but-Steady variant of NewReno from */ /* RFC 2582, with the retransmit timer reset */ /* after each partial new ack. */ /* Newreno_changes1_ set to 1 gives the */ /* Impatient variant of NewReno from */ /* RFC 2582, with the retransmit timer reset */ /* only for the first partial new ack. */ /* The default is set to 0 */ void partialnewack(Packet *pkt); int allow_fast_retransmit(int last_cwnd_action_); int acked_, new_ssthresh_; /* used if newreno_changes_ == 1 */ double ack2_, ack3_, basertt_; /* used if newreno_changes_ == 1 */ int firstpartial_; /* For the first partial ACK. */ int partial_window_deflation_; /* 0 if set cwnd to ssthresh upon */ /* partial new ack (default) */ /* 1 if deflate (cwnd + dupwnd) by */ /* amount of data acked */ /* "Partial window deflation" is */ /* discussed in RFC 2582. */ int exit_recovery_fix_; /* 0 for setting cwnd to ssthresh upon */ /* leaving fast recovery (default) */ /* 1 for setting cwnd to min(ssthresh, */ /* amnt. of data in network) when leaving */ }; /* TCP vegas (VegasTcpAgent) */ class VegasTcpAgent : public virtual TcpAgent { public: VegasTcpAgent(); ~VegasTcpAgent(); virtual void recv(Packet *pkt, Handler *); virtual void timeout(int tno); protected: double vegastime() { return(Scheduler::instance().clock() - firstsent_); } 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); double t_cwnd_changed_; // last time cwnd changed double firstrecv_; // time recv the 1st ack int v_alpha_; // vegas thruput thresholds in pkts int v_beta_; int v_gamma_; // threshold to change from slow-start to // congestion avoidance, in pkts int v_slowstart_; // # of pkts to send after slow-start, deflt(2) int v_worried_; // # of pkts to chk after dup ack (1 or 2) double v_timeout_; // based on fine-grained timer double v_rtt_; double v_sa_; double v_sd_; int v_cntRTT_; // # of rtt measured within one rtt double v_sumRTT_; // sum of rtt measured within one rtt double v_begtime_; // tagged pkt sent int v_begseq_; // tagged pkt seqno double* v_sendtime_; // each unacked pkt's sendtime is recorded. int* v_transmits_; // # of retx for an unacked pkt int v_maxwnd_; // maxwnd size for v_sendtime_[] double v_newcwnd_; // record un-inflated cwnd double v_baseRTT_; // min of all rtt double v_incr_; // amount cwnd is increased in the next rtt int v_inc_flag_; // if cwnd is allowed to incr for this rtt double v_actual_; // actual send rate (pkt/s; needed for tcp-rbp) int ns_vegas_fix_level_; // see comment at end of tcp-vegas.cc for details of fixes }; // Local Variables: // mode:c++ // c-basic-offset: 8 // End: #endif