draft-ietf-tcpm-rack-05.txt   draft-ietf-tcpm-rack-06.txt 
TCP Maintenance Working Group Y. Cheng TCP Maintenance Working Group Y. Cheng
Internet-Draft N. Cardwell Internet-Draft N. Cardwell
Intended status: Experimental N. Dukkipati Intended status: Experimental N. Dukkipati
Expires: October 28, 2019 P. Jha Expires: May 4, 2020 P. Jha
Google, Inc Google, Inc
April 26, 2019 November 1, 2019
RACK: a time-based fast loss detection algorithm for TCP RACK: a time-based fast loss detection algorithm for TCP
draft-ietf-tcpm-rack-05 draft-ietf-tcpm-rack-06
Abstract Abstract
This document presents a new TCP loss detection algorithm called RACK This document presents a new TCP loss detection algorithm called RACK
("Recent ACKnowledgment"). RACK uses the notion of time, instead of ("Recent ACKnowledgment"). RACK uses the notion of time, instead of
packet or sequence counts, to detect losses, for modern TCP packet or sequence counts, to detect losses, for modern TCP
implementations that can support per-packet timestamps and the implementations that can support per-packet timestamps and the
selective acknowledgment (SACK) option. It is intended to replace selective acknowledgment (SACK) option. It is intended to replace
the conventional DUPACK threshold approach and its variants, as well the conventional DUPACK threshold approach and its variants, as well
as other nonstandard approaches. as other nonstandard approaches.
skipping to change at page 1, line 38 skipping to change at page 1, line 38
Internet-Drafts are working documents of the Internet Engineering Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF). Note that other groups may also distribute Task Force (IETF). Note that other groups may also distribute
working documents as Internet-Drafts. The list of current Internet- working documents as Internet-Drafts. The list of current Internet-
Drafts is at https://datatracker.ietf.org/drafts/current/. Drafts is at https://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet-Drafts as reference time. It is inappropriate to use Internet-Drafts as reference
material or to cite them other than as "work in progress." material or to cite them other than as "work in progress."
This Internet-Draft will expire on October 28, 2019. This Internet-Draft will expire on May 4, 2020.
Copyright Notice Copyright Notice
Copyright (c) 2019 IETF Trust and the persons identified as the Copyright (c) 2019 IETF Trust and the persons identified as the
document authors. All rights reserved. document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents Provisions Relating to IETF Documents
(https://trustee.ietf.org/license-info) in effect on the date of (https://trustee.ietf.org/license-info) in effect on the date of
publication of this document. Please review these documents publication of this document. Please review these documents
carefully, as they describe your rights and restrictions with respect carefully, as they describe your rights and restrictions with respect
to this document. Code Components extracted from this document must to this document. Code Components extracted from this document must
include Simplified BSD License text as described in Section 4.e of include Simplified BSD License text as described in Section 4.e of
the Trust Legal Provisions and are provided without warranty as the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License. described in the Simplified BSD License.
1. Introduction 1. Terminology
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
"OPTIONAL" in this document are to be interpreted as described in BCP
14 [RFC2119] [RFC8174] when, and only when, they appear in all
capitals, as shown here. In this document, these words will appear
with that interpretation only when in UPPER CASE. Lower case uses of
these words are not to be interpreted as carrying [RFC2119]
significance.
2. Introduction
This document presents a new loss detection algorithm called RACK This document presents a new loss detection algorithm called RACK
("Recent ACKnowledgment"). RACK uses the notion of time instead of ("Recent ACKnowledgment"). RACK uses the notion of time instead of
the conventional packet or sequence counting approaches for detecting the conventional packet or sequence counting approaches for detecting
losses. RACK deems a packet lost if some packet sent sufficiently losses. RACK deems a packet lost if some packet sent sufficiently
later has been delivered. It does this by recording packet later has been delivered. It does this by recording packet
transmission times and inferring losses using cumulative transmission times and inferring losses using cumulative
acknowledgments or selective acknowledgment (SACK) TCP options. acknowledgments or selective acknowledgment (SACK) TCP options.
In the last couple of years we have been observing several In the last couple of years we have been observing several
skipping to change at page 3, line 9 skipping to change at page 3, line 20
Also, these algorithms, including RFCs, rarely address the Also, these algorithms, including RFCs, rarely address the
interactions with other algorithms. For example, FACK may consider a interactions with other algorithms. For example, FACK may consider a
packet is lost while RFC6675 may not. Implementing N algorithms packet is lost while RFC6675 may not. Implementing N algorithms
while dealing with N^2 interactions is a daunting task and error- while dealing with N^2 interactions is a daunting task and error-
prone. prone.
The goal of RACK is to solve all the problems above by replacing many The goal of RACK is to solve all the problems above by replacing many
of the loss detection algorithms above with one more effective of the loss detection algorithms above with one more effective
algorithm to handle loss and reordering. algorithm to handle loss and reordering.
2. Overview 3. Overview
The main idea behind RACK is that if a packet has been delivered out The main idea behind RACK is that if a packet has been delivered out
of order, then the packets sent chronologically before that were of order, then the packets sent chronologically before that were
either lost or reordered. This concept is not fundamentally either lost or reordered. This concept is not fundamentally
different from [RFC5681][RFC6675][FACK]. But the key innovation in different from [RFC5681][RFC6675][FACK]. But the key innovation in
RACK is to use a per-packet transmission timestamp and widely RACK is to use a per-packet transmission timestamp and widely
deployed SACK options to conduct time-based inferences instead of deployed SACK options to conduct time-based inferences instead of
inferring losses with packet or sequence counting approaches. inferring losses with packet or sequence counting approaches.
Using a threshold for counting duplicate acknowledgments (i.e., Using a threshold for counting duplicate acknowledgments (i.e.,
skipping to change at page 3, line 48 skipping to change at page 4, line 11
that time have "expired" by passing a certain reordering settling that time have "expired" by passing a certain reordering settling
window. On each ACK, RACK marks any already-expired packets lost, window. On each ACK, RACK marks any already-expired packets lost,
and for any packets that have not yet expired it waits until the and for any packets that have not yet expired it waits until the
reordering window passes and then marks those lost as well. In reordering window passes and then marks those lost as well. In
either case, RACK can repair the loss without waiting for a (long) either case, RACK can repair the loss without waiting for a (long)
RTO. RACK can be applied to both fast recovery and timeout recovery, RTO. RACK can be applied to both fast recovery and timeout recovery,
and can detect losses on both originally transmitted and and can detect losses on both originally transmitted and
retransmitted packets, making it a great all-weather loss detection retransmitted packets, making it a great all-weather loss detection
mechanism. mechanism.
3. Design Rationale for Reordering Tolerance 4. Design Rationale for Reordering Tolerance
The reordering behavior of networks can evolve (over years) in The reordering behavior of networks can evolve (over years) in
response to the behavior of transport protocols and applications, as response to the behavior of transport protocols and applications, as
well as the needs of network designers and operators. From a network well as the needs of network designers and operators. From a network
or link designer's viewpoint, parallelization (eg. link bonding) is or link designer's viewpoint, parallelization (eg. link bonding) is
the easiest way to get a network to go faster. Therefore their main the easiest way to get a network to go faster. Therefore their main
constraint on speed is reordering, and there is pressure to relax constraint on speed is reordering, and there is pressure to relax
that constraint. If RACK becomes widely deployed, the underlying that constraint. If RACK becomes widely deployed, the underlying
networks may introduce more reordering for higher throughput. But networks may introduce more reordering for higher throughput. But
this may result in excessive reordering that hurts end to end this may result in excessive reordering that hurts end to end
skipping to change at page 6, line 5 skipping to change at page 6, line 12
presence of reordering, the adaptation algorithm can impose presence of reordering, the adaptation algorithm can impose
sometimes-needless delays when it waits to disambiguate loss from sometimes-needless delays when it waits to disambiguate loss from
reordering, but the penalty for waiting is bounded to one round trip reordering, but the penalty for waiting is bounded to one round trip
and such delays are confined to longer-running flows. and such delays are confined to longer-running flows.
This document provides a concrete and detailed reordering window This document provides a concrete and detailed reordering window
adaptation algorithm for implementors. We note that the specifics of adaptation algorithm for implementors. We note that the specifics of
the algorithm are likely to evolve over time. But that is a separate the algorithm are likely to evolve over time. But that is a separate
engineering optimization that's out of scope for this document. engineering optimization that's out of scope for this document.
4. Requirements 5. Requirements
The reader is expected to be familiar with the definitions given in The reader is expected to be familiar with the definitions given in
the TCP congestion control [RFC5681] and selective acknowledgment the TCP congestion control [RFC5681] and selective acknowledgment
[RFC2018] RFCs. Familiarity with the conservative SACK-based [RFC2018] RFCs. Familiarity with the conservative SACK-based
recovery for TCP [RFC6675] is not expected but helps. recovery for TCP [RFC6675] is not expected but helps.
RACK has three requirements: RACK has three requirements:
1. The connection MUST use selective acknowledgment (SACK) options 1. The connection MUST use selective acknowledgment (SACK) options
[RFC2018]. [RFC2018].
skipping to change at page 6, line 35 skipping to change at page 6, line 42
We assume that requirement 1 implies the sender keeps a SACK We assume that requirement 1 implies the sender keeps a SACK
scoreboard, which is a data structure to store selective scoreboard, which is a data structure to store selective
acknowledgment information on a per-connection basis ([RFC6675] acknowledgment information on a per-connection basis ([RFC6675]
section 3). For the ease of explaining the algorithm, we use a section 3). For the ease of explaining the algorithm, we use a
pseudo-scoreboard that manages the data in sequence number ranges. pseudo-scoreboard that manages the data in sequence number ranges.
But the specifics of the data structure are left to the implementor. But the specifics of the data structure are left to the implementor.
RACK does not need any change on the receiver. RACK does not need any change on the receiver.
5. Definitions 6. Definitions
5.1. Terminology
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in [RFC2119 [1]]. In
this document, these words will appear with that interpretation only
when in UPPER CASE. Lower case uses of these words are not to be
interpreted as carrying [RFC2119 [2]] significance.
The reader is expected to be familiar with the definitions given in The reader is expected to be familiar with the definitions given in
[RFC793], including SND.UNA, SND.NXT, SEG.ACK, and SEG.SEQ. [RFC793], including SND.UNA, SND.NXT, SEG.ACK, and SEG.SEQ.
5.2. Definitions of variables 6.1. Definitions of variables
A sender implementing RACK needs to store these new RACK variables: A sender implementing RACK needs to store these new RACK variables:
"Packet.xmit_ts" is the time of the last transmission of a data "Packet.xmit_ts" is the time of the last transmission of a data
packet, including retransmissions, if any. The sender needs to packet, including retransmissions, if any. The sender needs to
record the transmission time for each packet sent and not yet record the transmission time for each packet sent and not yet
acknowledged. The time MUST be stored at millisecond granularity or acknowledged. The time MUST be stored at millisecond granularity or
finer. finer.
"RACK.packet". Among all the packets that have been either "RACK.packet". Among all the packets that have been either
selectively or cumulatively acknowledged, RACK.packet is the one that selectively or cumulatively acknowledged, RACK.packet is the one that
was sent most recently (including retransmissions). was sent most recently including retransmissions.
"RACK.xmit_ts" is the latest transmission timestamp of RACK.packet. "RACK.xmit_ts" is the latest transmission timestamp of RACK.packet.
"RACK.end_seq" is the ending TCP sequence number of RACK.packet. "RACK.end_seq" is the ending TCP sequence number of RACK.packet.
"RACK.rtt" is the RTT of the most recently transmitted packet that "RACK.rtt" is the RTT of the most recently delivered packet on the
has been delivered (either cumulatively acknowledged or selectively connection (either cumulatively acknowledged or selectively
acknowledged) on the connection. acknowledged) that was not marked invalid as a possible spurious
retransmission.
"RACK.rtt_seq" is the SND.NXT when RACK.rtt is updated. "RACK.rtt_seq" is the SND.NXT when RACK.rtt is updated.
"RACK.reo_wnd" is a reordering window computed in the unit of time "RACK.reo_wnd" is a reordering window computed in the unit of time
used for recording packet transmission times. It is used to defer used for recording packet transmission times. It is used to defer
the moment at which RACK marks a packet lost. the moment at which RACK marks a packet lost.
"RACK.dupthresh" is a constant specifying the number of duplicate "RACK.dupthresh" is a constant specifying the number of duplicate
acknowledgments, or selectively acknowledged segments, that can acknowledgments, or selectively acknowledged segments, that can
(under certain conditions) trigger fast recovery, similar to (under certain conditions) trigger fast recovery, similar to
skipping to change at page 8, line 7 skipping to change at page 8, line 4
"RACK.reo_wnd_persist" is the number of loss recoveries before "RACK.reo_wnd_persist" is the number of loss recoveries before
resetting RACK.reo_wnd resetting RACK.reo_wnd
"RACK.dsack" indicates if a DSACK option has been received since last "RACK.dsack" indicates if a DSACK option has been received since last
RACK.reo_wnd change "RACK.pkts_sacked" returns the total number of RACK.reo_wnd change "RACK.pkts_sacked" returns the total number of
packets selectively acknowledged in the SACK scoreboard. packets selectively acknowledged in the SACK scoreboard.
"RACK.reord" indicates the connection has detected packet reordering "RACK.reord" indicates the connection has detected packet reordering
event(s) event(s)
"RACK.fack" is the highest selectively or cumulatively acknowledged "RACK.fack" is the highest selectively or cumulatively acknowledged
sequence sequence
Note that the Packet.xmit_ts variable is per packet in flight. The Note that the Packet.xmit_ts variable is per packet in flight. The
RACK.xmit_ts, RACK.end_seq, RACK.rtt, RACK.reo_wnd, and RACK.min_RTT RACK.xmit_ts, RACK.end_seq, RACK.rtt, RACK.reo_wnd, and RACK.min_RTT
variables are kept in the per-connection TCP control block. variables are kept in the per-connection TCP control block.
RACK.packet and RACK.ack_ts are used as local variables in the RACK.packet and RACK.ack_ts are used as local variables in the
algorithm. algorithm.
6. Algorithm Details 7. Algorithm Details
6.1. Transmitting a data packet 7.1. Transmitting a data packet
Upon transmitting a new packet or retransmitting an old packet, Upon transmitting a new packet or retransmitting an old packet,
record the time in Packet.xmit_ts. RACK does not care if the record the time in Packet.xmit_ts. RACK does not care if the
retransmission is triggered by an ACK, new application data, an RTO, retransmission is triggered by an ACK, new application data, an RTO,
or any other means. or any other means.
6.2. Upon receiving an ACK 7.2. Upon receiving an ACK
Step 1: Update RACK.min_RTT. Step 1: Update RACK.min_RTT.
Use the RTT measurements obtained via [RFC6298] or [RFC7323] to Use the RTT measurements obtained via [RFC6298] or [RFC7323] to
update the estimated minimum RTT in RACK.min_RTT. The sender can update the estimated minimum RTT in RACK.min_RTT. The sender can
track a simple global minimum of all RTT measurements from the track a simple global minimum of all RTT measurements from the
connection, or a windowed min-filtered value of recent RTT connection, or a windowed min-filtered value of recent RTT
measurements. This document does not specify an exact approach. measurements. This document does not specify an exact approach.
Step 2: Update RACK stats Step 2: Update RACK stats
Given the information provided in an ACK, each packet cumulatively Given the information provided in an ACK, each packet cumulatively
ACKed or SACKed is marked as delivered in the scoreboard. Among all ACKed or SACKed is marked as delivered in the scoreboard. Among all
the packets newly ACKed or SACKed in the connection, record the most the packets newly ACKed or SACKed in the connection, record the most
recent Packet.xmit_ts in RACK.xmit_ts if it is ahead of RACK.xmit_ts. recent Packet.xmit_ts in RACK.xmit_ts if it is ahead of RACK.xmit_ts.
Sometimes the timestamps of RACK.Packet and Packet could carry the Sometimes the timestamps of RACK.Packet and Packet could carry the
same transmit timestamps due to clock granularity or segmentation same transmit timestamps due to clock granularity or segmentation
offloading (i.e. the two packets were sent as a jumbo frame into the offloading (i.e. the two packets were handed to the NIC as a single
NIC). In that case the sequence numbers of RACK.end_seq and unit). In that case the sequence numbers of RACK.end_seq and
Packet.end_seq are compared to break the tie. Packet.end_seq are compared to break the tie.
Since an ACK can also acknowledge retransmitted data packets, Since an ACK can also acknowledge retransmitted data packets, and
RACK.rtt can be vastly underestimated if the retransmission was retransmissions can be spurious, the sender must take care to avoid
spurious. To avoid that, ignore a packet if any of its TCP sequences spurious inferences. For example, if the sender were to use timing
have been retransmitted before and either of two conditions is true: information from a spurious retransmission, the RACK.rtt could be
vastly underestimated.
To avoid spurious inferences, ignore a packet as invalid if any of
its TCP sequences have been retransmitted before and either of two
conditions is true:
1. The Timestamp Echo Reply field (TSecr) of the ACK's timestamp 1. The Timestamp Echo Reply field (TSecr) of the ACK's timestamp
option [RFC7323], if available, indicates the ACK was not option [RFC7323], if available, indicates the ACK was not
acknowledging the last retransmission of the packet. acknowledging the last retransmission of the packet.
2. The packet was last retransmitted less than RACK.min_rtt ago. 2. The packet was last retransmitted less than RACK.min_rtt ago.
If the ACK is not ignored as invalid, update the RACK.rtt to be the If the ACK is not ignored as invalid, update the RACK.rtt to be the
RTT sample calculated using this ACK, and continue. If this ACK or RTT sample calculated using this ACK, and continue. If this ACK or
SACK was for the most recently sent packet, then record the SACK was for the most recently sent packet, then record the
skipping to change at page 12, line 43 skipping to change at page 12, line 46
RACK.xmit_ts >= Packet.xmit_ts RACK.xmit_ts >= Packet.xmit_ts
AND AND
(RACK.xmit_ts - Packet.xmit_ts) + (now - RACK.ack_ts) >= RACK.reo_wnd (RACK.xmit_ts - Packet.xmit_ts) + (now - RACK.ack_ts) >= RACK.reo_wnd
If we solve this second condition for "now", the moment at which we If we solve this second condition for "now", the moment at which we
can declare a packet lost, then we get: can declare a packet lost, then we get:
now >= Packet.xmit_ts + RACK.reo_wnd + (RACK.ack_ts - RACK.xmit_ts) now >= Packet.xmit_ts + RACK.reo_wnd + (RACK.ack_ts - RACK.xmit_ts)
Then (RACK.ack_ts - RACK.xmit_ts) is just the RTT of the packet we Then (RACK.ack_ts - RACK.xmit_ts) is the RTT of the packet the sender
used to set RACK.xmit_ts, so this reduces to: used to set RACK.xmit_ts: the round trip time of the most recently
(re)transmitted packet that's been delivered. To be more robust to
reordering, RACK uses a more conservative RTT value to decide if an
unacknowledged packet should be considered lost, RACK.rtt: the round
trip time of the most recently delivered packet on the connection
that was not marked invalid as a possible spurious retransmission.
When packets are delivered in order, the most recently
(re)transmitted packet that's been delivered is also the most
recently delivered, hence RACK.rtt == RACK.ack_ts - RACK.xmit_ts.
But if packets were reordered, then the packet delivered most
recently was sent before the most recently (re)transmitted packet.
Hence RACK.rtt > (RACK.ack_ts - RACK.xmit_ts).
Since RACK.RTT >= (RACK.ack_ts - RACK.xmit_ts), the previous equation
reduces to saying that the sender can declare a packet lost when:
now >= Packet.xmit_ts + RACK.reo_wnd + RACK.rtt
In turn, that is equivalent to stating that a RACK sender should
declare a packet lost when:
Packet.xmit_ts + RACK.rtt + RACK.reo_wnd - now <= 0 Packet.xmit_ts + RACK.rtt + RACK.reo_wnd - now <= 0
The following pseudocode implements the algorithm above. When an ACK The following pseudocode implements the algorithm above. When an ACK
is received or the RACK timer expires, call RACK_detect_loss(). The is received or the RACK timer expires, call RACK_detect_loss(). The
algorithm includes an additional optimization to break timestamp ties algorithm includes an additional optimization to break timestamp ties
by using the TCP sequence space. The optimization is particularly by using the TCP sequence space. The optimization is particularly
useful to detect losses in a timely manner with TCP Segmentation useful to detect losses in a timely manner with TCP Segmentation
Offload, where multiple packets in one TSO blob have identical Offload, where multiple packets in one TSO blob have identical
timestamps. It is also useful when the timestamp clock granularity timestamps. It is also useful when the timestamp clock granularity
skipping to change at page 13, line 42 skipping to change at page 14, line 15
(re)transmission time, then the loop can start on the least recently (re)transmission time, then the loop can start on the least recently
sent packet and abort on the first packet sent after RACK.time_ts. sent packet and abort on the first packet sent after RACK.time_ts.
This can be implemented by using a seperate list sorted in time This can be implemented by using a seperate list sorted in time
order. The implementation inserts the packet at the tail of the list order. The implementation inserts the packet at the tail of the list
when it is (re)transmitted, and removes a packet from the list when when it is (re)transmitted, and removes a packet from the list when
it is delivered or marked lost. We RECOMMEND such an optimization it is delivered or marked lost. We RECOMMEND such an optimization
because it enables implementations to support high-BDP networks. because it enables implementations to support high-BDP networks.
This optimization is implemented in Linux and sees orders of This optimization is implemented in Linux and sees orders of
magnitude improvement in CPU usage on high-speed WAN networks. magnitude improvement in CPU usage on high-speed WAN networks.
6.3. Tail Loss Probe: fast recovery for tail losses 7.3. Tail Loss Probe: fast recovery for tail losses
This section describes a supplemental algorithm, Tail Loss Probe This section describes a supplemental algorithm, Tail Loss Probe
(TLP), which leverages RACK to further reduce RTO recoveries. TLP (TLP), which leverages RACK to further reduce RTO recoveries. TLP
triggers fast recovery to quickly repair tail losses that can triggers fast recovery to quickly repair tail losses that can
otherwise be recovered by RTOs only. After an original data otherwise be recovered by RTOs only. After an original data
transmission, TLP sends a probe data segment within one to two RTTs. transmission, TLP sends a probe data segment within one to two RTTs.
The probe data segment can either be new, previously unsent data, or The probe data segment can either be new, previously unsent data, or
a retransmission of previously sent data just below SND.NXT. In a retransmission of previously sent data just below SND.NXT. In
either case the goal is to elicit more feedback from the receiver, in either case the goal is to elicit more feedback from the receiver, in
the form of an ACK (potentially with SACK blocks), to allow RACK to the form of an ACK (potentially with SACK blocks), to allow RACK to
skipping to change at page 14, line 32 skipping to change at page 15, line 5
P2 as lost and retransmits them as R1 and R2. Suppose R1 and R2 P2 as lost and retransmits them as R1 and R2. Suppose R1 and R2
are lost as well, so there are no more returning ACKs to detect are lost as well, so there are no more returning ACKs to detect
R1 and R2 as lost. Recovery stalls. R1 and R2 as lost. Recovery stalls.
5. An unexpectedly long round-trip time (RTT). This can cause ACKs 5. An unexpectedly long round-trip time (RTT). This can cause ACKs
to arrive after the RTO timer expires. The F-RTO algorithm to arrive after the RTO timer expires. The F-RTO algorithm
[RFC5682] is designed to detect such spurious retransmission [RFC5682] is designed to detect such spurious retransmission
timeouts and at least partially undo the consequences of such timeouts and at least partially undo the consequences of such
events, but F-RTO cannot be used in many situations. events, but F-RTO cannot be used in many situations.
6.4. Tail Loss Probe: An Example 7.4. Tail Loss Probe: An Example
Following is an example of TLP. All events listed are at a TCP Following is an example of TLP. All events listed are at a TCP
sender. sender.
1. Sender transmits segments 1-10: 1, 2, 3, ..., 8, 9, 10. There is 1. Sender transmits segments 1-10: 1, 2, 3, ..., 8, 9, 10. There is
no more new data to transmit. A PTO is scheduled to fire in 2 no more new data to transmit. A PTO is scheduled to fire in 2
RTTs, after the transmission of the 10th segment. RTTs, after the transmission of the 10th segment.
2. Sender receives acknowledgements (ACKs) for segments 1-5; 2. Sender receives acknowledgements (ACKs) for segments 1-5;
segments 6-10 are lost and no ACKs are received. The sender segments 6-10 are lost and no ACKs are received. The sender
skipping to change at page 15, line 12 skipping to change at page 15, line 30
3. When PTO fires, sender retransmits segment 10. 3. When PTO fires, sender retransmits segment 10.
4. After an RTT, a SACK for packet 10 arrives. The ACK also carries 4. After an RTT, a SACK for packet 10 arrives. The ACK also carries
SACK holes for segments 6, 7, 8 and 9. This triggers RACK-based SACK holes for segments 6, 7, 8 and 9. This triggers RACK-based
loss recovery. loss recovery.
5. The connection enters fast recovery and retransmits the remaining 5. The connection enters fast recovery and retransmits the remaining
lost segments. lost segments.
6.5. Tail Loss Probe Algorithm Details 7.5. Tail Loss Probe Algorithm Details
We define the terminology used in specifying the TLP algorithm: We define the terminology used in specifying the TLP algorithm:
FlightSize: amount of outstanding data in the network, as defined in FlightSize: amount of outstanding data in the network, as defined in
[RFC5681]. [RFC5681].
RTO: The transport's retransmission timeout (RTO) is based on RTO: The transport's retransmission timeout (RTO) is based on
measured round-trip times (RTT) between the sender and receiver, as measured round-trip times (RTT) between the sender and receiver, as
specified in [RFC6298] for TCP. PTO: Probe timeout (PTO) is a timer specified in [RFC6298] for TCP. PTO: Probe timeout (PTO) is a timer
event indicating that an ACK is overdue. Its value is constrained to event indicating that an ACK is overdue. Its value is constrained to
be smaller than or equal to an RTO. be smaller than or equal to an RTO.
SRTT: smoothed round-trip time, computed as specified in [RFC6298]. SRTT: smoothed round-trip time, computed as specified in [RFC6298].
TLPRxtOut: a boolean indicating whether there is an unacknowledged
TLP retransmission.
TLPHighRxt: the value of SND.NXT at the time of sending a TLP
retransmission.
The TLP algorithm has three phases, which we discuss in turn. The TLP algorithm has three phases, which we discuss in turn.
6.5.1. Phase 1: Scheduling a loss probe 7.5.1. Phase 1: Scheduling a loss probe
Step 1: Check conditions for scheduling a PTO. Step 1: Check conditions for scheduling a PTO.
A sender should check to see if it should schedule a PTO in the A sender should check to see if it should schedule a PTO in the
following situations: following situations:
1. After transmitting new data that was not itself a TLP probe 1. After transmitting new data that was not itself a TLP probe
2. Upon receiving an ACK that cumulatively acknowledges data 2. Upon receiving an ACK that cumulatively acknowledges data
skipping to change at page 17, line 9 skipping to change at page 17, line 41
WCDelAckT stands for worst case delayed ACK timer. When FlightSize WCDelAckT stands for worst case delayed ACK timer. When FlightSize
is 1, PTO is inflated by WCDelAckT time to compensate for a potential is 1, PTO is inflated by WCDelAckT time to compensate for a potential
long delayed ACK timer at the receiver. The RECOMMENDED value for long delayed ACK timer at the receiver. The RECOMMENDED value for
WCDelAckT is 200ms. WCDelAckT is 200ms.
Finally, if the time at which an RTO would fire (here denoted Finally, if the time at which an RTO would fire (here denoted
"TCP_RTO_expire") is sooner than the computed time for the PTO, then "TCP_RTO_expire") is sooner than the computed time for the PTO, then
a probe is scheduled to be sent at that earlier time. a probe is scheduled to be sent at that earlier time.
6.5.2. Phase 2: Sending a loss probe 7.5.2. Phase 2: Sending a loss probe
When the PTO fires, transmit a probe data segment: When the PTO fires, transmit a probe data segment:
TLP_send_probe(): TLP_send_probe():
If an unsent segment exists AND If an unsent segment exists AND
the receive window allows new data to be sent: the receive window allows new data to be sent:
Transmit the lowest-sequence unsent segment of up to SMSS Transmit the lowest-sequence unsent segment of up to SMSS
Increment FlightSize by the size of the newly-sent segment Increment FlightSize by the size of the newly-sent segment
Else:
Retransmit the highest-sequence segment sent so far Else if TLPRxtOut is not set:
Retransmit the highest-sequence segment sent so far
The cwnd remains unchanged The cwnd remains unchanged
When the loss probe is a retransmission, the sender uses the highest- When the loss probe is a retransmission, the sender uses the highest-
sequence segment sent so far. This is in order to deal with the sequence segment sent so far. This is in order to deal with the
retransmission ambiguity problem in TCP. Suppose a sender sends N retransmission ambiguity problem in TCP. Suppose a sender sends N
segments, and then retransmits the last segment (segment N) as a loss segments, and then retransmits the last segment (segment N) as a loss
probe, and then the sender receives a SACK for segment N. As long as probe, and then the sender receives a SACK for segment N. As long as
the sender waits for any required RACK reordering settling timer to the sender waits for any required RACK reordering settling timer to
then expire, it doesn't matter if that SACK was for the original then expire, it doesn't matter if that SACK was for the original
transmission of segment N or the TLP retransmission; in either case transmission of segment N or the TLP retransmission; in either case
the arrival of the SACK for segment N provides evidence that the N-1 the arrival of the SACK for segment N provides evidence that the N-1
segments preceding segment N were likely lost. In the case where segments preceding segment N were likely lost. In the case where
there is only one original outstanding segment of data (N=1), the there is only one original outstanding segment of data (N=1), the
same logic (trivially) applies: an ACK for a single outstanding same logic (trivially) applies: an ACK for a single outstanding
segment tells the sender the N-1=0 segments preceding that segment segment tells the sender the N-1=0 segments preceding that segment
were lost. Furthermore, whether there are N>1 or N=1 outstanding were lost. Furthermore, whether there are N>1 or N=1 outstanding
segments, there is a question about whether the original last segment segments, there is a question about whether the original last segment
or its TLP retransmission were lost; the sender estimates this using or its TLP retransmission were lost; the sender estimates this using
TLP recovery detection (see below). TLP recovery detection (see below).
Note that after transmitting a TLP, the sender MUST arm an RTO timer, Note that wether a probe was sent or not in TLP_send_probe(), the
and not the PTO timer. This ensures that the sender does not send sender MUST arm the RTO timer, not the PTO timer, at the end of
repeated, back-to-back TLP probes. This is important to avoid TLP TLP_send_probe() if FlightSize is not zero. This ensures that the
loops if an application writes periodically at an interval less than sender does not send repeated, back-to-back TLP probes. Checking
PTO. TLPRxtOut prior to sending the loss probe is also critical to avoid
TLP loops if an application writes periodically at an interval less
than PTO.
6.5.3. Phase 3: ACK processing 7.5.3. Phase 3: ACK processing
On each incoming ACK, the sender should check the conditions in Step On each incoming ACK, the sender should check the conditions in Step
1 of Phase 1 to see if it should schedule (or reschedule) the loss 1 of Phase 1 to see if it should schedule (or reschedule) the loss
probe timer. probe timer.
6.6. TLP recovery detection 7.6. TLP recovery detection
If the only loss in an outstanding window of data was the last If the only loss in an outstanding window of data was the last
segment, then a TLP loss probe retransmission of that data segment segment, then a TLP loss probe retransmission of that data segment
might repair the loss. TLP recovery detection examines ACKs to might repair the loss. TLP recovery detection examines ACKs to
detect when the probe might have repaired a loss, and thus allows detect when the probe might have repaired a loss, and thus allows
congestion control to properly reduce the congestion window (cwnd) congestion control to properly reduce the congestion window (cwnd)
[RFC5681]. [RFC5681].
Consider a TLP retransmission episode where a sender retransmits a Consider a TLP retransmission episode where a sender retransmits a
tail packet in a flight. The TLP retransmission episode ends when tail packet in a flight. The TLP retransmission episode ends when
skipping to change at page 18, line 32 skipping to change at page 19, line 25
retransmission episode, then it MUST estimate that either the retransmission episode, then it MUST estimate that either the
original data segment or the TLP retransmission were lost, and original data segment or the TLP retransmission were lost, and
congestion control MUST react appropriately to that loss as it would congestion control MUST react appropriately to that loss as it would
any other loss. any other loss.
Since a significant fraction of the hosts that support SACK do not Since a significant fraction of the hosts that support SACK do not
support duplicate selective acknowledgments (D-SACKs) [RFC2883] the support duplicate selective acknowledgments (D-SACKs) [RFC2883] the
TLP algorithm for detecting such lost segments relies only on basic TLP algorithm for detecting such lost segments relies only on basic
SACK support [RFC2018]. SACK support [RFC2018].
Definitions of variables 7.6.1. Initializing and resetting state
TLPRxtOut: a boolean indicating whether there is an unacknowledged
TLP retransmission.
TLPHighRxt: the value of SND.NXT at the time of sending a TLP
retransmission.
6.6.1. Initializing and resetting state
When a connection is created, or suffers a retransmission timeout, or When a connection is created, or suffers a retransmission timeout, or
enters fast recovery, it executes the following: enters fast recovery, it executes the following:
TLPRxtOut = false TLPRxtOut = false
6.6.2. Recording loss probe states 7.6.2. Recording loss probe states
Senders MUST only send a TLP loss probe retransmission if TLPRxtOut Senders MUST only send a TLP loss probe retransmission if TLPRxtOut
is false. This ensures that at any given time a connection has at is false. This ensures that at any given time a connection has at
most one outstanding TLP retransmission. This allows the sender to most one outstanding TLP retransmission. This allows the sender to
use the algorithm described in this section to estimate whether any use the algorithm described in this section to estimate whether any
data segments were lost. data segments were lost.
Note that this condition only restricts TLP loss probes that are Note that this condition only restricts TLP loss probes that are
retransmissions. There may be an arbitrary number of outstanding retransmissions. There may be an arbitrary number of outstanding
unacknowledged TLP loss probes that consist of new, previously-unsent unacknowledged TLP loss probes that consist of new, previously-unsent
skipping to change at page 20, line 27 skipping to change at page 21, line 13
a congestion control response equivalent to fast recovery. a congestion control response equivalent to fast recovery.
More precisely, on each ACK the sender executes the following: More precisely, on each ACK the sender executes the following:
if (TLPRxtOut and SEG.ACK >= TLPHighRxt) { if (TLPRxtOut and SEG.ACK >= TLPHighRxt) {
TLPRxtOut = false TLPRxtOut = false
EnterRecovery() EnterRecovery()
ExitRecovery() ExitRecovery()
} }
7. RACK and TLP discussions 8. RACK and TLP discussions
7.1. Advantages 8.1. Advantages
The biggest advantage of RACK is that every data packet, whether it The biggest advantage of RACK is that every data packet, whether it
is an original data transmission or a retransmission, can be used to is an original data transmission or a retransmission, can be used to
detect losses of the packets sent chronologically prior to it. detect losses of the packets sent chronologically prior to it.
Example: TAIL DROP. Consider a sender that transmits a window of Example: TAIL DROP. Consider a sender that transmits a window of
three data packets (P1, P2, P3), and P1 and P3 are lost. Suppose the three data packets (P1, P2, P3), and P1 and P3 are lost. Suppose the
transmission of each packet is at least RACK.reo_wnd (1 millisecond transmission of each packet is at least RACK.reo_wnd (1 millisecond
by default) after the transmission of the previous packet. RACK will by default) after the transmission of the previous packet. RACK will
mark P1 as lost when the SACK of P2 is received, and this will mark P1 as lost when the SACK of P2 is received, and this will
skipping to change at page 21, line 42 skipping to change at page 22, line 28
For some implementations (e.g., Linux), RACK works quite efficiently For some implementations (e.g., Linux), RACK works quite efficiently
with TCP Segmentation Offload (TSO). RACK always marks the entire with TCP Segmentation Offload (TSO). RACK always marks the entire
TSO blob lost because the packets in the same TSO blob have the same TSO blob lost because the packets in the same TSO blob have the same
transmission timestamp. By contrast, the algorithms based on transmission timestamp. By contrast, the algorithms based on
sequence counting (e.g., [RFC6675][RFC5681]) may mark only a subset sequence counting (e.g., [RFC6675][RFC5681]) may mark only a subset
of packets in the TSO blob lost, forcing the stack to perform of packets in the TSO blob lost, forcing the stack to perform
expensive fragmentation of the TSO blob, or to selectively tag expensive fragmentation of the TSO blob, or to selectively tag
individual packets lost in the scoreboard. individual packets lost in the scoreboard.
7.2. Disadvantages 8.2. Disadvantages
RACK requires the sender to record the transmission time of each RACK requires the sender to record the transmission time of each
packet sent at a clock granularity of one millisecond or finer. TCP packet sent at a clock granularity of one millisecond or finer. TCP
implementations that record this already for RTT estimation do not implementations that record this already for RTT estimation do not
require any new per-packet state. But implementations that are not require any new per-packet state. But implementations that are not
yet recording packet transmission times will need to add per-packet yet recording packet transmission times will need to add per-packet
internal state (commonly either 4 or 8 octets per packet or TSO blob) internal state (commonly either 4 or 8 octets per packet or TSO blob)
to track transmission times. In contrast, the conventional [RFC6675] to track transmission times. In contrast, the conventional [RFC6675]
loss detection approach does not require any per-packet state beyond loss detection approach does not require any per-packet state beyond
the SACK scoreboard. This is particularly useful on ultra-low RTT the SACK scoreboard. This is particularly useful on ultra-low RTT
skipping to change at page 22, line 19 skipping to change at page 23, line 5
[RFC6675][RFC5681] by resetting the reordering window to zero when [RFC6675][RFC5681] by resetting the reordering window to zero when
the threshold is met. Note that this approach differs slightly from the threshold is met. Note that this approach differs slightly from
[RFC6675] which considers a packet lost when at least #DupThresh [RFC6675] which considers a packet lost when at least #DupThresh
higher-sequenc packets are SACKed. RACK's approach considers a higher-sequenc packets are SACKed. RACK's approach considers a
packet lost when at least one higher sequence packet is SACKed and packet lost when at least one higher sequence packet is SACKed and
the total number of SACKed packets is at least DupThresh. For the total number of SACKed packets is at least DupThresh. For
example, suppose a connection sends 10 packets, and packets 3, 5, 7 example, suppose a connection sends 10 packets, and packets 3, 5, 7
are SACKed. [RFC6675] considers packets 1 and 2 lost. RACK are SACKed. [RFC6675] considers packets 1 and 2 lost. RACK
considers packets 1, 2, 4, 6 lost. considers packets 1, 2, 4, 6 lost.
7.3. Adjusting the reordering window 8.3. Adjusting the reordering window
When the sender detects packet reordering, RACK uses a reordering When the sender detects packet reordering, RACK uses a reordering
window of min_rtt / 4. It uses the minimum RTT to accommodate window of min_rtt / 4. It uses the minimum RTT to accommodate
reordering introduced by packets traversing slightly different paths reordering introduced by packets traversing slightly different paths
(e.g., router-based parallelism schemes) or out-of-order deliveries (e.g., router-based parallelism schemes) or out-of-order deliveries
in the lower link layer (e.g., wireless links using link-layer in the lower link layer (e.g., wireless links using link-layer
retransmission). RACK uses a quarter of minimum RTT because Linux retransmission). RACK uses a quarter of minimum RTT because Linux
TCP used the same factor in its implementation to delay Early TCP used the same factor in its implementation to delay Early
Retransmit [RFC5827] to reduce spurious loss detections in the Retransmit [RFC5827] to reduce spurious loss detections in the
presence of reordering, and experience shows that this seems to work presence of reordering, and experience shows that this seems to work
reasonably well. We have evaluated using the smoothed RTT (SRTT from reasonably well. We have evaluated using the smoothed RTT (SRTT from
[RFC6298] RTT estimation) or the most recently measured RTT [RFC6298] RTT estimation) or the most recently measured RTT
(RACK.rtt) using an experiment similar to that in the Performance (RACK.rtt) using an experiment similar to that in the Performance
Evaluation section. They do not make any significant difference in Evaluation section. They do not make any significant difference in
terms of total recovery latency. terms of total recovery latency.
7.4. Relationships with other loss recovery algorithms 8.4. Relationships with other loss recovery algorithms
The primary motivation of RACK is to ultimately provide a simple and The primary motivation of RACK is to ultimately provide a simple and
general replacement for some of the standard loss recovery algorithms general replacement for some of the standard loss recovery algorithms
[RFC5681][RFC6675][RFC5827][RFC4653], as well as some nonstandard [RFC5681][RFC6675][RFC5827][RFC4653], as well as some nonstandard
ones [FACK][THIN-STREAM]. While RACK can be a supplemental loss ones [FACK][THIN-STREAM]. While RACK can be a supplemental loss
detection mechanism on top of these algorithms, this is not detection mechanism on top of these algorithms, this is not
necessary, because RACK implicitly subsumes most of them. necessary, because RACK implicitly subsumes most of them.
[RFC5827][RFC4653][THIN-STREAM] dynamically adjusts the duplicate ACK [RFC5827][RFC4653][THIN-STREAM] dynamically adjusts the duplicate ACK
threshold based on the current or previous flight sizes. RACK takes threshold based on the current or previous flight sizes. RACK takes
skipping to change at page 23, line 29 skipping to change at page 24, line 14
Furthermore, RACK naturally works well with Tail Loss Probe [TLP] Furthermore, RACK naturally works well with Tail Loss Probe [TLP]
because a tail loss probe solicits either an ACK or SACK, which can because a tail loss probe solicits either an ACK or SACK, which can
be used by RACK to detect more losses. RACK can be used to relax be used by RACK to detect more losses. RACK can be used to relax
TLP's requirement for using FACK and retransmitting the the highest- TLP's requirement for using FACK and retransmitting the the highest-
sequenced packet, because RACK is agnostic to packet sequence sequenced packet, because RACK is agnostic to packet sequence
numbers, and uses transmission time instead. Thus TLP could be numbers, and uses transmission time instead. Thus TLP could be
modified to retransmit the first unacknowledged packet, which could modified to retransmit the first unacknowledged packet, which could
improve application latency. improve application latency.
7.5. Interaction with congestion control 8.5. Interaction with congestion control
RACK intentionally decouples loss detection from congestion control. RACK intentionally decouples loss detection from congestion control.
RACK only detects losses; it does not modify the congestion control RACK only detects losses; it does not modify the congestion control
algorithm [RFC5681][RFC6937]. However, RACK may detect losses algorithm [RFC5681][RFC6937]. However, RACK may detect losses
earlier or later than the conventional duplicate ACK threshold earlier or later than the conventional duplicate ACK threshold
approach does. A packet marked lost by RACK SHOULD NOT be approach does. A packet marked lost by RACK SHOULD NOT be
retransmitted until congestion control deems this appropriate. retransmitted until congestion control deems this appropriate.
Specifically, Proportional Rate Reduction [RFC6937] SHOULD be used Specifically, Proportional Rate Reduction [RFC6937] SHOULD be used
when using RACK. when using RACK.
skipping to change at page 24, line 29 skipping to change at page 25, line 15
In both cases, the sender after the recovery would be in congestion In both cases, the sender after the recovery would be in congestion
avoidance. The difference in recovery latency (RTO + 4*RTT vs 6*RTT) avoidance. The difference in recovery latency (RTO + 4*RTT vs 6*RTT)
can be significant if the RTT is much smaller than the minimum RTO (1 can be significant if the RTT is much smaller than the minimum RTO (1
second in RFC6298) or if the RTT is large. The former case is common second in RFC6298) or if the RTT is large. The former case is common
in local area networks, data-center networks, or content distribution in local area networks, data-center networks, or content distribution
networks with deep deployments. The latter case is more common in networks with deep deployments. The latter case is more common in
developing regions with highly congested and/or high-latency developing regions with highly congested and/or high-latency
networks. The ending congestion window after recovery also impacts networks. The ending congestion window after recovery also impacts
subsequent data transfer. subsequent data transfer.
7.6. TLP recovery detection with delayed ACKs 8.6. TLP recovery detection with delayed ACKs
Delayed ACKs complicate the detection of repairs done by TLP, since Delayed ACKs complicate the detection of repairs done by TLP, since
with a delayed ACK the sender receives one fewer ACK than would with a delayed ACK the sender receives one fewer ACK than would
normally be expected. To mitigate this complication, before sending normally be expected. To mitigate this complication, before sending
a TLP loss probe retransmission, the sender should attempt to wait a TLP loss probe retransmission, the sender should attempt to wait
long enough that the receiver has sent any delayed ACKs that it is long enough that the receiver has sent any delayed ACKs that it is
withholding. The sender algorithm described above features such a withholding. The sender algorithm described above features such a
delay, in the form of WCDelAckT. Furthermore, if the receiver delay, in the form of WCDelAckT. Furthermore, if the receiver
supports duplicate selective acknowledgments (D-SACKs) [RFC2883] then supports duplicate selective acknowledgments (D-SACKs) [RFC2883] then
in the case of a delayed ACK the sender's TLP recovery detection in the case of a delayed ACK the sender's TLP recovery detection
algorithm (see above) can use the D-SACK information to infer that algorithm (see above) can use the D-SACK information to infer that
the original and TLP retransmission both arrived at the receiver. the original and TLP retransmission both arrived at the receiver.
If there is ACK loss or a delayed ACK without a D-SACK, then this If there is ACK loss or a delayed ACK without a D-SACK, then this
algorithm is conservative, because the sender will reduce cwnd when algorithm is conservative, because the sender will reduce cwnd when
in fact there was no packet loss. In practice this is acceptable, in fact there was no packet loss. In practice this is acceptable,
and potentially even desirable: if there is reverse path congestion and potentially even desirable: if there is reverse path congestion
then reducing cwnd can be prudent. then reducing cwnd can be prudent.
7.7. RACK for other transport protocols 8.7. RACK for other transport protocols
RACK can be implemented in other transport protocols. The algorithm RACK can be implemented in other transport protocols. The algorithm
can be simplified by skipping step 3 if the protocol can support a can be simplified by skipping step 3 if the protocol can support a
unique transmission or packet identifier (e.g. TCP timestamp options unique transmission or packet identifier (e.g. TCP timestamp options
[RFC7323]). For example, the QUIC protocol implements RACK [QUIC- [RFC7323]). For example, the QUIC protocol implements RACK [QUIC-
LR]. LR]. The [Sprout] congestion control also independently designed to
use a 10ms reordering window to improve its loss detection.
8. Experiments and Performance Evaluations 9. Experiments and Performance Evaluations
RACK and TLP have been deployed at Google, for both connections to RACK and TLP have been deployed at Google, for both connections to
users in the Internet and internally. We conducted a performance users in the Internet and internally. We conducted a performance
evaluation experiment for RACK and TLP on a small set of Google Web evaluation experiment for RACK and TLP on a small set of Google Web
servers in Western Europe that serve mostly European and some African servers in Western Europe that serve mostly European and some African
countries. The experiment lasted three days in March 2017. The countries. The experiment lasted three days in March 2017. The
servers were divided evenly into four groups of roughly 5.3 million servers were divided evenly into four groups of roughly 5.3 million
flows each: flows each:
Group 1 (control): RACK off, TLP off, RFC 6675 on Group 1 (control): RACK off, TLP off, RFC 6675 on
skipping to change at page 26, line 19 skipping to change at page 26, line 48
for performance. Group 4's total recovery latency is 0.02% lower for performance. Group 4's total recovery latency is 0.02% lower
than Group 3's, indicating that RACK plus TLP can successfully than Group 3's, indicating that RACK plus TLP can successfully
replace RFC6675 as a standalone recovery mechanism. replace RFC6675 as a standalone recovery mechanism.
We want to emphasize that the current experiment is limited in terms We want to emphasize that the current experiment is limited in terms
of network coverage. The connectivity in Western Europe is fairly of network coverage. The connectivity in Western Europe is fairly
good, therefore loss recovery is not a major performance bottleneck. good, therefore loss recovery is not a major performance bottleneck.
We plan to expand our experiments to regions with worse connectivity, We plan to expand our experiments to regions with worse connectivity,
in particular on networks with strong traffic policing. in particular on networks with strong traffic policing.
9. Security Considerations 10. Security Considerations
RACK does not change the risk profile for TCP. RACK does not change the risk profile for TCP.
An interesting scenario is ACK-splitting attacks [SCWA99]: for an An interesting scenario is ACK-splitting attacks [SCWA99]: for an
MSS-size packet sent, the receiver or the attacker might send MSS MSS-size packet sent, the receiver or the attacker might send MSS
ACKs that SACK or acknowledge one additional byte per ACK. This ACKs that SACK or acknowledge one additional byte per ACK. This
would not fool RACK. RACK.xmit_ts would not advance because all the would not fool RACK. RACK.xmit_ts would not advance because all the
sequences of the packet are transmitted at the same time (carry the sequences of the packet are transmitted at the same time (carry the
same transmission timestamp). In other words, SACKing only one byte same transmission timestamp). In other words, SACKing only one byte
of a packet or SACKing the packet in entirety have the same effect on of a packet or SACKing the packet in entirety have the same effect on
RACK. RACK.
10. IANA Considerations 11. IANA Considerations
This document makes no request of IANA. This document makes no request of IANA.
Note to RFC Editor: this section may be removed on publication as an Note to RFC Editor: this section may be removed on publication as an
RFC. RFC.
11. Acknowledgments 12. Acknowledgments
The authors thank Matt Mathis for his insights in FACK and Michael The authors thank Matt Mathis for his insights in FACK and Michael
Welzl for his per-packet timer idea that inspired this work. Eric Welzl for his per-packet timer idea that inspired this work. Eric
Dumazet, Randy Stewart, Van Jacobson, Ian Swett, Rick Jones, Jana Dumazet, Randy Stewart, Van Jacobson, Ian Swett, Rick Jones, Jana
Iyengar, Hiren Panchasara, Praveen Balasubramanian, Yoshifumi Iyengar, Hiren Panchasara, Praveen Balasubramanian, Yoshifumi
Nishida, Bob Briscoe, Felix Weinrank, and Michael Tuexen contributed Nishida, Bob Briscoe, Felix Weinrank, Michael Tuexen, and Martin Duke
to the draft or the implementations in Linux, FreeBSD, Windows and contributed to the draft or the implementations in Linux, FreeBSD,
QUIC. Windows and QUIC.
12. References 13. References
12.1. Normative References 13.1. Normative References
[RFC2018] Mathis, M. and J. Mahdavi, "TCP Selective Acknowledgment [RFC2018] Mathis, M. and J. Mahdavi, "TCP Selective Acknowledgment
Options", RFC 2018, October 1996. Options", RFC 2018, October 1996.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", RFC 2119, March 1997. Requirement Levels", RFC 2119, March 1997.
[RFC2883] Floyd, S., Mahdavi, J., Mathis, M., and M. Podolsky, "An [RFC2883] Floyd, S., Mahdavi, J., Mathis, M., and M. Podolsky, "An
Extension to the Selective Acknowledgement (SACK) Option Extension to the Selective Acknowledgement (SACK) Option
for TCP", RFC 2883, July 2000. for TCP", RFC 2883, July 2000.
skipping to change at page 28, line 5 skipping to change at page 28, line 33
[RFC6937] Mathis, M., Dukkipati, N., and Y. Cheng, "Proportional [RFC6937] Mathis, M., Dukkipati, N., and Y. Cheng, "Proportional
Rate Reduction for TCP", May 2013. Rate Reduction for TCP", May 2013.
[RFC7323] Borman, D., Braden, B., Jacobson, V., and R. [RFC7323] Borman, D., Braden, B., Jacobson, V., and R.
Scheffenegger, "TCP Extensions for High Performance", Scheffenegger, "TCP Extensions for High Performance",
September 2014. September 2014.
[RFC793] Postel, J., "Transmission Control Protocol", September [RFC793] Postel, J., "Transmission Control Protocol", September
1981. 1981.
12.2. Informative References 13.2. Informative References
[FACK] Mathis, M. and M. Jamshid, "Forward acknowledgement: [FACK] Mathis, M. and M. Jamshid, "Forward acknowledgement:
refining TCP congestion control", ACM SIGCOMM Computer refining TCP congestion control", ACM SIGCOMM Computer
Communication Review, Volume 26, Issue 4, Oct. 1996. , Communication Review, Volume 26, Issue 4, Oct. 1996. ,
1996. 1996.
[POLICER16] [POLICER16]
Flach, T., Papageorge, P., Terzis, A., Pedrosa, L., Cheng, Flach, T., Papageorge, P., Terzis, A., Pedrosa, L., Cheng,
Y., Karim, T., Katz-Bassett, E., and R. Govindan, "An Y., Karim, T., Katz-Bassett, E., and R. Govindan, "An
Analysis of Traffic Policing in the Web", ACM SIGCOMM , Analysis of Traffic Policing in the Web", ACM SIGCOMM ,
skipping to change at page 28, line 29 skipping to change at page 29, line 9
Congestion Control", draft-tsvwg-quic-loss-recovery-01 Congestion Control", draft-tsvwg-quic-loss-recovery-01
(work in progress), June 2016. (work in progress), June 2016.
[RFC7765] Hurtig, P., Brunstrom, A., Petlund, A., and M. Welzl, "TCP [RFC7765] Hurtig, P., Brunstrom, A., Petlund, A., and M. Welzl, "TCP
and SCTP RTO Restart", February 2016. and SCTP RTO Restart", February 2016.
[SCWA99] Savage, S., Cardwell, N., Wetherall, D., and T. Anderson, [SCWA99] Savage, S., Cardwell, N., Wetherall, D., and T. Anderson,
"TCP Congestion Control With a Misbehaving Receiver", ACM "TCP Congestion Control With a Misbehaving Receiver", ACM
Computer Communication Review, 29(5) , 1999. Computer Communication Review, 29(5) , 1999.
[Sprout] Winstein, K., Sivaraman, A., and H. Balakrishnan,
"Stochastic Forecasts Achieve High Throughput and Low
Delay over Cellular Networks", USENIX Symposium on
Networked Systems Design and Implementation (NSDI) , 2013.
[THIN-STREAM] [THIN-STREAM]
Petlund, A., Evensen, K., Griwodz, C., and P. Halvorsen, Petlund, A., Evensen, K., Griwodz, C., and P. Halvorsen,
"TCP enhancements for interactive thin-stream "TCP enhancements for interactive thin-stream
applications", NOSSDAV , 2008. applications", NOSSDAV , 2008.
[TLP] Dukkipati, N., Cardwell, N., Cheng, Y., and M. Mathis, [TLP] Dukkipati, N., Cardwell, N., Cheng, Y., and M. Mathis,
"Tail Loss Probe (TLP): An Algorithm for Fast Recovery of "Tail Loss Probe (TLP): An Algorithm for Fast Recovery of
Tail Drops", draft-dukkipati-tcpm-tcp-loss-probe-01 (work Tail Drops", draft-dukkipati-tcpm-tcp-loss-probe-01 (work
in progress), August 2013. in progress), August 2013.
12.3. URIs
[1] https://tools.ietf.org/html/rfc2119
[2] https://tools.ietf.org/html/rfc2119
Authors' Addresses Authors' Addresses
Yuchung Cheng Yuchung Cheng
Google, Inc Google, Inc
1600 Amphitheater Parkway
Mountain View, California 94043
USA
Email: ycheng@google.com Email: ycheng@google.com
Neal Cardwell Neal Cardwell
Google, Inc Google, Inc
76 Ninth Avenue
New York, NY 10011
USA
Email: ncardwell@google.com Email: ncardwell@google.com
Nandita Dukkipati Nandita Dukkipati
Google, Inc Google, Inc
1600 Amphitheater Parkway
Mountain View, California 94043
Email: nanditad@google.com Email: nanditad@google.com
Priyaranjan Jha Priyaranjan Jha
Google, Inc Google, Inc
1600 Amphitheater Parkway
Mountain View, California 94043
Email: priyarjha@google.com Email: priyarjha@google.com
 End of changes. 55 change blocks. 
96 lines changed or deleted 114 lines changed or added

This html diff was produced by rfcdiff 1.47. The latest version is available from http://tools.ietf.org/tools/rfcdiff/