TCP的.cc文件代码解释（中文）

#ifndef lint

static const char rcsid[] =

    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp/tcp.cc,v 1.163 2005/06/21 01:48:24 sfloyd Exp $ (LBL)";

#endif

#include <stdlib.h>

#include <math.h>

#include <sys/types.h>

#include "ip.h"

#include "tcp.h"

#include "flags.h"

#include "random.h"

#include "basetrace.h"

#include "hdr_qs.h"

int hdr_tcp::offset_;

static class TCPHeaderClass : public PacketHeaderClass {

public:

        TCPHeaderClass() : PacketHeaderClass("PacketHeader/TCP",

          sizeof(hdr_tcp)) {

  bind_offset(&hdr_tcp::offset_);

 }

} class_tcphdr;

static class TcpClass : public TclClass {

public:

 TcpClass() : TclClass("Agent/TCP") {}

 TclObject* create(int , const char*const*) {

  return (new TcpAgent());

 }

} class_tcp;

TcpAgent::TcpAgent() 

 : Agent(PT_TCP), 

   t_seqno_(0), t_rtt_(0), t_srtt_(0), t_rttvar_(0), 

   t_backoff_(0), ts_peer_(0), ts_echo_(0),

   tss(NULL), tss_size_(100), 

   rtx_timer_(this), delsnd_timer_(this), burstsnd_timer_(this), 

   dupacks_(0), curseq_(0), highest_ack_(0), cwnd_(0), ssthresh_(0), 

   maxseq_(0), count_(0), rtt_active_(0), rtt_seq_(-1), rtt_ts_(0.0), 

   lastreset_(0.0), closed_(0), first_decrease_(1), fcnt_(0), 

   nrexmit_(0), restart_bugfix_(1), cong_action_(0), 

   ecn_burst_(0), ecn_backoff_(0), ect_(0), 

   qs_requested_(0), qs_approved_(0),

   qs_window_(0), qs_cwnd_(0), frto_(0)

 

{

#ifdef TCP_DELAY_BIND_ALL

#else /* ! TCP_DELAY_BIND_ALL */

 // not delay-bound because delay-bound tracevars aren't yet supported

 bind("t_seqno_", &t_seqno_);

 bind("rtt_", &t_rtt_);

 bind("srtt_", &t_srtt_);

 bind("rttvar_", &t_rttvar_);

 bind("backoff_", &t_backoff_);

 bind("dupacks_", &dupacks_);

 bind("seqno_", &curseq_);

 bind("ack_", &highest_ack_);

 bind("cwnd_", &cwnd_);

 bind("ssthresh_", &ssthresh_);

 bind("maxseq_", &maxseq_);

        bind("ndatapack_", &ndatapack_);

        bind("ndatabytes_", &ndatabytes_);

        bind("nackpack_", &nackpack_);

        bind("nrexmit_", &nrexmit_);

        bind("nrexmitpack_", &nrexmitpack_);

        bind("nrexmitbytes_", &nrexmitbytes_);

        bind("necnresponses_", &necnresponses_);

        bind("ncwndcuts_", &ncwndcuts_);

 bind("ncwndcuts1_", &ncwndcuts1_);

#endif /* TCP_DELAY_BIND_ALL */

}

void

TcpAgent::delay_bind_init_all()

{

// Defaults for bound variables should be set in ns-default.tcl.

        delay_bind_init_one("window_");

        delay_bind_init_one("windowInit_");

        delay_bind_init_one("windowInitOption_");

delay_bind_init_one("syn_");

        delay_bind_init_one("windowOption_");

        delay_bind_init_one("windowConstant_");

        delay_bind_init_one("windowThresh_");

        delay_bind_init_one("delay_growth_");

        delay_bind_init_one("overhead_");

        delay_bind_init_one("tcpTick_");

        delay_bind_init_one("ecn_");

        delay_bind_init_one("SetCWRonRetransmit_");

        delay_bind_init_one("old_ecn_");

        delay_bind_init_one("eln_");

        delay_bind_init_one("eln_rxmit_thresh_");

        delay_bind_init_one("packetSize_");

        delay_bind_init_one("tcpip_base_hdr_size_");

 delay_bind_init_one("ts_option_size_");

        delay_bind_init_one("bugFix_");

 delay_bind_init_one("bugFix_ack_");

 delay_bind_init_one("bugFix_ts_");

 delay_bind_init_one("lessCareful_");

        delay_bind_init_one("slow_start_restart_");

        delay_bind_init_one("restart_bugfix_");

        delay_bind_init_one("timestamps_");

 delay_bind_init_one("ts_resetRTO_");

        delay_bind_init_one("maxburst_");

 delay_bind_init_one("aggressive_maxburst_");

        delay_bind_init_one("maxcwnd_");

 delay_bind_init_one("numdupacks_");

 delay_bind_init_one("numdupacksFrac_");

 delay_bind_init_one("exitFastRetrans_");

        delay_bind_init_one("maxrto_");

 delay_bind_init_one("minrto_");

        delay_bind_init_one("srtt_init_");

        delay_bind_init_one("rttvar_init_");

        delay_bind_init_one("rtxcur_init_");

        delay_bind_init_one("T_SRTT_BITS");

        delay_bind_init_one("T_RTTVAR_BITS");

        delay_bind_init_one("rttvar_exp_");

        delay_bind_init_one("awnd_");

        delay_bind_init_one("decrease_num_");

        delay_bind_init_one("increase_num_");

 delay_bind_init_one("k_parameter_");

 delay_bind_init_one("l_parameter_");

        delay_bind_init_one("trace_all_oneline_");

        delay_bind_init_one("nam_tracevar_");

delay_bind_init_one("QOption_");

        delay_bind_init_one("EnblRTTCtr_");

        delay_bind_init_one("control_increase_");

 delay_bind_init_one("noFastRetrans_");

 delay_bind_init_one("precisionReduce_");

 delay_bind_init_one("oldCode_");

 delay_bind_init_one("useHeaders_");

 delay_bind_init_one("low_window_");

 delay_bind_init_one("high_window_");

 delay_bind_init_one("high_p_");

 delay_bind_init_one("high_decrease_");

 delay_bind_init_one("max_ssthresh_");

 delay_bind_init_one("cwnd_range_");

 delay_bind_init_one("timerfix_");

 delay_bind_init_one("rfc2988_");

 delay_bind_init_one("singledup_");

 delay_bind_init_one("LimTransmitFix_");

 delay_bind_init_one("rate_request_");

 delay_bind_init_one("qs_enabled_");

 delay_bind_init_one("tcp_qs_recovery_");

 delay_bind_init_one("qs_request_mode_");

 delay_bind_init_one("qs_thresh_");

 delay_bind_init_one("qs_rtt_");

delay_bind_init_one("frto_enabled_");

 delay_bind_init_one("sfrto_enabled_");

 delay_bind_init_one("spurious_response_");

#ifdef TCP_DELAY_BIND_ALL

 // out because delay-bound tracevars aren't yet supported

        delay_bind_init_one("t_seqno_");

        delay_bind_init_one("rtt_");

        delay_bind_init_one("srtt_");

        delay_bind_init_one("rttvar_");

        delay_bind_init_one("backoff_");

        delay_bind_init_one("dupacks_");

        delay_bind_init_one("seqno_");

        delay_bind_init_one("ack_");

        delay_bind_init_one("cwnd_");

        delay_bind_init_one("ssthresh_");

        delay_bind_init_one("maxseq_");

        delay_bind_init_one("ndatapack_");

        delay_bind_init_one("ndatabytes_");

        delay_bind_init_one("nackpack_");

        delay_bind_init_one("nrexmit_");

        delay_bind_init_one("nrexmitpack_");

        delay_bind_init_one("nrexmitbytes_");

        delay_bind_init_one("necnresponses_");

        delay_bind_init_one("ncwndcuts_");

 delay_bind_init_one("ncwndcuts1_");

#endif /* TCP_DELAY_BIND_ALL */

Agent::delay_bind_init_all();

reset();

}

int

TcpAgent::delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer)

{

        if (delay_bind(varName, localName, "window_", &wnd_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "windowInit_", &wnd_init_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "windowInitOption_", &wnd_init_option_, tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "syn_", &syn_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "windowOption_", &wnd_option_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "windowConstant_",  &wnd_const_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "windowThresh_", &wnd_th_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "delay_growth_", &delay_growth_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "overhead_", &overhead_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "tcpTick_", &tcp_tick_, tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "ecn_", &ecn_, tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "SetCWRonRetransmit_", &SetCWRonRetransmit_, tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "old_ecn_", &old_ecn_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "eln_", &eln_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "eln_rxmit_thresh_", &eln_rxmit_thresh_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "packetSize_", &size_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "tcpip_base_hdr_size_", &tcpip_base_hdr_size_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "ts_option_size_", &ts_option_size_, tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "bugFix_", &bug_fix_ , tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "bugFix_ack_", &bugfix_ack_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "bugFix_ts_", &bugfix_ts_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "lessCareful_", &less_careful_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "timestamps_", &ts_option_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "ts_resetRTO_", &ts_resetRTO_, tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "slow_start_restart_", &slow_start_restart_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "restart_bugfix_", &restart_bugfix_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "maxburst_", &maxburst_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "aggressive_maxburst_", &aggressive_maxburst_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "maxcwnd_", &maxcwnd_ , tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "numdupacks_", &numdupacks_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "numdupacksFrac_", &numdupacksFrac_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "exitFastRetrans_", &exitFastRetrans_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "maxrto_", &maxrto_ , tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "minrto_", &minrto_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "srtt_init_", &srtt_init_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "rttvar_init_", &rttvar_init_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "rtxcur_init_", &rtxcur_init_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "T_SRTT_BITS", &T_SRTT_BITS , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "T_RTTVAR_BITS", &T_RTTVAR_BITS , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "rttvar_exp_", &rttvar_exp_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "awnd_", &awnd_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "decrease_num_", &decrease_num_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "increase_num_", &increase_num_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "k_parameter_", &k_parameter_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "l_parameter_", &l_parameter_, tracer)) return TCL_OK;

if (delay_bind_bool(varName, localName, "trace_all_oneline_", &trace_all_oneline_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "nam_tracevar_", &nam_tracevar_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "QOption_", &QOption_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "EnblRTTCtr_", &EnblRTTCtr_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "control_increase_", &control_increase_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "noFastRetrans_", &noFastRetrans_, tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "precisionReduce_", &precision_reduce_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "oldCode_", &oldCode_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "useHeaders_", &useHeaders_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "low_window_", &low_window_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "high_window_", &high_window_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "high_p_", &high_p_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "high_decrease_", &high_decrease_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "max_ssthresh_", &max_ssthresh_, tracer)) return TCL_OK;

 if (delay_bind(varName, localName, "cwnd_range_", &cwnd_range_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "timerfix_", &timerfix_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "rfc2988_", &rfc2988_, tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "singledup_", &singledup_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "LimTransmitFix_", &LimTransmitFix_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "rate_request_", &rate_request_ , tracer)) return TCL_OK;

        if (delay_bind_bool(varName, localName, "qs_enabled_", &qs_enabled_ , tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "tcp_qs_recovery_", &tcp_qs_recovery_, tracer)) return TCL_OK;

if (delay_bind_bool(varName, localName, "frto_enabled_", &frto_enabled_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "sfrto_enabled_", &sfrto_enabled_, tracer)) return TCL_OK;

 if (delay_bind_bool(varName, localName, "spurious_response_", &spurious_response_, tracer)) return TCL_OK;

#ifdef TCP_DELAY_BIND_ALL

 // not if (delay-bound delay-bound tracevars aren't yet supported

        if (delay_bind(varName, localName, "t_seqno_", &t_seqno_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "rtt_", &t_rtt_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "srtt_", &t_srtt_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "rttvar_", &t_rttvar_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "backoff_", &t_backoff_ , tracer)) return TCL_OK;

if (delay_bind(varName, localName, "dupacks_", &dupacks_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "seqno_", &curseq_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "ack_", &highest_ack_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "cwnd_", &cwnd_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "ssthresh_", &ssthresh_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "maxseq_", &maxseq_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "ndatapack_", &ndatapack_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "ndatabytes_", &ndatabytes_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "nackpack_", &nackpack_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "nrexmit_", &nrexmit_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "nrexmitpack_", &nrexmitpack_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "nrexmitbytes_", &nrexmitbytes_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "necnresponses_", &necnresponses_ , tracer)) return TCL_OK;

        if (delay_bind(varName, localName, "ncwndcuts_", &ncwndcuts_ , tracer)) return TCL_OK;

  if (delay_bind(varName, localName, "ncwndcuts1_", &ncwndcuts1_ , tracer)) return TCL_OK;

#endif

return Agent::delay_bind_dispatch(varName, localName, tracer);

}

