开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tcp.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：67k
源码类别：

通讯编程

开发平台：

Visual C++

tcp.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1991-1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  * This product includes software developed by the Computer Systems
  17.  * Engineering Group at Lawrence Berkeley Laboratory.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  */
  35. #ifndef lint
  36. static const char rcsid[] =
  37.     "@(#) $Header: /cvsroot/nsnam/ns-2/tcp/tcp.cc,v 1.179 2007/12/04 19:59:35 seashadow Exp $ (LBL)";
  38. #endif
  40. #include <stdlib.h>
  41. #include <math.h>
  42. #include <sys/types.h>
  43. #include "ip.h"
  44. #include "tcp.h"
  45. #include "flags.h"
  46. #include "random.h"
  47. #include "basetrace.h"
  48. #include "hdr_qs.h"
  50. int hdr_tcp::offset_;
  52. static class TCPHeaderClass : public PacketHeaderClass {
  53. public:
  54.         TCPHeaderClass() : PacketHeaderClass("PacketHeader/TCP",
  55.      sizeof(hdr_tcp)) {
  56. bind_offset(&hdr_tcp::offset_);
  57. }
  58. } class_tcphdr;
  60. static class TcpClass : public TclClass {
  61. public:
  62. TcpClass() : TclClass("Agent/TCP") {}
  63. TclObject* create(int , const char*const*) {
  64. return (new TcpAgent());
  65. }
  66. } class_tcp;
  68. TcpAgent::TcpAgent() 
  69. : Agent(PT_TCP), 
  70.   t_seqno_(0), dupacks_(0), curseq_(0), highest_ack_(0), 
  71.           cwnd_(0), ssthresh_(0), maxseq_(0), count_(0), 
  72.           rtt_active_(0), rtt_seq_(-1), rtt_ts_(0.0), 
  73.           lastreset_(0.0), closed_(0), t_rtt_(0), t_srtt_(0), t_rttvar_(0), 
  74.   t_backoff_(0), ts_peer_(0), ts_echo_(0), tss(NULL), tss_size_(100), 
  75.   rtx_timer_(this), delsnd_timer_(this), burstsnd_timer_(this), 
  76.   first_decrease_(1), fcnt_(0), nrexmit_(0), restart_bugfix_(1), 
  77.           cong_action_(0), ecn_burst_(0), ecn_backoff_(0), ect_(0), 
  78.           use_rtt_(0), qs_requested_(0), qs_approved_(0),
  79.   qs_window_(0), qs_cwnd_(0), frto_(0)
  80. {
  81. #ifdef TCP_DELAY_BIND_ALL
  82.         // defined since Dec 1999.
  83. #else /* ! TCP_DELAY_BIND_ALL */
  84. bind("t_seqno_", &t_seqno_);
  85. bind("rtt_", &t_rtt_);
  86. bind("srtt_", &t_srtt_);
  87. bind("rttvar_", &t_rttvar_);
  88. bind("backoff_", &t_backoff_);
  89. bind("dupacks_", &dupacks_);
  90. bind("seqno_", &curseq_);
  91. bind("ack_", &highest_ack_);
  92. bind("cwnd_", &cwnd_);
  93. bind("ssthresh_", &ssthresh_);
  94. bind("maxseq_", &maxseq_);
  95.         bind("ndatapack_", &ndatapack_);
  96.         bind("ndatabytes_", &ndatabytes_);
  97.         bind("nackpack_", &nackpack_);
  98.         bind("nrexmit_", &nrexmit_);
  99.         bind("nrexmitpack_", &nrexmitpack_);
  100.         bind("nrexmitbytes_", &nrexmitbytes_);
  101.         bind("necnresponses_", &necnresponses_);
  102.         bind("ncwndcuts_", &ncwndcuts_);
  103. bind("ncwndcuts1_", &ncwndcuts1_);
  104. #endif /* TCP_DELAY_BIND_ALL */
  106. }
  108. void
  109. TcpAgent::delay_bind_init_all()
  110. {
  112.         // Defaults for bound variables should be set in ns-default.tcl.
  113.         delay_bind_init_one("window_");
  114.         delay_bind_init_one("windowInit_");
  115.         delay_bind_init_one("windowInitOption_");
  117.         delay_bind_init_one("syn_");
  118.         delay_bind_init_one("max_connects_");
  119.         delay_bind_init_one("windowOption_");
  120.         delay_bind_init_one("windowConstant_");
  121.         delay_bind_init_one("windowThresh_");
  122.         delay_bind_init_one("delay_growth_");
  123.         delay_bind_init_one("overhead_");
  124.         delay_bind_init_one("tcpTick_");
  125.         delay_bind_init_one("ecn_");
  126.         delay_bind_init_one("SetCWRonRetransmit_");
  127.         delay_bind_init_one("old_ecn_");
  128.         delay_bind_init_one("bugfix_ss_");
  129.         delay_bind_init_one("eln_");
  130.         delay_bind_init_one("eln_rxmit_thresh_");
  131.         delay_bind_init_one("packetSize_");
  132.         delay_bind_init_one("tcpip_base_hdr_size_");
  133. delay_bind_init_one("ts_option_size_");
  134.         delay_bind_init_one("bugFix_");
  135. delay_bind_init_one("bugFix_ack_");
  136. delay_bind_init_one("bugFix_ts_");
  137. delay_bind_init_one("lessCareful_");
  138.         delay_bind_init_one("slow_start_restart_");
  139.         delay_bind_init_one("restart_bugfix_");
  140.         delay_bind_init_one("timestamps_");
  141. delay_bind_init_one("ts_resetRTO_");
  142.         delay_bind_init_one("maxburst_");
  143. delay_bind_init_one("aggressive_maxburst_");
  144.         delay_bind_init_one("maxcwnd_");
  145. delay_bind_init_one("numdupacks_");
  146. delay_bind_init_one("numdupacksFrac_");
  147. delay_bind_init_one("exitFastRetrans_");
  148.         delay_bind_init_one("maxrto_");
  149. delay_bind_init_one("minrto_");
  150.         delay_bind_init_one("srtt_init_");
  151.         delay_bind_init_one("rttvar_init_");
  152.         delay_bind_init_one("rtxcur_init_");
  153.         delay_bind_init_one("T_SRTT_BITS");
  154.         delay_bind_init_one("T_RTTVAR_BITS");
  155.         delay_bind_init_one("rttvar_exp_");
  156.         delay_bind_init_one("awnd_");
  157.         delay_bind_init_one("decrease_num_");
  158.         delay_bind_init_one("increase_num_");
  159. delay_bind_init_one("k_parameter_");
  160. delay_bind_init_one("l_parameter_");
  161.         delay_bind_init_one("trace_all_oneline_");
  162.         delay_bind_init_one("nam_tracevar_");
  164.         delay_bind_init_one("QOption_");
  165.         delay_bind_init_one("EnblRTTCtr_");
  166.         delay_bind_init_one("control_increase_");
  167. delay_bind_init_one("noFastRetrans_");
  168. delay_bind_init_one("precisionReduce_");
  169. delay_bind_init_one("oldCode_");
  170. delay_bind_init_one("useHeaders_");
  171. delay_bind_init_one("low_window_");
  172. delay_bind_init_one("high_window_");
  173. delay_bind_init_one("high_p_");
  174. delay_bind_init_one("high_decrease_");
  175. delay_bind_init_one("max_ssthresh_");
  176. delay_bind_init_one("cwnd_range_");
  177. delay_bind_init_one("timerfix_");
  178. delay_bind_init_one("rfc2988_");
  179. delay_bind_init_one("singledup_");
  180. delay_bind_init_one("LimTransmitFix_");
  181. delay_bind_init_one("rate_request_");
  182. delay_bind_init_one("qs_enabled_");
  183. delay_bind_init_one("tcp_qs_recovery_");
  184. delay_bind_init_one("qs_request_mode_");
  185. delay_bind_init_one("qs_thresh_");
  186. delay_bind_init_one("qs_rtt_");
  187. delay_bind_init_one("print_request_");
  189. delay_bind_init_one("frto_enabled_");
  190. delay_bind_init_one("sfrto_enabled_");
  191. delay_bind_init_one("spurious_response_");
  193. #ifdef TCP_DELAY_BIND_ALL
  194. // out because delay-bound tracevars aren't yet supported
  195.         delay_bind_init_one("t_seqno_");
  196.         delay_bind_init_one("rtt_");
  197.         delay_bind_init_one("srtt_");
  198.         delay_bind_init_one("rttvar_");
  199.         delay_bind_init_one("backoff_");
  200.         delay_bind_init_one("dupacks_");
  201.         delay_bind_init_one("seqno_");
  202.         delay_bind_init_one("ack_");
  203.         delay_bind_init_one("cwnd_");
  204.         delay_bind_init_one("ssthresh_");
  205.         delay_bind_init_one("maxseq_");
  206.         delay_bind_init_one("ndatapack_");
  207.         delay_bind_init_one("ndatabytes_");
  208.         delay_bind_init_one("nackpack_");
  209.         delay_bind_init_one("nrexmit_");
  210.         delay_bind_init_one("nrexmitpack_");
  211.         delay_bind_init_one("nrexmitbytes_");
  212.         delay_bind_init_one("necnresponses_");
  213.         delay_bind_init_one("ncwndcuts_");
  214. delay_bind_init_one("ncwndcuts1_");
  215. #endif /* TCP_DELAY_BIND_ALL */
  217. Agent::delay_bind_init_all();
  219.         reset();
  220. }
  222. int
  223. TcpAgent::delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer)
  224. {
  225.         if (delay_bind(varName, localName, "window_", &wnd_, tracer)) return TCL_OK;
  226.         if (delay_bind(varName, localName, "windowInit_", &wnd_init_, tracer)) return TCL_OK;
  227.         if (delay_bind(varName, localName, "windowInitOption_", &wnd_init_option_, tracer)) return TCL_OK;
  228.         if (delay_bind_bool(varName, localName, "syn_", &syn_, tracer)) return TCL_OK;
  229.         if (delay_bind(varName, localName, "max_connects_", &max_connects_, tracer)) return TCL_OK;
  230.         if (delay_bind(varName, localName, "windowOption_", &wnd_option_ , tracer)) return TCL_OK;
  231.         if (delay_bind(varName, localName, "windowConstant_",  &wnd_const_, tracer)) return TCL_OK;
  232.         if (delay_bind(varName, localName, "windowThresh_", &wnd_th_ , tracer)) return TCL_OK;
  233.         if (delay_bind_bool(varName, localName, "delay_growth_", &delay_growth_ , tracer)) return TCL_OK;
  234.         if (delay_bind(varName, localName, "overhead_", &overhead_, tracer)) return TCL_OK;
  235.         if (delay_bind(varName, localName, "tcpTick_", &tcp_tick_, tracer)) return TCL_OK;
  236.         if (delay_bind_bool(varName, localName, "ecn_", &ecn_, tracer)) return TCL_OK;
  237.         if (delay_bind_bool(varName, localName, "SetCWRonRetransmit_", &SetCWRonRetransmit_, tracer)) return TCL_OK;
  238.         if (delay_bind_bool(varName, localName, "old_ecn_", &old_ecn_ , tracer)) return TCL_OK;
  239.         if (delay_bind_bool(varName, localName, "bugfix_ss_", &bugfix_ss_ , tracer)) return TCL_OK;
  240.         if (delay_bind(varName, localName, "eln_", &eln_ , tracer)) return TCL_OK;
  241.         if (delay_bind(varName, localName, "eln_rxmit_thresh_", &eln_rxmit_thresh_ , tracer)) return TCL_OK;
  242.         if (delay_bind(varName, localName, "packetSize_", &size_ , tracer)) return TCL_OK;
  243.         if (delay_bind(varName, localName, "tcpip_base_hdr_size_", &tcpip_base_hdr_size_, tracer)) return TCL_OK;
  244. if (delay_bind(varName, localName, "ts_option_size_", &ts_option_size_, tracer)) return TCL_OK;
  245.         if (delay_bind_bool(varName, localName, "bugFix_", &bug_fix_ , tracer)) return TCL_OK;
  246. if (delay_bind_bool(varName, localName, "bugFix_ack_", &bugfix_ack_, tracer)) return TCL_OK;
  247. if (delay_bind_bool(varName, localName, "bugFix_ts_", &bugfix_ts_ , tracer)) return TCL_OK;
  248.         if (delay_bind_bool(varName, localName, "lessCareful_", &less_careful_ , tracer)) return TCL_OK;
  249.         if (delay_bind_bool(varName, localName, "timestamps_", &ts_option_ , tracer)) return TCL_OK;
  250.         if (delay_bind_bool(varName, localName, "ts_resetRTO_", &ts_resetRTO_, tracer)) return TCL_OK;
  251.         if (delay_bind_bool(varName, localName, "slow_start_restart_", &slow_start_restart_ , tracer)) return TCL_OK;
  252.         if (delay_bind_bool(varName, localName, "restart_bugfix_", &restart_bugfix_ , tracer)) return TCL_OK;
  253.         if (delay_bind(varName, localName, "maxburst_", &maxburst_ , tracer)) return TCL_OK;
  254.         if (delay_bind_bool(varName, localName, "aggressive_maxburst_", &aggressive_maxburst_ , tracer)) return TCL_OK;
  255.         if (delay_bind(varName, localName, "maxcwnd_", &maxcwnd_ , tracer)) return TCL_OK;
  256. if (delay_bind(varName, localName, "numdupacks_", &numdupacks_, tracer)) return TCL_OK;
  257. if (delay_bind(varName, localName, "numdupacksFrac_", &numdupacksFrac_, tracer)) return TCL_OK;
  258. if (delay_bind_bool(varName, localName, "exitFastRetrans_", &exitFastRetrans_, tracer)) return TCL_OK;
  259.         if (delay_bind(varName, localName, "maxrto_", &maxrto_ , tracer)) return TCL_OK;
  260. if (delay_bind(varName, localName, "minrto_", &minrto_ , tracer)) return TCL_OK;
  261.         if (delay_bind(varName, localName, "srtt_init_", &srtt_init_ , tracer)) return TCL_OK;
  262.         if (delay_bind(varName, localName, "rttvar_init_", &rttvar_init_ , tracer)) return TCL_OK;
  263.         if (delay_bind(varName, localName, "rtxcur_init_", &rtxcur_init_ , tracer)) return TCL_OK;
  264.         if (delay_bind(varName, localName, "T_SRTT_BITS", &T_SRTT_BITS , tracer)) return TCL_OK;
  265.         if (delay_bind(varName, localName, "T_RTTVAR_BITS", &T_RTTVAR_BITS , tracer)) return TCL_OK;
  266.         if (delay_bind(varName, localName, "rttvar_exp_", &rttvar_exp_ , tracer)) return TCL_OK;
  267.         if (delay_bind(varName, localName, "awnd_", &awnd_ , tracer)) return TCL_OK;
  268.         if (delay_bind(varName, localName, "decrease_num_", &decrease_num_, tracer)) return TCL_OK;
  269.         if (delay_bind(varName, localName, "increase_num_", &increase_num_, tracer)) return TCL_OK;
  270. if (delay_bind(varName, localName, "k_parameter_", &k_parameter_, tracer)) return TCL_OK;
  271.         if (delay_bind(varName, localName, "l_parameter_", &l_parameter_, tracer)) return TCL_OK;
  274.         if (delay_bind_bool(varName, localName, "trace_all_oneline_", &trace_all_oneline_ , tracer)) return TCL_OK;
  275.         if (delay_bind_bool(varName, localName, "nam_tracevar_", &nam_tracevar_ , tracer)) return TCL_OK;
  276.         if (delay_bind(varName, localName, "QOption_", &QOption_ , tracer)) return TCL_OK;
  277.         if (delay_bind(varName, localName, "EnblRTTCtr_", &EnblRTTCtr_ , tracer)) return TCL_OK;
  278.         if (delay_bind(varName, localName, "control_increase_", &control_increase_ , tracer)) return TCL_OK;
  279.         if (delay_bind_bool(varName, localName, "noFastRetrans_", &noFastRetrans_, tracer)) return TCL_OK;
  280.         if (delay_bind_bool(varName, localName, "precisionReduce_", &precision_reduce_, tracer)) return TCL_OK;
  281. if (delay_bind_bool(varName, localName, "oldCode_", &oldCode_, tracer)) return TCL_OK;
  282. if (delay_bind_bool(varName, localName, "useHeaders_", &useHeaders_, tracer)) return TCL_OK;
  283. if (delay_bind(varName, localName, "low_window_", &low_window_, tracer)) return TCL_OK;
  284. if (delay_bind(varName, localName, "high_window_", &high_window_, tracer)) return TCL_OK;
  285. if (delay_bind(varName, localName, "high_p_", &high_p_, tracer)) return TCL_OK;
  286. if (delay_bind(varName, localName, "high_decrease_", &high_decrease_, tracer)) return TCL_OK;
  287. if (delay_bind(varName, localName, "max_ssthresh_", &max_ssthresh_, tracer)) return TCL_OK;
  288. if (delay_bind(varName, localName, "cwnd_range_", &cwnd_range_, tracer)) return TCL_OK;
  289. if (delay_bind_bool(varName, localName, "timerfix_", &timerfix_, tracer)) return TCL_OK;
  290. if (delay_bind_bool(varName, localName, "rfc2988_", &rfc2988_, tracer)) return TCL_OK;
  291.         if (delay_bind(varName, localName, "singledup_", &singledup_ , tracer)) return TCL_OK;
  292.         if (delay_bind_bool(varName, localName, "LimTransmitFix_", &LimTransmitFix_ , tracer)) return TCL_OK;
  293.         if (delay_bind(varName, localName, "rate_request_", &rate_request_ , tracer)) return TCL_OK;
  294.         if (delay_bind_bool(varName, localName, "qs_enabled_", &qs_enabled_ , tracer)) return TCL_OK;
  295. if (delay_bind_bool(varName, localName, "tcp_qs_recovery_", &tcp_qs_recovery_, tracer)) return TCL_OK;
  296. if (delay_bind(varName, localName, "qs_request_mode_", &qs_request_mode_, tracer)) return TCL_OK;
  297. if (delay_bind(varName, localName, "qs_thresh_", &qs_thresh_, tracer)) return TCL_OK;
  298. if (delay_bind(varName, localName, "qs_rtt_", &qs_rtt_, tracer)) return TCL_OK;
  299. if (delay_bind_bool(varName, localName, "print_request_", &print_request_, tracer)) return TCL_OK;
  300. if (delay_bind_bool(varName, localName, "frto_enabled_", &frto_enabled_, tracer)) return TCL_OK;
  301. if (delay_bind_bool(varName, localName, "sfrto_enabled_", &sfrto_enabled_, tracer)) return TCL_OK;
  302. if (delay_bind_bool(varName, localName, "spurious_response_", &spurious_response_, tracer)) return TCL_OK;
  304. #ifdef TCP_DELAY_BIND_ALL
  305. // not if (delay-bound delay-bound tracevars aren't yet supported
  306.         if (delay_bind(varName, localName, "t_seqno_", &t_seqno_ , tracer)) return TCL_OK;
  307.         if (delay_bind(varName, localName, "rtt_", &t_rtt_ , tracer)) return TCL_OK;
  308.         if (delay_bind(varName, localName, "srtt_", &t_srtt_ , tracer)) return TCL_OK;
  309.         if (delay_bind(varName, localName, "rttvar_", &t_rttvar_ , tracer)) return TCL_OK;
  310.         if (delay_bind(varName, localName, "backoff_", &t_backoff_ , tracer)) return TCL_OK;
  312.         if (delay_bind(varName, localName, "dupacks_", &dupacks_ , tracer)) return TCL_OK;
  313.         if (delay_bind(varName, localName, "seqno_", &curseq_ , tracer)) return TCL_OK;
  314.         if (delay_bind(varName, localName, "ack_", &highest_ack_ , tracer)) return TCL_OK;
  315.         if (delay_bind(varName, localName, "cwnd_", &cwnd_ , tracer)) return TCL_OK;
  316.         if (delay_bind(varName, localName, "ssthresh_", &ssthresh_ , tracer)) return TCL_OK;
  317.         if (delay_bind(varName, localName, "maxseq_", &maxseq_ , tracer)) return TCL_OK;
  318.         if (delay_bind(varName, localName, "ndatapack_", &ndatapack_ , tracer)) return TCL_OK;
  319.         if (delay_bind(varName, localName, "ndatabytes_", &ndatabytes_ , tracer)) return TCL_OK;
  320.         if (delay_bind(varName, localName, "nackpack_", &nackpack_ , tracer)) return TCL_OK;
  321.         if (delay_bind(varName, localName, "nrexmit_", &nrexmit_ , tracer)) return TCL_OK;
  322.         if (delay_bind(varName, localName, "nrexmitpack_", &nrexmitpack_ , tracer)) return TCL_OK;
  323.         if (delay_bind(varName, localName, "nrexmitbytes_", &nrexmitbytes_ , tracer)) return TCL_OK;
  324.         if (delay_bind(varName, localName, "necnresponses_", &necnresponses_ , tracer)) return TCL_OK;
  325.         if (delay_bind(varName, localName, "ncwndcuts_", &ncwndcuts_ , tracer)) return TCL_OK;
  326.   if (delay_bind(varName, localName, "ncwndcuts1_", &ncwndcuts1_ , tracer)) return TCL_OK;
  328. #endif
  330.         return Agent::delay_bind_dispatch(varName, localName, tracer);
  331. }
  333. #define TCP_WRK_SIZE 512
  334. /* Print out all the traced variables whenever any one is changed */
  335. void
  336. TcpAgent::traceAll() {
  337. if (!channel_)
  338. return;
  340. double curtime;
  341. Scheduler& s = Scheduler::instance();
  342. char wrk[TCP_WRK_SIZE];
  344. curtime = &s ? s.clock() : 0;
  345. snprintf(wrk, TCP_WRK_SIZE,
  346.  "time: %-8.5f saddr: %-2d sport: %-2d daddr: %-2d dport:"
  347.  " %-2d maxseq: %-4d hiack: %-4d seqno: %-4d cwnd: %-6.3f"
  348.  " ssthresh: %-3d dupacks: %-2d rtt: %-6.3f srtt: %-6.3f"
  349.  " rttvar: %-6.3f bkoff: %-dn", curtime, addr(), port(),
  350.  daddr(), dport(), int(maxseq_), int(highest_ack_),
  351.  int(t_seqno_), double(cwnd_), int(ssthresh_),
  352.  int(dupacks_), int(t_rtt_)*tcp_tick_, 
  353.  (int(t_srtt_) >> T_SRTT_BITS)*tcp_tick_, 
  354.  int(t_rttvar_)*tcp_tick_/4.0, int(t_backoff_)); 
  355. (void)Tcl_Write(channel_, wrk, -1);
  356. }
  358. /* Print out just the variable that is modified */
  359. void
  360. TcpAgent::traceVar(TracedVar* v) 
  361. {
  362. if (!channel_)
  363. return;
  365. double curtime;
  366. Scheduler& s = Scheduler::instance();
  367. char wrk[TCP_WRK_SIZE];
  369. curtime = &s ? s.clock() : 0;
  371. // XXX comparing addresses is faster than comparing names
  372. if (v == &cwnd_)
  373. snprintf(wrk, TCP_WRK_SIZE,
  374.  "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3fn",
  375.  curtime, addr(), port(), daddr(), dport(),
  376.  v->name(), double(*((TracedDouble*) v))); 
  377.   else if (v == &t_rtt_)
  378. snprintf(wrk, TCP_WRK_SIZE,
  379.  "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3fn",
  380.  curtime, addr(), port(), daddr(), dport(),
  381.  v->name(), int(*((TracedInt*) v))*tcp_tick_); 
  382. else if (v == &t_srtt_)
  383. snprintf(wrk, TCP_WRK_SIZE,
  384.  "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3fn",
  385.  curtime, addr(), port(), daddr(), dport(),
  386.  v->name(), 
  387.  (int(*((TracedInt*) v)) >> T_SRTT_BITS)*tcp_tick_); 
  388. else if (v == &t_rttvar_)
  389. snprintf(wrk, TCP_WRK_SIZE,
  390.  "%-8.5f %-2d %-2d %-2d %-2d %s %-6.3fn",
  391.  curtime, addr(), port(), daddr(), dport(),
  392.  v->name(), 
  393.  int(*((TracedInt*) v))*tcp_tick_/4.0); 
  394. else
  395. snprintf(wrk, TCP_WRK_SIZE,
  396.  "%-8.5f %-2d %-2d %-2d %-2d %s %dn",
  397.  curtime, addr(), port(), daddr(), dport(),
  398.  v->name(), int(*((TracedInt*) v))); 
  400. (void)Tcl_Write(channel_, wrk, -1);
  401. }
  403. void
  404. TcpAgent::trace(TracedVar* v) 
  405. {
  406. if (nam_tracevar_) {
  407. Agent::trace(v);
  408. } else if (trace_all_oneline_)
  409. traceAll();
  410. else 
  411. traceVar(v);
  412. }
  414. //
  415. // in 1-way TCP, syn_ indicates we are modeling
  416. // a SYN exchange at the beginning.  If this is true
  417. // and we are delaying growth, then use an initial
  418. // window of one.  If not, we do whatever initial_window()
  419. // says to do.
  420. //
  422. void
  423. TcpAgent::set_initial_window()
  424. {
  425. if (syn_ && delay_growth_) {
  426. cwnd_ = 1.0; 
  427. syn_connects_ = 0;
  428. } else
  429. cwnd_ = initial_window();
  430. }
  432. void
  433. TcpAgent::reset_qoption()
  434. {
  435. int now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
  437. T_start = now ; 
  438. RTT_count = 0 ; 
  439. RTT_prev = 0 ; 
  440. RTT_goodcount = 1 ; 
  441. F_counting = 0 ; 
  442. W_timed = -1 ; 
  443. F_full = 0 ;
  444. Backoffs = 0 ; 
  445. }
  447. void
  448. TcpAgent::reset()
  449. {
  450. rtt_init();
  451. rtt_seq_ = -1;
  452. /*XXX lookup variables */
  453. dupacks_ = 0;
  454. curseq_ = 0;
  455. set_initial_window();
  457. t_seqno_ = 0;
  458. maxseq_ = -1;
  459. last_ack_ = -1;
  460. highest_ack_ = -1;
  461. //highest_ack_ = 1;
  462. ssthresh_ = int(wnd_);
  463. if (max_ssthresh_ > 0 && max_ssthresh_ < ssthresh_) 
  464. ssthresh_ = max_ssthresh_;
  465. wnd_restart_ = 1.;
  466. awnd_ = wnd_init_ / 2.0;
  467. recover_ = 0;
  468. closed_ = 0;
  469. last_cwnd_action_ = 0;
  470. boot_time_ = Random::uniform(tcp_tick_);
  471. first_decrease_ = 1;
  472. /* W.N.: for removing packets from previous incarnations */
  473. lastreset_ = Scheduler::instance().clock();
  475. /* Now these variables will be reset 
  476.    - Debojyoti Dutta 12th Oct'2000 */
  477.  
  478. ndatapack_ = 0;
  479. ndatabytes_ = 0;
  480. nackpack_ = 0;
  481. nrexmitbytes_ = 0;
  482. nrexmit_ = 0;
  483. nrexmitpack_ = 0;
  484. necnresponses_ = 0;
  485. ncwndcuts_ = 0;
  486. ncwndcuts1_ = 0;
  488. if (control_increase_) {
  489. prev_highest_ack_ = highest_ack_ ; 
  490. }
  492. if (wnd_option_ == 8) {
  493. // HighSpeed TCP
  494. hstcp_.low_p = 1.5/(low_window_*low_window_);
  495. double highLowWin = log(high_window_)-log(low_window_);
  496. double highLowP = log(high_p_) - log(hstcp_.low_p);
  497. hstcp_.dec1 = 
  498.    0.5 - log(low_window_) * (high_decrease_ - 0.5)/highLowWin;
  499. hstcp_.dec2 = (high_decrease_ - 0.5)/highLowWin;
  500.          hstcp_.p1 = 
  501.   log(hstcp_.low_p) - log(low_window_) * highLowP/highLowWin;
  502. hstcp_.p2 = highLowP/highLowWin;
  503. }
  505. if (QOption_) {
  506. int now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
  507. T_last = now ; 
  508. T_prev = now ; 
  509. W_used = 0 ;
  510. if (EnblRTTCtr_) {
  511. reset_qoption();
  512. }
  513. }
  514. }
  516. /*
  517.  * Initialize variables for the retransmit timer.
  518.  */
  519. void TcpAgent::rtt_init()
  520. {
  521. t_rtt_ = 0;
  522. t_srtt_ = int(srtt_init_ / tcp_tick_) << T_SRTT_BITS;
  523. t_rttvar_ = int(rttvar_init_ / tcp_tick_) << T_RTTVAR_BITS;
  524. t_rtxcur_ = rtxcur_init_;
  525. t_backoff_ = 1;
  526. }
  528. double TcpAgent::rtt_timeout()
  529. {
  530. double timeout;
  531. if (rfc2988_) {
  532. // Correction from Tom Kelly to be RFC2988-compliant, by
  533. // clamping minrto_ before applying t_backoff_.
  534. if (t_rtxcur_ < minrto_ && !use_rtt_)
  535. timeout = minrto_ * t_backoff_;
  536. else
  537. timeout = t_rtxcur_ * t_backoff_;
  538. } else {
  539. // only of interest for backwards compatibility
  540. timeout = t_rtxcur_ * t_backoff_;
  541. if (timeout < minrto_)
  542. timeout = minrto_;
  543. }
  545. if (timeout > maxrto_)
  546. timeout = maxrto_;
  548.         if (timeout < 2.0 * tcp_tick_) {
  549. if (timeout < 0) {
  550. fprintf(stderr, "TcpAgent: negative RTO!  (%f)n",
  551. timeout);
  552. exit(1);
  553. } else if (use_rtt_ && timeout < tcp_tick_)
  554. timeout = tcp_tick_;
  555. else
  556. timeout = 2.0 * tcp_tick_;
  557. }
  558. use_rtt_ = 0;
  559. return (timeout);
  560. }
  563. /* This has been modified to use the tahoe code. */
  564. void TcpAgent::rtt_update(double tao)
  565. {
  566. double now = Scheduler::instance().clock();
  567. if (ts_option_)
  568. t_rtt_ = int(tao /tcp_tick_ + 0.5);
  569. else {
  570. double sendtime = now - tao;
  571. sendtime += boot_time_;
  572. double tickoff = fmod(sendtime, tcp_tick_);
  573. t_rtt_ = int((tao + tickoff) / tcp_tick_);
  574. }
  575. if (t_rtt_ < 1)
  576. t_rtt_ = 1;
  577. //
  578. // t_srtt_ has 3 bits to the right of the binary point
  579. // t_rttvar_ has 2
  580.         // Thus "t_srtt_ >> T_SRTT_BITS" is the actual srtt, 
  581.    //   and "t_srtt_" is 8*srtt.
  582. // Similarly, "t_rttvar_ >> T_RTTVAR_BITS" is the actual rttvar,
  583. //   and "t_rttvar_" is 4*rttvar.
  584. //
  585.         if (t_srtt_ != 0) {
  586. register short delta;
  587. delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS); // d = (m - a0)
  588. if ((t_srtt_ += delta) <= 0) // a1 = 7/8 a0 + 1/8 m
  589. t_srtt_ = 1;
  590. if (delta < 0)
  591. delta = -delta;
  592. delta -= (t_rttvar_ >> T_RTTVAR_BITS);
  593. if ((t_rttvar_ += delta) <= 0) // var1 = 3/4 var0 + 1/4 |d|
  594. t_rttvar_ = 1;
  595. } else {
  596. t_srtt_ = t_rtt_ << T_SRTT_BITS; // srtt = rtt
  597. t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1); // rttvar = rtt / 2
  598. }
  599. //
  600. // Current retransmit value is 
  601. //    (unscaled) smoothed round trip estimate
  602. //    plus 2^rttvar_exp_ times (unscaled) rttvar. 
  603. //
  604. t_rtxcur_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS))) +
  605. t_srtt_)  >> T_SRTT_BITS ) * tcp_tick_;
  607. return;
  608. }
  610. void TcpAgent::rtt_backoff()
  611. {
  612. if (t_backoff_ < 64 || rfc2988_)
  613.          t_backoff_ <<= 1;
  614.         // RFC2988 allows a maximum for the backed-off RTO of 60 seconds.
  615.         // This is applied by maxrto_.
  617. if (t_backoff_ > 8) {
  618. /*
  619.  * If backed off this far, clobber the srtt
  620.  * value, storing it in the mean deviation
  621.  * instead.
  622.  */
  623. t_rttvar_ += (t_srtt_ >> T_SRTT_BITS);
  624. t_srtt_ = 0;
  625. }
  626. }
  628. /*
  629.  * headersize:
  630.  *      how big is an IP+TCP header in bytes; include options such as ts
  631.  * this function should be virtual so others (e.g. SACK) can override
  632.  */
  633. int TcpAgent::headersize()
  634. {
  635.         int total = tcpip_base_hdr_size_;
  636. if (total < 1) {
  637. fprintf(stderr,
  638.   "TcpAgent(%s): warning: tcpip hdr size is only %d bytesn",
  639.   name(), tcpip_base_hdr_size_);
  640. }
  641. if (ts_option_)
  642. total += ts_option_size_;
  643.         return (total);
  644. }
  646. void TcpAgent::output(int seqno, int reason)
  647. {
  648. int force_set_rtx_timer = 0;
  649. Packet* p = allocpkt();
  650. hdr_tcp *tcph = hdr_tcp::access(p);
  651. hdr_flags* hf = hdr_flags::access(p);
  652. hdr_ip *iph = hdr_ip::access(p);
  653. int databytes = hdr_cmn::access(p)->size();
  654. tcph->seqno() = seqno;
  655. tcph->ts() = Scheduler::instance().clock();
  656. int is_retransmit = (seqno < maxseq_);
  657.  
  658. // Mark packet for diagnosis purposes if we are in Quick-Start Phase
  659. if (qs_approved_) {
  660. hf->qs() = 1;
  661. }
  662.  
  663.         // store timestamps, with bugfix_ts_.  From Andrei Gurtov. 
  664. // (A real TCP would use scoreboard for this.)
  665.         if (bugfix_ts_ && tss==NULL) {
  666.                 tss = (double*) calloc(tss_size_, sizeof(double));
  667.                 if (tss==NULL) exit(1);
  668.         }
  669.         //dynamically grow the timestamp array if it's getting full
  670.         if (bugfix_ts_ && ((seqno - highest_ack_) > tss_size_* 0.9)) {
  671.                 double *ntss;
  672.                 ntss = (double*) calloc(tss_size_*2, sizeof(double));
  673.                 printf("%p resizing timestamp tablen", this);
  674.                 if (ntss == NULL) exit(1);
  675.                 for (int i=0; i<tss_size_; i++)
  676.                         ntss[(highest_ack_ + i) % (tss_size_ * 2)] =
  677.                                 tss[(highest_ack_ + i) % tss_size_];
  678.                 free(tss);
  679.                 tss_size_ *= 2;
  680.                 tss = ntss;
  681.         }
  682.  
  683.         if (tss!=NULL)
  684.                 tss[seqno % tss_size_] = tcph->ts(); 
  686. tcph->ts_echo() = ts_peer_;
  687. tcph->reason() = reason;
  688. tcph->last_rtt() = int(int(t_rtt_)*tcp_tick_*1000);
  690. if (ecn_) {
  691. hf->ect() = 1; // ECN-capable transport
  692. }
  693. if (cong_action_ && (!is_retransmit || SetCWRonRetransmit_)) {
  694. hf->cong_action() = TRUE;  // Congestion action.
  695. cong_action_ = FALSE;
  696.         }
  697. /* Check if this is the initial SYN packet. */
  698. if (seqno == 0) {
  699. if (syn_) {
  700. databytes = 0;
  701. curseq_ += 1;
  702. hdr_cmn::access(p)->size() = tcpip_base_hdr_size_;
  703. ++syn_connects_;
  704. //fprintf(stderr, "TCPAgent: syn_connects_ %d max_connects_ %dn",
  705. // syn_connects_, max_connects_);
  706. if (max_connects_ > 0 &&
  707.                                syn_connects_ > max_connects_) {
  708.       // Abort the connection.
  709.       // What is the best way to abort the connection?
  710.       curseq_ = 0;
  711.                       rtx_timer_.resched(10000);
  712.                               return;
  713.                         }
  714. }
  715. if (ecn_) {
  716. hf->ecnecho() = 1;
  717. // hf->cong_action() = 1;
  718. hf->ect() = 0;
  719. }
  720. if (qs_enabled_) {
  721. hdr_qs *qsh = hdr_qs::access(p);
  723. // dataout is kilobytes queued for sending
  724. int dataout = (curseq_ - maxseq_ - 1) * (size_ + headersize()) / 1024;
  725. int qs_rr = rate_request_;
  726. if (qs_request_mode_ == 1 && qs_rtt_ > 0) {
  727. // PS: Avoid making unnecessary QS requests
  728. // use a rough estimation of RTT in qs_rtt_
  729. // to calculate the desired rate from dataout.
  730. // printf("dataout %d qs_rr %d qs_rtt_ %dn",
  731. // dataout, qs_rr, qs_rtt_);
  732. if (dataout * 1000 / qs_rtt_ < qs_rr) {
  733. qs_rr = dataout * 1000 / qs_rtt_;
  734. }
  735. // printf("request %dn", qs_rr);
  736. // qs_thresh_ is minimum number of unsent
  737. // segments needed to activate QS request
  738. // printf("curseq_ %d maxseq_ %d qs_thresh_ %dn",
  739. //  int(curseq_), int(maxseq_), qs_thresh_);
  740. if ((curseq_ - maxseq_ - 1) < qs_thresh_) {
  741. qs_rr = 0;
  742. }
  743. } 
  745.      if (qs_rr > 0) {
  746. if (print_request_) 
  747. printf("QS request (before encoding): %d KBpsn", qs_rr);
  748. // QuickStart code from Srikanth Sundarrajan.
  749. qsh->flag() = QS_REQUEST;
  750. qsh->ttl() = Random::integer(256);
  751. ttl_diff_ = (iph->ttl() - qsh->ttl()) % 256;
  752. qsh->rate() = hdr_qs::Bps_to_rate(qs_rr * 1024);
  753. qs_requested_ = 1;
  754.      } else {
  755. qsh->flag() = QS_DISABLE;
  756. }
  757. }
  758. }
  759. else if (useHeaders_ == true) {
  760. hdr_cmn::access(p)->size() += headersize();
  761. }
  762.         hdr_cmn::access(p)->size();
  764. /* if no outstanding data, be sure to set rtx timer again */
  765. if (highest_ack_ == maxseq_)
  766. force_set_rtx_timer = 1;
  767. /* call helper function to fill in additional fields */
  768. output_helper(p);
  770.         ++ndatapack_;
  771.         ndatabytes_ += databytes;
  772. send(p, 0);
  773. if (seqno == curseq_ && seqno > maxseq_)
  774. idle();  // Tell application I have sent everything so far
  775. if (seqno > maxseq_) {
  776. maxseq_ = seqno;
  777. if (!rtt_active_) {
  778. rtt_active_ = 1;
  779. if (seqno > rtt_seq_) {
  780. rtt_seq_ = seqno;
  781. rtt_ts_ = Scheduler::instance().clock();
  782. }
  784. }
  785. } else {
  786.          ++nrexmitpack_;
  787. nrexmitbytes_ += databytes;
  788. }
  789. if (!(rtx_timer_.status() == TIMER_PENDING) || force_set_rtx_timer)
  790. /* No timer pending.  Schedule one. */
  791. set_rtx_timer();
  792. }
  794. /*
  795.  * Must convert bytes into packets for one-way TCPs.
  796.  * If nbytes == -1, this corresponds to infinite send.  We approximate
  797.  * infinite by a very large number (TCP_MAXSEQ).
  798.  */
  799. void TcpAgent::sendmsg(int nbytes, const char* /*flags*/)
  800. {
  801. if (nbytes == -1 && curseq_ <= TCP_MAXSEQ)
  802. curseq_ = TCP_MAXSEQ; 
  803. else
  804. curseq_ += (nbytes/size_ + (nbytes%size_ ? 1 : 0));
  805. send_much(0, 0, maxburst_);
  806. }
  808. void TcpAgent::advanceby(int delta)
  809. {
  810.   curseq_ += delta;
  811. if (delta > 0)
  812. closed_ = 0;
  813. send_much(0, 0, maxburst_); 
  814. }
  817. int TcpAgent::command(int argc, const char*const* argv)
  818. {
  819. if (argc == 3) {
  820. if (strcmp(argv[1], "advance") == 0) {
  821. int newseq = atoi(argv[2]);
  822. if (newseq > maxseq_)
  823. advanceby(newseq - curseq_);
  824. else
  825. advanceby(maxseq_ - curseq_);
  826. return (TCL_OK);
  827. }
  828. if (strcmp(argv[1], "advanceby") == 0) {
  829. advanceby(atoi(argv[2]));
  830. return (TCL_OK);
  831. }
  832. if (strcmp(argv[1], "eventtrace") == 0) {
  833. et_ = (EventTrace *)TclObject::lookup(argv[2]);
  834. return (TCL_OK);
  835. }
  836. /*
  837.  * Curtis Villamizar's trick to transfer tcp connection
  838.  * parameters to emulate http persistent connections.
  839.  *
  840.  * Another way to do the same thing is to open one tcp
  841.  * object and use start/stop/maxpkts_ or advanceby to control
  842.  * how much data is sent in each burst.
  843.  * With a single connection, slow_start_restart_
  844.  * should be configured as desired.
  845.  *
  846.  * This implementation (persist) may not correctly
  847.  * emulate pure-BSD-based systems which close cwnd
  848.  * after the connection goes idle (slow-start
  849.  * restart).  See appendix C in
  850.  * Jacobson and Karels ``Congestion
  851.  * Avoidance and Control'' at
  852.  * <ftp://ftp.ee.lbl.gov/papers/congavoid.ps.Z>
  853.  * (*not* the original
  854.  * '88 paper) for why BSD does this.  See
  855.  * ``Performance Interactions Between P-HTTP and TCP
  856.  * Implementations'' in CCR 27(2) for descriptions of
  857.  * what other systems do the same.
  858.  *
  859.  */
  860. if (strcmp(argv[1], "persist") == 0) {
  861. TcpAgent *other
  862.   = (TcpAgent*)TclObject::lookup(argv[2]);
  863. cwnd_ = other->cwnd_;
  864. awnd_ = other->awnd_;
  865. ssthresh_ = other->ssthresh_;
  866. t_rtt_ = other->t_rtt_;
  867. t_srtt_ = other->t_srtt_;
  868. t_rttvar_ = other->t_rttvar_;
  869. t_backoff_ = other->t_backoff_;
  870. return (TCL_OK);
  871. }
  872. }
  873. return (Agent::command(argc, argv));
  874. }
  876. /*
  877.  * Returns the window size adjusted to allow <num> segments past recovery
  878.  * point to be transmitted on next ack.
  879.  */
  880. int TcpAgent::force_wnd(int num)
  881. {
  882. return recover_ + num - (int)highest_ack_;
  883. }
  885. int TcpAgent::window()
  886. {
  887.         /*
  888.          * If F-RTO is enabled and first ack has come in, temporarily open
  889.          * window for sending two segments.
  890.  * The F-RTO code is from Pasi Sarolahti.  F-RTO is an algorithm
  891.  * for detecting spurious retransmission timeouts.
  892.          */
  893.         if (frto_ == 2) {
  894.                 return (force_wnd(2) < wnd_ ?
  895.                         force_wnd(2) : (int)wnd_);
  896.         } else {
  897. return (cwnd_ < wnd_ ? (int)cwnd_ : (int)wnd_);
  898.         }
  899. }
  901. double TcpAgent::windowd()
  902. {
  903. return (cwnd_ < wnd_ ? (double)cwnd_ : (double)wnd_);
  904. }
  906. /*
  907.  * Try to send as much data as the window will allow.  The link layer will 
  908.  * do the buffering; we ask the application layer for the size of the packets.
  909.  */
  910. void TcpAgent::send_much(int force, int reason, int maxburst)
  911. {
  912. send_idle_helper();
  913. int win = window();
  914. int npackets = 0;
  916. if (!force && delsnd_timer_.status() == TIMER_PENDING)
  917. return;
  918. /* Save time when first packet was sent, for newreno  --Allman */
  919. if (t_seqno_ == 0)
  920. firstsent_ = Scheduler::instance().clock();
  922. if (burstsnd_timer_.status() == TIMER_PENDING)
  923. return;
  924. while (t_seqno_ <= highest_ack_ + win && t_seqno_ < curseq_) {
  925. if (overhead_ == 0 || force || qs_approved_) {
  926. output(t_seqno_, reason);
  927. npackets++;
  928. if (QOption_)
  929. process_qoption_after_send () ; 
  930. t_seqno_ ++ ;
  931. if (qs_approved_ == 1) {
  932. // delay = effective RTT / window
  933. double delay = (double) t_rtt_ * tcp_tick_ / win;
  934. if (overhead_) { 
  935. delsnd_timer_.resched(delay + Random::uniform(overhead_));
  936. } else {
  937. delsnd_timer_.resched(delay);
  938. }
  939. return;
  940. }
  941. } else if (!(delsnd_timer_.status() == TIMER_PENDING)) {
  942. /*
  943.  * Set a delayed send timeout.
  944.  */
  945. delsnd_timer_.resched(Random::uniform(overhead_));
  946. return;
  947. }
  948. win = window();
  949. if (maxburst && npackets == maxburst)
  950. break;
  951. }
  952. /* call helper function */
  953. send_helper(maxburst);
  954. }
  956. /*
  957.  * We got a timeout or too many duplicate acks.  Clear the retransmit timer.  
  958.  * Resume the sequence one past the last packet acked.  
  959.  * "mild" is 0 for timeouts and Tahoe dup acks, 1 for Reno dup acks.
  960.  * "backoff" is 1 if the timer should be backed off, 0 otherwise.
  961.  */
  962. void TcpAgent::reset_rtx_timer(int mild, int backoff)
  963. {
  964. if (backoff)
  965. rtt_backoff();
  966. set_rtx_timer();
  967. if (!mild)
  968. t_seqno_ = highest_ack_ + 1;
  969. rtt_active_ = 0;
  970. }
  972. /*
  973.  * Set retransmit timer using current rtt estimate.  By calling resched(), 
  974.  * it does not matter whether the timer was already running.
  975.  */
  976. void TcpAgent::set_rtx_timer()
  977. {
  978. rtx_timer_.resched(rtt_timeout());
  979. }
  981. /*
  982.  * Set new retransmission timer if not all outstanding
  983.  * or available data acked, or if we are unable to send because 
  984.  * cwnd is less than one (as when the ECN bit is set when cwnd was 1).
  985.  * Otherwise, if a timer is still outstanding, cancel it.
  986.  */
  987. void TcpAgent::newtimer(Packet* pkt)
  988. {
  989. hdr_tcp *tcph = hdr_tcp::access(pkt);
  990. /*
  991.  * t_seqno_, the next packet to send, is reset (decreased) 
  992.  *   to highest_ack_ + 1 after a timeout,
  993.  *   so we also have to check maxseq_, the highest seqno sent.
  994.  * In addition, if the packet sent after the timeout has
  995.  *   the ECN bit set, then the returning ACK caused cwnd_ to
  996.  *   be decreased to less than one, and we can't send another
  997.  *   packet until the retransmit timer again expires.
  998.  *   So we have to check for "cwnd_ < 1" as well.
  999.  */
  1000. if (t_seqno_ > tcph->seqno() || tcph->seqno() < maxseq_ || cwnd_ < 1) 
  1001. set_rtx_timer();
  1002. else
  1003. cancel_rtx_timer();
  1004. }
  1006. /*
  1007.  * for experimental, high-speed TCP
  1008.  */
  1009. double TcpAgent::linear(double x, double x_1, double y_1, double x_2, double y_2)
  1010. {
  1011. // The y coordinate factor ranges from y_1 to y_2
  1012. //  as the x coordinate ranges from x_1 to x_2.
  1013. double y = y_1 + ((y_2 - y_1) * ((x - x_1)/(x_2-x_1)));
  1014. return y;
  1015. }
  1017. /*
  1018.  * Limited Slow-Start for large congestion windows.
  1019.  * This should only be called when max_ssthresh_ is non-zero.
  1020.  */
  1021. double TcpAgent::limited_slow_start(double cwnd, int max_ssthresh, double increment)
  1022. {
  1023.         if (max_ssthresh <= 0) {
  1024.    return increment;
  1025. } else {
  1026.                 double increment1 = 0.0;
  1027. int round = int(cwnd / (double(max_ssthresh)/2.0));
  1028. if (round > 0) {
  1029.    increment1 = 1.0/double(round); 
  1030. } 
  1031. if (increment < increment1) {
  1032.    return increment1;
  1033. } else {
  1034.    return increment;
  1035. }
  1036. }
  1037. }
  1039. /*
  1040.  * For retrieving numdupacks_.
  1041.  */
  1042. int TcpAgent::numdupacks(double cwnd)
  1043. {
  1044.         int cwndfraction = (int) cwnd/numdupacksFrac_;
  1045. if (numdupacks_ > cwndfraction) {
  1046.    return numdupacks_;
  1047.         } else {
  1048.    return cwndfraction;
  1049. }
  1050. }
  1052. /*
  1053.  * Calculating the decrease parameter for highspeed TCP.
  1054.  */
  1055. double TcpAgent::decrease_param()
  1056. {
  1057. double decrease;
  1058. // OLD:
  1059. // decrease = linear(log(cwnd_), log(low_window_), 0.5, log(high_window_), high_decrease_);
  1060. // NEW (but equivalent):
  1061.         decrease = hstcp_.dec1 + log(cwnd_) * hstcp_.dec2;  
  1062. return decrease;
  1063. }
  1065. /*
  1066.  * Calculating the increase parameter for highspeed TCP.
  1067.  */
  1068. double TcpAgent::increase_param()
  1069. {
  1070. double increase, decrease, p, answer;
  1071. /* extending the slow-start for high-speed TCP */
  1073. /* for highspeed TCP -- from Sylvia Ratnasamy, */
  1074. /* modifications by Sally Floyd and Evandro de Souza */
  1075.   // p ranges from 1.5/W^2 at congestion window low_window_, to
  1076. //    high_p_ at congestion window high_window_, on a log-log scale.
  1077.         // The decrease factor ranges from 0.5 to high_decrease
  1078. //  as the window ranges from low_window to high_window, 
  1079. //  as the log of the window. 
  1080. // For an efficient implementation, this would just be looked up
  1081. //   in a table, with the increase and decrease being a function of the
  1082. //   congestion window.
  1084.        if (cwnd_ <= low_window_) { 
  1085. answer = 1 / cwnd_;
  1086.         return answer; 
  1087.        } else if (cwnd_ >= hstcp_.cwnd_last_ && 
  1088.       cwnd_ < hstcp_.cwnd_last_ + cwnd_range_) {
  1089.       // cwnd_range_ can be set to 0 to be disabled,
  1090.       //  or can be set from 1 to 100 
  1091.         answer = hstcp_.increase_last_ / cwnd_;
  1092.                return answer;
  1093.        } else { 
  1094. // OLD:
  1095.   // p = exp(linear(log(cwnd_), log(low_window_), log(hstcp_.low_p), log(high_window_), log(high_p_)));
  1096. // NEW, but equivalent:
  1097.          p = exp(hstcp_.p1 + log(cwnd_) * hstcp_.p2);  
  1098.          decrease = decrease_param();
  1099. // OLD:
  1100. // increase = cwnd_*cwnd_*p *(2.0*decrease)/(2.0 - decrease); 
  1101. // NEW, but equivalent:
  1102. increase = cwnd_ * cwnd_ * p /(1/decrease - 0.5);
  1103. // if (increase > max_increase) { 
  1104. // increase = max_increase;
  1105. // } 
  1106. answer = increase / cwnd_;
  1107. hstcp_.cwnd_last_ = cwnd_;
  1108. hstcp_.increase_last_ = increase;
  1109.         return answer;
  1110. }       
  1111. }
  1113. /*
  1114.  * open up the congestion window
  1115.  */
  1116. void TcpAgent::opencwnd()
  1117. {
  1118. double increment;
  1119. if (cwnd_ < ssthresh_) {
  1120. /* slow-start (exponential) */
  1121. cwnd_ += 1;
  1122. } else {
  1123. /* linear */
  1124. double f;
  1125. switch (wnd_option_) {
  1126. case 0:
  1127. if (++count_ >= cwnd_) {
  1128. count_ = 0;
  1129. ++cwnd_;
  1130. }
  1131. break;
  1133. case 1:
  1134. /* This is the standard algorithm. */
  1135. increment = increase_num_ / cwnd_;
  1136. if ((last_cwnd_action_ == 0 ||
  1137.   last_cwnd_action_ == CWND_ACTION_TIMEOUT) 
  1138.   && max_ssthresh_ > 0) {
  1139. increment = limited_slow_start(cwnd_,
  1140.   max_ssthresh_, increment);
  1141. }
  1142. cwnd_ += increment;
  1143. break;
  1145. case 2:
  1146. /* These are window increase algorithms
  1147.  * for experimental purposes only. */
  1148. /* This is the Constant-Rate increase algorithm 
  1149.                          *  from the 1991 paper by S. Floyd on "Connections  
  1150.  *  with Multiple Congested Gateways". 
  1151.  *  The window is increased by roughly 
  1152.  *  wnd_const_*RTT^2 packets per round-trip time.  */
  1153. f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
  1154. f *= f;
  1155. f *= wnd_const_;
  1156. /* f = wnd_const_ * RTT^2 */
  1157. f += fcnt_;
  1158. if (f > cwnd_) {
  1159. fcnt_ = 0;
  1160. ++cwnd_;
  1161. } else
  1162. fcnt_ = f;
  1163. break;
  1165. case 3:
  1166. /* The window is increased by roughly 
  1167.  *  awnd_^2 * wnd_const_ packets per RTT,
  1168.  *  for awnd_ the average congestion window. */
  1169. f = awnd_;
  1170. f *= f;
  1171. f *= wnd_const_;
  1172. f += fcnt_;
  1173. if (f > cwnd_) {
  1174. fcnt_ = 0;
  1175. ++cwnd_;
  1176. } else
  1177. fcnt_ = f;
  1178. break;
  1180.                 case 4:
  1181. /* The window is increased by roughly 
  1182.  *  awnd_ * wnd_const_ packets per RTT,
  1183.  *  for awnd_ the average congestion window. */
  1184.                         f = awnd_;
  1185.                         f *= wnd_const_;
  1186.                         f += fcnt_;
  1187.                         if (f > cwnd_) {
  1188.                                 fcnt_ = 0;
  1189.                                 ++cwnd_;
  1190.                         } else
  1191.                                 fcnt_ = f;
  1192.                         break;
  1193. case 5:
  1194. /* The window is increased by roughly wnd_const_*RTT 
  1195.  *  packets per round-trip time, as discussed in
  1196.  *  the 1992 paper by S. Floyd on "On Traffic 
  1197.  *  Phase Effects in Packet-Switched Gateways". */
  1198.                         f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
  1199.                         f *= wnd_const_;
  1200.                         f += fcnt_;
  1201.                         if (f > cwnd_) {
  1202.                                 fcnt_ = 0;
  1203.                                 ++cwnd_;
  1204.                         } else
  1205.                                 fcnt_ = f;
  1206.                         break;
  1207.                 case 6:
  1208.                         /* binomial controls */ 
  1209.                         cwnd_ += increase_num_ / (cwnd_*pow(cwnd_,k_parameter_));                
  1210.                         break; 
  1211.   case 8: 
  1212. /* high-speed TCP, RFC 3649 */
  1213. increment = increase_param();
  1214. if ((last_cwnd_action_ == 0 ||
  1215.   last_cwnd_action_ == CWND_ACTION_TIMEOUT) 
  1216.   && max_ssthresh_ > 0) {
  1217. increment = limited_slow_start(cwnd_,
  1218.   max_ssthresh_, increment);
  1219. }
  1220. cwnd_ += increment;
  1221.                         break;
  1222. default:
  1223. #ifdef notdef
  1224. /*XXX*/
  1225. error("illegal window option %d", wnd_option_);
  1226. #endif
  1227. abort();
  1228. }
  1229. }
  1230. // if maxcwnd_ is set (nonzero), make it the cwnd limit
  1231. if (maxcwnd_ && (int(cwnd_) > maxcwnd_))
  1232. cwnd_ = maxcwnd_;
  1234. return;
  1235. }
  1237. void
  1238. TcpAgent::slowdown(int how)
  1239. {
  1240. double decrease;  /* added for highspeed - sylvia */
  1241. double win, halfwin, decreasewin;
  1242. int slowstart = 0;
  1243. ++ncwndcuts_;
  1244. if (!(how & TCP_IDLE) && !(how & NO_OUTSTANDING_DATA)){
  1245. ++ncwndcuts1_; 
  1246. }
  1247. // we are in slowstart for sure if cwnd < ssthresh
  1248. if (cwnd_ < ssthresh_) 
  1249. slowstart = 1;
  1250.         if (precision_reduce_) {
  1251. halfwin = windowd() / 2;
  1252.                 if (wnd_option_ == 6) {         
  1253.                         /* binomial controls */
  1254.                         decreasewin = windowd() - (1.0-decrease_num_)*pow(windowd(),l_parameter_);
  1255.                 } else if (wnd_option_ == 8 && (cwnd_ > low_window_)) { 
  1256.                         /* experimental highspeed TCP */
  1257. decrease = decrease_param();
  1258. //if (decrease < 0.1) 
  1259. // decrease = 0.1;
  1260. decrease_num_ = decrease;
  1261.                         decreasewin = windowd() - (decrease * windowd());
  1262.                 } else {
  1263.   decreasewin = decrease_num_ * windowd();
  1264. }
  1265. win = windowd();
  1266. } else  {
  1267. int temp;
  1268. temp = (int)(window() / 2);
  1269. halfwin = (double) temp;
  1270.                 if (wnd_option_ == 6) {
  1271.                         /* binomial controls */
  1272.                         temp = (int)(window() - (1.0-decrease_num_)*pow(window(),l_parameter_));
  1273.                 } else if ((wnd_option_ == 8) && (cwnd_ > low_window_)) { 
  1274.                         /* experimental highspeed TCP */
  1275. decrease = decrease_param();
  1276. //if (decrease < 0.1)
  1277.                         //       decrease = 0.1;
  1278. decrease_num_ = decrease;
  1279.                         temp = (int)(windowd() - (decrease * windowd()));
  1280.                 } else {
  1281.   temp = (int)(decrease_num_ * window());
  1282. }
  1283. decreasewin = (double) temp;
  1284. win = (double) window();
  1285. }
  1286. if (how & CLOSE_SSTHRESH_HALF)
  1287. // For the first decrease, decrease by half
  1288. // even for non-standard values of decrease_num_.
  1289. if (first_decrease_ == 1 || slowstart ||
  1290. last_cwnd_action_ == CWND_ACTION_TIMEOUT) {
  1291. // Do we really want halfwin instead of decreasewin
  1292. // after a timeout?
  1293. ssthresh_ = (int) halfwin;
  1294. } else {
  1295. ssthresh_ = (int) decreasewin;
  1296. }
  1297.         else if (how & THREE_QUARTER_SSTHRESH)
  1298. if (ssthresh_ < 3*cwnd_/4)
  1299. ssthresh_  = (int)(3*cwnd_/4);
  1300. if (how & CLOSE_CWND_HALF)
  1301. // For the first decrease, decrease by half
  1302. // even for non-standard values of decrease_num_.
  1303. if (first_decrease_ == 1 || slowstart || decrease_num_ == 0.5) {
  1304. cwnd_ = halfwin;
  1305. } else cwnd_ = decreasewin;
  1306.         else if (how & CWND_HALF_WITH_MIN) {
  1307. // We have not thought about how non-standard TCPs, with
  1308. // non-standard values of decrease_num_, should respond
  1309. // after quiescent periods.
  1310.                 cwnd_ = decreasewin;
  1311.                 if (cwnd_ < 1)
  1312.                         cwnd_ = 1;
  1313. }
  1314. else if (how & CLOSE_CWND_RESTART) 
  1315. cwnd_ = int(wnd_restart_);
  1316. else if (how & CLOSE_CWND_INIT)
  1317. cwnd_ = int(wnd_init_);
  1318. else if (how & CLOSE_CWND_ONE)
  1319. cwnd_ = 1;
  1320. else if (how & CLOSE_CWND_HALF_WAY) {
  1321. // cwnd_ = win - (win - W_used)/2 ;
  1322. cwnd_ = W_used + decrease_num_ * (win - W_used);
  1323.                 if (cwnd_ < 1)
  1324.                         cwnd_ = 1;
  1325. }
  1326. if (ssthresh_ < 2)
  1327. ssthresh_ = 2;
  1328. if (how & (CLOSE_CWND_HALF|CLOSE_CWND_RESTART|CLOSE_CWND_INIT|CLOSE_CWND_ONE))
  1329. cong_action_ = TRUE;
  1331. fcnt_ = count_ = 0;
  1332. if (first_decrease_ == 1)
  1333. first_decrease_ = 0;
  1334. // for event tracing slow start
  1335. if (cwnd_ == 1 || slowstart) 
  1336. // Not sure if this is best way to capture slow_start
  1337. // This is probably tracing a superset of slowdowns of
  1338. // which all may not be slow_start's --Padma, 07/'01.
  1339. trace_event("SLOW_START");
  1344. }
  1346. /*
  1347.  * Process a packet that acks previously unacknowleged data.
  1348.  */
  1349. void TcpAgent::newack(Packet* pkt)
  1350. {
  1351. double now = Scheduler::instance().clock();
  1352. hdr_tcp *tcph = hdr_tcp::access(pkt);
  1353. /* 
  1354.  * Wouldn't it be better to set the timer *after*
  1355.  * updating the RTT, instead of *before*? 
  1356.  */
  1357. if (!timerfix_) newtimer(pkt);
  1358. dupacks_ = 0;
  1359. last_ack_ = tcph->seqno();
  1360. prev_highest_ack_ = highest_ack_ ;
  1361. highest_ack_ = last_ack_;
  1363. if (t_seqno_ < last_ack_ + 1)
  1364. t_seqno_ = last_ack_ + 1;
  1365. /* 
  1366.  * Update RTT only if it's OK to do so from info in the flags header.
  1367.  * This is needed for protocols in which intermediate agents
  1368.  * in the network intersperse acks (e.g., ack-reconstructors) for
  1369.  * various reasons (without violating e2e semantics).
  1370.  */
  1371. hdr_flags *fh = hdr_flags::access(pkt);
  1372. if (!fh->no_ts_) {
  1373. if (ts_option_) {
  1374. ts_echo_=tcph->ts_echo();
  1375. rtt_update(now - tcph->ts_echo());
  1376. if (ts_resetRTO_ && (!ect_ || !ecn_backoff_ ||
  1377.     !hdr_flags::access(pkt)->ecnecho())) { 
  1378. // From Andrei Gurtov
  1379. /* 
  1380.  * Don't end backoff if still in ECN-Echo with
  1381.    * a congestion window of 1 packet. 
  1382.  */
  1383. t_backoff_ = 1;
  1384. ecn_backoff_ = 0;
  1385. }
  1386. }
  1387. if (rtt_active_ && tcph->seqno() >= rtt_seq_) {
  1388. if (!ect_ || !ecn_backoff_ || 
  1389. !hdr_flags::access(pkt)->ecnecho()) {
  1390. /* 
  1391.  * Don't end backoff if still in ECN-Echo with
  1392.    * a congestion window of 1 packet. 
  1393.  */
  1394. t_backoff_ = 1;
  1395. ecn_backoff_ = 0;
  1396. }
  1397. rtt_active_ = 0;
  1398. if (!ts_option_)
  1399. rtt_update(now - rtt_ts_);
  1400. }
  1401. }
  1402. if (timerfix_) newtimer(pkt);
  1403. /* update average window */
  1404. awnd_ *= 1.0 - wnd_th_;
  1405. awnd_ += wnd_th_ * cwnd_;
  1406. }
  1409. /*
  1410.  * Respond either to a source quench or to a congestion indication bit.
  1411.  * This is done at most once a roundtrip time;  after a source quench,
  1412.  * another one will not be done until the last packet transmitted before
  1413.  * the previous source quench has been ACKed.
  1414.  *
  1415.  * Note that this procedure is called before "highest_ack_" is
  1416.  * updated to reflect the current ACK packet.  
  1417.  */
  1418. void TcpAgent::ecn(int seqno)
  1419. {
  1420. if (seqno > recover_ || 
  1421.       last_cwnd_action_ == CWND_ACTION_TIMEOUT) {
  1422. recover_ =  maxseq_;
  1423. last_cwnd_action_ = CWND_ACTION_ECN;
  1424. if (cwnd_ <= 1.0) {
  1425. if (ecn_backoff_) 
  1426. rtt_backoff();
  1427. else ecn_backoff_ = 1;
  1428. } else ecn_backoff_ = 0;
  1429. slowdown(CLOSE_CWND_HALF|CLOSE_SSTHRESH_HALF);
  1430. ++necnresponses_ ;
  1431. // added by sylvia to count number of ecn responses 
  1432. }
  1433. }
  1435. /*
  1436.  *  Is the connection limited by the network (instead of by a lack
  1437.  *    of data from the application?
  1438.  */
  1439. int TcpAgent::network_limited() {
  1440. int win = window () ;
  1441. if (t_seqno_ > (prev_highest_ack_ + win))
  1442. return 1;
  1443. else
  1444. return 0;
  1445. }
  1447. void TcpAgent::recv_newack_helper(Packet *pkt) {
  1448. //hdr_tcp *tcph = hdr_tcp::access(pkt);
  1449. newack(pkt);
  1450.         if (qs_window_ && highest_ack_ >= qs_window_) {
  1451.                 // All segments in the QS window have been acknowledged.
  1452.                 // We can exit the Quick-Start phase.
  1453.                 qs_window_ = 0;
  1454.         }
  1455. if (!ect_ || !hdr_flags::access(pkt)->ecnecho() ||
  1456. (old_ecn_ && ecn_burst_)) {
  1457. /* If "old_ecn", this is not the first ACK carrying ECN-Echo
  1458.  * after a period of ACKs without ECN-Echo.
  1459.  * Therefore, open the congestion window. */
  1460. /* if control option is set, and the sender is not
  1461.  window limited, then do not increase the window size */
  1463. if (!control_increase_ || 
  1464.    (control_increase_ && (network_limited() == 1))) 
  1465.        opencwnd();
  1466. }
  1467. if (ect_) {
  1468. if (!hdr_flags::access(pkt)->ecnecho())
  1469. ecn_backoff_ = 0;
  1470. if (!ecn_burst_ && hdr_flags::access(pkt)->ecnecho())
  1471. ecn_burst_ = TRUE;
  1472. else if (ecn_burst_ && ! hdr_flags::access(pkt)->ecnecho())
  1473. ecn_burst_ = FALSE;
  1474. }
  1475. if (!ect_ && hdr_flags::access(pkt)->ecnecho() &&
  1476. !hdr_flags::access(pkt)->cong_action())
  1477. ect_ = 1;
  1478. /* if the connection is done, call finish() */
  1479. if ((highest_ack_ >= curseq_-1) && !closed_) {
  1480. closed_ = 1;
  1481. finish();
  1482. }
  1483. if (QOption_ && curseq_ == highest_ack_ +1) {
  1484. cancel_rtx_timer();
  1485. }
  1486. if (frto_ == 1) {
  1487. /*
  1488.  * New ack after RTO. If F-RTO is enabled, try to transmit new
  1489.  * previously unsent segments.
  1490.  * If there are no new data or receiver window limits the
  1491.  * transmission, revert to traditional recovery.
  1492.  */
  1493. if (recover_ + 1 >= highest_ack_ + wnd_ ||
  1494.     recover_ + 1 >= curseq_) {
  1495. frto_ = 0;
  1496.   } else if (highest_ack_ == recover_) {
  1497.   /*
  1498.    * F-RTO step 2a) RTO retransmission fixes whole
  1499.  * window => cancel F-RTO
  1500.    */
  1501.   frto_ = 0;
  1502. } else {
  1503. t_seqno_ = recover_ + 1;
  1504. frto_ = 2;
  1505. }
  1506. } else if (frto_ == 2) {
  1507. /*
  1508.  * Second new ack after RTO. If F-RTO is enabled, RTO can be
  1509.  * declared spurious
  1510.  */
  1511. spurious_timeout();
  1512. }
  1513. }
  1515. /*
  1516.  * Set the initial window. 
  1517.  */
  1518. double
  1519. TcpAgent::initial_window()
  1520. {
  1521.         // If Quick-Start Request was approved, use that as a basis for
  1522.         // initial window
  1523.         if (qs_cwnd_) {
  1524.                 return (qs_cwnd_);
  1525.         }
  1526. //
  1527. // init_option = 1: static iw of wnd_init_
  1528. //
  1529. if (wnd_init_option_ == 1) {
  1530. return (wnd_init_);
  1531. }
  1532.         else if (wnd_init_option_ == 2) {
  1533. // do iw according to Internet draft
  1534.   if (size_ <= 1095) {
  1535. return (4.0);
  1536.   } else if (size_ < 2190) {
  1537. return (3.0);
  1538. } else {
  1539. return (2.0);
  1540. }
  1541. }
  1542. // XXX what should we return here???
  1543. fprintf(stderr, "Wrong number of wnd_init_option_ %dn", 
  1544. wnd_init_option_);
  1545. abort();
  1546. return (2.0); // XXX make msvc happy.
  1547. }
  1549. /*
  1550.  * Dupack-action: what to do on a DUP ACK.  After the initial check
  1551.  * of 'recover' below, this function implements the following truth
  1552.  * table:
  1553.  *
  1554.  * bugfix ecn last-cwnd == ecn action
  1555.  *
  1556.  * 0 0 0 tahoe_action
  1557.  * 0 0 1 tahoe_action [impossible]
  1558.  * 0 1 0 tahoe_action
  1559.  * 0 1 1 slow-start, return
  1560.  * 1 0 0 nothing
  1561.  * 1 0 1 nothing [impossible]
  1562.  * 1 1 0 nothing
  1563.  * 1 1 1 slow-start, return
  1564.  */
  1566. /* 
  1567.  * A first or second duplicate acknowledgement has arrived, and
  1568.  * singledup_ is enabled.
  1569.  * If the receiver's advertised window permits, and we are exceeding our
  1570.  * congestion window by less than numdupacks_, then send a new packet.
  1571.  */
  1572. void
  1573. TcpAgent::send_one()
  1574. {
  1575. if (t_seqno_ <= highest_ack_ + wnd_ && t_seqno_ < curseq_ &&
  1576. t_seqno_ <= highest_ack_ + cwnd_ + dupacks_ ) {
  1577. output(t_seqno_, 0);
  1578. if (QOption_)
  1579. process_qoption_after_send () ;
  1580. t_seqno_ ++ ;
  1581. // send_helper(); ??
  1582. }
  1583. return;
  1584. }
  1586. void
  1587. TcpAgent::dupack_action()
  1588. {
  1589. int recovered = (highest_ack_ > recover_);
  1590. if (recovered || (!bug_fix_ && !ecn_) || 
  1591. (bugfix_ss_ && highest_ack_ == 0)) {
  1592. // (highest_ack_ == 0) added to allow Fast Retransmit
  1593. //  when the first data packet is dropped.
  1594. //  Bug report from Mark Allman.
  1595. goto tahoe_action;
  1596. }
  1598. if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {
  1599. last_cwnd_action_ = CWND_ACTION_DUPACK;
  1600. slowdown(CLOSE_CWND_ONE);
  1601. reset_rtx_timer(0,0);
  1602. return;
  1603. }
  1605. if (bug_fix_) {
  1606. /*
  1607.  * The line below, for "bug_fix_" true, avoids
  1608.  * problems with multiple fast retransmits in one
  1609.  * window of data. 
  1610.  */
  1611. return;
  1612. }
  1614. tahoe_action:
  1615.         recover_ = maxseq_;
  1616.         if (!lossQuickStart()) {
  1617. // we are now going to fast-retransmit and willtrace that event
  1618. trace_event("FAST_RETX");
  1619. last_cwnd_action_ = CWND_ACTION_DUPACK;
  1620. slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_ONE);
  1621. }
  1622. reset_rtx_timer(0,0);
  1623. return;
  1624. }
  1626. /*
  1627.  * When exiting QuickStart, reduce the congestion window to the
  1628.  *   size that was actually used.
  1629.  */
  1630. void TcpAgent::endQuickStart()
  1631. {
  1632. qs_approved_ = 0;
  1633.         qs_cwnd_ = 0;
  1634.         qs_window_ = maxseq_;
  1635. int new_cwnd = maxseq_ - last_ack_;
  1636. if (new_cwnd > 1 && new_cwnd < cwnd_) {
  1637.   cwnd_ = new_cwnd;
  1638. if (cwnd_ < initial_window()) 
  1639. cwnd_ = initial_window();
  1640. }
  1641. }
  1643. void TcpAgent::processQuickStart(Packet *pkt)
  1644. {
  1645. // QuickStart code from Srikanth Sundarrajan.
  1646. hdr_tcp *tcph = hdr_tcp::access(pkt);
  1647. hdr_qs *qsh = hdr_qs::access(pkt);
  1648. double now = Scheduler::instance().clock();
  1649. int app_rate;
  1651.         // printf("flag: %d ttl: %d ttl_diff: %d rate: %dn", qsh->flag(),
  1652. //     qsh->ttl(), ttl_diff_, qsh->rate());
  1653. qs_requested_ = 0;
  1654. qs_approved_ = 0;
  1655. if (qsh->flag() == QS_RESPONSE && qsh->ttl() == ttl_diff_ && 
  1656.             qsh->rate() > 0) {
  1657.                 app_rate = (int) ((hdr_qs::rate_to_Bps(qsh->rate()) *
  1658.                       (now - tcph->ts_echo())) / (size_ + headersize()));
  1659. if (print_request_) {
  1660.   double num1 = hdr_qs::rate_to_Bps(qsh->rate());
  1661.   double time = now - tcph->ts_echo();
  1662.   int size = size_ + headersize();
  1663.   printf("Quick Start request, rate: %g Bps, encoded rate: %dn", 
  1664.      num1, qsh->rate());
  1665.   printf("Quick Start request, window %d rtt: %4.2f pktsize: %dn",
  1666.      app_rate, time, size);
  1667. }
  1668.                 if (app_rate > initial_window()) {
  1669. qs_cwnd_ = app_rate;
  1670.                         qs_approved_ = 1;
  1671.                 }
  1672.         } else { // Quick Start rejected
  1673. #ifdef QS_DEBUG
  1674.                 printf("Quick Start rejectedn");
  1675. #endif
  1676.         }
  1678. }
  1682. /*
  1683.  * ACK has been received, hook from recv()
  1684.  */
  1685. void TcpAgent::recv_frto_helper(Packet *pkt)
  1686. {
  1687. hdr_tcp *tcph = hdr_tcp::access(pkt);
  1688. if (tcph->seqno() == last_ack_ && frto_ != 0) {
  1689. /*
  1690.  * Duplicate ACK while in F-RTO indicates that the
  1691.  * timeout was valid. Go to slow start retransmissions.
  1692.  */
  1693. t_seqno_ = highest_ack_ + 1;
  1694. cwnd_ = frto_;
  1695. frto_ = 0;
  1697. // Must zero dupacks (in order to trigger send_much at recv)
  1698. // dupacks is increased in recv after exiting this function
  1699. dupacks_ = -1;
  1700. }
  1701. }
  1704. /*
  1705.  * A spurious timeout has been detected. Do appropriate actions.
  1706.  */
  1707. void TcpAgent::spurious_timeout()
  1708. {
  1709. frto_ = 0;
  1711. switch (spurious_response_) {
  1712. case 1:
  1713. default:
  1714. /*
  1715.  * Full revert of congestion window
  1716.  * (FlightSize before last acknowledgment)
  1717.  */
  1718. cwnd_ = t_seqno_ - prev_highest_ack_;
  1719. break;
  1720.  
  1721. case 2:
  1722. /*
  1723.  * cwnd = reduced ssthresh (approx. half of the earlier pipe)
  1724.  */
  1725. cwnd_ = ssthresh_; break;
  1726. case 3:
  1727. /*
  1728.  * slow start, but without retransmissions
  1729.  */
  1730. cwnd_ = 1; break;
  1731. }
  1733. /*
  1734.  * Revert ssthresh to size before retransmission timeout
  1735.  */
  1736. ssthresh_ = pipe_prev_;
  1738. /* If timeout was spurious, bugfix is not needed */
  1739. recover_ = highest_ack_ - 1;
  1740. }
  1743. /*
  1744.  * Loss occurred in Quick-Start window.
  1745.  * If Quick-Start is enabled, packet loss in the QS phase, during slow-start,
  1746.  * should trigger slow start instead of the regular fast retransmit.
  1747.  * We use variable tcp_qs_recovery_ to toggle this behaviour on and off.
  1748.  * If tcp_qs_recovery_ is true, initiate slow start to probe for
  1749.  * a correct window size.
  1750.  *
  1751.  * Return value: non-zero if Quick-Start specific loss recovery took place
  1752.  */
  1753. int TcpAgent::lossQuickStart()
  1754. {
  1755.        if (qs_window_ && tcp_qs_recovery_) {
  1756.                 //recover_ = maxseq_;
  1757.                 //reset_rtx_timer(1,0);
  1758.                 slowdown(CLOSE_CWND_INIT);
  1759. // reset ssthresh to half of W-D/2?
  1760.                 qs_window_ = 0;
  1761.                 output(last_ack_ + 1, TCP_REASON_DUPACK);
  1762.                 return 1;
  1763.        }
  1764.        return 0;
  1765. }
  1770. /*
  1771.  * main reception path - should only see acks, otherwise the
  1772.  * network connections are misconfigured
  1773.  */
  1774. void TcpAgent::recv(Packet *pkt, Handler*)
  1775. {
  1776. hdr_tcp *tcph = hdr_tcp::access(pkt);
  1777. int valid_ack = 0;
  1778. if (qs_approved_ == 1 && tcph->seqno() > last_ack_) 
  1779. endQuickStart();
  1780. if (qs_requested_ == 1)
  1781. processQuickStart(pkt);
  1782. #ifdef notdef
  1783. if (pkt->type_ != PT_ACK) {
  1784. Tcl::instance().evalf("%s error "received non-ack"",
  1785.       name());
  1786. Packet::free(pkt);
  1787. return;
  1788. }
  1789. #endif
  1790. /* W.N.: check if this is from a previous incarnation */
  1791. if (tcph->ts() < lastreset_) {
  1792. // Remove packet and do nothing
  1793. Packet::free(pkt);
  1794. return;
  1795. }
  1796. ++nackpack_;
  1797. ts_peer_ = tcph->ts();
  1798. int ecnecho = hdr_flags::access(pkt)->ecnecho();
  1799. if (ecnecho && ecn_)
  1800. ecn(tcph->seqno());
  1801. recv_helper(pkt);
  1802. recv_frto_helper(pkt);
  1803. /* grow cwnd and check if the connection is done */ 
  1804. if (tcph->seqno() > last_ack_) {
  1805. recv_newack_helper(pkt);
  1806. if (last_ack_ == 0 && delay_growth_) { 
  1807. cwnd_ = initial_window();
  1808. }
  1809. } else if (tcph->seqno() == last_ack_) {
  1810.                 if (hdr_flags::access(pkt)->eln_ && eln_) {
  1811.                         tcp_eln(pkt);
  1812.                         return;
  1813.                 }
  1814. if (++dupacks_ == numdupacks_ && !noFastRetrans_) {
  1815. dupack_action();
  1816. } else if (dupacks_ < numdupacks_ && singledup_ ) {
  1817. send_one();
  1818. }
  1819. }
  1821. if (QOption_ && EnblRTTCtr_)
  1822. process_qoption_after_ack (tcph->seqno());
  1824. if (tcph->seqno() >= last_ack_)  
  1825. // Check if ACK is valid.  Suggestion by Mark Allman. 
  1826. valid_ack = 1;
  1827. Packet::free(pkt);
  1828. /*
  1829.  * Try to send more data.
  1830.  */
  1831. if (valid_ack || aggressive_maxburst_)
  1832. send_much(0, 0, maxburst_);
  1833. }
  1835. /*
  1836.  * Process timeout events other than rtx timeout. Having this as a separate 
  1837.  * function allows derived classes to make alterations/enhancements (e.g.,
  1838.  * response to new types of timeout events).
  1839.  */ 
  1840. void TcpAgent::timeout_nonrtx(int tno) 
  1841. {
  1842. if (tno == TCP_TIMER_DELSND)  {
  1843.  /*
  1844.   * delayed-send timer, with random overhead
  1845.   * to avoid phase effects
  1846.   */
  1847. send_much(1, TCP_REASON_TIMEOUT, maxburst_);
  1848. }
  1849. }
  1851. void TcpAgent::timeout(int tno)
  1852. {
  1853. /* retransmit timer */
  1854. if (tno == TCP_TIMER_RTX) {
  1856. // There has been a timeout - will trace this event
  1857. trace_event("TIMEOUT");
  1859. frto_ = 0;
  1860. // Set pipe_prev as per Eifel Response
  1861. pipe_prev_ = (window() > ssthresh_) ?
  1862. window() : (int)ssthresh_;
  1864.         if (cwnd_ < 1) cwnd_ = 1;
  1865. if (qs_approved_ == 1) qs_approved_ = 0;
  1866. if (highest_ack_ == maxseq_ && !slow_start_restart_) {
  1867. /*
  1868.  * TCP option:
  1869.  * If no outstanding data, then don't do anything.  
  1870.  */
  1871.  // Should this return be here?
  1872.  // What if CWND_ACTION_ECN and cwnd < 1?
  1873.  // return;
  1874. } else {
  1875. recover_ = maxseq_;
  1876. if (highest_ack_ == -1 && wnd_init_option_ == 2)
  1877. /* 
  1878.  * First packet dropped, so don't use larger
  1879.  * initial windows. 
  1880.  */
  1881. wnd_init_option_ = 1;
  1882.                         else if ((highest_ack_ == -1) &&
  1883.                                 (wnd_init_option_ == 1) && (wnd_init_ > 1)
  1884. && bugfix_ss_)
  1885.                                 /*
  1886.                                  * First packet dropped, so don't use larger
  1887.                                  * initial windows.  Bugfix from Mark Allman.
  1888.                                  */
  1889.                                 wnd_init_ = 1;
  1890. if (highest_ack_ == maxseq_ && restart_bugfix_)
  1891.        /* 
  1892. * if there is no outstanding data, don't cut 
  1893. * down ssthresh_.
  1894. */
  1895. slowdown(CLOSE_CWND_ONE|NO_OUTSTANDING_DATA);
  1896. else if (highest_ack_ < recover_ &&
  1897.   last_cwnd_action_ == CWND_ACTION_ECN) {
  1898.        /*
  1899. * if we are in recovery from a recent ECN,
  1900. * don't cut down ssthresh_.
  1901. */
  1902. slowdown(CLOSE_CWND_ONE);
  1903. if (frto_enabled_ || sfrto_enabled_) {
  1904. frto_ = 1;
  1905. }
  1906. }
  1907. else {
  1908. ++nrexmit_;
  1909. last_cwnd_action_ = CWND_ACTION_TIMEOUT;
  1910. slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_RESTART);
  1911. if (frto_enabled_ || sfrto_enabled_) {
  1912. frto_ = 1;
  1913. }
  1914. }
  1915. }
  1916. /* if there is no outstanding data, don't back off rtx timer */
  1917. if (highest_ack_ == maxseq_ && restart_bugfix_) {
  1918. reset_rtx_timer(0,0);
  1919. }
  1920. else {
  1921. reset_rtx_timer(0,1);
  1922. }
  1923. last_cwnd_action_ = CWND_ACTION_TIMEOUT;
  1924. send_much(0, TCP_REASON_TIMEOUT, maxburst_);
  1925. } 
  1926. else {
  1927. timeout_nonrtx(tno);
  1928. }
  1929. }
  1931. /* 
  1932.  * Check if the packet (ack) has the ELN bit set, and if it does, and if the
  1933.  * last ELN-rxmitted packet is smaller than this one, then retransmit the
  1934.  * packet.  Do not adjust the cwnd when this happens.
  1935.  */
  1936. void TcpAgent::tcp_eln(Packet *pkt)
  1937. {
  1938.         //int eln_rxmit;
  1939.         hdr_tcp *tcph = hdr_tcp::access(pkt);
  1940.         int ack = tcph->seqno();
  1942.         if (++dupacks_ == eln_rxmit_thresh_ && ack > eln_last_rxmit_) {
  1943.                 /* Retransmit this packet */
  1944.                 output(last_ack_ + 1, TCP_REASON_DUPACK);
  1945.                 eln_last_rxmit_ = last_ack_+1;
  1946.         } else
  1947.                 send_much(0, 0, maxburst_);
  1949.         Packet::free(pkt);
  1950.         return;
  1951. }
  1953. /*
  1954.  * This function is invoked when the connection is done. It in turn
  1955.  * invokes the Tcl finish procedure that was registered with TCP.
  1956.  */
  1957. void TcpAgent::finish()
  1958. {
  1959. Tcl::instance().evalf("%s done", this->name());
  1960. }
  1962. void RtxTimer::expire(Event*)
  1963. {
  1964. a_->timeout(TCP_TIMER_RTX);
  1965. }
  1967. void DelSndTimer::expire(Event*)
  1968. {
  1969. a_->timeout(TCP_TIMER_DELSND);
  1970. }
  1972. void BurstSndTimer::expire(Event*)
  1973. {
  1974. a_->timeout(TCP_TIMER_BURSTSND);
  1975. }
  1977. /*
  1978.  * THE FOLLOWING FUNCTIONS ARE OBSOLETE, but REMAIN HERE
  1979.  * DUE TO OTHER PEOPLE's TCPs THAT MIGHT USE THEM
  1980.  *
  1981.  * These functions are now replaced by ecn() and slowdown(),
  1982.  * respectively.
  1983.  */
  1985. /*
  1986.  * Respond either to a source quench or to a congestion indication bit.
  1987.  * This is done at most once a roundtrip time;  after a source quench,
  1988.  * another one will not be done until the last packet transmitted before
  1989.  * the previous source quench has been ACKed.
  1990.  */
  1991. void TcpAgent::quench(int how)
  1992. {
  1993. if (highest_ack_ >= recover_) {
  1994. recover_ =  maxseq_;
  1995. last_cwnd_action_ = CWND_ACTION_ECN;
  1996. closecwnd(how);
  1997. }
  1998. }
  2000. /*
  2001.  * close down the congestion window
  2002.  */
  2003. void TcpAgent::closecwnd(int how)
  2004. {   
  2005. static int first_time = 1;
  2006. if (first_time == 1) {
  2007. fprintf(stderr, "the TcpAgent::closecwnd() function is now deprecated, please use the function slowdown() insteadn");
  2008. }
  2009. switch (how) {
  2010. case 0:
  2011. /* timeouts */
  2012. ssthresh_ = int( window() / 2 );
  2013. if (ssthresh_ < 2)
  2014. ssthresh_ = 2;
  2015. cwnd_ = int(wnd_restart_);
  2016. break;
  2018. case 1:
  2019. /* Reno dup acks, or after a recent congestion indication. */
  2020. // cwnd_ = window()/2;
  2021. cwnd_ = decrease_num_ * window();
  2022. ssthresh_ = int(cwnd_);
  2023. if (ssthresh_ < 2)
  2024. ssthresh_ = 2;
  2025. break;
  2027. case 2:
  2028. /* Tahoe dup acks  
  2029.  * after a recent congestion indication */
  2030. cwnd_ = wnd_init_;
  2031. break;
  2033. case 3:
  2034. /* Retransmit timeout, but no outstanding data. */ 
  2035. cwnd_ = int(wnd_init_);
  2036. break;
  2037. case 4:
  2038. /* Tahoe dup acks */
  2039. ssthresh_ = int( window() / 2 );
  2040. if (ssthresh_ < 2)
  2041. ssthresh_ = 2;
  2042. cwnd_ = 1;
  2043. break;
  2045. default:
  2046. abort();
  2047. }
  2048. fcnt_ = 0.;
  2049. count_ = 0;
  2050. }
  2052. /*
  2053.  * Check if the sender has been idle or application-limited for more
  2054.  * than an RTO, and if so, reduce the congestion window.
  2055.  */
  2056. void TcpAgent::process_qoption_after_send ()
  2057. {
  2058. int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
  2059. int rto = (int)(t_rtxcur_/tcp_tick_) ; 
  2060. /*double ct = Scheduler::instance().clock();*/
  2062. if (!EnblRTTCtr_) {
  2063. if (tcp_now - T_last >= rto) {
  2064. // The sender has been idle.
  2065.   slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE) ;
  2066. for (int i = 0 ; i < (tcp_now - T_last)/rto; i ++) {
  2067. slowdown(CWND_HALF_WITH_MIN|TCP_IDLE);
  2068. }
  2069. T_prev = tcp_now ;
  2070. W_used = 0 ;
  2071. }
  2072. T_last = tcp_now ;
  2073. if (t_seqno_ == highest_ack_+ window()) {
  2074. T_prev = tcp_now ; 
  2075. W_used = 0 ; 
  2076. }
  2077. else if (t_seqno_ == curseq_-1) {
  2078. // The sender has no more data to send.
  2079. int tmp = t_seqno_ - highest_ack_ ;
  2080. if (tmp > W_used)
  2081. W_used = tmp ;
  2082. if (tcp_now - T_prev >= rto) {
  2083. // The sender has been application-limited.
  2084. slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE);
  2085. slowdown(CLOSE_CWND_HALF_WAY|TCP_IDLE);
  2086. T_prev = tcp_now ;
  2087. W_used = 0 ;
  2088. }
  2089. }
  2090. } else {
  2091. rtt_counting();
  2092. }
  2093. }
  2095. /*
  2096.  * Check if the sender has been idle or application-limited for more
  2097.  * than an RTO, and if so, reduce the congestion window, for a TCP sender
  2098.  * that "counts RTTs" by estimating the number of RTTs that fit into
  2099.  * a single clock tick.
  2100.  */
  2101. void
  2102. TcpAgent::rtt_counting()
  2103. {
  2104.         int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
  2105. int rtt = (int(t_srtt_) >> T_SRTT_BITS) ;
  2107. if (rtt < 1) 
  2108. rtt = 1 ;
  2109. if (tcp_now - T_last >= 2*rtt) {
  2110. // The sender has been idle.
  2111. int RTTs ; 
  2112. RTTs = (tcp_now -T_last)*RTT_goodcount/(rtt*2) ; 
  2113. RTTs = RTTs - Backoffs ; 
  2114. Backoffs = 0 ; 
  2115. if (RTTs > 0) {
  2116. slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE) ;
  2117. for (int i = 0 ; i < RTTs ; i ++) {
  2118. slowdown(CWND_HALF_WITH_MIN|TCP_IDLE);
  2119. RTT_prev = RTT_count ; 
  2120. W_used = 0 ;
  2121. }
  2122. }
  2123. }
  2124. T_last = tcp_now ;
  2125. if (tcp_now - T_start >= 2*rtt) {
  2126. if ((RTT_count > RTT_goodcount) || (F_full == 1)) {
  2127. RTT_goodcount = RTT_count ; 
  2128. if (RTT_goodcount < 1) RTT_goodcount = 1 ; 
  2129. }
  2130. RTT_prev = RTT_prev - RTT_count ;
  2131. RTT_count = 0 ; 
  2132. T_start  = tcp_now ;
  2133. F_full = 0;
  2134. }
  2135. if (t_seqno_ == highest_ack_ + window()) {
  2136. W_used = 0 ; 
  2137. F_full = 1 ; 
  2138. RTT_prev = RTT_count ;
  2139. }
  2140. else if (t_seqno_ == curseq_-1) {
  2141. // The sender has no more data to send.
  2142. int tmp = t_seqno_ - highest_ack_ ;
  2143. if (tmp > W_used)
  2144. W_used = tmp ;
  2145. if (RTT_count - RTT_prev >= 2) {
  2146. // The sender has been application-limited.
  2147. slowdown(THREE_QUARTER_SSTHRESH|TCP_IDLE) ;
  2148. slowdown(CLOSE_CWND_HALF_WAY|TCP_IDLE);
  2149. RTT_prev = RTT_count ; 
  2150. Backoffs ++ ; 
  2151. W_used = 0;
  2152. }
  2153. }
  2154. if (F_counting == 0) {
  2155. W_timed = t_seqno_  ;
  2156. F_counting = 1 ;
  2157. }
  2158. }
  2160. void TcpAgent::process_qoption_after_ack (int seqno)
  2161. {
  2162. if (F_counting == 1) {
  2163. if (seqno >= W_timed) {
  2164. RTT_count ++ ; 
  2165. F_counting = 0 ; 
  2166. }
  2167. else {
  2168. if (dupacks_ == numdupacks_)
  2169. RTT_count ++ ;
  2170. }
  2171. }
  2172. }
  2174. void TcpAgent::trace_event(char *eventtype)
  2175. {
  2176. if (et_ == NULL) return;
  2177. int seqno = t_seqno_;
  2178. char *wrk = et_->buffer();
  2179. char *nwrk = et_->nbuffer();
  2180. if (wrk != 0)
  2181. sprintf(wrk,
  2182. "E "TIME_FORMAT" %d %d TCP %s %d %d %d",
  2183. et_->round(Scheduler::instance().clock()),   // time
  2184. addr(),                       // owner (src) node id
  2185. daddr(),                      // dst node id
  2186. eventtype,                    // event type
  2187. fid_,                         // flow-id
  2188. seqno,                        // current seqno
  2189. int(cwnd_)                         //cong. window
  2190. );
  2192. if (nwrk != 0)
  2193. sprintf(nwrk,
  2194. "E -t "TIME_FORMAT" -o TCP -e %s -s %d.%d -d %d.%d",
  2195. et_->round(Scheduler::instance().clock()),   // time
  2196. eventtype,                    // event type
  2197. addr(),                       // owner (src) node id
  2198. port(),                       // owner (src) port id
  2199. daddr(),                      // dst node id
  2200. dport()                       // dst port id
  2201. );
  2202. et_->trace();
  2203. }