draft-ietf-tcpm-rack-02.txt   draft-ietf-tcpm-rack-03.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: September 14, 2017 Google, Inc Expires: September 6, 2018 P. Jha
March 13, 2017 Google, Inc
March 5, 2018
RACK: a time-based fast loss detection algorithm for TCP RACK: a time-based fast loss detection algorithm for TCP
draft-ietf-tcpm-rack-02 draft-ietf-tcpm-rack-03
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.
Status of This Memo Status of This Memo
This Internet-Draft is submitted in full conformance with the This Internet-Draft is submitted in full conformance with the
provisions of BCP 78 and BCP 79. provisions of BCP 78 and BCP 79.
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 http://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 September 14, 2017. This Internet-Draft will expire on September 6, 2018.
Copyright Notice Copyright Notice
Copyright (c) 2017 IETF Trust and the persons identified as the Copyright (c) 2018 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
(http://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. Introduction
This document presents a new loss detection algorithm called RACK This document presents a new loss detection algorithm called RACK
skipping to change at page 4, line 47 skipping to change at page 4, line 47
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 associated RTT measured when RACK.xmit_ts, above, "RACK.RTT" is the associated RTT measured when RACK.xmit_ts, above,
was changed. It is the RTT of the most recently transmitted packet was changed. It is the RTT of the most recently transmitted packet
that has been delivered (either cumulatively acknowledged or that has been delivered (either cumulatively acknowledged or
selectively acknowledged) on the connection. selectively acknowledged) on the connection.
"RACK.reo_wnd" is a reordering window for the connection, computed in "RACK.reo_wnd" is a reordering window for the connection, computed in
the unit of time used for recording packet transmission times. It is the unit of time used for recording packet transmission times. It is
used to defer the moment at which RACK marks a packet lost. used to defer the moment at which RACK marks a packet lost.
"RACK.min_RTT" is the estimated minimum round-trip time (RTT) of the "RACK.min_RTT" is the estimated minimum round-trip time (RTT) of the
connection. connection.
"RACK.ack_ts" is the time when all the sequences in RACK.packet were "RACK.ack_ts" is the time when all the sequences in RACK.packet were
selectively or cumulatively acknowledged. selectively or cumulatively acknowledged.
"RACK.reo_wnd_incr" is the multiplier applied to adjust RACK.reo_wnd
"RACK.reo_wnd_persist" is the number of loss recoveries before
resetting RACK.reo_wnd "RACK.dsack" indicates if RACK.reo_wnd has
been adjusted upon receiving a DSACK option
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.
5. Algorithm Details 5. Algorithm Details
5.1. Transmitting a data packet 5.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.
5.2. Upon receiving an ACK 5.2. Upon receiving an ACK
Step 1: Update RACK.min_RTT. Step 1: Update RACK.min_RTT.
Use the RTT measurements obtained in [RFC6298] or [RFC7323] to update Use the RTT measurements obtained via [RFC6298] or [RFC7323] to
the estimated minimum RTT in RACK.min_RTT. The sender can track a update the estimated minimum RTT in RACK.min_RTT. The sender can
simple global minimum of all RTT measurements from the connection, or track a simple global minimum of all RTT measurements from the
a windowed min-filtered value of recent RTT measurements. This connection, or a windowed min-filtered value of recent RTT
document does not specify an exact approach. measurements. This document does not specify an exact approach.
Step 2: Update RACK.reo_wnd.
To handle the prevalent small degree of reordering, RACK.reo_wnd Step 2: Update RACK stats
serves as an allowance for settling time before marking a packet
lost. By default it is 1 millisecond. [REORDER-DETECT][RFC4737] MAY
be implemented to dynamically adjust the reordering window upon
detecting reordering. When the sender detects packet reordering
RACK.reo_wnd MAY be changed to RACK.min_RTT/4. We discuss more about
the reordering window in the next section.
Step 3: Advance RACK.xmit_ts and update RACK.RTT and RACK.end_seq
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.
Ignore the packet if any of its TCP sequences have been retransmitted Sometimes the timestamps of RACK.Packet and Packet could carry the
before and either of two conditions is true: same transmit timestamps due to clock granularity or segmentation
offloading (i.e. the two packets were sent as a jumbo frame into the
NIC). In that case the sequence numbers of RACK.end_seq and
Packet.end_seq are compared to break the tie.
Since an ACK can also acknowledge retransmitted data packets,
RACK.RTT can be vastly underestimated if the retransmission was
spurious. To avoid that, ignore a packet 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.
While it is still possible the packet is spuriously retransmitted While it is still possible the packet is spuriously retransmitted
because of a recent RTT decrease, we believe that our experience because of a recent RTT decrease, we believe that our experience
suggests this is a reasonable heuristic. suggests this is a reasonable heuristic.
If this ACK causes a change to RACK.xmit_ts then record the RTT and If the ACK is not ignored as invalid, update the RACK.RTT to be the
sequence implied by this ACK: RTT sample calculated using this ACK, and continue. If this ACK or
SACK was for the most recently sent packet, then record the
RACK.xmit_ts timestamp and RACK.end_seq sequence implied by this ACK.
Otherwise exit here and omit the following steps.
RACK.RTT = Now() - RACK.xmit_ts Step 2 may be summarized in pseudocode as:
RACK.end_seq = Packet.end_seq
Exit here and omit the following steps if RACK.xmit_ts has not RACK_sent_after(t1, seq1, t2, seq2):
changed. If t1 > t2:
Return true
Else if t1 == t2 AND seq1 > seq2:
Return true
Else:
Return false
RACK_update():
For each Packet newly acknowledged cumulatively or selectively:
rtt = Now() - RACK.xmit_ts
If Packet has been retransmitted:
If ACK.ts_option.echo_reply < Packet.xmit_ts:
Return
If rtt < RACK.min_rtt:
Return
RACK.RTT = rtt
If RACK_sent_after(Packet.xmit_ts, Packet.end_seq
RACK.xmit_ts, RACK.end_seq):
RACK.xmit_ts = Packet.xmit_ts
RACK.end_seq = Packet.end_seq
Step 3: Update RACK reordering window
To handle the prevalent small degree of reordering, RACK.reo_wnd
serves as an allowance for settling time before marking a packet
lost. Use a conservative window of min_RTT / 4 if the connection is
not currently in loss recovery. When in loss recovery, use a
RACK.reo_wnd of zero in order to retransmit quickly.
Extension 1: Optionally size the window based on DSACK Further, the
sender MAY leverage DSACK [RFC3708] to adapt the reordering window to
higher degrees of reordering. Receiving an ACK with a DSACK
indicates a spurious retransmission, which in turn suggests that the
RACK reordering window, RACK.reo_wnd, is likely too small. The
sender MAY increase the RACK.reo_wnd window linearly for every round
trip in which the sender receives a DSACK, so that after N distinct
round trips in which a DSACK is received, the RACK.reo_wnd is N *
min_RTT / 4. The inflated RACK.reo_wnd would persist for 16 loss
recoveries and then reset to its starting value, min_RTT / 4.
Extension 2: Optionally size the window if reordering has been
observed
If the reordering window is too small or the connection does not
support DSACK, then RACK can trigger spurious loss recoveries and
reduce the congestion window unnecessarily. If the implementation
supports reordering detection such as [REORDER-DETECT], then the
sender MAY use the dynamically-sized reordering window based on
min_RTT during loss recovery instead of a zero reordering window to
compensate. Extension 3: Optionally size the window with the classic
DUPACK threshold heuristic The DUPACK threshold approach in the
current standards [RFC5681][RFC6675] is simple, and for decades has
been effective in quickly detecting losses, despite the drawbacks
discussed earlier. RACK can easily maintain the DUPACK threshold's
advantages of quick detection by resetting the reordering window to
zero (using RACK.reo_wnd = 0) when the DUPACK threshold is met (i.e.
when at least three packets have been selectively acknowledged). The
subtle differences are discussed in the section "RACK and TLP
discussions".
The following algorithm includes the basic and all the extensions
mentioned above. Note that individual extensions that require
additional TCP features (e.g. DSACK) would work if the feature
functions simply return false.
RACK_update_reo_wnd:
RACK.min_RTT = TCP_min_RTT()
If RACK_ext_TCP_ACK_has_DSACK_option():
RACK.dsack = true
If SND.UNA < RACK.roundtrip_seq:
RACK.dsack = false /* React to DSACK once within a round trip */
If RACK.dsack:
RACK.reo_wnd_incr += 1
RACK.dsack = false
RACK.roundtrip_seq = SND.NXT
RACK.reo_wnd_persist = 16 /* Keep window for 16 loss recoveries */
Else if exiting loss recovery:
RACK.reo_wnd_persist -= 1
If RACK.reo_wnd_persist <= 0:
RACK.reo_wnd_incr = 1
If in loss recovery and not RACK_ext_TCP_seen_reordering():
RACK.reo_wnd = 0
Else if RACK_ext_TCP_dupack_threshold_hit(): /* DUPTHRESH emulation mode */
RACK.reo_wnd = 0
Else:
RACK.reo_wnd = RACK.min_RTT / 4 * RACK.reo_wnd_incr
RACK.reo_wnd = min(RACK.reo_wnd, SRTT)
Step 4: Detect losses. Step 4: Detect losses.
For each packet that has not been fully SACKed, if RACK.xmit_ts is For each packet that has not been SACKed, if RACK.xmit_ts is after
after Packet.xmit_ts + RACK.reo_wnd, then mark the packet (or its Packet.xmit_ts + RACK.reo_wnd, then mark the packet (or its
corresponding sequence range) lost in the scoreboard. The rationale corresponding sequence range) lost in the scoreboard. The rationale
is that if another packet that was sent later has been delivered, and is that if another packet that was sent later has been delivered, and
the reordering window or "reordering settling time" has already the reordering window or "reordering settling time" has already
passed, then the packet was likely lost. passed, then the packet was likely lost.
If another packet that was sent later has been delivered, but the If another packet that was sent later has been delivered, but the
reordering window has not passed, then it is not yet safe to deem the reordering window has not passed, then it is not yet safe to deem the
unacked packet lost. Using the basic algorithm above, the sender unacked packet lost. Using the basic algorithm above, the sender
would wait for the next ACK to further advance RACK.xmit_ts; but this would wait for the next ACK to further advance RACK.xmit_ts; but this
risks a timeout (RTO) if no more ACKs come back (e.g, due to losses risks a timeout (RTO) if no more ACKs come back (e.g, due to losses
skipping to change at page 7, line 15 skipping to change at page 9, line 37
some combination of the two. More precisely, RACK marks a packet as some combination of the two. More precisely, RACK marks a packet as
lost if the reordering window for a packet has elapsed through the lost if the reordering window for a packet has elapsed through the
sum of: sum of:
1. delta in transmit time between a packet and the RACK.packet 1. delta in transmit time between a packet and the RACK.packet
2. delta in time between RACK.ack_ts and now 2. delta in time between RACK.ack_ts and now
So we mark a packet as lost if: So we mark a packet as lost if:
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 just the RTT of the packet we
used to set RACK.xmit_ts, so this reduces to: used to set RACK.xmit_ts, so this reduces to:
now > Packet.xmit_ts + RACK.RTT + RACK.reo_wnd 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
is close to or longer than the actual round trip time. is close to or longer than the actual round trip time.
RACK_detect_loss(): RACK_detect_loss():
min_timeout = 0 timeout = 0
For each packet, Packet, in the scoreboard: For each packet, Packet, in the scoreboard:
If Packet is already SACKed, ACKed, If Packet is already SACKed
or marked lost and not yet retransmitted: or marked lost and not yet retransmitted:
Skip to the next packet Continue
If Packet.xmit_ts > RACK.xmit_ts: If RACK_sent_after(RACK.xmit_ts, RACK.end_seq,
Skip to the next packet Packet.xmit_ts, Packet.end_seq):
/* Timestamp tie breaker */ remaining = Packet.xmit_ts + RACK.RTT + RACK.reo_wnd - Now()
If Packet.xmit_ts == RACK.xmit_ts AND If remaining <= 0:
Packet.end_seq > RACK.end_seq: Mark Packet lost
Skip to the next packet Else:
timeout = max(remaining, timeout)
timeout = Packet.xmit_ts + RACK.RTT + RACK.reo_wnd + 1 If timeout != 0
If Now() >= timeout: Arm a timer to call RACK_detect_loss() after timeout
Mark Packet lost
Else If (min_timeout == 0) or (timeout is before min_timeout):
min_timeout = timeout
If min_timeout != 0 Implementation optimization: looping through packets in the SACK
Arm a timer to call RACK_detect_loss() after min_timeout scoreboard above could be very costly on large BDP networks since the
inflight could be very large. If the implementation can organize the
scoreboard data structures to have packets sorted by the last
(re)transmission time, then the loop can start on the least recently
sent packet and aborts on the first packet sent after RACK.time_ts.
This can be implemented by using a seperate list sorted in time
order. The implementation inserts the packet to the tail of the list
when it is (re)transmitted, and removes a packet from the list when
it is delivered or marked lost. We RECOMMEND such an optimization
for implementations for support high BDP networks. The optimization
is implemented in Linux and sees orders of magnitude improvement on
CPU usage on high speed WAN networks.
6. Tail Loss Probe: fast recovery on tail losses Tail Loss Probe: fast recovery on 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
trigger fast recovery instead of an RTO. trigger fast recovery instead of an RTO.
An RTO occurs when the first unacknowledged sequence number is not An RTO occurs when the first unacknowledged sequence number is not
acknowledged after a conservative period of time has elapsed acknowledged after a conservative period of time has elapsed
[RFC6298]. Common causes of RTOs include: [RFC6298]. Common causes of RTOs include:
1. Tail losses at the end of an application transaction. 1. The entire flight is lost
2. Lost retransmits, which can halt fast recovery based on [RFC6675] 2. Tail losses at the end of an application transaction
3. Lost retransmits, which can halt fast recovery based on [RFC6675]
if the ACK stream completely dries up. For example, consider a if the ACK stream completely dries up. For example, consider a
window of three data packets (P1, P2, P3) that are sent; P1 and window of three data packets (P1, P2, P3) that are sent; P1 and
P2 are dropped. On receipt of a SACK for P3, RACK marks P1 and P2 are dropped. On receipt of a SACK for P3, RACK marks P1 and
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.
3. Tail losses of ACKs. 4. Tail losses of ACKs.
4. 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.1. Tail Loss Probe: An Example 5.3. 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 RTTs, no more new data to transmit. A PTO is scheduled to fire in 2
after the transmission of the 10th segment. (2) Sender receives RTTs, after the transmission of the 10th segment.
acknowledgements (ACKs) for segments 1-5; segments 6-10 are lost and
no ACKs are received. The sender reschedules its PTO timer relative
to the last received ACK, which is the ACK for segment 5 in this
case. The sender sets the PTO interval using the calculation
described in step (2) of the algorithm. (3) When PTO fires, sender
retransmits segment 10. (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 loss recovery. (5) The connection enters
fast recovery and retransmits the remaining lost segments.
6.2. Tail Loss Probe Algorithm Details 2. Sender receives acknowledgements (ACKs) for segments 1-5;
segments 6-10 are lost and no ACKs are received. The sender
reschedules its PTO timer relative to the last received ACK,
which is the ACK for segment 5 in this case. The sender sets the
PTO interval using the calculation described in step (2) of the
algorithm.
3. When PTO fires, sender retransmits segment 10.
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
loss recovery.
5. The connection enters fast recovery and retransmits the remaining
lost segments.
5.4. 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].
Open state: the sender has so far received in-sequence ACKs with no Open state: the sender's loss recovery state machine is in its
SACK blocks, and no other indications (such as retransmission normal, default state: there are no SACKed sequence ranges in the
timeout) that a loss may have occurred. SACK scoreboard, and neither fast recovery, timeout-based recovery,
nor ECN-based cwnd reduction are underway.
The TLP algorithm has three phases, which we discuss in turn. The TLP algorithm has three phases, which we discuss in turn.
6.2.1. Phase 1: Scheduling a loss probe 5.4.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 schedule a PTO after transmitting new data or A sender should check to see if it should schedule a PTO in two
receiving an ACK if the following conditions are met: situations:
(a) The connection is in Open state 1. After transmitting new data
(b) The connection is either cwnd-limited (the data in flight matches
or exceeds the cwnd) or application-limited (there is no unsent 2. Upon receiving an ACK that cumulatively acknowledges data.
data that the receiver window allows to be sent)
(c) SACK is enabled for the connection A sender should schedule a PTO only if all of the following
(d) The most recently transmitted data was not itself a TLP probe conditions are met:
(i.e. a sender MUST NOT send consecutive TLP probes)
1. The connection supports SACK [RFC2018]
2. The connection is not in loss recovery
3. The connection is either limited by congestion window (the data
in flight matches or exceeds the cwnd) or application-limited
(there is no unsent data that the receiver window allows to be
sent).
4. The most recently transmitted data was not itself a TLP probe
(i.e. a sender MUST NOT send consecutive or back-to-back TLP
probes).
If a PTO cannot be scheduled according to these conditions, then the
sender MUST arm the RTO timer if there is unacknowledged data in
flight.
Step 2: Select the duration of the PTO. Step 2: Select the duration of the PTO.
A sender SHOULD use the following logic to select the duration of a A sender SHOULD use the following logic to select the duration of a
PTO: PTO:
If an SRTT estimate is available: TLP_timeout():
If SRTT is available:
PTO = 2 * SRTT PTO = 2 * SRTT
If FlightSize = 1:
PTO += WCDelAckT
Else:
PTO += 2ms
Else: Else:
PTO = initial RTO of 1 sec PTO = 1 sec
If FlightSize = 1:
PTO = max(PTO, 1.5 * SRTT + WCDelAckT) If Now() + PTO > TCP_RTO_expire():
PTO = max(10ms, PTO) PTO = TCP_RTO_expire() - Now()
PTO = max(RTO, PTO)
Aiming for a PTO value of 2*SRTT allows a sender to wait long enough Aiming for a PTO value of 2*SRTT allows a sender to wait long enough
to know that an ACK is overdue. Under normal circumstances, i.e. no to know that an ACK is overdue. Under normal circumstances, i.e. no
losses, an ACK typically arrives in one SRTT. But choosing PTO to be losses, an ACK typically arrives in one SRTT. But choosing PTO to be
exactly an SRTT is likely to generate spurious probes given that exactly an SRTT is likely to generate spurious probes given that
network delay variance and even end-system timings can easily push an network delay variance and even end-system timings can easily push an
ACK to be above an SRTT. We chose PTO to be the next integral ACK to be above an SRTT. We chose PTO to be the next integral
multiple of SRTT. Similarly, current end-system processing latencies multiple of SRTT.
and timer granularities can easily push an ACK beyond 10ms, so
senders SHOULD use a minimum PTO value of 10ms. If RTO is smaller Similarly, current end-system processing latencies and timer
than the computed value for PTO, then a probe is scheduled to be sent granularities can easily delay ACKs, so senders SHOULD add at least
at the RTO time. 2ms to a computed PTO value (and MAY add more if the sending host OS
timer granularity is more coarse than 1ms).
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 additionally by WCDelAckT time to compensate is 1, PTO is inflated by WCDelAckT time to compensate for a potential
for a potential long delayed ACK timer at the receiver. The long delayed ACK timer at the receiver. The RECOMMENDED value for
RECOMMENDED value for WCDelAckT is 200ms, or the delayed ACK interval WCDelAckT is 200ms.
value explicitly negotiated by the sender and receiver, if one is
available.
6.2.2. Phase 2: Sending a loss probe 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
a probe is scheduled to be sent at that earlier time..
5.4.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():
If a previously unsent segment exists AND If a previously unsent segment exists AND
the receive window allows new data to be sent: the receive window allows new data to be sent:
Transmit that new segment Transmit that new segment
FlightSize += SMSS FlightSize += SMSS
Else: Else:
Retransmit the last segment Retransmit the last segment
The cwnd remains unchanged The cwnd remains unchanged
6.2.3. Phase 3: ACK processing 5.4.3. Phase 3: ACK processing
On each incoming ACK, the sender should cancel any existing loss On each incoming ACK, the sender should cancel any existing loss
probe timer. The sender should then reschedule the loss probe timer probe timer. The sender should then reschedule the loss probe timer
if the conditions in Step 1 of Phase 1 allow. if the conditions in Step 1 of Phase 1 allow.
6.3. TLP recovery detection 5.5. 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 12, line 20 skipping to change at page 15, line 15
SACK support [RFC2018]. SACK support [RFC2018].
Definitions of variables Definitions of variables
TLPRxtOut: a boolean indicating whether there is an unacknowledged TLPRxtOut: a boolean indicating whether there is an unacknowledged
TLP retransmission. TLP retransmission.
TLPHighRxt: the value of SND.NXT at the time of sending a TLP TLPHighRxt: the value of SND.NXT at the time of sending a TLP
retransmission. retransmission.
6.3.1. Initializing and resetting state 5.5.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.3.2. Recording loss probe states 5.5.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 12, line 50 skipping to change at page 15, line 45
Upon sending a TLP probe that is a retransmission, the sender sets Upon sending a TLP probe that is a retransmission, the sender sets
TLPRxtOut to true and TLPHighRxt to SND.NXT. TLPRxtOut to true and TLPHighRxt to SND.NXT.
Detecting recoveries accomplished by loss probes Detecting recoveries accomplished by loss probes
Step 1: Track ACKs indicating receipt of original and retransmitted Step 1: Track ACKs indicating receipt of original and retransmitted
segments segments
A sender considers both the original segment and TLP probe A sender considers both the original segment and TLP probe
retransmission segment as acknowledged if either (i) or (ii) are retransmission segment as acknowledged if either 1 or 2 are true:
true:
(i) This is a duplicate acknowledgment (as defined in [RFC5681],
section 2), and all of the following conditions are met:
(a) TLPRxtOut is true 1. This is a duplicate acknowledgment (as defined in [RFC5681],
section 2), and all of the following conditions are met:
(b) SEG.ACK == TLPHighRxt 1. TLPRxtOut is true
2. SEG.ACK == TLPHighRxt
(c) SEG.ACK == SND.UNA 3. SEG.ACK == SND.UNA
(d) the segment contains no SACK blocks for sequence ranges above 4. the segment contains no SACK blocks for sequence ranges above
TLPHighRxt TLPHighRxt
(e) the segment contains no data 5. the segment contains no data
(f) the segment is not a window update 6. the segment is not a window update
(ii) This is an ACK acknowledging a sequence number at or above 2. This is an ACK acknowledging a sequence number at or above
TLPHighRxt and it contains a D-SACK; i.e. all of the following TLPHighRxt and it contains a D-SACK; i.e. all of the following
conditions are met: conditions are met:
(a) TLPRxtOut is true 1. TLPRxtOut is true
(b) SEG.ACK >= TLPHighRxt and 2. SEG.ACK >= TLPHighRxt
(c) the ACK contains a D-SACK block 3. the ACK contains a D-SACK block
If either conditions (i) or (ii) are met, then the sender estimates If neither conditions are met, then the sender estimates that the
that the receiver received both the original data segment and the TLP receiver received both the original data segment and the TLP probe
probe retransmission, and so the sender considers the TLP episode to retransmission, and so the sender considers the TLP episode to be
be done, and records that fact by setting TLPRxtOut to false. done, and records that fact by setting TLPRxtOut to false.
Step 2: Mark the end of a TLP episode and detect losses Step 2: Mark the end of a TLP retransmission episode and detect
losses
If the sender receives a cumulative ACK for data beyond the TLP loss If the sender receives a cumulative ACK for data beyond the TLP loss
probe retransmission then, in the absence of reordering on the return probe retransmission then, in the absence of reordering on the return
path of ACKs, it should have received any ACKs for the original path of ACKs, it should have received any ACKs for the original
segment and TLP probe retransmission segment. At that time, if the segment and TLP probe retransmission segment. At that time, if the
TLPRxtOut flag is still true and thus indicates that the TLP probe TLPRxtOut flag is still true and thus indicates that the TLP probe
retransmission remains unacknowledged, then the sender should presume retransmission remains unacknowledged, then the sender should presume
that at least one of its data segments was lost, so it SHOULD invoke that at least one of its data segments was lost, so it SHOULD invoke
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 6. RACK and TLP discussions
7.1. Advantages 6.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 15, line 29 skipping to change at page 18, line 20
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 counting based algorithms transmission timestamp. By contrast, the counting based algorithms
(e.g., [RFC3517][RFC5681]) may mark only a subset of packets in the (e.g., [RFC3517][RFC5681]) may mark only a subset of packets in the
TSO blob lost, forcing the stack to perform expensive fragmentation TSO blob lost, forcing the stack to perform expensive fragmentation
of the TSO blob, or to selectively tag individual packets lost in the of the TSO blob, or to selectively tag individual packets lost in the
scoreboard. scoreboard.
7.2. Disadvantages 6.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. the SACK scoreboard. This is particularly useful on ultra-low RTT
networks where the RTT is far less than the sender TCP clock
grainularity (e.g. inside data-centers).
7.3. Adjusting the reordering window RACK can easily and optionally support the conventional approach in
[RFC6675][RFC5681] by resetting the reordering window to zero when
the threshold is met. Note that this approach differs slightly from
[RFC6675] which considers a packet lost when at least #DupThresh
higher-sequenc packets are SACKed. RACK's approach considers a
packet lost when at least one higher sequence packet is SACKed and
the total number of SACKed packets is at least DupThresh. For
example, suppose a connection sends 10 packets, and packets 3, 5, 7
are SACKed. [RFC6675] considers packets 1 and 2 lost. RACK
considers packets 1, 2, 4, 6 lost.
6.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
skipping to change at page 16, line 4 skipping to change at page 19, line 8
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.
One potential improvement would be to further adapt the reordering 6.4. Relationships with other loss recovery algorithms
window by measuring the degree of reordering in time, instead of
packet distances. But that requires storing the delivery timestamp
of each packet. Some scoreboard implementations currently merge
SACKed packets together to support TSO (TCP Segmentation Offload) for
faster scoreboard indexing. Supporting per-packet delivery
timestamps is difficult in such implementations. However, we
acknowledge that the current metric can be improved by further
research.
7.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 16, line 42 skipping to change at page 19, line 35
window. RACK can be seen as an extended Early Retransmit [RFC5827] window. RACK can be seen as an extended Early Retransmit [RFC5827]
without a FlightSize limit but with an additional reordering window. without a FlightSize limit but with an additional reordering window.
[FACK] considers an original packet to be lost when its sequence [FACK] considers an original packet to be lost when its sequence
range is sufficiently far below the highest SACKed sequence. In some range is sufficiently far below the highest SACKed sequence. In some
sense RACK can be seen as a generalized form of FACK that operates in sense RACK can be seen as a generalized form of FACK that operates in
time space instead of sequence space, enabling it to better handle time space instead of sequence space, enabling it to better handle
reordering, application-limited traffic, and lost retransmissions. reordering, application-limited traffic, and lost retransmissions.
Nevertheless RACK is still an experimental algorithm. Since the Nevertheless RACK is still an experimental algorithm. Since the
oldest loss detection algorithm, the 3 duplicate ACK threshold oldest loss detection algorithm, the 3 duplicate ACK threshold
[RFC5681], has been standardized and widely deployed, we RECOMMEND [RFC5681], has been standardized and widely deployed. RACK can
TCP implementations use both RACK and the algorithm specified in easily and optionally support the conventional approach for
Section 3.2 in [RFC5681] for compatibility. compatibility.
RACK is compatible with and does not interfere with the the standard RACK is compatible with and does not interfere with the the standard
RTO [RFC6298], RTO-restart [RFC7765], F-RTO [RFC5682] and Eifel RTO [RFC6298], RTO-restart [RFC7765], F-RTO [RFC5682] and Eifel
algorithms [RFC3522]. This is because RACK only detects loss by algorithms [RFC3522]. This is because RACK only detects loss by
using ACK events. It neither changes the RTO timer calculation nor using ACK events. It neither changes the RTO timer calculation nor
detects spurious timeouts. detects spurious timeouts.
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 6.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 (e.g. retransmitted until congestion control deems this appropriate.
using [RFC6937]). Specifically, Proportional Rate Reduction [RFC6937] SHOULD be used
when using RACK.
RACK is applicable for both fast recovery and recovery after a RACK is applicable for both fast recovery and recovery after a
retransmission timeout (RTO) in [RFC5681]. RACK applies equally to retransmission timeout (RTO) in [RFC5681]. RACK applies equally to
fast recovery and RTO recovery because RACK is purely based on the fast recovery and RTO recovery because RACK is purely based on the
transmission time order of packets. When a packet retransmitted by transmission time order of packets. When a packet retransmitted by
RTO is acknowledged, RACK will mark any unacked packet sent RTO is acknowledged, RACK will mark any unacked packet sent
sufficiently prior to the RTO as lost, because at least one RTT has sufficiently prior to the RTO as lost, because at least one RTT has
elapsed since these packets were sent. elapsed since these packets were sent.
The following simple example compares how RACK and non-RACK loss The following simple example compares how RACK and non-RACK loss
detection interacts with congestion control: suppose a TCP sender has detection interacts with congestion control: suppose a TCP sender has
a congestion window (cwnd) of 20 packets on a SACK-enabled a congestion window (cwnd) of 20 packets on a SACK-enabled
connection. It sends 10 data packets and all of them are lost. connection. It sends 10 data packets and all of them are lost.
Without RACK, the sender would time out, reset cwnd to 1, and Without RACK, the sender would time out, reset cwnd to 1, and
retransmit first packet. It would take another four round trips (1 + retransmit the first packet. It would take four round trips (1 + 2 +
2 + 4 + 3 = 10) to retransmit all the 10 lost packets using slow 4 + 3 = 10) to retransmit all the 10 lost packets using slow start.
start. The recovery latency would be RTO + 4*RTT, with an ending The recovery latency would be RTO + 4*RTT, with an ending cwnd of 4
cwnd of 4 packets due to congestion window validation. packets due to congestion window validation.
With RACK, a sender would send the TLP after 2*RTT and get a DUPACK. With RACK, a sender would send the TLP after 2*RTT and get a DUPACK.
If the sender implements Proportional Rate Reduction [RFC6937] it If the sender implements Proportional Rate Reduction [RFC6937] it
would slow start to retransmit the remaining 9 lost packets since the would slow start to retransmit the remaining 9 lost packets since the
number of packets in flight (0) is lower than the slow start number of packets in flight (0) is lower than the slow start
threshold (10). The slow start would again take another four round threshold (10). The slow start would again take four round trips (1
trips (1 + 2 + 4 + 3 = 10). The recovery latency would be 2*RTT + + 2 + 4 + 3 = 10). The recovery latency would be 2*RTT + 4*RTT, with
4*RTT, with an ending cwnd set to the slow start threshold of 10 an ending cwnd set to the slow start threshold of 10 packets.
packets.
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 6.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 6.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 echo options). unique transmission or packet identifier (e.g. TCP echo options).
For example, the QUIC protocol implements RACK [QUIC-LR]. For example, the QUIC protocol implements RACK [QUIC-LR].
8. Experiments and Performance Evaluations 7. 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 3517 on Group 1 (control): RACK off, TLP off, RFC 3517 on
skipping to change at page 19, line 45 skipping to change at page 22, line 39
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 RFC3517 as a standalone recovery mechanism. replace RFC3517 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 8. 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 9. 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 10. 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, and Jana Dumazet, Randy Stewart, Van Jacobson, Ian Swett, Rick Jones, Jana
Iyengar contributed to the draft and the implementations in Linux, Iyengar, and Hiren Panchasara contributed to the draft and the
FreeBSD and QUIC. implementations in Linux, FreeBSD and QUIC.
12. References
12.1. Normative References 11. References
[RFC793] Postel, J., "Transmission Control Protocol", September 11.1. Normative References
1981.
[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.
[RFC6937] Mathis, M., Dukkipati, N., and Y. Cheng, "Proportional [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Rate Reduction for TCP", May 2013. Requirement Levels", RFC 2119, March 1997.
[RFC2883] Floyd, S., Mahdavi, J., Mathis, M., and M. Podolsky, "An
Extension to the Selective Acknowledgement (SACK) Option
for TCP", RFC 2883, July 2000.
[RFC4737] Morton, A., Ciavattone, L., Ramachandran, G., Shalunov, [RFC4737] Morton, A., Ciavattone, L., Ramachandran, G., Shalunov,
S., and J. Perser, "Packet Reordering Metrics", RFC 4737, S., and J. Perser, "Packet Reordering Metrics", RFC 4737,
November 2006. November 2006.
[RFC6675] Blanton, E., Allman, M., Wang, L., Jarvinen, I., Kojo, M., [RFC5681] Allman, M., Paxson, V., and E. Blanton, "TCP Congestion
and Y. Nishida, "A Conservative Loss Recovery Algorithm Control", RFC 5681, September 2009.
Based on Selective Acknowledgment (SACK) for TCP",
RFC 6675, August 2012.
[RFC6298] Paxson, V., Allman, M., Chu, J., and M. Sargent,
"Computing TCP's Retransmission Timer", RFC 6298, June
2011.
[RFC5827] Allman, M., Ayesta, U., Wang, L., Blanton, J., and P.
Hurtig, "Early Retransmit for TCP and Stream Control
Transmission Protocol (SCTP)", RFC 5827, April 2010.
[RFC5682] Sarolahti, P., Kojo, M., Yamamoto, K., and M. Hata, [RFC5682] Sarolahti, P., Kojo, M., Yamamoto, K., and M. Hata,
"Forward RTO-Recovery (F-RTO): An Algorithm for Detecting "Forward RTO-Recovery (F-RTO): An Algorithm for Detecting
Spurious Retransmission Timeouts with TCP", RFC 5682, Spurious Retransmission Timeouts with TCP", RFC 5682,
September 2009. September 2009.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate [RFC5827] Allman, M., Ayesta, U., Wang, L., Blanton, J., and P.
Requirement Levels", RFC 2119, March 1997. Hurtig, "Early Retransmit for TCP and Stream Control
Transmission Protocol (SCTP)", RFC 5827, April 2010.
[RFC5681] Allman, M., Paxson, V., and E. Blanton, "TCP Congestion [RFC6298] Paxson, V., Allman, M., Chu, J., and M. Sargent,
Control", RFC 5681, September 2009. "Computing TCP's Retransmission Timer", RFC 6298, June
2011.
[RFC2883] Floyd, S., Mahdavi, J., Mathis, M., and M. Podolsky, "An [RFC6675] Blanton, E., Allman, M., Wang, L., Jarvinen, I., Kojo, M.,
Extension to the Selective Acknowledgement (SACK) Option and Y. Nishida, "A Conservative Loss Recovery Algorithm
for TCP", RFC 2883, July 2000. Based on Selective Acknowledgment (SACK) for TCP",
RFC 6675, August 2012.
[RFC6937] Mathis, M., Dukkipati, N., and Y. Cheng, "Proportional
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.
12.2. Informative References [RFC793] Postel, J., "Transmission Control Protocol", September
1981.
11.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.
[TLP] Dukkipati, N., Cardwell, N., Cheng, Y., and M. Mathis, [POLICER16]
"Tail Loss Probe (TLP): An Algorithm for Fast Recovery of Flach, T., Papageorge, P., Terzis, A., Pedrosa, L., Cheng,
Tail Drops", draft-dukkipati-tcpm-tcp-loss-probe-01 (work Y., Karim, T., Katz-Bassett, E., and R. Govindan, "An
in progress), August 2013. Analysis of Traffic Policing in the Web", ACM SIGCOMM ,
2016.
[RFC7765] Hurtig, P., Brunstrom, A., Petlund, A., and M. Welzl, "TCP [QUIC-LR] Iyengar, J. and I. Swett, "QUIC Loss Recovery And
and SCTP RTO Restart", February 2016. Congestion Control", draft-tsvwg-quic-loss-recovery-01
(work in progress), June 2016.
[REORDER-DETECT] [REORDER-DETECT]
Zimmermann, A., Schulte, L., Wolff, C., and A. Hannemann, Zimmermann, A., Schulte, L., Wolff, C., and A. Hannemann,
"Detection and Quantification of Packet Reordering with "Detection and Quantification of Packet Reordering with
TCP", draft-zimmermann-tcpm-reordering-detection-02 (work TCP", draft-zimmermann-tcpm-reordering-detection-02 (work
in progress), November 2014. in progress), November 2014.
[QUIC-LR] Iyengar, J. and I. Swett, "QUIC Loss Recovery And [RFC7765] Hurtig, P., Brunstrom, A., Petlund, A., and M. Welzl, "TCP
Congestion Control", draft-tsvwg-quic-loss-recovery-01 and SCTP RTO Restart", February 2016.
(work in progress), June 2016.
[SCWA99] Savage, S., Cardwell, N., Wetherall, D., and T. Anderson,
"TCP Congestion Control With a Misbehaving Receiver", ACM
Computer Communication Review, 29(5) , 1999.
[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.
[SCWA99] Savage, S., Cardwell, N., Wetherall, D., and T. Anderson, [TLP] Dukkipati, N., Cardwell, N., Cheng, Y., and M. Mathis,
"TCP Congestion Control With a Misbehaving Receiver", ACM "Tail Loss Probe (TLP): An Algorithm for Fast Recovery of
Computer Communication Review, 29(5) , 1999. Tail Drops", draft-dukkipati-tcpm-tcp-loss-probe-01 (work
in progress), August 2013.
[POLICER16]
Flach, T., Papageorge, P., Terzis, A., Pedrosa, L., Cheng,
Y., Karim, T., Katz-Bassett, E., and R. Govindan, "An
Analysis of Traffic Policing in the Web", ACM SIGCOMM ,
2016.
Authors' Addresses Authors' Addresses
Yuchung Cheng Yuchung Cheng
Google, Inc Google, Inc
1600 Amphitheater Parkway 1600 Amphitheater Parkway
Mountain View, California 94043 Mountain View, California 94043
USA USA
Email: ycheng@google.com Email: ycheng@google.com
skipping to change at page 22, line 42 skipping to change at page 25, line 37
76 Ninth Avenue 76 Ninth Avenue
New York, NY 10011 New York, NY 10011
USA USA
Email: ncardwell@google.com Email: ncardwell@google.com
Nandita Dukkipati Nandita Dukkipati
Google, Inc Google, Inc
1600 Amphitheater Parkway 1600 Amphitheater Parkway
Mountain View, California 94043 Mountain View, California 94043
USA
Email: nanditad@google.com Email: nanditad@google.com
Priyaranjan Jha
Google, Inc
1600 Amphitheater Parkway
Mountain View, California 94043
Email: priyarjha@google.com
 End of changes. 95 change blocks. 
222 lines changed or deleted 363 lines changed or added

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