#define TCP_WRK_SIZE  512

/* Print out all the traced variables whenever any one is changed */

void

TcpAgent::traceAll() {

 if (!channel_)

  return;

double curtime;

 Scheduler& s = Scheduler::instance();

 char wrk[TCP_WRK_SIZE];

curtime = &s ? s.clock() : 0;

 snprintf(wrk, TCP_WRK_SIZE,

   "time: %-8.5f saddr: %-2d sport: %-2d daddr: %-2d dport:"

   " %-2d maxseq: %-4d hiack: %-4d seqno: %-4d cwnd: %-6.3f"

   " ssthresh: %-3d dupacks: %-2d rtt: %-6.3f srtt: %-6.3f"

   " rttvar: %-6.3f bkoff: %-d/n", curtime, addr(), port(),

   daddr(), dport(), int(maxseq_), int(highest_ack_),

   int(t_seqno_), double(cwnd_), int(ssthresh_),

   int(dupacks_), int(t_rtt_)*tcp_tick_, 

   (int(t_srtt_) >> T_SRTT_BITS)*tcp_tick_, 

   int(t_rttvar_)*tcp_tick_/4.0, int(t_backoff_)); 

 (void)Tcl_Write(channel_, wrk, -1);

}

/* Print out just the variable that is modified */

void

TcpAgent::traceVar(TracedVar* v) 

{

 if (!channel_)

  return;

double curtime;

 Scheduler& s = Scheduler::instance();

 char wrk[TCP_WRK_SIZE];

curtime = &s ? s.clock() : 0;

// XXX comparing addresses is faster than comparing names

 if (v == &cwnd_)

  snprintf(wrk, TCP_WRK_SIZE,

    "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f/n",

    curtime, addr(), port(), daddr(), dport(),

    v->name(), double(*((TracedDouble*) v))); 

  else if (v == &t_rtt_)

  snprintf(wrk, TCP_WRK_SIZE,

    "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f/n",

    curtime, addr(), port(), daddr(), dport(),

    v->name(), int(*((TracedInt*) v))*tcp_tick_); 

 else if (v == &t_srtt_)

  snprintf(wrk, TCP_WRK_SIZE,

    "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f/n",

    curtime, addr(), port(), daddr(), dport(),

    v->name(), 

    (int(*((TracedInt*) v)) >> T_SRTT_BITS)*tcp_tick_); 

 else if (v == &t_rttvar_)

  snprintf(wrk, TCP_WRK_SIZE,

    "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f/n",

    curtime, addr(), port(), daddr(), dport(),

    v->name(), 

    int(*((TracedInt*) v))*tcp_tick_/4.0); 

 else

  snprintf(wrk, TCP_WRK_SIZE,

    "%-8.5f %-2d %-2d %-2d %-2d %s %d/n",

    curtime, addr(), port(), daddr(), dport(),

    v->name(), int(*((TracedInt*) v)));

(void)Tcl_Write(channel_, wrk, -1);

}

void

TcpAgent::trace(TracedVar* v) 

{

 if (nam_tracevar_) {

  Agent::trace(v);

 } else if (trace_all_oneline_)

  traceAll();

 else 

  traceVar(v);

}

//

// in 1-way TCP, syn_ indicates we are modeling

// a SYN exchange at the beginning.  If this is true

// and we are delaying growth, then use an initial

// window of one.  If not, we do whatever initial_window()

// says to do.

//

void

TcpAgent::set_initial_window()              //初始化CWND

{

 if (syn_ && delay_growth_)         

  cwnd_ = 1.0;                 //连接开始，初始窗口为1

 else

  cwnd_ = initial_window();   //

}

void

TcpAgent::reset_qoption()

{

 int now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);

T_start = now ; 

 RTT_count = 0 ; 

 RTT_prev = 0 ; 

 RTT_goodcount = 1 ; 

 F_counting = 0 ; 

 W_timed = -1 ; 

 F_full = 0 ;

 Backoffs = 0 ; 

}

//reset()仅被delay_bind_init_all()调用，用于初始化参数

void

TcpAgent::reset()

{

 rtt_init();

 rtt_seq_ = -1;

 /*XXX lookup variables */

 dupacks_ = 0;

 curseq_ = 0;

 set_initial_window();

t_seqno_ = 0;

 maxseq_ = -1;

 last_ack_ = -1;

 highest_ack_ = -1;

 ssthresh_ = int(wnd_);        //wnd_默认为20，SSTHRESH初始也为20

 if (max_ssthresh_ > 0 && max_ssthresh_ < ssthresh_) 

  ssthresh_ = max_ssthresh_;         //max_ssthresh_默认为0，表示无限

 wnd_restart_ = 1.;

 awnd_ = wnd_init_ / 2.0;

 recover_ = 0;

 closed_ = 0;

 last_cwnd_action_ = 0;

 boot_time_ = Random::uniform(tcp_tick_);    //计算RTT时用到，用来模拟系统启动时间（在两个TCP时钟之间）

 first_decrease_ = 1;                       //用于在slowdown()中判断是否第一次减少CWND，＝1，是

 /* W.N.: for removing packets from previous incarnations */

 lastreset_ = Scheduler::instance().clock();

/* Now these variables will be reset 

    - Debojyoti Dutta 12th Oct'2000 */

 

 ndatapack_ = 0;

 ndatabytes_ = 0;

 nackpack_ = 0;

 nrexmitbytes_ = 0;

 nrexmit_ = 0;

 nrexmitpack_ = 0;

 necnresponses_ = 0;

 ncwndcuts_ = 0;

 ncwndcuts1_ = 0;

if (control_increase_) {

  prev_highest_ack_ = highest_ack_ ; 

 }

if (wnd_option_ == 8) {

  // HighSpeed TCP

  hstcp_.low_p = 1.5/(low_window_*low_window_);

  double highLowWin = log(high_window_)-log(low_window_);

  double highLowP = log(high_p_) - log(hstcp_.low_p);

  hstcp_.dec1 = 

     0.5 - log(low_window_) * (high_decrease_ - 0.5)/highLowWin;

  hstcp_.dec2 = (high_decrease_ - 0.5)/highLowWin;

         hstcp_.p1 = 

    log(hstcp_.low_p) - log(low_window_) * highLowP/highLowWin;

  hstcp_.p2 = highLowP/highLowWin;

 }

if (QOption_) {

  int now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);

  T_last = now ; 

  T_prev = now ; 

  W_used = 0 ;

  if (EnblRTTCtr_) {

   reset_qoption();

  }

 }

}

/*仅在reset()作初始化时调用，reset()又被delay_bind_init_all()调用

 * Initialize variables for the retransmit timer.

 */

void TcpAgent::rtt_init()       //初始化RTT、SRTT、RTTVAR、RTXCUR和回退(补偿)因子

{

 t_rtt_ = 0;        

 t_srtt_ = int(srtt_init_ / tcp_tick_) << T_SRTT_BITS;

 t_rttvar_ = int(rttvar_init_ / tcp_tick_) << T_RTTVAR_BITS;

 t_rtxcur_ = rtxcur_init_;             //初始化重传定时时间

 t_backoff_ = 1;

}

//由set_rtx_timer()调用rtt_timeout()设定超时值

double TcpAgent::rtt_timeout()          //根据给定的t_rtxcur_（考虑上下限和回退因子）

{

 double timeout;

 if (rfc2988_) {           //按rfc2988的算法，不同处在于2988的minrto要乘回退因子，默认为FALSE

 // Correction from Tom Kelly to be RFC2988-compliant, by

 // clamping minrto_ before applying t_backoff_.

  if (t_rtxcur_ < minrto_)                   //重传超时值不能小于最小RTO

   timeout = minrto_ * t_backoff_;    //否则按最小值算 

  else

   timeout = t_rtxcur_ * t_backoff_;  //按给定值RTXCUR算，都要乘回退因子

 } else {

  timeout = t_rtxcur_ * t_backoff_;    

  if (timeout < minrto_)

   timeout = minrto_;

 }

if (timeout > maxrto_)                   //限制最大超时值

  timeout = maxrto_;

if (timeout < 2.0 * tcp_tick_) {     //超时值为负则退出，小于2个tcp时钟则为2个tcp时钟

  if (timeout < 0) {

   fprintf(stderr, "TcpAgent: negative RTO!  (%f)/n",

    timeout);

   exit(1);

  }

  timeout = 2.0 * tcp_tick_;

 }

 return (timeout);

}

//由newack()调用，再由recv_newack_helper()调用，最终由recv()调用

//算得的t_rtxcur_由rtt_timeout()调用，再由set_rtx_timer()调用rtt_timeout设定超时值，set_rtx_timer()主要由output()等调用

/* This has been modified to use the tahoe code. */

void TcpAgent::rtt_update(double tao)      //更新RTT，将双精度的RTT转化成整数的RTT，由此计算t_rtxcur_

{                                                          //tao为newack（）中的now-ts_echo或now-rtt_ts_，相当于未整数化的RTT

 double now = Scheduler::instance().clock();

 if (ts_option_)                                  //采用回应时间戳的情况，默认不采用

  t_rtt_ = int(tao /tcp_tick_ + 0.5);     //RTT整数化，＋0.5表示不四舍五入，只要有小数，都入。其中tcp_tick_默认为0.01，即RTT的值精确到0.01秒

 else {                                              //不采用时间戳的情况

  double sendtime = now - tao;         //计算本端发送该序号的时间

  sendtime += boot_time_;               //发送时间要加上boot时间，boot时间用于系统模拟启动时间？？是个随机数，小于一个tcp嘀哒

  double tickoff = fmod(sendtime, tcp_tick_);        //取发送时间对tcp_tick_取模的余数，是整数

  t_rtt_ = int((tao + tickoff) / tcp_tick_);     //计算不采用时间戳的RTT时间 

 }

 if (t_rtt_ < 1)          //rtt不能小于一个TCP时钟周期

  t_rtt_ = 1;

 //

 // t_srtt_ has 3 bits to the right of the binary point

 // t_rttvar_ has 2

        // Thus "t_srtt_ >> T_SRTT_BITS" is the actual srtt, 

   //   and "t_srtt_" is 8*srtt.

 // Similarly, "t_rttvar_ >> T_RTTVAR_BITS" is the actual rttvar,

 //   and "t_rttvar_" is 4*rttvar.

 //以下计算srtt和varrtt,算法不必关心

        if (t_srtt_ != 0) {

  register short delta;

  delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS); // d = (m - a0)

  if ((t_srtt_ += delta) <= 0) // srtt的计算：a1 = 7/8 a0 + 1/8 m

   t_srtt_ = 1;

  if (delta < 0)

   delta = -delta;

  delta -= (t_rttvar_ >> T_RTTVAR_BITS);

  if ((t_rttvar_ += delta) <= 0) // varrtt的计算：var1 = 3/4 var0 + 1/4 |d|

   t_rttvar_ = 1;

 } else {

  t_srtt_ = t_rtt_ << T_SRTT_BITS;  // srtt = rtt

  t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1); // rttvar = rtt / 2

 }

 //

 // Current retransmit value is 

 //    (unscaled) smoothed round trip estimate

 //    plus 2^rttvar_exp_ times (unscaled) rttvar. 

 //

 //计算重传超时时间RTO= SRTT + max (G, K*RTTVAR)，算法不必关心

 t_rtxcur_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS))) +

  t_srtt_)  >> T_SRTT_BITS ) * tcp_tick_;

