idnits 2.17.1 draft-cheng-tcpm-rack-00.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- ** There are 3 instances of too long lines in the document, the longest one being 5 characters in excess of 72. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the IETF Trust and authors Copyright Line does not match the current year == The document seems to lack the recommended RFC 2119 boilerplate, even if it appears to use RFC 2119 keywords. (The document does seem to have the reference to RFC 2119 which the ID-Checklist requires). -- The document date (October 19, 2015) is 3104 days in the past. Is this intentional? Checking references for intended status: Experimental ---------------------------------------------------------------------------- == Missing Reference: 'RFC4653' is mentioned on line 369, but not defined == Missing Reference: 'RFC3522' is mentioned on line 388, but not defined == Unused Reference: 'RFC793' is defined on line 452, but no explicit reference was found in the text == Unused Reference: 'RFC2119' is defined on line 483, but no explicit reference was found in the text == Unused Reference: 'RFC2883' is defined on line 489, but no explicit reference was found in the text ** Obsolete normative reference: RFC 793 (Obsoleted by RFC 9293) == Outdated reference: A later version (-10) exists of draft-ietf-tcpm-rtorestart-08 Summary: 2 errors (**), 0 flaws (~~), 8 warnings (==), 1 comment (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 TCP Maintenance Working Group Y. Cheng 3 Internet-Draft N. Cardwell 4 Intended status: Experimental Google, Inc 5 Expires: April 21, 2016 October 19, 2015 7 RACK: a time-based fast loss detection algorithm for TCP 8 draft-cheng-tcpm-rack-00 10 Abstract 12 This document presents a new TCP loss detection algorithm called RACK 13 ("Recent ACKnowledgment"). RACK uses the notion of time, instead of 14 packet or sequence counts, to detect losses, for modern TCP 15 implementations that can support per-packet timestamps and the 16 selective acknowledgment (SACK) option. It is intended to replace 17 the conventional DUPACK threshold approach and its variants, as well 18 as other nonstandard approaches. 20 Status of This Memo 22 This Internet-Draft is submitted in full conformance with the 23 provisions of BCP 78 and BCP 79. 25 Internet-Drafts are working documents of the Internet Engineering 26 Task Force (IETF). Note that other groups may also distribute 27 working documents as Internet-Drafts. The list of current Internet- 28 Drafts is at http://datatracker.ietf.org/drafts/current/. 30 Internet-Drafts are draft documents valid for a maximum of six months 31 and may be updated, replaced, or obsoleted by other documents at any 32 time. It is inappropriate to use Internet-Drafts as reference 33 material or to cite them other than as "work in progress." 35 This Internet-Draft will expire on April 21, 2016. 37 Copyright Notice 39 Copyright (c) 2015 IETF Trust and the persons identified as the 40 document authors. All rights reserved. 42 This document is subject to BCP 78 and the IETF Trust's Legal 43 Provisions Relating to IETF Documents 44 (http://trustee.ietf.org/license-info) in effect on the date of 45 publication of this document. Please review these documents 46 carefully, as they describe your rights and restrictions with respect 47 to this document. Code Components extracted from this document must 48 include Simplified BSD License text as described in Section 4.e of 49 the Trust Legal Provisions and are provided without warranty as 50 described in the Simplified BSD License. 52 1. Introduction 54 This document presents a new loss detection algorithm called RACK 55 ("Recent ACKnowledgment"). RACK uses the notion of time instead of 56 the conventional packet or sequence counting approaches for detecting 57 losses. RACK deems a packet lost if some packet sent sufficiently 58 later has been cumulatively or selectively acknowledged. It does 59 this by recording packet transmission times and inferring losses 60 using cumulative acknowledgments or selective acknowledgment (SACK) 61 TCP options. 63 The main motivation for RACK is to replace both the standard and 64 nonstandard loss detection algorithms 65 [RFC5681][RFC6675][RFC5827][RFC4653][FACK][THIN-STREAM] to simplify 66 TCP development. 68 Another motivation is to improve loss detection for modern traffic 69 patterns and underlying network changes. First, the prevalence of 70 interactive request-response traffic means TCP is often application- 71 limited. Second, wide deployment of traffic policers results in 72 frequent lost retransmissions and losses at the tail of transactions. 73 Third, mobile wireless and router load-balancing cause frequent 74 occurrences of small degrees of reordering. 76 These three factors together make existing packet or sequence 77 counting approaches inefficient. This is because mechanisms based 78 purely on counting packets in sequence order can either detect loss 79 quickly or accurately, but it is hard to achieve both, especially 80 when the sender is application-limited and reordering is 81 unpredictable. And under these conditions none of them can detect 82 lost retransmission well. 84 2. Requirements 86 The reader is expected to be familiar with the definitions given in 87 the TCP congestion control [RFC5681] and selective acknowledgment 88 [RFC2018] RFCs. Familiarity with the conservative SACK-based 89 recovery for TCP [RFC6675] is not expected but helps. 91 RACK has three requirements: 93 1. The connection MUST use selective acknowledgment (SACK) options 94 [RFC2018]. 96 2. For each packet sent, the sender MUST store its most recent 97 transmission time with (at least) millisecond granularity. For 98 round-trip times lower than a millisecond (e.g., intra-datacenter 99 communications) microsecond granularity would significantly help 100 the detection latency but is not required. 102 3. For each packet sent, the sender MUST store whether the packet 103 has been retransmitted or not. 105 We assume that requirement 1 implies the sender keeps a SACK 106 scoreboard, which is a data structure to store selective 107 acknowledgment information on a per-connection basis. For the ease 108 of explaining the algorithm, we use a pseudo-scoreboard that manages 109 the data in sequence number ranges. But the specifics of the data 110 structure are left to the implementor. 112 RACK does not need any change on the receiver. 114 3. Definitions of variables 116 A sender needs to store these new RACK variables: 118 "Packet.xmit_time" is the time of the last transmission of a data 119 packet, including any retransmissions, if any. The sender needs to 120 record the transmission time for each packet sent and not yet 121 acknowledged. The time MUST be stored at millisecond granularity or 122 finer. 124 "RACK.xmit_time" is the most recent Packet.xmit_time among all the 125 packets that were delivered (either cumulatively acknowledged or 126 selectively acknowledged) on the connection. 128 "RACK.RTT" is the associated RTT measured when RACK.xmit_time, above, 129 was changed. It is the RTT of the most recently transmitted packet 130 that has been delivered (either cumulatively acknowledged or 131 selectively acknowledged) on the connection. 133 "RACK.reo_wnd" is a reordering window for the connection, computed in 134 the unit of time used for recording packet transmission times. It is 135 used to defer the moment at which RACK marks a packet lost. 137 "RACK.min_RTT" is the estimated minimum round-trip time (RTT) of the 138 connection. 140 Note that the Packet.xmit_time variable is per packet in flight. The 141 RACK.xmit_time, RACK.RTT, RACK.reo_wnd, and RACK.min_RTT variables 142 are per connection. 144 4. Algorithm Details 146 4.1. Transmitting a data packet 148 Upon transmitting or retransmitting a packet, record the time in 149 Packet.xmit_time. 151 4.2. Upon receiving an ACK 153 Step 1: Update RACK.min_RTT. 155 Use the RTT measurements obtained in [RFC6298] or [RFC7323] to update 156 the estimated minimum RTT in RACK.min_RTT. The sender can track a 157 simple global minimum of all RTT measurements from the connection, or 158 a windowed min-filtered value of recent RTT measurements. This 159 document does not specify an exact approach. 161 Step 2: Update RACK.reo_wnd. 163 To handle the prevalent small degree of reordering, RACK.reo_wnd 164 serves as an allowance for settling time before marking a packet 165 lost. By default it is 1 millisecond. We RECOMMEND implementing the 166 reordering detection in [REORDER-DETECT][RFC4737] to dynamically 167 adjust the reordering window. When the sender detects packet 168 reordering RACK.reo_wnd MAY be changed to RACK.min_RTT/4. We discuss 169 more about the reordering window in the next section. 171 Step 3: Advance RACK.xmit_time and update RACK.RTT. 173 Given the information provided in an ACK, each packet cumulatively 174 ACKed or SACKed is marked as delivered in the scoreboard. Among all 175 the packets ACKed or SACKed so far in the connection, record the most 176 recent Packet.xmit_time in RACK.xmit_time if it is ahead of 177 RACK.xmit_time, unless the retransmission is considered as likely 178 spurious by the following check. Ignore the packet if it has been 179 retransmitted and either of two condition is true: 181 1. The Timestamp Echo Reply field (TSecr) of the ACK's timestamp 182 option [RFC7323], if available, indicates the ACK was not 183 acknowledging the last retransmission of the packet. 185 2. The packet was last retransmitted less than RACK.min_rtt ago. 186 While it is still possible the packet is spuriously retransmitted 187 because of a recent RTT decrease, we believe that our experience 188 suggests this is a reasonable heuristic. 190 If this ACK causes a change to RACK.xmit_time then record the RTT 191 implied by this ACK: set RACK.RTT = now - RACK.xmit_time. 193 Exit here and omit step 3 if RACK.xmit_time has not changed. 195 Step 3: Detect losses. 197 For each packet that has not been fully SACKed, if RACK.xmit_time is 198 after Packet.xmit_time + RACK.reo_wnd, then mark the packet (or its 199 corresponding sequence range) lost in the scoreboard. The rationale 200 is that if another packet that was sent later has been delivered, and 201 the reordering window or "reordering settling time" has already 202 passed, the packet was likely lost. 204 If a packet that was sent later has been delivered, but the 205 reordering window has not passed, then it is not yet safe to deem the 206 given packet lost. Using the basic algorithm above, the sender would 207 wait for the next ACK to further advance RACK.xmit_time; but this 208 risks a timeout (RTO) if no more ACKs come back (e.g, due to losses 209 or application limit). For timely loss detection, the sender MAY 210 install a "reordering settling" timer set to fire at the earliest 211 moment at which it is safe to conclude that some packet is lost. The 212 earliest moment is the time it takes to expire the reordering window 213 of the earliest unacked packet in flight, which is the minimum value 214 of (Packet.xmit_time + RACK.RTT + RACK.reo_wnd + 1ms) across all 215 unacknowledged packets. 217 This timer expiration value can be derived as follows. As a starting 218 point, we consider that the reordering window has passed if the RACK 219 packet was sent sufficiently after the packet in question, or a 220 sufficient time has elapsed since the RACK packet was S/ACKed, or 221 some combination of the two. More precisely, RACK marks a packet as 222 lost if the reordering window for a packet has elapsed through the 223 sum of: 225 1. delta in transmit time between a packet and the RACK packet 227 2. delta in time between the S/ACK of the RACK packet 228 (RACK.sacked_time) and now 230 So we mark a packet as lost if: 232 RACK.xmit_time > Packet.xmit_time 233 AND 234 (RACK.xmit_time - Packet.xmit_time) + (now - RACK.sacked_time) > RACK.reo_wnd 236 If we solve this second condition for "now", the moment at which we 237 can declare a packet lost, then we get: 239 now > Packet.xmit_time + RACK.reo_wnd + (RACK.sacked_time - RACK.xmit_time) 240 Then (RACK.sacked_time - RACK.xmit_time) is just the RTT of the 241 packet we used to set RACK.xmit_time, so this reduces to: 243 now > Packet.xmit_time + RACK.RTT + RACK.reo_wnd 245 The following pseudocode implements the algorithm above. When an ACK 246 is received or the RACK timer expires, call RACK_detect_loss(): 248 RACK_detect_loss(): 249 min_timeout = 0 251 For each packet, Packet, in the scoreboard: 252 If Packet is already SACKed, ACKed, 253 or marked lost and not yet retransmitted: 254 Skip to the next packet 256 If Packet.xmit_time > RACK.xmit_time: 257 Skip to the next packet 259 timeout = Packet.xmit_time + RACK.RTT + RACK.reo_wnd + 1 260 If now >= timeout 261 Mark Packet lost 262 Else If (min_timeout == 0) or (timeout is before min_timeout): 263 min_timeout = timeout 265 If min_timeout != 0 266 Arm the RACK timer to call RACK_detect_loss() at the time min_timeout 268 5. Algorithm Analysis 270 5.1. Advantages 272 The biggest advantage of RACK is that every data packet, whether it 273 is an original data transmission or a retransmission, can be used to 274 detect losses of the packets sent prior to it. 276 Example: tail drop. Consider a sender that transmits a window of 277 three data packets (P1, P2, P3), and P1 and P3 are lost. Suppose the 278 transmission of each packet is at least RACK.reo_wnd (1 millisecond 279 by default) after the transmission of the previous packet. RACK will 280 mark P1 as lost when the SACK of P2 is received, and this will 281 trigger the retransmission of P1 as R1. When R1 is cumulatively 282 acknowledged, RACK will mark P3 as lost and the sender will 283 retransmit P3 as R3. This example illustrates how RACK is able to 284 repair certain drops at the tail of a transaction without any timer. 285 Notice that neither the conventional duplicate ACK threshold 286 [RFC5681], nor [RFC6675], nor the Forward Acknowledgment [FACK] 287 algorithm can detect such losses, because of the required packet or 288 sequence count. 290 Example: lost retransmit. Consider a window of three data packets 291 (P1, P2, P3) that are sent; P1 and P2 are dropped. Suppose the 292 transmission of each packet is at least RACK.reo_wnd (1 millisecond 293 by default) after the transmission of the previous packet. When P3 294 is SACKed, RACK will mark P1 and P2 lost and they will be 295 retransmitted as R1 and R2. Suppose R1 is lost again (as a tail 296 drop) but R2 is SACKed; RACK will mark R1 lost for retransmission 297 again. Again, neither the conventional three duplicate ACK threshold 298 approach, nor [RFC6675], nor the Forward Acknowledgment [FACK] 299 algorithm can detect such losses. And such a lost retransmission is 300 very common when TCP is being rate-limited, particularly by token 301 bucket policers with large bucket depth and low rate limit. 302 Retransmissions are often lost repeatedly because standard congestion 303 control requires multiple round trips to reduce the rate below the 304 policed rate. 306 Example: (small) degree of reordering. Consider a common reordering 307 event: a window of packets are sent as (P1, P2, P3). P1 and P2 carry 308 a full payload of MSS octets, but P3 has only a 1-octet payload due 309 to application-limited behavior. Suppose the sender has detected 310 reordering previously (e.g., by implementing the algorithm in 311 [REORDER-DETECT]) and thus RACK.reo_wnd is min_RTT/4. Now P3 is 312 reordered and delivered first, before P1 and P2. As long as P1 and 313 P2 are delivered within min_RTT/4, RACK will not consider P1 and P2 314 lost. But if P1 and P2 are delivered outside the reordering window, 315 then RACK will still falsely mark P1 and P2 lost. We discuss how to 316 reduce the false positives in the end of this section. 318 The examples above show that RACK is particularly useful when the 319 sender is limited by the application, which is common for 320 interactive, request/response traffic. Similarly, RACK still works 321 when the sender is limited by the receive window, which is common for 322 applications that use the receive window to throttle the sender. 324 5.2. Disadvantages 326 RACK requires the sender to record the transmission time of each 327 packet sent at a clock granularity of one millisecond or finer. TCP 328 implementations that record this already for RTT estimation do not 329 require any new per-packet state. But implementations that are not 330 yet recording packet transmission times will need to add per-packet 331 internal state (commonly either 4 or 8 octets per packet) to track 332 transmission times. In contrast, the conventional approach requires 333 one variable to track number of duplicate ACK threshold. 335 5.3. Adjusting the reordering window 337 RACK uses a reordering window of min_rtt / 4. It uses the minimum 338 RTT to accommodate reordering introduced by packets traversing 339 slightly different paths (e.g., router-based parallelism schemes) or 340 out-of-order deliveries in the lower link layer (e.g., wireless links 341 using link-layer retransmission). Alternatively, RACK can use the 342 smoothed RTT used in RTT estimation [RFC6298]. However, smoothed RTT 343 can be significantly inflated by orders of magnitude due to 344 congestion and buffer-bloat, which would result in an overly 345 conservative reordering window and slow loss detection. Furthermore, 346 RACK uses a quarter of minimum RTT because Linux TCP uses the same 347 factor in its implementation to delay Early Retransmit [RFC5827] to 348 reduce spurious loss detections in the presence of reordering, and 349 experience shows that this seems to work reasonably well. 351 One potential improvement is to further adapt the reordering window 352 by measuring the degree of reordering in time, instead of packet 353 distances. But that requires storing the delivery timestamp of each 354 packet. Some scoreboard implementations currently merge SACKed 355 packets together to support TSO (TCP Segmentation Offload) for faster 356 scoreboard indexing. Supporting per-packet delivery timestamps is 357 difficult in such implementations. However, we acknowledge that the 358 current metric can be improved by further research. 360 5.4. Relationships with other loss recovery algorithms 362 The primary motivation of RACK is to ultimately provide a simple and 363 general replacement for some of the standard loss recovery algorithms 364 [RFC5681][RFC6675][RFC5827][RFC4653] and nonstandard ones 365 [FACK][THIN-STREAM]. While RACK can be a supplemental loss detection 366 on top of these algorithms, this is not necessary, because the RACK 367 implicitly subsumes most of them. 369 [RFC5827][RFC4653][THIN-STREAM] dynamically adjusts the duplicate ACK 370 threshold based on the current or previous flight sizes. RACK takes 371 a different approach, by using only one ACK event and a reordering 372 window. RACK can be seen as an extended Early Retransmit [RFC5827] 373 without a FlightSize limit but with an additional reordering window. 374 [FACK] considers an original packet to be lost when its sequence 375 range is sufficiently far below the highest SACKed sequence. In some 376 sense RACK can be seen as a generalized form of FACK that operates in 377 time space instead of sequence space, enabling it to better handle 378 reordering, application-limited traffic, and lost retransmissions. 380 Nevertheless RACK is still an experimental algorithm. Since the 381 oldest loss detection algorithm, the 3 duplicate ACK threshold 382 [RFC5681], has been standardized and widely deployed, we RECOMMEND 383 TCP implementations use both RACK and the algorithm specified in 384 Section 3.2 in [RFC5681] for compatibility. 386 RACK is compatible with and does not interfere with the the standard 387 RTO [RFC6298], RTO-restart [RTO-RESTART], F-RTO [RFC5682] and Eifel 388 algorithms [RFC3522]. This is because RACK only detects loss by 389 using ACK events. It neither changes the timer calculation nor 390 detects spurious timeouts. 392 Furthermore, RACK naturally works well with Tail Loss Probe [TLP] 393 because a tail loss probe solicit seither an ACK or SACK, which can 394 be used by RACK to detect more losses. RACK can be used to relax 395 TLP's requirement for using FACK and retransmitting the the highest- 396 sequenced packet, because RACK is agnostic to packet sequence 397 numbers, and uses transmission time instead. Thus TLP can be 398 modified to retransmit the first unacknowledged packet, which can 399 improve application latency. 401 5.5. Interaction with congestion control 403 RACK intentionally decouples loss detection from congestion control. 404 RACK only detects losses; it does not modify the congestion control 405 algorithm [RFC5681][RFC6937]. However, RACK may detect losses 406 earlier or later than the conventional duplicate ACK threshold 407 approach does. A packet marked lost by RACK SHOULD NOT be 408 retransmitted until congestion control deems this appropriate (e.g. 409 using [RFC6937]). 411 RACK is applicable for both fast recovery and recovery after a 412 retransmission timeout (RTO) in [RFC5681]. The distinction between 413 fast recovery or RTO recovery is not necessary because RACK is purely 414 based on the transmission time order of packets. When a packet 415 retransmitted by RTO is acknowledged, RACK will mark any unacked 416 packet sent sufficiently prior to the RTO as lost, because at least 417 one RTT has elapsed since these packets were sent. 419 6. Security Considerations 421 RACK does not change the risk profile for TCP. 423 An interesting scenario is ACK-splitting attacks [SCWA99]: for an 424 MSS-size packet sent, the receiver or the attacker might send MSS 425 ACKs that SACK or acknowledge one additional byte per ACK. This 426 would not fool RACK. RACK.xmit_time would not advance because all 427 the sequences of the packet are transmitted at the same time (carry 428 the same transmission timestamp). In other words, SACKing only one 429 byte of a packet or SACKing the packet in entirety have the same 430 effect on RACK. 432 7. IANA Considerations 434 This document makes no request of IANA. 436 Note to RFC Editor: this section may be removed on publication as an 437 RFC. 439 8. Acknowledgments 441 The authors wish to thank Matt Mathis for his insights in FACK that 442 inspired this work. Nandita Dukkipati, Eric Dumazet, Van Jacobson, 443 Ian Swett, and Jana Iyengar contributed to the algorithm and the 444 implementations in TCP and QUIC. We thank the authors of RFC3517 for 445 a great document on an excellent loss recovery algorithm that this 446 draft is trying to improve upon. 448 9. References 450 9.1. Normative References 452 [RFC793] Postel, J., "Transmission Control Protocol", September 453 1981. 455 [RFC2018] Mathis, M. and J. Mahdavi, "TCP Selective Acknowledgment 456 Options", RFC 2018, October 1996. 458 [RFC6937] Mathis, M., Dukkipati, N., and Y. Cheng, "Proportional 459 Rate Reduction for TCP", May 2013. 461 [RFC4737] Morton, A., Ciavattone, L., Ramachandran, G., Shalunov, 462 S., and J. Perser, "Packet Reordering Metrics", RFC 4737, 463 November 2006. 465 [RFC6675] Blanton, E., Allman, M., Wang, L., Jarvinen, I., Kojo, M., 466 and Y. Nishida, "A Conservative Loss Recovery Algorithm 467 Based on Selective Acknowledgment (SACK) for TCP", 468 RFC 6675, August 2012. 470 [RFC6298] Paxson, V., Allman, M., Chu, J., and M. Sargent, 471 "Computing TCP's Retransmission Timer", RFC 6298, June 472 2011. 474 [RFC5827] Allman, M., Ayesta, U., Wang, L., Blanton, J., and P. 475 Hurtig, "Early Retransmit for TCP and Stream Control 476 Transmission Protocol (SCTP)", RFC 5827, April 2010. 478 [RFC5682] Sarolahti, P., Kojo, M., Yamamoto, K., and M. Hata, 479 "Forward RTO-Recovery (F-RTO): An Algorithm for Detecting 480 Spurious Retransmission Timeouts with TCP", RFC 5682, 481 September 2009. 483 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 484 Requirement Levels", RFC 2119, March 1997. 486 [RFC5681] Allman, M., Paxson, V., and E. Blanton, "TCP Congestion 487 Control", RFC 5681, September 2009. 489 [RFC2883] Floyd, S., Mahdavi, J., Mathis, M., and M. Podolsky, "An 490 Extension to the Selective Acknowledgement (SACK) Option 491 for TCP", RFC 2883, July 2000. 493 [RFC7323] Borman, D., Braden, B., Jacobson, V., and R. 494 Scheffenegger, "TCP Extensions for High Performance", 495 September 2014. 497 9.2. Informative References 499 [FACK] Mathis, M. and M. Jamshid, "Forward acknowledgement: 500 refining TCP congestion control", ACM SIGCOMM Computer 501 Communication Review, Volume 26, Issue 4, Oct. 1996. , 502 1996. 504 [TLP] Dukkipati, N., Cardwell, N., Cheng, Y., and M. Mathis, 505 "Tail Loss Probe (TLP): An Algorithm for Fast Recovery of 506 Tail Drops", draft-dukkipati-tcpm-tcp-loss-probe-01 (work 507 in progress), August 2013. 509 [RTO-RESTART] 510 Hurtig, P., Brunstrom, A., Petlund, A., and M. Welzl, "TCP 511 and SCTP RTO Restart", draft-ietf-tcpm-rtorestart-08 (work 512 in progress), June 2015. 514 [REORDER-DETECT] 515 Zimmermann, A., Schulte, L., Wolff, C., and A. Hannemann, 516 "Detection and Quantification of Packet Reordering with 517 TCP", draft-zimmermann-tcpm-reordering-detection-02 (work 518 in progress), November 2014. 520 [THIN-STREAM] 521 Petlund, A., Evensen, K., Griwodz, C., and P. Halvorsen, 522 "TCP enhancements for interactive thin-stream 523 applications", NOSSDAV , 2008. 525 [SCWA99] Savage, S., Cardwell, N., Wetherall, D., and T. Anderson, 526 "TCP Congestion Control With a Misbehaving Receiver", ACM 527 Computer Communication Review, 29(5) , 1999. 529 Authors' Addresses 531 Yuchung Cheng 532 Google, Inc 533 1600 Amphitheater Parkway 534 Mountain View, California 93117 535 USA 537 Email: ycheng@google.com 539 Neal Cardwell 540 Google, Inc 541 76 Ninth Avenue 542 New York, NY 10011 543 USA 545 Email: ncardwell@google.com