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