return;

}

//在reset_rtx_timer()中使用,t_backoff用于在重传超时时对RTO进行翻倍

void TcpAgent::rtt_backoff()

{

 if (t_backoff_ < 64)          /*t_backoff_即RTO补偿因子，初始化为0，启动后为1，

                                 最大为64，即最大重传超时时间为：最初的RTO*64 */

  t_backoff_ <<= 1;     //每次补偿因子*2

if (t_backoff_ > 8) {         //补偿因子>8，说明重发了3次以上，则对rtt平均偏差和平滑值做出修正

  /*

   * If backed off this far, clobber the srtt

   * value, storing it in the mean deviation

   * instead.

   */

  t_rttvar_ += (t_srtt_ >> T_SRTT_BITS);

  t_srtt_ = 0;

 }

}

/*

 * headersize:

 *      how big is an IP+TCP header in bytes; include options such as ts

 * this function should be virtual so others (e.g. SACK) can override

 */

int TcpAgent::headersize()  //IP+TCP头大小＝基本头大小＋时间选项大小      

{

        int total = tcpip_base_hdr_size_;

 if (total < 1) {

  fprintf(stderr,

    "TcpAgent(%s): warning: tcpip hdr size is only %d bytes/n",

    name(), tcpip_base_hdr_size_);

 }

 if (ts_option_)

  total += ts_option_size_;

        return (total);

}

//output（）发送单个分组，被send_much、send_one等调用，不直接使用

void TcpAgent::output(int seqno, int reason)     //reason表示重发原因，本端不用，传给对端用    

{

 int force_set_rtx_timer = 0;                        //后面有highest_ack_ == maxseq_时，该值为0

 Packet* p = allocpkt();

 hdr_tcp *tcph = hdr_tcp::access(p);

 hdr_flags* hf = hdr_flags::access(p);

 hdr_ip *iph = hdr_ip::access(p);

 int databytes = hdr_cmn::access(p)->size();    //记录本分组的字节数

 tcph->seqno() = seqno;                                 //当前将发送的分组号

 tcph->ts() = Scheduler::instance().clock();      //记录发送当前分组的时间戳

 int is_retransmit = (seqno < maxseq_);           //当前分组号<以发最大分组号，表示本次是重传该分组

 

 // Mark packet for diagnosis purposes if we are in Quick-Start Phase

 if (qs_approved_) {                                   //不看

  hf->qs() = 1;

 }

 

        // store timestamps, with bugfix_ts_.  From Andrei Gurtov. 

 // (A real TCP would use scoreboard for this.)

        if (bugfix_ts_ && tss==NULL) {              //不看

                tss = (double*) calloc(tss_size_, sizeof(double));

                if (tss==NULL) exit(1);

        }

        //dynamically grow the timestamp array if it's getting full

        if (bugfix_ts_ && window() > tss_size_* 0.9) {         //不看

                double *ntss;

                ntss = (double*) calloc(tss_size_*2, sizeof(double));

                printf("resizing timestamp table/n");

                if (ntss == NULL) exit(1);

                for (int i=0; i<tss_size_; i++)

                        ntss[(highest_ack_ + i) % (tss_size_ * 2)] =

                                tss[(highest_ack_ + i) % tss_size_];

                free(tss);

                tss_size_ *= 2;

                tss = ntss;

        }

 

        if (tss!=NULL)                            //不看

                tss[seqno % tss_size_] = tcph->ts();

tcph->ts_echo() = ts_peer_;           //将对方发送的时间戳返回给对方

 tcph->reason() = reason;              //重发的原因传给对方

 tcph->last_rtt() = int(int(t_rtt_)*tcp_tick_*1000);      //将上次的RTT结果传给对方，以毫秒计，只用于统计

if (ecn_) {                //不看

  hf->ect() = 1; // ECN-capable transport

 }

 if (cong_action_ && (!is_retransmit || SetCWRonRetransmit_)) {   //不看

  hf->cong_action() = TRUE;  

  cong_action_ = FALSE;

        }

 /* Check if this is the initial SYN packet. */

 if (seqno == 0) {              //是否支持第一个分组

  if (syn_) {                    //是第一个分组，且支持SYN

   databytes = 0;         //是SYN分组，则不参加ndatabytes的统计

   curseq_ += 1;         //应用的最大分组数＋1

   hdr_cmn::access(p)->size() = tcpip_base_hdr_size_;

  }

  if (ecn_) {                   //不看

   hf->ecnecho() = 1;

//   hf->cong_action() = 1;

   hf->ect() = 0;

  }

  if (qs_enabled_) {       //不看

   hdr_qs *qsh = hdr_qs::access(p);

// dataout is kilobytes queued for sending

   int dataout = (curseq_ - maxseq_ - 1) * (size_ + headersize()) / 1024;

   int qs_rr = rate_request_;

   if (qs_request_mode_ == 1) {

    // PS: Avoid making unnecessary QS requests

    // use a rough estimation of RTT in qs_rtt_

    // to calculate the desired rate from dataout.

    if (dataout * 1000 / qs_rtt_ < qs_rr) {

     qs_rr = dataout * 1000 / qs_rtt_;

    }

    // qs_thresh_ is minimum number of unsent

    // segments needed to activate QS request

    if ((curseq_ - maxseq_ - 1) < qs_thresh_) {

     qs_rr = 0;

    }

   }

if (qs_rr > 0) {

    // QuickStart code from Srikanth Sundarrajan.

    qsh->flag() = QS_REQUEST;

    qsh->ttl() = Random::integer(256);

    ttl_diff_ = (iph->ttl() - qsh->ttl()) % 256;

    qsh->rate() = hdr_qs::Bps_to_rate(qs_rr * 1024);

    qs_requested_ = 1;

       } else {

    qsh->flag() = QS_DISABLE;

   }

  }

 }

 else if (useHeaders_ == true) {               //不是第一个分组

  hdr_cmn::access(p)->size() += headersize();    //计算分组头大小

 }

        hdr_cmn::access(p)->size();

/* if no outstanding data, be sure to set rtx timer again */

 if (highest_ack_ == maxseq_)           //最高的已确认ACK号＝最大已发分组号，表示已发送的全都得到了确认，

  force_set_rtx_timer = 1;               //该数据肯定为新的未收到ACK的数据，肯定要重新设置重传定时器，原因见后面的“注”

 /* call helper function to fill in additional fields */

 output_helper(p);

++ndatapack_;                          //统计总的发送分组数

        ndatabytes_ += databytes;         //统计总发送字节数

 send(p, 0);                                   //发送该分组

 if (seqno == curseq_ && seqno > maxseq_)      //发送序号＝最大允许发送序号，表示已发完

  idle();  // 告诉应用程序已经发完数据         Tell application I have sent everything so far

 if (seqno > maxseq_) {           //发送序号>上次最大发送序号，表示是新发送分组

  maxseq_ = seqno;             //新发送分组，记录最大发送序号

  if (!rtt_active_) {                //如果上一个RTT样本刚刚收到，rtt_active=1表示正在等待RTT接收样本ACK返回

   rtt_active_ = 1;              //表示本分组是新的RTT样本,rtt开始新的计算

   if (seqno > rtt_seq_) {    //若发送序号>上次RTT样本号

    rtt_seq_ = seqno;       //则本序号是新的RTT样本

    rtt_ts_ = Scheduler::instance().clock();    //且记录该样本的发送时间戳

   }

     

  }

 } else {     //不是新分组了，则是重传

         ++nrexmitpack_;     //统计重传分组数

  nrexmitbytes_ += databytes;   //统计重传字节数

 }

 if (!(rtx_timer_.status() == TIMER_PENDING) || force_set_rtx_timer) 

                   /*TIMER_PENDING表示超时重传定时器在等待状态，即对定时器定时的分组号尚未收到ACK，

                  若该分组的ACK刚刚收到，或在强制重传定时器的情况时，对重传定时器重新设定超时 */

  /* No timer pending.  Schedule one. */

  set_rtx_timer();

}

/* 

         注：重传定时的原理：只设定一个重传定时器，对每一个发送的分组号，设为A，

设为检查定时器是否已经在用，若没有用，则设定该定时器，此时该定时器对应该分组号；

若在用，则不修改，继续传该分组。

        当收到对方对分组A的确认ACK，则将重新设定定时器，到下一个分组号A+1，此时定时器对应A+1分组；

以后，每收到一个新确认，都将定时器对应到该分组号+1。即每次都对第一个未被确认的分组进行监控，

 保证此分组一旦得不到确认就超时。           

  */

/*

 * Must convert bytes into packets for one-way TCPs.

 * If nbytes == -1, this corresponds to infinite send.  We approximate

 * infinite by a very large number (TCP_MAXSEQ).

 */

 //该程序由上层应用调用，用来产生TCP流，完成tcp连接、传输、结束全过程，而不用管数据具体怎么传输

void TcpAgent::sendmsg(int nbytes, const char* /*flags*/)      //若nbyte=-1,表示发送允许的无限多数据

{

 if (nbytes == -1 && curseq_ <= TCP_MAXSEQ)             //若无限发送，则确定发送的最大数据量

  curseq_ = TCP_MAXSEQ; 

 else

  curseq_ += (nbytes/size_ + (nbytes%size_ ? 1 : 0));  //有限发送，则按字节数计算将发送的总的序列数

 send_much(0, 0, maxburst_);              //尽量发送多的数据，直到发送完或连接终止，maxburst_是最大允许发送的数值，默认值0，表示不限数量

}

void TcpAgent::advanceby(int delta)

{

  curseq_ += delta;

 if (delta > 0)

  closed_ = 0;

 send_much(0, 0, maxburst_); 

}

int TcpAgent::command(int argc, const char*const* argv)

{

 if (argc == 3) {

  if (strcmp(argv[1], "advance") == 0) {

   int newseq = atoi(argv[2]);

   if (newseq > maxseq_)

    advanceby(newseq - curseq_);

   else

    advanceby(maxseq_ - curseq_);

   return (TCL_OK);

  }

  if (strcmp(argv[1], "advanceby") == 0) {

   advanceby(atoi(argv[2]));

   return (TCL_OK);

  }

  if (strcmp(argv[1], "eventtrace") == 0) {

   et_ = (EventTrace *)TclObject::lookup(argv[2]);

   return (TCL_OK);

  }

  /*

   * Curtis Villamizar's trick to transfer tcp connection

   * parameters to emulate http persistent connections.

   *

   * Another way to do the same thing is to open one tcp

   * object and use start/stop/maxpkts_ or advanceby to control

   * how much data is sent in each burst.

   * With a single connection, slow_start_restart_

   * should be configured as desired.

   *

   * This implementation (persist) may not correctly

   * emulate pure-BSD-based systems which close cwnd

   * after the connection goes idle (slow-start

   * restart).  See appendix C in

   * Jacobson and Karels ``Congestion

   * Avoidance and Control'' at

   * <ftp://ftp.ee.lbl.gov/papers/congavoid.ps.Z>

   * (*not* the original

   * '88 paper) for why BSD does this.  See

   * ``Performance Interactions Between P-HTTP and TCP

   * Implementations'' in CCR 27(2) for descriptions of

   * what other systems do the same.

   *

   */

  if (strcmp(argv[1], "persist") == 0) {

   TcpAgent *other

     = (TcpAgent*)TclObject::lookup(argv[2]);

   cwnd_ = other->cwnd_;

   awnd_ = other->awnd_;

   ssthresh_ = other->ssthresh_;

   t_rtt_ = other->t_rtt_;

   t_srtt_ = other->t_srtt_;

   t_rttvar_ = other->t_rttvar_;

   t_backoff_ = other->t_backoff_;

   return (TCL_OK);

  }

 }

 return (Agent::command(argc, argv));

}

