1 diff -crbB ns-allinone-2.35/ns-2.35/queue/red.cc ns-2.35/queue/red.cc 2 *** ns-allinone-2.35/ns-2.35/queue/red.cc 2011-10-02 15:32:34.000000000 -0700 3 --- ns-2.35/queue/red.cc 2012-03-19 02:40:10.827778003 -0700 4 *************** 5 *** 559,565 **** 6 edv_.count_bytes = 0; 7 hdr_flags* hf = hdr_flags::access(pickPacketForECN(pkt)); 8 if (edp_.setbit && hf->ect() && 9 ! (!edp_.use_mark_p || edv_.v_prob1 < edp_.mark_p)) { 10 hf->ce() = 1; // mark Congestion Experienced bit 11 // Tell the queue monitor here - call emark(pkt) 12 return (0); // no drop 13 --- 559,565 ---- 14 edv_.count_bytes = 0; 15 hdr_flags* hf = hdr_flags::access(pickPacketForECN(pkt)); 16 if (edp_.setbit && hf->ect() && 17 ! (!edp_.use_mark_p || edv_.v_prob1 <= edp_.mark_p)) { // For DCTCP: '<' is changed to '<=' here 18 hf->ce() = 1; // mark Congestion Experienced bit 19 // Tell the queue monitor here - call emark(pkt) 20 return (0); // no drop 21 Only in ns-2.35/queue: red.cc~ 22 diff -crbB ns-allinone-2.35/ns-2.35/tcl/lib/ns-default.tcl ns-2.35/tcl/lib/ns-default.tcl 23 *** ns-allinone-2.35/ns-2.35/tcl/lib/ns-default.tcl 2010-07-03 15:45:45.000000000 -0700 24 --- ns-2.35/tcl/lib/ns-default.tcl 2012-03-19 02:40:08.415778003 -0700 25 *************** 26 *** 1026,1031 **** 27 --- 1026,1035 ---- 28 29 Agent/TCP set SetCWRonRetransmit_ true ; # added on 2005/06/19. 30 # default changed on 2008/06/05. 31 + # DCTCP 32 + Agent/TCP set dctcp_ false; 33 + Agent/TCP set dctcp_alpha_ 0.0; 34 + Agent/TCP set dctcp_g_ 0.0625; 35 36 # XXX Generate nam trace or plain old text trace for variables. 37 # When it's true, generate nam trace. 38 Only in ns-2.35/tcl/lib: ns-default.tcl~ 39 Only in ns-2.35/tcp: .swp 40 diff -crbB ns-allinone-2.35/ns-2.35/tcp/tcp.cc ns-2.35/tcp/tcp.cc 41 *** ns-allinone-2.35/ns-2.35/tcp/tcp.cc 2011-06-19 21:51:46.000000000 -0700 42 --- ns-2.35/tcp/tcp.cc 2012-03-19 02:40:09.966778001 -0700 43 *************** 44 *** 101,106 **** 45 --- 101,109 ---- 46 bind("necnresponses_", &necnresponses_); 47 bind("ncwndcuts_", &ncwndcuts_); 48 bind("ncwndcuts1_", &ncwndcuts1_); 49 + bind("dctcp_", &dctcp_); 50 + bind("dctcp_alpha_", &dctcp_alpha_); 51 + bind("dctcp_g_", &dctcp_g_); 52 #endif /* TCP_DELAY_BIND_ALL */ 53 54 } 55 *************** 56 *** 123,128 **** 57 --- 126,136 ---- 58 delay_bind_init_one("overhead_"); 59 delay_bind_init_one("tcpTick_"); 60 delay_bind_init_one("ecn_"); 61 + // DCTCP 62 + delay_bind_init_one("dctcp_"); 63 + delay_bind_init_one("dctcp_alpha_"); 64 + delay_bind_init_one("dctcp_g_"); 65 + 66 delay_bind_init_one("SetCWRonRetransmit_"); 67 delay_bind_init_one("old_ecn_"); 68 delay_bind_init_one("bugfix_ss_"); 69 *************** 70 *** 234,239 **** 71 --- 242,251 ---- 72 if (delay_bind(varName, localName, "overhead_", &overhead_, tracer)) return TCL_OK; 73 if (delay_bind(varName, localName, "tcpTick_", &tcp_tick_, tracer)) return TCL_OK; 74 if (delay_bind_bool(varName, localName, "ecn_", &ecn_, tracer)) return TCL_OK; 75 + // Mohammad 76 + if (delay_bind_bool(varName, localName, "dctcp_", &dctcp_, tracer)) return TCL_OK; 77 + if (delay_bind(varName, localName, "dctcp_alpha_", &dctcp_alpha_ , tracer)) return TCL_OK; 78 + if (delay_bind(varName, localName, "dctcp_g_", &dctcp_g_ , tracer)) return TCL_OK; 79 if (delay_bind_bool(varName, localName, "SetCWRonRetransmit_", &SetCWRonRetransmit_, tracer)) return TCL_OK; 80 if (delay_bind_bool(varName, localName, "old_ecn_", &old_ecn_ , tracer)) return TCL_OK; 81 if (delay_bind_bool(varName, localName, "bugfix_ss_", &bugfix_ss_ , tracer)) return TCL_OK; 82 *************** 83 *** 1297,1302 **** 84 --- 1309,1316 ---- 85 } else { 86 ssthresh_ = (int) decreasewin; 87 } 88 + else if (how & CLOSE_SSTHRESH_DCTCP) 89 + ssthresh_ = (int) ((1 - dctcp_alpha_/2.0) * windowd()); 90 else if (how & THREE_QUARTER_SSTHRESH) 91 if (ssthresh_ < 3*cwnd_/4) 92 ssthresh_ = (int)(3*cwnd_/4); 93 *************** 94 *** 1306,1311 **** 95 --- 1321,1328 ---- 96 if (first_decrease_ == 1 || slowstart || decrease_num_ == 0.5) { 97 cwnd_ = halfwin; 98 } else cwnd_ = decreasewin; 99 + else if (how & CLOSE_CWND_DCTCP) 100 + cwnd_ = (1 - dctcp_alpha_/2.0) * windowd(); 101 else if (how & CWND_HALF_WITH_MIN) { 102 // We have not thought about how non-standard TCPs, with 103 // non-standard values of decrease_num_, should respond 104 *************** 105 *** 1328,1334 **** 106 } 107 if (ssthresh_ < 2) 108 ssthresh_ = 2; 109 ! if (how & (CLOSE_CWND_HALF|CLOSE_CWND_RESTART|CLOSE_CWND_INIT|CLOSE_CWND_ONE)) 110 cong_action_ = TRUE; 111 112 fcnt_ = count_ = 0; 113 --- 1345,1353 ---- 114 } 115 if (ssthresh_ < 2) 116 ssthresh_ = 2; 117 ! if (cwnd_ < 1) 118 ! cwnd_ = 1; 119 ! if (how & (CLOSE_CWND_HALF|CLOSE_CWND_RESTART|CLOSE_CWND_INIT|CLOSE_CWND_ONE|CLOSE_CWND_DCTCP)) 120 cong_action_ = TRUE; 121 122 fcnt_ = count_ = 0; 123 *************** 124 *** 1429,1434 **** 125 --- 1448,1456 ---- 126 rtt_backoff(); 127 else ecn_backoff_ = 1; 128 } else ecn_backoff_ = 0; 129 + if (dctcp_) 130 + slowdown(CLOSE_CWND_DCTCP|CLOSE_SSTHRESH_DCTCP); 131 + else 132 slowdown(CLOSE_CWND_HALF|CLOSE_SSTHRESH_HALF); 133 ++necnresponses_ ; 134 // added by sylvia to count number of ecn responses 135 Only in ns-2.35/tcp: tcp.cc~ 136 diff -crbB ns-allinone-2.35/ns-2.35/tcp/tcp-full.cc ns-2.35/tcp/tcp-full.cc 137 *** ns-allinone-2.35/ns-2.35/tcp/tcp-full.cc 2010-03-07 21:54:54.000000000 -0800 138 --- ns-2.35/tcp/tcp-full.cc 2012-03-19 02:40:10.049778005 -0700 139 *************** 140 *** 871,876 **** 141 --- 871,881 ---- 142 /* Set ect() to 0. -M. Weigle 1/19/05 */ 143 fh->ect() = 0; 144 } 145 + 146 + // For DCTCP, ect should be set on all packets 147 + if (dctcp_) 148 + fh->ect() = ect_; 149 + 150 if (ecn_ && ect_ && recent_ce_ ) { 151 // This is needed here for the ACK in a SYN, SYN/ACK, ACK 152 // sequence. 153 *************** 154 *** 960,968 **** 155 // Q: how can this happen? 156 157 if (maxseg_ == 0) 158 ! maxseg_ = size_ - headersize(); 159 else 160 size_ = maxseg_ + headersize(); 161 162 int is_retransmit = (seqno < maxseq_); 163 int quiet = (highest_ack_ == maxseq_); 164 --- 965,976 ---- 165 // Q: how can this happen? 166 167 if (maxseg_ == 0) 168 ! maxseg_ = size_; // Mohammad: changed from size_ - headersize(); 169 ! /* Mohammad: This else condition is unnecessary and conflates 170 ! * with tcp.cc 171 else 172 size_ = maxseg_ + headersize(); 173 + */ 174 175 int is_retransmit = (seqno < maxseq_); 176 int quiet = (highest_ack_ == maxseq_); 177 *************** 178 *** 1156,1161 **** 179 --- 1164,1171 ---- 180 */ 181 flags_ &= ~(TF_ACKNOW|TF_DELACK); 182 183 + delack_timer_.force_cancel(); 184 + 185 /* 186 * if we have reacted to congestion recently, the 187 * slowdown() procedure will have set cong_action_ and 188 *************** 189 *** 1178,1183 **** 190 --- 1188,1195 ---- 191 // and adjusted for SYNs and FINs which use up one number 192 193 int highest = seqno + reliable; 194 + if (highest > dctcp_maxseq) 195 + dctcp_maxseq = highest; 196 if (highest > maxseq_) { 197 maxseq_ = highest; 198 // 199 *************** 200 *** 1415,1421 **** 201 { 202 // we are now going to fast-retransmit and willtrace that event 203 trace_event("FAST_RETX"); 204 - 205 recover_ = maxseq_; // recovery target 206 last_cwnd_action_ = CWND_ACTION_DUPACK; 207 return(foutput(seq, REASON_DUPACK)); // send one pkt 208 --- 1427,1432 ---- 209 *************** 210 *** 1564,1574 **** 211 --- 1576,1594 ---- 212 * at time t0 = (0.0 + k * interval_) for some k such 213 * that t0 > now 214 */ 215 + /* 216 + * Mohammad: commented this out for more efficient 217 + * delayed ack generation. 218 + * 219 if (delack_interval_ > 0.0 && 220 (delack_timer_.status() != TIMER_PENDING)) { 221 int last = int(now() / delack_interval_); 222 delack_timer_.resched(delack_interval_ * (last + 1.0) - now()); 223 } 224 + */ 225 + 226 + if (dctcp_) 227 + update_dctcp_alpha(pkt); 228 229 /* 230 * Try header prediction: in seq data or in seq pure ACK 231 *************** 232 *** 1597,1602 **** 233 --- 1617,1641 ---- 234 // 235 236 if (ecn_) { 237 + if (dctcp_) { // DCTCP 238 + if (fh->ce() && fh->ect()) { 239 + // no CWR from peer yet... arrange to 240 + // keep sending ECNECHO 241 + if (recent_ce_ == FALSE) { 242 + ce_transition = 1; 243 + recent_ce_ = TRUE; 244 + } else { 245 + ce_transition = 0; 246 + } 247 + } else if (datalen > 0 && !fh->ce() && fh->ect()){ 248 + if (recent_ce_ == TRUE) { 249 + ce_transition = 1; 250 + recent_ce_ = FALSE; 251 + } else { 252 + ce_transition = 0; 253 + } 254 + } 255 + } else { 256 if (fh->ce() && fh->ect()) { 257 // no CWR from peer yet... arrange to 258 // keep sending ECNECHO 259 *************** 260 *** 1607,1612 **** 261 --- 1646,1652 ---- 262 recent_ce_ = FALSE; 263 } 264 } 265 + } 266 267 // Header predication basically looks to see 268 // if the incoming packet is an expected pure ACK 269 *************** 270 *** 1638,1645 **** 271 --- 1678,1698 ---- 272 // this routine scans all tcpcb's looking for 273 // DELACK segments and when it finds them 274 // changes DELACK to ACKNOW and calls tcp_output() 275 + 276 + /* DCTCP receiver state machine */ 277 + if (dctcp_ && ce_transition && ((rcv_nxt_ - last_ack_sent_) > 0)) { 278 + // Must send an immediate ACK with with previous ECN state 279 + // before transitioning to new state 280 + flags_ |= TF_ACKNOW; 281 + recent_ce_ = !recent_ce_; 282 + send_much(1, REASON_NORMAL, maxburst_); 283 + recent_ce_ = !recent_ce_; 284 + } 285 + 286 rcv_nxt_ += datalen; 287 flags_ |= TF_DELACK; 288 + // Mohammad 289 + delack_timer_.resched(delack_interval_); 290 recvBytes(datalen); // notify application of "delivery" 291 // 292 // special code here to simulate the operation 293 *************** 294 *** 1816,1821 **** 295 --- 1869,1876 ---- 296 */ 297 if (datalen > 0) { 298 flags_ |= TF_DELACK; // data there: wait 299 + // Mohammad 300 + delack_timer_.resched(delack_interval_); 301 } else { 302 flags_ |= TF_ACKNOW; // ACK peer's SYN 303 } 304 *************** 305 *** 2131,2140 **** 306 // cong_action bit 307 // 308 if (ecn_) { 309 ! if (fh->ce() && fh->ect()) 310 recent_ce_ = TRUE; 311 ! else if (fh->cwr()) 312 recent_ce_ = FALSE; 313 } 314 315 // 316 --- 2186,2216 ---- 317 // cong_action bit 318 // 319 if (ecn_) { 320 ! if (dctcp_) { // Mohammad 321 ! if (fh->ce() && fh->ect()) { 322 ! // no CWR from peer yet... arrange to 323 ! // keep sending ECNECHO 324 ! if (recent_ce_ == FALSE) { 325 ! ce_transition = 1; 326 recent_ce_ = TRUE; 327 ! } else { 328 ! ce_transition = 0; 329 ! } 330 ! } else if (datalen > 0 && !fh->ce() && fh->ect()){ 331 ! if (recent_ce_ == TRUE) { 332 ! ce_transition = 1; 333 recent_ce_ = FALSE; 334 + } else { 335 + ce_transition = 0; 336 + } 337 + } 338 + } else { 339 + if (fh->ce() && fh->ect()) { 340 + recent_ce_ = TRUE; 341 + } else if (fh->cwr()) { 342 + recent_ce_ = FALSE; 343 + } 344 + } 345 } 346 347 // 348 *************** 349 *** 2297,2307 **** 350 if ((!delay_growth_ || (rcv_nxt_ > 0)) && 351 last_state_ == TCPS_ESTABLISHED) { 352 if (!partial || open_cwnd_on_pack_) { 353 ! if (!ect_ || !hdr_flags::access(pkt)->ecnecho()) 354 opencwnd(); 355 } 356 } 357 358 if ((state_ >= TCPS_FIN_WAIT_1) && (ackno == maxseq_)) { 359 ourfinisacked = TRUE; 360 } 361 --- 2373,2391 ---- 362 if ((!delay_growth_ || (rcv_nxt_ > 0)) && 363 last_state_ == TCPS_ESTABLISHED) { 364 if (!partial || open_cwnd_on_pack_) { 365 ! if (!ect_ || !hdr_flags::access(pkt)->ecnecho() || ecn_burst_) 366 opencwnd(); 367 } 368 } 369 370 + // Mohammad: Detect bursts of ECN marks 371 + if (ect_) { 372 + if (!ecn_burst_ && hdr_flags::access(pkt)->ecnecho()) 373 + ecn_burst_ = TRUE; 374 + else if (ecn_burst_ && ! hdr_flags::access(pkt)->ecnecho()) 375 + ecn_burst_ = FALSE; 376 + } 377 + 378 if ((state_ >= TCPS_FIN_WAIT_1) && (ackno == maxseq_)) { 379 ourfinisacked = TRUE; 380 } 381 *************** 382 *** 2395,2401 **** 383 --- 2479,2499 ---- 384 // don't really have a process anyhow, just 385 // accept the data here as-is (i.e. don't 386 // require being in ESTABLISHED state) 387 + 388 + /* Mohammad: For DCTCP state machine */ 389 + if (dctcp_ && ce_transition && ((rcv_nxt_ - last_ack_sent_) > 0)) { 390 + // Must send an immediate ACK with with previous ECN state 391 + // before transitioning to new state 392 + flags_ |= TF_ACKNOW; 393 + recent_ce_ = !recent_ce_; 394 + send_much(1, REASON_NORMAL, maxburst_); 395 + recent_ce_ = !recent_ce_; 396 + } 397 + 398 flags_ |= TF_DELACK; 399 + // Mohammad 400 + delack_timer_.resched(delack_interval_); 401 + 402 rcv_nxt_ += datalen; 403 tiflags = tcph->flags() & TH_FIN; 404 405 *************** 406 *** 2412,2417 **** 407 --- 2510,2519 ---- 408 // segments or hole-fills. Also, 409 // send an ACK (or SACK) to the other side right now. 410 // Note that we may have just a FIN here (datalen = 0) 411 + 412 + /* Note: The DCTCP receiver conveys the ECN-CE 413 + received on each out-of-order data packet */ 414 + 415 int rcv_nxt_old_ = rcv_nxt_; // notify app. if changes 416 tiflags = reass(pkt); 417 if (rcv_nxt_ > rcv_nxt_old_) { 418 *************** 419 *** 2608,2616 **** 420 --- 2710,2756 ---- 421 } 422 reset_rtx_timer(1); 423 t_seqno_ = (highest_ack_ < 0) ? iss_ : int(highest_ack_); 424 + dctcp_alpha_update_seq = t_seqno_; 425 + dctcp_maxseq = dctcp_alpha_update_seq; 426 fastrecov_ = FALSE; 427 dupacks_ = 0; 428 } 429 + 430 + /* 431 + * Update dctcp alpha based on the ecn bit in the received packet. 432 + * This procedure is called only when dctcp_ is 1. 433 + */ 434 + void FullTcpAgent::update_dctcp_alpha(Packet *pkt) 435 + { 436 + int ecnbit = hdr_flags::access(pkt)->ecnecho(); 437 + int ackno = hdr_tcp::access(pkt)->ackno(); 438 + int acked_bytes = ackno - highest_ack_; 439 + 440 + if (acked_bytes <= 0) 441 + acked_bytes = size_; 442 + dctcp_total += acked_bytes; 443 + if (ecnbit) { 444 + dctcp_marked += acked_bytes; 445 + } 446 + 447 + /* Check for barrier indicating its time to recalculate alpha. 448 + * This code basically updated alpha roughly once per RTT. 449 + */ 450 + if (ackno > dctcp_alpha_update_seq) { 451 + double temp_alpha; 452 + dctcp_alpha_update_seq = dctcp_maxseq; 453 + if (dctcp_total > 0) 454 + temp_alpha = ((double) dctcp_marked) / dctcp_total; 455 + else 456 + temp_alpha = 0.0; 457 + 458 + dctcp_alpha_ = (1 - dctcp_g_) * dctcp_alpha_ + dctcp_g_ * temp_alpha; 459 + dctcp_marked = 0; 460 + dctcp_total = 0; 461 + } 462 + } 463 + 464 + 465 /* 466 * deal with timers going off. 467 * 2 types for now: 468 *************** 469 *** 2662,2668 **** 470 flags_ |= TF_ACKNOW; 471 send_much(1, REASON_NORMAL, 0); 472 } 473 ! delack_timer_.resched(delack_interval_); 474 break; 475 default: 476 fprintf(stderr, "%f: FullTcpAgent(%s) Unknown Timeout type %d ", 477 --- 2802,2809 ---- 478 flags_ |= TF_ACKNOW; 479 send_much(1, REASON_NORMAL, 0); 480 } 481 ! // Mohammad 482 ! // delack_timer_.resched(delack_interval_); 483 break; 484 default: 485 fprintf(stderr, "%f: FullTcpAgent(%s) Unknown Timeout type %d ", 486 *************** 487 *** 2874,2879 **** 488 --- 3015,3023 ---- 489 * packet. -M. Weigle 6/19/02 490 */ 491 last_cwnd_action_ = CWND_ACTION_DUPACK; 492 + /* Mohammad: cut window by half when we have 3 dup ack */ 493 + if (dctcp_) 494 + slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF); 495 cancel_rtx_timer(); 496 rtt_active_ = FALSE; 497 int amt = fast_retransmit(highest_ack_); 498 Only in ns-2.35/tcp: tcp-full.cc~ 499 diff -crbB ns-allinone-2.35/ns-2.35/tcp/tcp-full.h ns-2.35/tcp/tcp-full.h 500 *** ns-allinone-2.35/ns-2.35/tcp/tcp-full.h 2008-10-14 10:42:52.000000000 -0700 501 --- ns-2.35/tcp/tcp-full.h 2012-03-19 02:40:10.052777998 -0700 502 *************** 503 *** 120,126 **** 504 last_send_time_(-1.0), infinite_send_(FALSE), irs_(-1), 505 delack_timer_(this), flags_(0), 506 state_(TCPS_CLOSED), recent_ce_(FALSE), 507 ! last_state_(TCPS_CLOSED), rq_(rcv_nxt_), last_ack_sent_(-1) { } 508 509 ~FullTcpAgent() { cancel_timers(); rq_.clear(); } 510 virtual void recv(Packet *pkt, Handler*); 511 --- 120,128 ---- 512 last_send_time_(-1.0), infinite_send_(FALSE), irs_(-1), 513 delack_timer_(this), flags_(0), 514 state_(TCPS_CLOSED), recent_ce_(FALSE), 515 ! last_state_(TCPS_CLOSED), rq_(rcv_nxt_), last_ack_sent_(-1), 516 ! dctcp_total(0), dctcp_marked(0), dctcp_alpha_update_seq(0), 517 ! dctcp_maxseq(0), ce_transition(0) { } 518 519 ~FullTcpAgent() { cancel_timers(); rq_.clear(); } 520 virtual void recv(Packet *pkt, Handler*); 521 *************** 522 *** 183,188 **** 523 --- 185,192 ---- 524 void finish(); 525 void reset_rtx_timer(int); // adjust the rtx timer 526 527 + void update_dctcp_alpha(Packet*); // DCTCP alpha update 528 + 529 virtual void timeout_action(); // what to do on rtx timeout 530 virtual void dupack_action(); // what to do on dup acks 531 virtual void pack_action(Packet*); // action on partial acks 532 *************** 533 *** 236,241 **** 534 --- 240,255 ---- 535 int last_state_; /* FSM state at last pkt recv */ 536 int rcv_nxt_; /* next sequence number expected */ 537 ReassemblyQueue rq_; /* TCP reassembly queue */ 538 + 539 + /* 540 + * variables for DCTCP 541 + */ 542 + int dctcp_total; 543 + int dctcp_marked; 544 + int dctcp_alpha_update_seq; 545 + int dctcp_maxseq; 546 + int ce_transition; 547 + 548 /* 549 * the following are part of a tcpcb in "real" RFC1323 TCP 550 */ 551 Only in ns-2.35/tcp: tcp-full.h~ 552 diff -crbB ns-allinone-2.35/ns-2.35/tcp/tcp.h ns-2.35/tcp/tcp.h 553 *** ns-allinone-2.35/ns-2.35/tcp/tcp.h 2011-08-26 12:29:57.000000000 -0700 554 --- ns-2.35/tcp/tcp.h 2012-03-19 02:40:10.049778005 -0700 555 *************** 556 *** 104,110 **** 557 #define CWND_HALF_WITH_MIN 0x00000200 558 #define TCP_IDLE 0x00000400 559 #define NO_OUTSTANDING_DATA 0x00000800 560 ! 561 /* 562 * tcp_tick_: 563 * default 0.1, 564 --- 104,111 ---- 565 #define CWND_HALF_WITH_MIN 0x00000200 566 #define TCP_IDLE 0x00000400 567 #define NO_OUTSTANDING_DATA 0x00000800 568 ! #define CLOSE_SSTHRESH_DCTCP 0x00001000 569 ! #define CLOSE_CWND_DCTCP 0x00002000 570 /* 571 * tcp_tick_: 572 * default 0.1, 573 *************** 574 *** 432,437 **** 575 --- 433,444 ---- 576 577 /* Used for ECN */ 578 int ecn_; /* Explicit Congestion Notification */ 579 + 580 + /* Use for DCTCP */ 581 + int dctcp_; 582 + double dctcp_alpha_; 583 + double dctcp_g_; 584 + 585 int cong_action_; /* Congestion Action. True to indicate 586 that the sender responded to congestion. */ 587 int ecn_burst_; /* True when the previous ACK packet 588 Only in ns-2.35/tcp: tcp.h~