/* -*- 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: /nfs/jade/vint/CVSROOT/ns-2/tcp/tcp.h,v 1.121 2005/06/20 16:30:30 sfloyd 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 //delsnd即delay send，即随机延迟一段时间的发送
#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 {
public:
TcpAgent();
~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);
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_; /* RTT时间*/
TracedInt t_srtt_; /* 平滑的RTT时间*/
TracedInt t_rttvar_; /* RTT的抖动平均偏差（均方值）*/
TracedInt t_backoff_; /* 计算RTO的回退因子，每次超时，有RTO=RTO*2。current multiplier, 1 if not backed off */
#define T_RTT_BITS 0
int T_SRTT_BITS; /* 用于更新SRTT的指数权值 exponent of weight for updating t_srtt_ */
int srtt_init_; /* initial value for computing t_srtt_ */
int T_RTTVAR_BITS; /* 用于更新RTTVAR的指数权值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_; /* 对方发送的最后一个ACK的时间戳 */
double ts_echo_; /*对方发送的最后一个ACK的回应时间戳，表示本方相应序号发送的时间 */
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_; /*＝1表示应用程序采用时间戳方式，应用程序也可以使用本方记录RTT样本时间的方式，相应参数为rtt_ts*/
/* 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);//一次发送窗口允许的尽量多的分组
/*force:表示非重传(延迟)定时器超时的情况；reason：发送原因，用来传给对方；
maxburst：允许一次发送的最大的分组数量，为系统固定值*/
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 */
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, double 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_; //修改后的更新RTO定时器策略，设为1表示采用在更新RTT以后而不是以前更新RTO定时器的策略
/* 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_; /*系统在两个TCP时钟之间启动经过的时间， where between 'ticks' this sytem came up */
double overhead_;
double wnd_; //接收方的通知窗口，在单向TCP程序中为固定值
double wnd_const_;
double wnd_th_; //窗口门限，用于计算awnd /* window "threshold" */
double wnd_init_;
double wnd_restart_;
double tcp_tick_; //TCP时间间隔 /* clock granularity */
int wnd_option_;
int wnd_init_option_; /* 设为1表示使用默认初始启动窗口，1 for using wnd_init_ */
/* 设为2表示使用大的初始启动窗口，2 for using large initial windows */
double decrease_num_; /*乘法减策略因子，默认为0.5 factor for multiplicative decrease */
double increase_num_; /*加法增策略因子，默认为1.0 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. */
/* 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_; /*＝1表示按双精度减少CWND 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_; //最大的ACK号，快速重传不会影响
TracedDouble cwnd_; /*即拥塞窗口，而发送窗口为min(cwnd,wnd)，即拥塞窗口和对端通告窗口的小者。
拥塞窗口是对发送端收到确认之前能向网络传送的最大数据量的一个发送端限制*/
TracedInt ssthresh_; /* slow start threshold */
TracedInt maxseq_; /*用于 Karn algorithm，记录发送分组的最大序号 */
/* highest seqno sent so far */
int last_ack_; //最大“连续”ACK号，快速重传时保持不变
int recover_; //recover_用于记录超时和快速重传前已发送分组的最大序号，F-RTO用
int last_cwnd_action_; /* CWND_ACTION_{TIMEOUT,DUPACK,ECN} */
int count_; /* used in window increment algorithms */
int rtt_active_; /* rtt样本还没收到时为1，1 if a rtt sample is pending */
int rtt_seq_; /* rtt样本号，其发送时间被记录了下来，seq # of timed seg if rtt_active_ is 1 */
double rtt_ts_; /* 上面的rtt_seq发送的时间，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 */
/* Dynamic state used for alternate congestion control mechanisms */
double awnd_; /* averaged window */
int first_decrease_; /*是否拥塞窗口第一次减少，用于防止减少数＝0.5 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_; /* 拥塞动作，=1表示发方是对拥塞的反映 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.
2 = 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 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_ ; /*在发方窗口不受限时，不增加CWND?? 默认为0 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 Veno */
class VenoTcpAgent : public virtual TcpAgent {
public:
VenoTcpAgent();
virtual int window();
virtual double windowd();
virtual void recv(Packet *pkt, Handler*);
virtual void timeout(int tno);
virtual void dupack_action();
virtual void rtt_update(double tao);
virtual void opencwnd();
protected:
virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer);
int allow_fast_retransmit(int last_cwnd_action_);
void veno_slowdown();
unsigned int dupwnd_;
double veno_rtt; //双精度的RTT,不同于整型t_rtt_
double base_rtt; // min of all rtt
double N_; //
double beta; //默认为3
int every_other_; //用于veno加增策略,N>=beta时每两个新ack，采用一次加增策略
};
/* 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_; // 测得的RTT数量 # of rtt measured within one rtt
double v_sumRTT_; // 测得的RTT值的总和 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
1327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