/*

 * Returns the window size adjusted to allow <num> segments past recovery

 * point to be transmitted on next ack.

 */

int TcpAgent::force_wnd(int num)

{

 return recover_ + num - (int)highest_ack_;

}

//整数型的发送窗口，发送窗口＝min(wnd_,cwnd_)

int TcpAgent::window()

{

        /*

         * If F-RTO is enabled and first ack has come in, temporarily open

         * window for sending two segments.

  * The F-RTO code is from Pasi Sarolahti.  F-RTO is an algorithm

  * for detecting spurious retransmission timeouts.

         */

        if (frto_ == 2) {

                return (force_wnd(2) < wnd_ ?

                        force_wnd(2) : (int)wnd_);

        } else {

  return (cwnd_ < wnd_ ? (int)cwnd_ : (int)wnd_);

        }

}

//双精度的发送窗口，发送窗口＝min(wnd_,cwnd_)

double TcpAgent::windowd()

{

 return (cwnd_ < wnd_ ? (double)cwnd_ : (double)wnd_);

}

/*被recv(),timeout(),timeout_nonrtx(),sendmsg()等调用

 * Try to send as much data as the window will allow.  The link layer will 

 * do the buffering; we ask the application layer for the size of the packets.

 */

void TcpAgent::send_much(int force, int reason, int maxburst)   

 //在窗口范围内把尽量多的数据发出去，完成连接、传输、结束全过程

{

 send_idle_helper();

 int win = window();                   //整型的发送窗口

 int npackets = 0;                     // 本次发送分组数

if (!force && delsnd_timer_.status() == TIMER_PENDING) //通常force＝0，在处理非重传的超时时为1

  /*非重传超时，即延迟随机时间发送数据，用于模拟网络的延迟，由timeout_nonrtx()调用，再被DelSndTimer::expire()调用

          这里表示如果不是非重传超时，但延迟定时器还在工作，就不发送，直接退出  */

  return;

 /* Save time when first packet was sent, for newreno  --Allman */

 if (t_seqno_ == 0)

  firstsent_ = Scheduler::instance().clock();   //记录第一个分组发送时间，newreno用

  

 if (burstsnd_timer_.status() == TIMER_PENDING)       //？

  return;

 while (t_seqno_ <= highest_ack_ + win && t_seqno_ < curseq_) {     

        //分组号在发送窗口内，且小于最大分组号，即满足条件就尽量发送，不满足条件才退出

  if (overhead_ == 0 || force || qs_approved_) {  

          //overhead是固定值，默认0;force＝1，即非重传超时；qs，即快启动

          //只要是正常情况，或非重传超时，或快启动，就按下面运行

   output(t_seqno_, reason);    //发送该分组，原因发到对端

   npackets++;       //已发送分组数记录

   if (QOption_)

    process_qoption_after_send () ; 

   t_seqno_ ++ ;     //将要发送分组号＋1

   if (qs_approved_ == 1) {

    // delay = effective RTT / window

    double delay = (double) t_rtt_ * tcp_tick_ / win;

    if (overhead_) { 

     delsnd_timer_.resched(delay + Random::uniform(overhead_));

    } else {

     delsnd_timer_.resched(delay);

    }

    return;

   }

  } else if (!(delsnd_timer_.status() == TIMER_PENDING)) {   

   //不是上面的三种情况，但延迟定时器没有等待了，就重新设置随机延迟时间，并返回

   /*

    * Set a delayed send timeout.

    */

   delsnd_timer_.resched(Random::uniform(overhead_));

   return;

  }

  win = window();    //发送了一个分组，发送窗口重新计算

  if (maxburst && npackets == maxburst)   //maxburst是一次最多发送的分组数，默认为0，表示不限制数量

   break;

 }

 /* call helper function */

 send_helper(maxburst);

}

/*主要在timeout()、dupack_action()中使用

 * We got a timeout or too many duplicate acks.  Clear the retransmit timer.  

 * Resume the sequence one past the last packet acked.  

 * "mild" is 0 for timeouts and Tahoe dup acks, 1 for Reno dup acks.

 * "backoff" is 1 if the timer should be backed off, 0 otherwise.

 */

void TcpAgent::reset_rtx_timer(int mild, int backoff)

{

 if (backoff)           //重传时，backoff=1,见timeout(),表示要对RTO做出调整，RTO=RTO*2

  rtt_backoff();

 set_rtx_timer();       //根据调整

 if (!mild)               //程序只用到了mild=0的情况，RENO用到mild=1的情况

  t_seqno_ = highest_ack_ + 1;

 rtt_active_ = 0;

}

/*

 * Set retransmit timer using current rtt estimate.  By calling resched(), 

 * it does not matter whether the timer was already running.

 */

void TcpAgent::set_rtx_timer()

{

 rtx_timer_.resched(rtt_timeout());

}

/*只被newack()调用，用来设置重传定时器，pkt是接收到的ACK分组

 * Set new retransmission timer if not all outstanding

 * or available data acked, or if we are unable to send because 

 * cwnd is less than one (as when the ECN bit is set when cwnd was 1).

 * Otherwise, if a timer is still outstanding, cancel it.

 */

void TcpAgent::newtimer(Packet* pkt)

{

 hdr_tcp *tcph = hdr_tcp::access(pkt);

 /*

  * t_seqno_, the next packet to send, is reset (decreased) 

  *   to highest_ack_ + 1 after a timeout,

  *   so we also have to check maxseq_, the highest seqno sent.

  * In addition, if the packet sent after the timeout has

  *   the ECN bit set, then the returning ACK caused cwnd_ to

  *   be decreased to less than one, and we can't send another

  *   packet until the retransmit timer again expires.

  *   So we have to check for "cwnd_ < 1" as well.

  */

  //当前将发送序号>本次接收ack号

 if (t_seqno_ > tcph->seqno() || tcph->seqno() < maxseq_ || cwnd_ < 1) 

  set_rtx_timer();

 else

  cancel_rtx_timer();       //程序中没有该子程序

}

/*

 * for experimental, high-speed TCP

 */

double TcpAgent::linear(double x, double x_1, double y_1, double x_2, double y_2)

{

 // The y coordinate factor ranges from y_1 to y_2

 //  as the x coordinate ranges from x_1 to x_2.

 double y = y_1 + ((y_2 - y_1) * ((x - x_1)/(x_2-x_1)));

 return y;

}

/*

 * Limited Slow-Start for large congestion windows.

 * This is only used when max_ssthresh_ is non-zero.

 */

double TcpAgent::limited_slow_start(double cwnd, double max_ssthresh, double increment)

{

 int round = int(cwnd / (double(max_ssthresh)/2.0));

 double increment1 = 1.0/(double(round)); 

 if (increment < increment1)

  increment = increment1;

 return increment;

}

/*

 * For retrieving numdupacks_.

 */

int TcpAgent::numdupacks(double cwnd)

{

        int cwndfraction = (int) cwnd/numdupacksFrac_;

 if (numdupacks_ > cwndfraction) {

    return numdupacks_;

        } else {

    return cwndfraction;

 }

}

/*

 * Calculating the decrease parameter for highspeed TCP.

 */

double TcpAgent::decrease_param()

{

 double decrease;

 // OLD:

 // decrease = linear(log(cwnd_), log(low_window_), 0.5, log(high_window_), high_decrease_);

 // NEW (but equivalent):

        decrease = hstcp_.dec1 + log(cwnd_) * hstcp_.dec2;  

 return decrease;

}

/*

 * Calculating the increase parameter for highspeed TCP.

 */

double TcpAgent::increase_param()

{

 double increase, decrease, p, answer;

 /* extending the slow-start for high-speed TCP */

/* for highspeed TCP -- from Sylvia Ratnasamy, */

 /* modifications by Sally Floyd and Evandro de Souza */

  // p ranges from 1.5/W^2 at congestion window low_window_, to

 //    high_p_ at congestion window high_window_, on a log-log scale.

        // The decrease factor ranges from 0.5 to high_decrease

 //  as the window ranges from low_window to high_window, 

 //  as the log of the window. 

 // For an efficient implementation, this would just be looked up

 //   in a table, with the increase and decrease being a function of the

 //   congestion window.

if (cwnd_ <= low_window_) { 

  answer = 1 / cwnd_;

         return answer; 

       } else if (cwnd_ >= hstcp_.cwnd_last_ && 

       cwnd_ < hstcp_.cwnd_last_ + cwnd_range_) {

       // cwnd_range_ can be set to 0 to be disabled,

       //  or can be set from 1 to 100 

         answer = hstcp_.increase_last_ / cwnd_;

               return answer;

       } else { 

  // OLD:

   // p = exp(linear(log(cwnd_), log(low_window_), log(hstcp_.low_p), log(high_window_), log(high_p_)));

  // NEW, but equivalent:

         p = exp(hstcp_.p1 + log(cwnd_) * hstcp_.p2);  

         decrease = decrease_param();

  // OLD:

  // increase = cwnd_*cwnd_*p *(2.0*decrease)/(2.0 - decrease); 

  // NEW, but equivalent:

  increase = cwnd_ * cwnd_ * p /(1/decrease - 0.5);

  // if (increase > max_increase) { 

  //  increase = max_increase;

  // } 

  answer = increase / cwnd_;

  hstcp_.cwnd_last_ = cwnd_;

  hstcp_.increase_last_ = increase;

         return answer;

 }       

}

/*仅被recv_newack_helper()调用，再被recv调用，在收到新ACK后，用于慢启动和拥塞避免，调整CWND，不调整SSTHRESH

 * open up the congestion window

 */

void TcpAgent::opencwnd()

{

 double increment;

 if (cwnd_ < ssthresh_) {     //慢启动情况，CWND=CWND+1,数据指数增加

  /* slow-start (exponential) */

  cwnd_ += 1;

 } else {      //cwnd_>=ssthresh_情况，CWND=CWND+1/CWND,数据线性增加

  /* linear */

  double f;

  switch (wnd_option_) {      //wnd_option_是窗口策略，系统固定设置，默认为1

  case 0:

   if (++count_ >= cwnd_) {

    count_ = 0;

    ++cwnd_;

   }

   break;

case 1:                               //默认情况，其他的情况不用看

   /* This is the standard algorithm. */

   increment = increase_num_ / cwnd_; //increase_num_：加法增策略因子，默认1.0

                         //算出增加量1/CWND

   if ((last_cwnd_action_ == 0 ||         //last_cwnd_action_初始化为0

     last_cwnd_action_ == CWND_ACTION_TIMEOUT) 

     && max_ssthresh_ > 0) {

    increment = limited_slow_start(cwnd_,

      max_ssthresh_, increment);

   }

   cwnd_ += increment;

   break;

case 2:

   /* These are window increase algorithms

    * for experimental purposes only. */

   /* This is the Constant-Rate increase algorithm 

                         *  from the 1991 paper by S. Floyd on "Connections  

    *  with Multiple Congested Gateways". 

    *  The window is increased by roughly 

    *  wnd_const_*RTT^2 packets per round-trip time.  */

   f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;

   f *= f;

   f *= wnd_const_;

   /* f = wnd_const_ * RTT^2 */

   f += fcnt_;

   if (f > cwnd_) {

    fcnt_ = 0;

    ++cwnd_;

   } else

    fcnt_ = f;

   break;

case 3:

   /* The window is increased by roughly 

    *  awnd_^2 * wnd_const_ packets per RTT,

    *  for awnd_ the average congestion window. */

   f = awnd_;

   f *= f;

   f *= wnd_const_;

   f += fcnt_;

   if (f > cwnd_) {

    fcnt_ = 0;

    ++cwnd_;

   } else

    fcnt_ = f;

   break;

case 4:

   /* The window is increased by roughly 

    *  awnd_ * wnd_const_ packets per RTT,

    *  for awnd_ the average congestion window. */

                        f = awnd_;

                        f *= wnd_const_;

                        f += fcnt_;

                        if (f > cwnd_) {

                                fcnt_ = 0;

                                ++cwnd_;

                        } else

                                fcnt_ = f;

                        break;

  case 5:

   /* The window is increased by roughly wnd_const_*RTT 

    *  packets per round-trip time, as discussed in

    *  the 1992 paper by S. Floyd on "On Traffic 

    *  Phase Effects in Packet-Switched Gateways". */

                        f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;

                        f *= wnd_const_;

                        f += fcnt_;

                        if (f > cwnd_) {

                                fcnt_ = 0;

                                ++cwnd_;

                        } else

                                fcnt_ = f;

                        break;

                case 6:

                        /* binomial controls */ 

                        cwnd_ += increase_num_ / (cwnd_*pow(cwnd_,k_parameter_));                

                        break; 

   case 8: 

   /* high-speed TCP, RFC 3649 */

   increment = increase_param();

   if ((last_cwnd_action_ == 0 ||

     last_cwnd_action_ == CWND_ACTION_TIMEOUT) 

     && max_ssthresh_ > 0) {

    increment = limited_slow_start(cwnd_,

      max_ssthresh_, increment);

   }

   cwnd_ += increment;

                        break;

  default:

#ifdef notdef

   /*XXX*/

   error("illegal window option %d", wnd_option_);

#endif

   abort();

  }

 }

 // if maxcwnd_ is set (nonzero), make it the cwnd limit

 if (maxcwnd_ && (int(cwnd_) > maxcwnd_))    //限制CWND,不能超过最大值，最大值默认为0，表示不限制

  cwnd_ = maxcwnd_;

return;

}

//被timeout、dupack_action等调用，用来降低拥塞窗口CWND和门限SSTHRESH

void

TcpAgent::slowdown(int how)

{

 double decrease;  /* added for highspeed - sylvia */

 double win, halfwin, decreasewin;

 int slowstart = 0;    //慢启动参数，＝1表示是慢启动

 ++ncwndcuts_;        //统计CWND被减少的次数，不管任何原因

 if (!(how & TCP_IDLE) && !(how & NO_OUTSTANDING_DATA)){

  ++ncwndcuts1_;  //统计因拥塞CWND被减少的次数

 }

 // we are in slowstart for sure if cwnd < ssthresh

 if (cwnd_ < ssthresh_)      //判断是否在慢启动状态

  slowstart = 1;

//下面一段分别按双精度和整型计算出发送窗口WND

        if (precision_reduce_) {           //是否按双精度计算发送窗口win，而不是整数减，默认为FALSE

  halfwin = windowd() / 2;

                if (wnd_option_ == 6) {        //wnd_option_值见opencwnd()，默认＝1， ＝6或8不用看

                        /* binomial controls */

                        decreasewin = windowd() - (1.0-decrease_num_)*pow(windowd(),l_parameter_);

                } else if (wnd_option_ == 8 && (cwnd_ > low_window_)) { 

                        /* experimental highspeed TCP */

   decrease = decrease_param();

   //if (decrease < 0.1) 

   // decrease = 0.1;

   decrease_num_ = decrease;

                        decreasewin = windowd() - (decrease * windowd());

                } else {                 //wnd_option_＝1到5的情况，＝1是默认情况，见opencwnd()

    decreasewin = decrease_num_ * windowd(); //decreasewin为窗口减少量

  }

  win = windowd();     //双精度发送窗口

 } else  {            //默认情况，按整数计算发送窗口win，算法同上面一样

  int temp;

  temp = (int)(window() / 2);

  halfwin = (double) temp;

                if (wnd_option_ == 6) {

                        /* binomial controls */

                        temp = (int)(window() - (1.0-decrease_num_)*pow(window(),l_parameter_));

                } else if ((wnd_option_ == 8) && (cwnd_ > low_window_)) { 

                        /* experimental highspeed TCP */

   decrease = decrease_param();

   //if (decrease < 0.1)

                        //       decrease = 0.1;  

   decrease_num_ = decrease;

                        temp = (int)(windowd() - (decrease * windowd()));

                } else {

    temp = (int)(decrease_num_ * window());

  }

  decreasewin = (double) temp;

  win = (double) window();    //整型发送窗口

 }

 

//以下按照HOW的值，针对各种情况，减少CWND和SSTHRESH 

 if (how & CLOSE_SSTHRESH_HALF)

  // For the first decrease, decrease by half

  // even for non-standard values of decrease_num_.

  if (first_decrease_ == 1 || slowstart ||              //在第一次减少，慢启动状态或超时重传时（为何第一次减少时一定要SSTHRESH减半？）

   last_cwnd_action_ == CWND_ACTION_TIMEOUT) {   //SSTHRESH降低到一半，wnd_option_＝默认1时，下面两种算法应该一样

                                          //正常应该CWND=decreasewin

   // Do we really want halfwin instead of decreasewin

  // after a timeout?

   ssthresh_ = (int) halfwin;

  } else {

   ssthresh_ = (int) decreasewin;                //即:SSTHRESH=CWND

  }

        else if (how & THREE_QUARTER_SSTHRESH)        //SSTHRESH减少到3/4窗口

  if (ssthresh_ < 3*cwnd_/4)

   ssthresh_  = (int)(3*cwnd_/4);

 if (how & CLOSE_CWND_HALF)                     //CWND减少一半

  // For the first decrease, decrease by half

  // even for non-standard values of decrease_num_.

  if (first_decrease_ == 1 || slowstart || decrease_num_ == 0.5) {

   cwnd_ = halfwin;

  } else cwnd_ = decreasewin;   //如果设decreasewin为其他值，则是用于测试

        else if (how & CWND_HALF_WITH_MIN) {           //QOPTION,不看

  // We have not thought about how non-standard TCPs, with

  // non-standard values of decrease_num_, should respond

  // after quiescent periods.

                cwnd_ = decreasewin;

                if (cwnd_ < 1)

                        cwnd_ = 1;

 }

 else if (how & CLOSE_CWND_RESTART)         //超时时使SSTHRESH减半，CWND＝1

  cwnd_ = int(wnd_restart_);         //wnd_restart_初始化为1

 else if (how & CLOSE_CWND_INIT)         //快速启动丢失时使用，不看

  cwnd_ = int(wnd_init_);

 else if (how & CLOSE_CWND_ONE)       //无显著数据，重复ACK，及F-RTO时使 CWND=1

  cwnd_ = 1;

 else if (how & CLOSE_CWND_HALF_WAY) {  //QOPTION时使用，不看

  // cwnd_ = win - (win - W_used)/2 ;

  cwnd_ = W_used + decrease_num_ * (win - W_used);

                if (cwnd_ < 1)

                        cwnd_ = 1;

 }

 if (ssthresh_ < 2)                 //SSTHRESH不能小于2

  ssthresh_ = 2;           

 if (how & (CLOSE_CWND_HALF|CLOSE_CWND_RESTART|CLOSE_CWND_INIT|CLOSE_CWND_ONE))

  cong_action_ = TRUE;        //根据HOW判断当前是否拥塞

fcnt_ = count_ = 0;                //用于wnd_option_＝2，3，4，5的情况，不看

 if (first_decrease_ == 1)          //本次是第一次减少,下次就不是了：每次连接只有一次减少

  first_decrease_ = 0;

 // for event tracing slow start

 if (cwnd_ == 1 || slowstart)        //跟踪慢启动

  // Not sure if this is best way to capture slow_start

  // This is probably tracing a superset of slowdowns of

  // which all may not be slow_start's --Padma, 07/'01.

  trace_event("SLOW_START");

}

/*被recv_newack_helper()调用，recv_newack_helper再被recv()调用，pkt为接收ACK分组

 * Process a packet that acks previously unacknowleged data.

 */

void TcpAgent::newack(Packet* pkt)

{

 double now = Scheduler::instance().clock();

 hdr_tcp *tcph = hdr_tcp::access(pkt);

 /* 

  * Wouldn't it be better to set the timer *after*

  * updating the RTT, instead of *before*? 

  */

 if (!timerfix_) newtimer(pkt);      //采用在更新RTT以前更新RTO定时器的策略

 dupacks_ = 0;                  //新ACK，将重复ACK的统计恢复为0

 last_ack_ = tcph->seqno();    // 记录本次新ACK号到last_ack_

 prev_highest_ack_ = highest_ack_ ; 

 highest_ack_ = last_ack_;     //记录本次新ACK号到last_ack_

if (t_seqno_ < last_ack_ + 1)     // 更新下一次要发送的包的记录

  t_seqno_ = last_ack_ + 1;      

 /* 

  * Update RTT only if it's OK to do so from info in the flags header.

  * This is needed for protocols in which intermediate agents

  * in the network intersperse acks (e.g., ack-reconstructors) for

  * various reasons (without violating e2e semantics).

  */ 

 hdr_flags *fh = hdr_flags::access(pkt);      

       //以下是有时间戳的RTT处理情况           

 if (!fh->no_ts_) {                                        //该ACK有时间戳

  if (ts_option_) {                                 //本连接可以采用时间戳

   ts_echo_=tcph->ts_echo();                 //记录该新ACK的回应时间，相当于rtt_ts_

   rtt_update(now - tcph->ts_echo());        //更新RTT值，now-回应时间即为rtt时间

   if (ts_resetRTO_ && (!ect_ || !ecn_backoff_ ||

       !hdr_flags::access(pkt)->ecnecho())) { 

    // From Andrei Gurtov

    /* 

     * Don't end backoff if still in ECN-Echo with

      * a congestion window of 1 packet. 

     */

    t_backoff_ = 1;

    ecn_backoff_ = 0;

   }

  }

  if (rtt_active_ && tcph->seqno() >= rtt_seq_) {

   if (!ect_ || !ecn_backoff_ || 

    !hdr_flags::access(pkt)->ecnecho()) {

    /* 

     * Don't end backoff if still in ECN-Echo with

      * a congestion window of 1 packet. 

     */

    t_backoff_ = 1;

    ecn_backoff_ = 0;

   }

   rtt_active_ = 0;

   if (!ts_option_)                          //本连接不能采用时间戳

    rtt_update(now - rtt_ts_);

  }

 }

              

 if (timerfix_) newtimer(pkt);            //采用在更新RTT以前更新RTO定时器的策略，更科学

 /* update average window */       //更新平均窗口awnd_=(1 - wnd_th_)*awnd+wnd_th_*cwnd

 awnd_ *= 1.0 - wnd_th_;

 awnd_ += wnd_th_ * cwnd_;

}

/*

 * Respond either to a source quench or to a congestion indication bit.

 * This is done at most once a roundtrip time;  after a source quench,

 * another one will not be done until the last packet transmitted before

 * the previous source quench has been ACKed.

 *

 * Note that this procedure is called before "highest_ack_" is

 * updated to reflect the current ACK packet.  

 */

void TcpAgent::ecn(int seqno)

{

 if (seqno > recover_ || 

       last_cwnd_action_ == CWND_ACTION_TIMEOUT) {

  recover_ =  maxseq_;

  last_cwnd_action_ = CWND_ACTION_ECN;

  if (cwnd_ <= 1.0) {

   if (ecn_backoff_) 

    rtt_backoff();

   else ecn_backoff_ = 1;

  } else ecn_backoff_ = 0;

  slowdown(CLOSE_CWND_HALF|CLOSE_SSTHRESH_HALF);

  ++necnresponses_ ;

  // added by sylvia to count number of ecn responses 

 }

}

/*

 *  Is the connection limited by the network (instead of by a lack

 *    of data from the application?

 */

int TcpAgent::network_limited() {

 int win = window () ;

 if (t_seqno_ > (prev_highest_ack_ + win))

  return 1;

 else

  return 0;

}

//由recv()调用，收到新ACK的情况，用于新ack处理（newack(pkt)），及cwnd设置，关闭连接等处理

void TcpAgent::recv_newack_helper(Packet *pkt) {

 //hdr_tcp *tcph = hdr_tcp::access(pkt);

 newack(pkt);                                                  //新ACK处理

        if (qs_window_ && highest_ack_ >= qs_window_) {                     //QS处理，不用看

                // All segments in the QS window have been acknowledged.

                // We can exit the Quick-Start phase.

                qs_window_ = 0;

        }

 if (!ect_ || !hdr_flags::access(pkt)->ecnecho() ||        //不是ECN分组，或"old ecn"。正常的新分组

  (old_ecn_ && ecn_burst_)) {

  /* If "old_ecn", this is not the first ACK carrying ECN-Echo

   * after a period of ACKs without ECN-Echo.

   * Therefore, open the congestion window. */

  /* if control option is set, and the sender is not

    window limited, then do not increase the window size 

   control_increase_设为1，则发方窗口不受限，不用增加窗口大小？

    */

  

  if (!control_increase_ ||                 //control_increase_系统固定值，默认为0

     (control_increase_ && (network_limited() == 1))) 

         opencwnd();            //正常情况，收到新ACK，就打开CWND设置

 }

 if (ect_) {                                              //是ECN分组

  if (!hdr_flags::access(pkt)->ecnecho())

   ecn_backoff_ = 0;

  if (!ecn_burst_ && hdr_flags::access(pkt)->ecnecho())

   ecn_burst_ = TRUE;

  else if (ecn_burst_ && ! hdr_flags::access(pkt)->ecnecho())

   ecn_burst_ = FALSE;

 }

 if (!ect_ && hdr_flags::access(pkt)->ecnecho() &&

  !hdr_flags::access(pkt)->cong_action())

  ect_ = 1;

 /* if the connection is done, call finish() */

 if ((highest_ack_ >= curseq_-1) && !closed_) {      //最大ACK>=应用程序最大值-1，表示连接结束

  closed_ = 1;          //关闭连接，运行finish();                      

  finish();

 }

 if (QOption_ && curseq_ == highest_ack_ +1) {     //不看

  cancel_rtx_timer();

 }

 if (frto_ == 1) {                              

  /*

   * New ack after RTO. If F-RTO is enabled, try to transmit new

   * previously unsent segments.

   * If there are no new data or receiver window limits the

   * transmission, revert to traditional recovery.

   */

  if (recover_ + 1 >= highest_ack_ + wnd_ ||

      recover_ + 1 >= curseq_) {

   frto_ = 0;

   } else if (highest_ack_ == recover_) {

    /*

     * F-RTO step 2a) RTO retransmission fixes whole

    * window => cancel F-RTO

     */

    frto_ = 0;

  } else {

   t_seqno_ = recover_ + 1;

   frto_ = 2;

  }

 } else if (frto_ == 2) {

  /*

   * Second new ack after RTO. If F-RTO is enabled, RTO can be

   * declared spurious

   */

  spurious_timeout();

 }

}

/*

 * Set the initial window. 

 */

double

TcpAgent::initial_window()

{

        // If Quick-Start Request was approved, use that as a basis for

        // initial window

        if (qs_cwnd_) {

                return (qs_cwnd_);

        }

 //

 // init_option = 1: static iw of wnd_init_

 //

 if (wnd_init_option_ == 1) {    //使用默认初始启动窗口

  return (wnd_init_);

 }

        else if (wnd_init_option_ == 2) {  //使用大的初始启动窗口

  // do iw according to Internet draft

   if (size_ <= 1095) {        //根据分组数据大小分段

   return (4.0);

   } else if (size_ < 2190) {

   return (3.0);

  } else {

   return (2.0);

  }

 }

 // XXX what should we return here???

 fprintf(stderr, "Wrong number of wnd_init_option_ %d/n", 

  wnd_init_option_);

 abort();

 return (2.0); // XXX make msvc happy.

}

/*

 * Dupack-action: what to do on a DUP ACK.  After the initial check

 * of 'recover' below, this function implements the following truth

 * table:

 *

 * bugfix ecn last-cwnd == ecn action

 *

 * 0 0 0   tahoe_action

 * 0 0 1   tahoe_action [impossible]

 * 0 1 0   tahoe_action

 * 0 1 1   slow-start, return

 * 1 0 0   nothing

 * 1 0 1   nothing  [impossible]

 * 1 1 0   nothing

 * 1 1 1   slow-start, return

 */

/* 

 * A first or second duplicate acknowledgement has arrived, and

 * singledup_ is enabled.

 * If the receiver's advertised window permits, and we are exceeding our

 * congestion window by less than numdupacks_, then send a new packet.

 */

//发送单个分组，可以是重传分组

void

TcpAgent::send_one()

{

 if (t_seqno_ <= highest_ack_ + wnd_ && t_seqno_ < curseq_ &&

  t_seqno_ <= highest_ack_ + cwnd_ + dupacks_ ) {

  output(t_seqno_, 0);  //

  if (QOption_)

   process_qoption_after_send () ;

  t_seqno_ ++ ;

  // send_helper(); ??

 }

 return;

}

//在recv()中，满足了快速重传的条件后调用，用于减少CWND和SSTHRESH,并重启重传定时器

void

TcpAgent::dupack_action()    

{

 int recovered = (highest_ack_ > recover_);  

             //recover_用于记录超时和快速重传前已发送分组的最大序号,用于F-RTO

 if (recovered || (!bug_fix_ && !ecn_)) {

  goto tahoe_action;                      //跳到tahoe_action

 }

if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {        //不看

  last_cwnd_action_ = CWND_ACTION_DUPACK;

  slowdown(CLOSE_CWND_ONE);

  reset_rtx_timer(0,0);

  return;

 }

if (bug_fix_) {

  /*

   * The line below, for "bug_fix_" true, avoids

   * problems with multiple fast retransmits in one

   * window of data. 

   */

  return;

 }

tahoe_action:                                     //tcp tahoe

        recover_ = maxseq_;                  //记录超时和快速重传前已发送分组的最大序号

        if (!lossQuickStart()) {                //

  // we are now going to fast-retransmit and willtrace that event

  trace_event("FAST_RETX");         //跟踪快速重传

  last_cwnd_action_ = CWND_ACTION_DUPACK;    //记录本次快速重传

  slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_ONE);    //SSTHRESH减半，CWND＝1

 }

 reset_rtx_timer(0,0);              //重设重传定时器

 return;

}

/*

 * When exiting QuickStart, reduce the congestion window to the

 *   size that was actually used.

 */

void TcpAgent::endQuickStart()

{

 qs_approved_ = 0;

        qs_cwnd_ = 0;

        qs_window_ = maxseq_;

 int new_cwnd = maxseq_ - last_ack_;

 if (new_cwnd > 1 && new_cwnd < cwnd_) {

   cwnd_ = new_cwnd;

  if (cwnd_ < initial_window()) 

   cwnd_ = initial_window();

 }

}

void TcpAgent::processQuickStart(Packet *pkt)

{

 // QuickStart code from Srikanth Sundarrajan.

 hdr_tcp *tcph = hdr_tcp::access(pkt);

 hdr_qs *qsh = hdr_qs::access(pkt);

 double now = Scheduler::instance().clock();

 int app_rate;

// printf("flag: %d ttl: %d ttl_diff: %d rate: %d/n", qsh->flag(),

 //     qsh->ttl(), ttl_diff_, qsh->rate());

 qs_requested_ = 0;

 qs_approved_ = 0;

 if (qsh->flag() == QS_RESPONSE && qsh->ttl() == ttl_diff_ && 

            qsh->rate() > 0) {

                app_rate = (int) (hdr_qs::rate_to_Bps(qsh->rate()) *

                      (now - tcph->ts_echo()) / (size_ + headersize()));

#ifdef QS_DEBUG

  printf("Quick Start approved, rate %d, window %d/n", 

         qsh->rate(), app_rate);

#endif

                if (app_rate > initial_window()) {

   qs_cwnd_ = app_rate;

                        qs_approved_ = 1;

                }

        } else { // Quick Start rejected

#ifdef QS_DEBUG

                printf("Quick Start rejected/n");

#endif

        }

}

/*

 * ACK has been received, hook from recv()

 */

void TcpAgent::recv_frto_helper(Packet *pkt)

{

 hdr_tcp *tcph = hdr_tcp::access(pkt);

 if (tcph->seqno() == last_ack_ && frto_ != 0) {

  /*

   * Duplicate ACK while in F-RTO indicates that the

   * timeout was valid. Go to slow start retransmissions.

   */

  t_seqno_ = highest_ack_ + 1;

  cwnd_ = frto_;

  frto_ = 0;

// Must zero dupacks (in order to trigger send_much at recv)

  // dupacks is increased in recv after exiting this function

  dupacks_ = -1;

 }

}

/*

 * A spurious timeout has been detected. Do appropriate actions.

 */

void TcpAgent::spurious_timeout()

{

 frto_ = 0;

switch (spurious_response_) {

 case 1:

 default:

  /*

   * Full revert of congestion window

   * (FlightSize before last acknowledgment)

   */

  cwnd_ = t_seqno_ - prev_highest_ack_;

  break;

 

 case 2:

  /*

   * cwnd = reduced ssthresh (approx. half of the earlier pipe)

   */

  cwnd_ = ssthresh_; break;

 case 3:

  /*

   * slow start, but without retransmissions

   */

  cwnd_ = 1; break;

 }

/*

  * Revert ssthresh to size before retransmission timeout

  */

 ssthresh_ = pipe_prev_;

/* If timeout was spurious, bugfix is not needed */

 recover_ = highest_ack_ - 1;

}

/*

 * Loss occurred in Quick-Start window.

 * If Quick-Start is enabled, packet loss in the QS phase should

 * trigger slow start instead of the regular fast retransmit,

 * see [draft-amit-quick-start-03.txt] (to appear).

 * We use variable tcp_qs_recovery_ to toggle this behaviour on and off.

 * If tcp_qs_recovery_ is true, initiate slow start to probe for

 * a correct window size.

 *

 * Return value: non-zero if Quick-Start specific loss recovery took place

 */

int TcpAgent::lossQuickStart()

{

       if (qs_window_ && tcp_qs_recovery_) {

                //recover_ = maxseq_;

                //reset_rtx_timer(1,0);

                slowdown(CLOSE_CWND_INIT);

  // reset ssthresh to half of W-D/2?

                qs_window_ = 0;

                output(last_ack_ + 1, TCP_REASON_DUPACK);

                return 1;

       }

       return 0;

}

/*

 * main reception path - should only see acks, otherwise the

 * network connections are misconfigured

 */

void TcpAgent::recv(Packet *pkt, Handler*)

{

 hdr_tcp *tcph = hdr_tcp::access(pkt);               //接受分组TCP头

 int valid_ack = 0;

 if (qs_approved_ == 1 && tcph->seqno() > last_ack_)           //快启动处理，不看 

  endQuickStart();

 if (qs_requested_ == 1)

  processQuickStart(pkt);

#ifdef notdef

 if (pkt->type_ != PT_ACK) {                                         //ACK包类型判断

  Tcl::instance().evalf("%s error /"received non-ack/"",

          name());

  Packet::free(pkt);

  return;                                                                   //不是ACK包，退出

 }

#endif

 /* W.N.: check if this is from a previous incarnation */

 if (tcph->ts() < lastreset_) {            //判断是否上次连接的尸体包

  // Remove packet and do nothing

  Packet::free(pkt);                    //是尸体分组，释放该分组内存，并退出

  return;

 }

 ++nackpack_;                              //ACK包数＋1

 ts_peer_ = tcph->ts();                   //记录对端发此ACK包时的时间

 int ecnecho = hdr_flags::access(pkt)->ecnecho();       //ECN处理，不看

 if (ecnecho && ecn_)

  ecn(tcph->seqno());

 recv_helper(pkt);                                                      //helper处理，不必看

 recv_frto_helper(pkt);

 /* grow cwnd and check if the connection is done */ 

 if (tcph->seqno() > last_ack_) {                 //本ACK序号>上次记录的ACK序号，表示是新的ACK       

  recv_newack_helper(pkt);                     //新ACK的helper

  if (last_ack_ == 0 && delay_growth_) {     //是连接以来的第一个ACK

   cwnd_ = initial_window();                    //初始化CWND

  }                                                      //下面一段处理重复ACK

 } else if (tcph->seqno() == last_ack_) {                // 不是新ACK,是上次的重复ACK

                if (hdr_flags::access(pkt)->eln_ && eln_) {            //ELN处理，不必看

                        tcp_eln(pkt);

                        return;

                }

  if (++dupacks_ == numdupacks_ && !noFastRetrans_) {   //重复ACK数＝numdupacks并且允许快速重传时，表示满足了快速快速重传条件，但tahoe中不支持快速重传

   dupack_action();                                           //快速重传动作，用于减少CWND和SSTHRESH,并重启重传定时器

  } else if (dupacks_ < numdupacks_ && singledup_ ) {    //这里singledup_是系统的固定值，这里使TCP不采用快速重传策略，

   send_one();                                                            //而是收到一个或两个重复ACK，就重传的策略

  }

 }

if (QOption_ && EnblRTTCtr_)                                            //QOPTION，不必看

  process_qoption_after_ack (tcph->seqno());

if (tcph->seqno() >= last_ack_)                                          //本ACK序号>=上次ACK，表示是新ACK或重复ACK,是合法的

  // Check if ACK is valid.  Suggestion by Mark Allman. 

  valid_ack = 1;

 Packet::free(pkt);                                                             //合法，回收该分组内存

 /*

  * Try to send more data.

  */

 if (valid_ack || aggressive_maxburst_)   //aggressive_maxburst_默认为1，接收处理完了，继续发送尽可能多的分组

  send_much(0, 0, maxburst_);

}

/*处理非重传的超时，即用于将发送数据进行随机延迟，模拟网络的延迟情况

 * Process timeout events other than rtx timeout. Having this as a separate 

 * function allows derived classes to make alterations/enhancements (e.g.,

 * response to new types of timeout events).

 */ 

void TcpAgent::timeout_nonrtx(int tno) 

{

 if (tno == TCP_TIMER_DELSND)  {

  /*

   * delayed-send timer, with random overhead

   * to avoid phase effects

   */

  send_much(1, TCP_REASON_TIMEOUT, maxburst_);

 }

}

//直接被几个定时器的expire()调用，即在超时后，各定时器通过超时类型，选择执行下面代码 

void TcpAgent::timeout(int tno)

{

 /* retransmit timer */

 if (tno == TCP_TIMER_RTX) {               //超时重传的情况

// There has been a timeout - will trace this event

  trace_event("TIMEOUT");              //跟踪超时

frto_ = 0;                                  //F-RTO        

  // Set pipe_prev as per Eifel Response

  pipe_prev_ = (window() > ssthresh_) ?

   window() : (int)ssthresh_;

if (cwnd_ < 1) cwnd_ = 1;             //CWND至少为1

  if (qs_approved_ == 1) qs_approved_ = 0;

  

  //此段对SSTHRESH和CWND做出调整

  if (highest_ack_ == maxseq_ && !slow_start_restart_) {

   /* 无显著数据：即发送的数据都已收到了应答

      这是无显著数据并且不是慢启动重启的情况，什么都不做，正常不会出现

    * TCP option:

    * If no outstanding data, then don't do anything.  

    */

    // Should this return be here?

    // What if CWND_ACTION_ECN and cwnd < 1?

    // return;

  } else {  //

   recover_ = maxseq_;

   if (highest_ack_ == -1 && wnd_init_option_ == 2)

    /* 上次ack号为－1，表示未收到ACK,第一个分组丢失了

     * First packet dropped, so don't use larger

     * initial windows. 

     */

    wnd_init_option_ = 1;

   if (highest_ack_ == maxseq_ && restart_bugfix_)

          /* 无显著数据的情况

    * if there is no outstanding data, don't cut 

    * down ssthresh_.

    */

    slowdown(CLOSE_CWND_ONE|NO_OUTSTANDING_DATA);

   else if (highest_ack_ < recover_ &&

     last_cwnd_action_ == CWND_ACTION_ECN) {

          /*

    * if we are in recovery from a recent ECN,

    * don't cut down ssthresh_.

    */

    slowdown(CLOSE_CWND_ONE);

    if (frto_enabled_ || sfrto_enabled_) {

     frto_ = 1;

    }

   }

   else {  //

    ++nrexmit_;         //重传超时计数＋1

    last_cwnd_action_ = CWND_ACTION_TIMEOUT;   //记录本次超时

    slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_RESTART); //超时，ssthresh减半，cwnd重启动

    if (frto_enabled_ || sfrto_enabled_) {

     frto_ = 1;

    }

   }

  }

  /* if there is no outstanding data, don't back off rtx timer */

  if (highest_ack_ == maxseq_ && restart_bugfix_) {    //无显著数据，重新设置重传定时器

   reset_rtx_timer(0,0);

  }

  else {

   reset_rtx_timer(0,1);         //这是发送的数据有未收到ACK的情况,这时是重传，backoff＝1，使RTO翻倍

  }

  last_cwnd_action_ = CWND_ACTION_TIMEOUT;  //记录本次超时

  send_much(0, TCP_REASON_TIMEOUT, maxburst_);   //重传尽可能多的数据

 } 

 else {

  timeout_nonrtx(tno);         //不是超时重传的情况，如：tno == TCP_TIMER_DELSND

 }

}

/* 

 * Check if the packet (ack) has the ELN bit set, and if it does, and if the

 * last ELN-rxmitted packet is smaller than this one, then retransmit the

 * packet.  Do not adjust the cwnd when this happens.

 */

void TcpAgent::tcp_eln(Packet *pkt)

{

        //int eln_rxmit;

        hdr_tcp *tcph = hdr_tcp::access(pkt);

        int ack = tcph->seqno();

if (++dupacks_ == eln_rxmit_thresh_ && ack > eln_last_rxmit_) {

                /* Retransmit this packet */

                output(last_ack_ + 1, TCP_REASON_DUPACK);

                eln_last_rxmit_ = last_ack_+1;

        } else

                send_much(0, 0, maxburst_);

Packet::free(pkt);

        return;

}

/*

 * This function is invoked when the connection is done. It in turn

 * invokes the Tcl finish procedure that was registered with TCP.

 */

void TcpAgent::finish()

{

 Tcl::instance().evalf("%s done", this->name());

}

void RtxTimer::expire(Event*)

{

 a_->timeout(TCP_TIMER_RTX);

}

void DelSndTimer::expire(Event*)

{

 a_->timeout(TCP_TIMER_DELSND);

}

void BurstSndTimer::expire(Event*)

{

 a_->timeout(TCP_TIMER_BURSTSND);

}

/*

 * THE FOLLOWING FUNCTIONS ARE OBSOLETE, but REMAIN HERE

 * DUE TO OTHER PEOPLE's TCPs THAT MIGHT USE THEM

 *

 * These functions are now replaced by ecn() and slowdown(),

 * respectively.

 */

/*

 * Respond either to a source quench or to a congestion indication bit.

 * This is done at most once a roundtrip time;  after a source quench,

 * another one will not be done until the last packet transmitted before

 * the previous source quench has been ACKed.

 */

//不被调用？是否其他非tahoe的TCP协议使用？

void TcpAgent::quench(int how)

{

 if (highest_ack_ >= recover_) {

  recover_ =  maxseq_;

  last_cwnd_action_ = CWND_ACTION_ECN;

  closecwnd(how);

 }

}

/*

 * close down the congestion window

 */

//仅仅被quench所调用

void TcpAgent::closecwnd(int how)

{   

 static int first_time = 1;

 if (first_time == 1) {

  fprintf(stderr, "the TcpAgent::closecwnd() function is now deprecated, please use the function slowdown() instead/n");

 }

 switch (how) {

 case 0:

  /* timeouts */

  ssthresh_ = int( window() / 2 );

  if (ssthresh_ < 2)

   ssthresh_ = 2;

  cwnd_ = int(wnd_restart_);

  break;

case 1:

  /* Reno dup acks, or after a recent congestion indication. */

  // cwnd_ = window()/2;

  cwnd_ = decrease_num_ * window();

  ssthresh_ = int(cwnd_);

  if (ssthresh_ < 2)

   ssthresh_ = 2;  

  break;

case 2:

  /* Tahoe dup acks    

   * after a recent congestion indication */

  cwnd_ = wnd_init_;

  break;

case 3:

  /* Retransmit timeout, but no outstanding data. */ 

  cwnd_ = int(wnd_init_);

  break;

 case 4:

  /* Tahoe dup acks */

  ssthresh_ = int( window() / 2 );

  if (ssthresh_ < 2)

   ssthresh_ = 2;

  cwnd_ = 1;

  break;

default:

  abort();

 }

 fcnt_ = 0.;

 count_ = 0;

}

/*

 * Check if the sender has been idle or application-limited for more

 * than an RTO, and if so, reduce the congestion window.

 */

void TcpAgent::process_qoption_after_send ()

{

 int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);

 int rto = (int)(t_rtxcur_/tcp_tick_) ; 

 /*double ct = Scheduler::instance().clock();*/

if (!EnblRTTCtr_) {

  if (tcp_now - T_last >= rto) {

   // The sender has been idle.

    slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE) ;

   for (int i = 0 ; i < (tcp_now - T_last)/rto; i ++) {

    slowdown(CWND_HALF_WITH_MIN|TCP_IDLE);

   }

   T_prev = tcp_now ;

   W_used = 0 ;

  }

  T_last = tcp_now ;

  if (t_seqno_ == highest_ack_+ window()) {

   T_prev = tcp_now ; 

   W_used = 0 ; 

  }

  else if (t_seqno_ == curseq_-1) {

   // The sender has no more data to send.

   int tmp = t_seqno_ - highest_ack_ ;

   if (tmp > W_used)

    W_used = tmp ;

   if (tcp_now - T_prev >= rto) {

    // The sender has been application-limited.

    slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE);

    slowdown(CLOSE_CWND_HALF_WAY|TCP_IDLE);

    T_prev = tcp_now ;

    W_used = 0 ;

   }

  }

 } else {

  rtt_counting();

 }

}

/*

 * Check if the sender has been idle or application-limited for more

 * than an RTO, and if so, reduce the congestion window, for a TCP sender

 * that "counts RTTs" by estimating the number of RTTs that fit into

 * a single clock tick.

 */

//仅被process_qoption_after_send ()所调用，不看

void

TcpAgent::rtt_counting()

{

        int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);

 int rtt = (int(t_srtt_) >> T_SRTT_BITS) ;

if (rtt < 1) 

  rtt = 1 ;

 if (tcp_now - T_last >= 2*rtt) {

  // The sender has been idle.

  int RTTs ; 

  RTTs = (tcp_now -T_last)*RTT_goodcount/(rtt*2) ; 

  RTTs = RTTs - Backoffs ; 

  Backoffs = 0 ; 

  if (RTTs > 0) {

   slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE) ;

   for (int i = 0 ; i < RTTs ; i ++) {

    slowdown(CWND_HALF_WITH_MIN|TCP_IDLE);

    RTT_prev = RTT_count ; 

    W_used = 0 ;

   }

  }

 }

 T_last = tcp_now ;

 if (tcp_now - T_start >= 2*rtt) {

  if ((RTT_count > RTT_goodcount) || (F_full == 1)) {

   RTT_goodcount = RTT_count ; 

   if (RTT_goodcount < 1) RTT_goodcount = 1 ; 

  }

  RTT_prev = RTT_prev - RTT_count ;

  RTT_count = 0 ; 

  T_start  = tcp_now ;

  F_full = 0;

 }

 if (t_seqno_ == highest_ack_ + window()) {

  W_used = 0 ; 

  F_full = 1 ; 

  RTT_prev = RTT_count ;

 }

 else if (t_seqno_ == curseq_-1) {

  // The sender has no more data to send.

  int tmp = t_seqno_ - highest_ack_ ;

  if (tmp > W_used)

   W_used = tmp ;

  if (RTT_count - RTT_prev >= 2) {

   // The sender has been application-limited.

   slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE) ;

   slowdown(CLOSE_CWND_HALF_WAY|TCP_IDLE);

   RTT_prev = RTT_count ; 

   Backoffs ++ ; 

   W_used = 0;

  }

 }

 if (F_counting == 0) {

  W_timed = t_seqno_  ;

  F_counting = 1 ;

 }

}

void TcpAgent::process_qoption_after_ack (int seqno)

{

 if (F_counting == 1) {

  if (seqno >= W_timed) {

   RTT_count ++ ; 

   F_counting = 0 ; 

  }

  else {

   if (dupacks_ == numdupacks_)

    RTT_count ++ ;

  }

 }

}

void TcpAgent::trace_event(char *eventtype)

{

 if (et_ == NULL) return;

 int seqno = t_seqno_;

 char *wrk = et_->buffer();

 char *nwrk = et_->nbuffer();

 if (wrk != 0)

  sprintf(wrk,

   "E "TIME_FORMAT" %d %d TCP %s %d %d %d",

   et_->round(Scheduler::instance().clock()),   // time

   addr(),                       // owner (src) node id

   daddr(),                      // dst node id

   eventtype,                    // event type

   fid_,                         // flow-id

   seqno,                        // current seqno

   int(cwnd_)                         //cong. window

   );

 

 if (nwrk != 0)

  sprintf(nwrk,

   "E -t "TIME_FORMAT" -o TCP -e %s -s %d.%d -d %d.%d",

   et_->round(Scheduler::instance().clock()),   // time

   eventtype,                    // event type

   addr(),                       // owner (src) node id

   port(),                       // owner (src) port id

   daddr(),                      // dst node id

   dport()                       // dst port id

   );

 et_->trace();

}

/*

结论1：接收RECV和发送OUTPUT时都没有去/自对方的窗口大小通告，

拥塞仅凭借自己的推算来进行发送端的拥塞控制，对端的通告窗口设为一个常量wnd_，

本端发送窗口为min(cwnd_,wnd_)，范围为:  highest_ack----highest_ack+win

发送窗口：从未确认的最小序号开始，如下                        

                   1         2          3          4      

              ----------|----------|----------|---------- 

                     SND.UNA    SND.NXT    SND.UNA        

                                          +SND.WND

结论2：有三个超时定时器

         rtxtimer        用于重传超时

         delsndtimer     用于随机产生延迟，模拟网络的延迟？发送端延迟？

         burstsndtimer   ？ 用途不明，sendmuch中有一句，但程序中没有用处，

                        它超时调用timeout，但timeout和timeout_nonrtx没有对TCP_TIMER_BURSTSND的处理

                        可能是非tahoe的TCP协议使用

*/

/*

F-RTO算法：

有人指出，重传定时器可能虚假超时，引起未丢失段不必要的重传[LK00, GL02,

LM03]。在虚假的重传超时发生后，源发送段迟到的确认到达了发送方，通常会在RTO

恢复期间触发一个不必要的整个窗口的重传。而且，在虚假重传超时后，通常TCP发送

方处于慢启动阶段，在此期间每次收到迟到的确认时，就使拥塞窗口增加1。这使在一

个往返时间内，大量的数据段涌入网络，从而违背了“数据包守恒”的原则[Jac88]。

当RTO到期后，F-RTO发送方像通常一样，重传第一个未确认段[APS99]。不同于

通常操作的是，对于第一个超时后的到达的确认（假设该确认在窗口之前），它开始

发送新的、当前未发送过的数据。如果在超时后到达的第二个确认在窗口之前（比如

说：未被重传的确认数据），F-RTO发送方宣布超时是虚假的，并且退出RTO恢复。

然而，如果两个确认的任意一个是重复ACK，就没有明显的证据表明超时是虚假超时。

因此，此时F-RTO发送方采用传统的慢启动策略，重传未确认段。采用SACK增强版本

的F-RTO算法，在RTO重传后收到重复ACK时，仍然可以检测出虚假超时。

算法(rfc4138)

    

    1)当RTO到期时，重传第一个未确认段，并设SpuriousRecovery为FALSE。同时，

将最高的已发送序号存入变量“recover”中。

    

    2)当RTO重传后的第一个确认到达发送方，发送方按照是否该ACK在窗口之前，

或是否该ACK为重复确认，选择下面的其中一步。

a)如果该确认是重复ACK，或是等于“recover”序号值的段，或是没有确

      认第1步重传的所有数据，则转回到常规的RTO恢复过程，开始慢启动过程，并

      重传未确认数据。切勿进入本算法的第3步。“SpuriousRecovery”参数保持为

      FALSE。

    

          b)否则，如果该确认在窗口之前并且它小于“recover”值，发送两个新段

      (前面未发送过的段)，并转入本算法的第3步。如果TCP发送方没有足够的未发送

      数据，则只发送一个段。另外，TCP发送方可能略过Nagle算法[Nag84]，需要的

      时候直接发送一个段。注意发送两个段符合TCP拥塞控制的要求[APS99]：F-RTO

      的TCP发送方只需要选择不同的段发送出去。

        

          如果TCP发送方并没有任何新的数据发送，或通告窗口不允许发送新数据，

      推荐操作是跳过本算法的第3步，按照常规RTO恢复算法，继续慢启动重传。然而，

      一些处理窗口受限的替换方法可以取得更好的性能，这将在附件C中讨论。

        

    3)当RTO重传后的第二个确认到达发送方时，TCP发送方可以选择宣布超时是虚假的，

    或者也可以开始重传未确认的段。

        

          a)如果该确认是重复确认，将拥塞窗口设置为不超过3×MSS，并且继续慢

      启动策略，重传未确认的段。拥塞窗口可以设为3×MSS，因为在RTO超时后，已经

      过了两个往返时间，同时常规的TCP发送方已经增加cwnd到了3。保持参数

      SpuriousRecovery为FALSE。

        

          b)如果该确认在窗口之前（比如，它确认了超时后没有重传的数据），则

      则宣布超时是虚假的，设置SpuriousRecovery为SPUR_TO，并将“recover”变量值

      设为SNA.UNA（最后一个未确认的序号）。

讨论

当重传超时后收到重复确认时，F-RTO发送方采取了谨慎的措施。因为重复确认

表示有可能段已经丢失，由于缺乏其他信息，可靠地检测一个虚假超时是很困难的。

因此，在这种情况下，算法谨慎地遵循了常规的TCP恢复方法。

在算法(2a)中，如果RTO重传后的第一个确认涵盖了“recover”点，则没有证据

表明超时后有非重传段到达接收方。一种常见情况是，快速重传丢失，RTO超时后，

该段又被重传,同时，在重传超时后，其他的未确认段成功地送到TCP接收端。因此，

此时该超时不能宣布为假超时。  

    

    如果RTO重传后的第一个确认没有确认第1步中重传的所有数据，TCP发送方转到

常规的RTO恢复程序。否则，不怀好意的接收方只确认部分数据，会导致发送方会在

数据丢失时宣布虚假超时。

在算法分支(2b)中，TCP发送方允许发送两个新段，因为在常规TCP中，RTO重传

后，当收到新的ACK，发送方将发送两个段。如果在算法分支(2b)中不能发送新段，

或是接收窗口限制了传输，TCP发送方必须要发送数据以防止TCP停转。如果没有数据

发送了，发送方和接收方在管道允许的范围内可能都已经发完了段，不会再有下一个

确认到达。因此，在窗口受限的情况下，推荐转回常规的RTO慢启动重传恢复阶段。

附件C讨论了一些可选的窗口受限情况。

如果重传超时被宣布为虚假，TCP发送方将“recover”变量设置为SNA.UNA，

以允许快速重传[FHG04]。“recover”变量用于在NewReno TCP快速恢复期间,当RTO

超时时，避免不必要的、成倍的快速重传。因为发送方只重传哪些触发了超时的段，

不必要的成倍快速重传的问题不可能发生。因此，如果超时后有3个重复ACK到达了

发送方，就表示可能丢失了包，使用快速重传以加快恢复效率。如果包丢失后没有

足够的重复ACK到达接收方，重传定时器又会出现超时，发送方即转入算法的第1步。

    

    当超时被宣布为虚假时，TCP发送方不能检测到是否存在不必要的RTO重传丢失。

原则上，RTO的重传丢失应该被视为一个拥塞信号。因此，如果在检测到虚假超时后，

F-RTO发送方选择完全还原到拥塞控制参数，则违反拥塞控制原则的可能性较小。

Eifel检测算法有相似的性质，其DSACK选项可以用于检测是否重传段成功地发送到

了接收方。

F-RTO算法在TCP往返时间测算中有副作用。TCP发送方在检测到虚假超时后，

能避免大多数不必要的重传，这使发送方能够在延迟的段上取得往返时间的采样。

如果在不使用TCP时间戳时采用常规的RTO恢复策略，因为重传的模糊性，不会出现

这种情况。结果是，同常规TCP比较，由于采用了F-RTO，在因为段的延迟而触发了

虚假超时，使RTO趋向于更精确，数值更大。我们相信在那些延迟尖峰较多的网络

中，这是一个优势。

在虚假超时后，存在F-RTO算法不能避免产生不必要重传的情况。如果包重排

序或重复包出现在触发虚假超时的段中，由于收到的重复ACK,F-RTO算法可能不能

检测虚假超时。另外，如果虚假超时发生在快速重传中，由于一些段在快速恢复触

发重复ACK前发送，F-RTO算法通常不能检测虚假重传。然而，我们认为这些情况

很少出现，注意在F-RTO没能检测到虚假超时的情况下，它采用慢启动策略，重传

未确认段，同常规的RTO恢复方法相似。

拥塞算法的具体响应措施见  rfc4015