draft-ietf-tcpm-rack-01.txt   draft-ietf-tcpm-rack-02.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: May 4, 2017 Google, Inc Expires: September 14, 2017 Google, Inc
October 31, 2016 March 13, 2017
RACK: a time-based fast loss detection algorithm for TCP RACK: a time-based fast loss detection algorithm for TCP
draft-ietf-tcpm-rack-01 draft-ietf-tcpm-rack-02
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 37 skipping to change at page 1, line 37
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 http://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 May 4, 2017. This Internet-Draft will expire on September 14, 2017.
Copyright Notice Copyright Notice
Copyright (c) 2016 IETF Trust and the persons identified as the Copyright (c) 2017 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 (http://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
skipping to change at page 3, line 20 skipping to change at page 3, line 20
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][RFC3517][FACK]. But the key innovation in different from [RFC5681][RFC3517][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.,
dupthresh) is no longer reliable because of today's prevalent DupThresh) is no longer reliable because of today's prevalent
reordering patterns. A common type of reordering is that the last reordering patterns. A common type of reordering is that the last
"runt" packet of a window's worth of packet bursts gets delivered "runt" packet of a window's worth of packet bursts gets delivered
first, then the rest arrive shortly after in order. To handle this first, then the rest arrive shortly after in order. To handle this
effectively, a sender would need to constantly adjust the dupthresh effectively, a sender would need to constantly adjust the DupThresh
to the burst size; but this would risk increasing the frequency of to the burst size; but this would risk increasing the frequency of
RTOs on real losses. RTOs on real losses.
Today's prevalent lost retransmissions also cause problems with Today's prevalent lost retransmissions also cause problems with
packet-counting approaches [RFC5681][RFC3517][FACK], since those packet-counting approaches [RFC5681][RFC3517][FACK], since those
approaches depend on reasoning in sequence number space. approaches depend on reasoning in sequence number space.
Retransmissions break the direct correspondence between ordering in Retransmissions break the direct correspondence between ordering in
sequence space and ordering in time. So when retransmissions are sequence space and ordering in time. So when retransmissions are
lost, sequence-based approaches are often unable to infer and quickly lost, sequence-based approaches are often unable to infer and quickly
repair losses that can be deduced with time-based approaches. repair losses that can be deduced with time-based approaches.
Instead of counting packets, RACK uses the most recently delivered Instead of counting packets, RACK uses the most recently delivered
packet's transmission time to judge if some packets sent previous to packet's transmission time to judge if some packets sent previous to
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 recovery retransmitted packets, making it a great all-weather loss detection
mechanism. mechanism.
3. Requirements 3. 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.
skipping to change at page 4, line 24 skipping to change at page 4, line 24
transmission time with (at least) millisecond granularity. For transmission time with (at least) millisecond granularity. For
round-trip times lower than a millisecond (e.g., intra-datacenter round-trip times lower than a millisecond (e.g., intra-datacenter
communications) microsecond granularity would significantly help communications) microsecond granularity would significantly help
the detection latency but is not required. the detection latency but is not required.
3. For each packet sent, the sender MUST remember whether the packet 3. For each packet sent, the sender MUST remember whether the packet
has been retransmitted or not. has been retransmitted or not.
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. For the ease acknowledgment information on a per-connection basis ([RFC6675]
of explaining the algorithm, we use a pseudo-scoreboard that manages section 3). For the ease of explaining the algorithm, we use a
the data in sequence number ranges. But the specifics of the data pseudo-scoreboard that manages the data in sequence number ranges.
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.
4. Definitions of variables 4. Definitions of variables
A sender needs to store these new RACK variables: A sender 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 cummulatively acknowledged, RACK.packet is the one selectively or cumulatively acknowledged, RACK.packet is the one that
that was sent most recently (including retransmission). 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.
skipping to change at page 5, line 16 skipping to change at page 5, line 16
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.
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.RTT, RACK.reo_wnd, and RACK.min_RTT variables are RACK.xmit_ts, RACK.end_seq, RACK.RTT, RACK.reo_wnd, and RACK.min_RTT
to keep in TCP control block per connection. RACK.packet and variables are kept in the per-connection TCP control block.
RACK.ack_ts are used as local variables in the algorithm. RACK.packet and RACK.ack_ts are used as local variables in the
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.
skipping to change at page 5, line 43 skipping to change at page 5, line 44
Use the RTT measurements obtained in [RFC6298] or [RFC7323] to update Use the RTT measurements obtained in [RFC6298] or [RFC7323] to update
the estimated minimum RTT in RACK.min_RTT. The sender can track a the estimated minimum RTT in RACK.min_RTT. The sender can track a
simple global minimum of all RTT measurements from the connection, or simple global minimum of all RTT measurements from the connection, or
a windowed min-filtered value of recent RTT measurements. This a windowed min-filtered value of recent RTT measurements. This
document does not specify an exact approach. document does not specify an exact approach.
Step 2: Update RACK.reo_wnd. Step 2: Update RACK.reo_wnd.
To handle the prevalent small degree of reordering, RACK.reo_wnd To handle the prevalent small degree of reordering, RACK.reo_wnd
serves as an allowance for settling time before marking a packet serves as an allowance for settling time before marking a packet
lost. By default it is 1 millisecond. We RECOMMEND implementing the lost. By default it is 1 millisecond. [REORDER-DETECT][RFC4737] MAY
reordering detection in [REORDER-DETECT][RFC4737] to dynamically be implemented to dynamically adjust the reordering window upon
adjust the reordering window. When the sender detects packet detecting reordering. When the sender detects packet reordering
reordering RACK.reo_wnd MAY be changed to RACK.min_RTT/4. We discuss RACK.reo_wnd MAY be changed to RACK.min_RTT/4. We discuss more about
more about the reordering window in the next section. the reordering window in the next section.
Step 3: Advance RACK.xmit_ts and update RACK.RTT and RACK.end_seq 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 has been retransmitted Ignore the packet if any of its TCP sequences have been retransmitted
before and either of two condition is true: 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 this ACK causes a change to RACK.xmit_ts then record the RTT and
sequence implied by this ACK: sequence implied by this ACK:
RACK.RTT = Now() - RACK.xmit_ts RACK.RTT = Now() - RACK.xmit_ts
RACK.end_seq = Packet.end_seq RACK.end_seq = Packet.end_seq
Exit here and omit the following steps if RACK.xmit_ts has not Exit here and omit the following steps if RACK.xmit_ts has not
changed. changed.
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 fully SACKed, if RACK.xmit_ts is
after Packet.xmit_ts + RACK.reo_wnd, then mark the packet (or its after 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, the packet was likely lost. passed, then the packet was likely lost.
If a 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
given packet lost. Using the basic algorithm above, the sender would unacked packet lost. Using the basic algorithm above, the sender
wait for the next ACK to further advance RACK.xmit_ts; but this risks would wait for the next ACK to further advance RACK.xmit_ts; but this
a timeout (RTO) if no more ACKs come back (e.g, due to losses or risks a timeout (RTO) if no more ACKs come back (e.g, due to losses
application limit). For timely loss detection, the sender MAY or application limit). For timely loss detection, the sender MAY
install a "reordering settling" timer set to fire at the earliest install a "reordering settling" timer set to fire at the earliest
moment at which it is safe to conclude that some packet is lost. The moment at which it is safe to conclude that some packet is lost. The
earliest moment is the time it takes to expire the reordering window earliest moment is the time it takes to expire the reordering window
of the earliest unacked packet in flight. of the earliest unacked packet in flight.
This timer expiration value can be derived as follows. As a starting This timer expiration value can be derived as follows. As a starting
point, we consider that the reordering window has passed if the point, we consider that the reordering window has passed if the
RACK.packet was sent sufficiently after the packet in question, or a RACK.packet was sent sufficiently after the packet in question, or a
sufficient time has elapsed since the RACK.packet was S/ACKed, or sufficient time has elapsed since the RACK.packet was S/ACKed, or
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 when 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 now > Packet.xmit_ts + RACK.RTT + RACK.reo_wnd
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.
skipping to change at page 8, line 34 skipping to change at page 8, line 34
min_timeout = timeout min_timeout = timeout
If min_timeout != 0 If min_timeout != 0
Arm a timer to call RACK_detect_loss() after min_timeout Arm a timer to call RACK_detect_loss() after min_timeout
6. Tail Loss Probe: fast recovery on tail losses 6. 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 only be recoverable by RTOs. 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. In either case the goal is to elicit more feedback a retransmission of previously sent data just below SND.NXT. In
from the receiver, in the form of an ACK (potentially with SACK either case the goal is to elicit more feedback from the receiver, in
blocks), to allow RACK to trigger fast recovery instead of an RTO. the form of an ACK (potentially with SACK blocks), to allow RACK to
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 [RFC6298 acknowledged after a conservative period of time has elapsed
[1]]. Common causes of RTOs include: [RFC6298]. Common causes of RTOs include:
1. Tail losses at the end of an application transaction. 1. Tail losses at the end of an application transaction.
2. Lost retransmits, which can halt fast recovery if the ACK stream 2. Lost retransmits, which can halt fast recovery based on [RFC6675]
completely dries up. For example, consider a window of three if the ACK stream completely dries up. For example, consider a
data packets (P1, P2, P3) that are sent; P1 and P2 are dropped. window of three data packets (P1, P2, P3) that are sent; P1 and
On receipt of a SACK for P3, RACK marks P1 and P2 as lost and P2 are dropped. On receipt of a SACK for P3, RACK marks P1 and
retransmits them as R1 and R2. Suppose R1 and R2 are lost as P2 as lost and retransmits them as R1 and R2. Suppose R1 and R2
well, so there are no more returning ACKs to detect R1 and R2 as are lost as well, so there are no more returning ACKs to detect
lost. Recovery stalls. R1 and R2 as lost. Recovery stalls.
3. Tail losses of ACKs. 3. Tail losses of ACKs.
4. An unexpectedly long round-trip time (RTT). This can cause ACKs 4. 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 [2]] 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 (though 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 6.1. 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 RTTs,
after the transmission of the 10th segment. (2) Sender receives after the transmission of the 10th segment. (2) Sender receives
acknowledgements (ACKs) for segments 1-5; segments 6-10 are lost and acknowledgements (ACKs) for segments 1-5; segments 6-10 are lost and
skipping to change at page 9, line 38 skipping to change at page 9, line 38
retransmits segment 10. (4) After an RTT, a SACK for packet 10 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. arrives. The ACK also carries SACK holes for segments 6, 7, 8 and 9.
This triggers RACK-based loss recovery. (5) The connection enters This triggers RACK-based loss recovery. (5) The connection enters
fast recovery and retransmits the remaining lost segments. fast recovery and retransmits the remaining lost segments.
6.2. Tail Loss Probe Algorithm Details 6.2. 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 [3]]. [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 [4]] for TCP. PTO: Probe timeout 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].
[5]].
Open state: the sender has so far received in-sequence ACKs with no Open state: the sender has so far received in-sequence ACKs with no
SACK blocks, and no other indications (such as retransmission SACK blocks, and no other indications (such as retransmission
timeout) that a loss may have occurred. timeout) that a loss may have occurred.
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 6.2.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 schedule a PTO after transmitting new data or
receiving an ACK if the following conditions are met: receiving an ACK if the following conditions are met:
(a) The connection is in Open state. (b) The connection is either (a) The connection is in Open state
cwnd-limited (the data in flight matches or exceeds the cwnd) or (b) The connection is either cwnd-limited (the data in flight matches
application-limited (there is no unsent data that the receiver window or exceeds the cwnd) or application-limited (there is no unsent
allows to be sent). (c) SACK is enabled for the connection. data that the receiver window allows to be sent)
(c) SACK is enabled for the connection
(d) The most recently transmitted data was not itself a TLP probe (d) 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). (i.e. a sender MUST NOT send consecutive TLP probes)
(e) TLPRtxOut is false, indicating there is no TLP retransmission
episode in progress (see below).
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: If an SRTT estimate is available:
PTO = 2 * SRTT PTO = 2 * SRTT
Else: Else:
PTO = initial RTO of 1 sec PTO = initial RTO of 1 sec
If FlightSize == 1: If FlightSize = 1:
PTO = max(PTO, 1.5 * SRTT + WCDelAckT) PTO = max(PTO, 1.5 * SRTT + WCDelAckT)
PTO = max(10ms, PTO) PTO = max(10ms, PTO)
PTO = min(RTO, PTO) 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. Similarly, current end-system processing latencies
and timer granularities can easily push an ACK beyond 10ms, so and timer granularities can easily push an ACK beyond 10ms, so
senders SHOULD use a minimum PTO value of 10ms. If RTO is smaller senders SHOULD use a minimum PTO value of 10ms. If RTO is smaller
skipping to change at page 11, line 17 skipping to change at page 11, line 22
available. available.
6.2.2. Phase 2: Sending a loss probe 6.2.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:
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
The cwnd remains unchanged
Record Packet.xmit_ts
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 6.2.3. Phase 3: ACK processing
On each incoming ACK, the sender should ancel any existing loss probe On each incoming ACK, the sender should cancel any existing loss
timer. The timer will be re-scheduled if appropriate. probe timer. The sender should then reschedule the loss probe timer
if the conditions in Step 1 of Phase 1 allow.
6.3. TLP recovery detection 6.3. 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 loss detection examines ACKs to detect might repair the loss. TLP recovery detection examines ACKs to
when the probe might have repaired a loss, and thus allows congestion detect when the probe might have repaired a loss, and thus allows
control to properly reduce the congestion window (cwnd) [RFC5681 congestion control to properly reduce the congestion window (cwnd)
[6]]. [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
the sender receives an ACK with a SEG.ACK above the SND.NXT at the the sender receives an ACK with a SEG.ACK above the SND.NXT at the
time the episode started. During the TLP retransmission episode the time the episode started. During the TLP retransmission episode the
sender checks for a duplicate ACK or D-SACK indicating that both the sender checks for a duplicate ACK or D-SACK indicating that both the
original segment and TLP retransmission arrived at the receiver, original segment and TLP retransmission arrived at the receiver,
meaning there was no loss that needed repairing. If the TLP sender meaning there was no loss that needed repairing. If the TLP sender
does not receive such an indication before the end of the TLP does not receive such an indication before the end of the TLP
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 [7]] support duplicate selective acknowledgments (D-SACKs) [RFC2883] the
the TLP algorithm for detecting such lost segments relies only on TLP algorithm for detecting such lost segments relies only on basic
basicRFC 2018 [8] SACK support [RFC2018 [9]]. SACK support [RFC2018].
Definitions of variables Definitions of variables
TLPRtxOut: 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 6.3.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 should reset TLPRtxOut to false enters fast recovery, it executes the following:
TLPRxtOut = false
6.3.2. Recording loss probe states 6.3.2. Recording loss probe states
Senders must only send a TLP loss probe retransmission if TLPRtxOut 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
data, since the retransmission timeout and fast recovery algorithms data, since the retransmission timeout and fast recovery algorithms
are sufficient to detect losses of such probe segments. are sufficient to detect losses of such probe segments.
Upon sending a TLP probe that is a retransmission, the sender set Upon sending a TLP probe that is a retransmission, the sender sets
TLPRtxOut to true and TLPHighRxt to SND.NXT TLPRxtOut to true and TLPHighRxt to SND.NXT.
Detecting recoveries done 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 (i) or (ii) are
true: true:
(i) This is a duplicate acknowledgment (as defined in [RFC5681 [10]], (i) This is a duplicate acknowledgment (as defined in [RFC5681],
section 2), and all of the following conditions are met: section 2), and all of the following conditions are met:
(a) TLPRtxOut is true (a) TLPRxtOut is true
(b) SEG.ACK == TLPHighRxt (b) SEG.ACK == TLPHighRxt
(c) SEG.ACK == SND.UNA (c) SEG.ACK == SND.UNA
(d) the segment contains no SACK blocks for sequence ranges above (d) the segment contains no SACK blocks for sequence ranges above
TLPHighRxt TLPHighRxt
(e) the segment contains no data (e) the segment contains no data
(f) the segment is not a window update (f) the segment is not a window update
(ii) This is an ACK acknowledging a sequence number at or above (ii) This is an ACK acknowledging a sequence number at or above
skipping to change at page 13, line 17 skipping to change at page 13, line 25
TLPHighRxt TLPHighRxt
(e) the segment contains no data (e) the segment contains no data
(f) the segment is not a window update (f) the segment is not a window update
(ii) This is an ACK acknowledging a sequence number at or above (ii) 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) TLPRtxOut is true (a) TLPRxtOut is true
(b) SEG.ACK >= TLPHighRxt and (b) SEG.ACK >= TLPHighRxt and
(c) the ACK contains a D-SACK block (c) the ACK contains a D-SACK block
If either conditions (i) or (ii) are met, then the sender estimates If either conditions (i) or (ii) are met, then the sender estimates
that the receiver received both the original data segment and the TLP that the receiver received both the original data segment and the TLP
probe retransmission, and so the sender considers the TLP episode to probe retransmission, and so the sender considers the TLP episode to
be done, and records that fact by setting TLPRtxOut to false. be done, and records that fact by setting TLPRxtOut to false.
Step 2: Mark the end of a TLP retransmission episode and detect Step 2: Mark the end of a TLP episode and detect losses
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
TLPRtxOut 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 the response to any other a congestion control response equivalent to fast recovery.
loss.
More precisely, on each ACK, after executing step (5a) the sender More precisely, on each ACK the sender executes the following:
SHOULD reset the TLPRtxOut to false, and invoke the congestion
control about the loss event that TLP has successfully repaired. If TLPRxtOut and SEG.ACK >= TLPHighRxt:
TLPRxtOut = false
EnterRecovery()
ExitRecovery()
7. RACK and TLP discussions 7. RACK and TLP discussions
7.1. Advantages 7.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 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
trigger the retransmission of P1 as R1. When R1 is cumulatively trigger the retransmission of P1 as R1. When R1 is cumulatively
acknowledged, RACK will mark P3 as lost and the sender will acknowledged, RACK will mark P3 as lost and the sender will
retransmit P3 as R3. This example illustrates how RACK is able to retransmit P3 as R3. This example illustrates how RACK is able to
repair certain drops at the tail of a transaction without any timer. repair certain drops at the tail of a transaction without any timer.
Notice that neither the conventional duplicate ACK threshold Notice that neither the conventional duplicate ACK threshold
[RFC5681], nor [RFC6675], nor the Forward Acknowledgment [FACK] [RFC5681], nor [RFC6675], nor the Forward Acknowledgment [FACK]
algorithm can detect such losses, because of the required packet or algorithm can detect such losses, because of the required packet or
sequence count. sequence count.
Example: lost retransmit. Consider a window of three data packets Example: LOST RETRANSMIT. Consider a window of three data packets
(P1, P2, P3) that are sent; P1 and P2 are dropped. Suppose the (P1, P2, P3) that are sent; P1 and P2 are dropped. 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. When P3 by default) after the transmission of the previous packet. When P3
is SACKed, RACK will mark P1 and P2 lost and they will be is SACKed, RACK will mark P1 and P2 lost and they will be
retransmitted as R1 and R2. Suppose R1 is lost again (as a tail retransmitted as R1 and R2. Suppose R1 is lost again but R2 is
drop) but R2 is SACKed; RACK will mark R1 lost for retransmission SACKed; RACK will mark R1 lost for retransmission again. Again,
again. Again, neither the conventional three duplicate ACK threshold neither the conventional three duplicate ACK threshold approach, nor
approach, nor [RFC6675], nor the Forward Acknowledgment [FACK] [RFC6675], nor the Forward Acknowledgment [FACK] algorithm can detect
algorithm can detect such losses. And such a lost retransmission is such losses. And such a lost retransmission is very common when TCP
very common when TCP is being rate-limited, particularly by token is being rate-limited, particularly by token bucket policers with
bucket policers with large bucket depth and low rate limit. large bucket depth and low rate limit. Retransmissions are often
Retransmissions are often lost repeatedly because standard congestion lost repeatedly because standard congestion control requires multiple
control requires multiple round trips to reduce the rate below the round trips to reduce the rate below the policed rate.
policed rate.
Example: (small) degree of reordering. Consider a common reordering Example: SMALL DEGREE OF REORDERING. Consider a common reordering
event: a window of packets are sent as (P1, P2, P3). P1 and P2 carry event: a window of packets are sent as (P1, P2, P3). P1 and P2 carry
a full payload of MSS octets, but P3 has only a 1-octet payload due a full payload of MSS octets, but P3 has only a 1-octet payload.
to application-limited behavior. Suppose the sender has detected
reordering previously (e.g., by implementing the algorithm in Suppose the sender has detected reordering previously (e.g., by
[REORDER-DETECT]) and thus RACK.reo_wnd is min_RTT/4. Now P3 is implementing the algorithm in [REORDER-DETECT]) and thus RACK.reo_wnd
reordered and delivered first, before P1 and P2. As long as P1 and is min_RTT/4. Now P3 is reordered and delivered first, before P1 and
P2 are delivered within min_RTT/4, RACK will not consider P1 and P2 P2. As long as P1 and P2 are delivered within min_RTT/4, RACK will
lost. But if P1 and P2 are delivered outside the reordering window, not consider P1 and P2 lost. But if P1 and P2 are delivered outside
then RACK will still falsely mark P1 and P2 lost. We discuss how to the reordering window, then RACK will still falsely mark P1 and P2
reduce the false positives in the end of this section. lost. We discuss how to reduce false positives in the end of this
section.
The examples above show that RACK is particularly useful when the The examples above show that RACK is particularly useful when the
sender is limited by the application, which is common for sender is limited by the application, which is common for
interactive, request/response traffic. Similarly, RACK still works interactive, request/response traffic. Similarly, RACK still works
when the sender is limited by the receive window, which is common for when the sender is limited by the receive window, which is common for
applications that use the receive window to throttle the sender. applications that use the receive window to throttle the sender.
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
skipping to change at page 15, line 21 skipping to change at page 15, line 36
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 7.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) to track internal state (commonly either 4 or 8 octets per packet or TSO blob)
transmission times. In contrast, the conventional approach requires to track transmission times. In contrast, the conventional [RFC6675]
one variable to track number of duplicate ACK threshold. loss detection approach does not require any per-packet state beyond
the SACK scoreboard.
7.3. Adjusting the reordering window 7.3. Adjusting the reordering window
RACK uses a reordering window of min_rtt / 4. It uses the minimum When the sender detects packet reordering, RACK uses a reordering
RTT to accommodate reordering introduced by packets traversing window of min_rtt / 4. It uses the minimum RTT to accommodate
slightly different paths (e.g., router-based parallelism schemes) or reordering introduced by packets traversing slightly different paths
out-of-order deliveries in the lower link layer (e.g., wireless links (e.g., router-based parallelism schemes) or out-of-order deliveries
using link-layer retransmission). Alternatively, RACK can use the in the lower link layer (e.g., wireless links using link-layer
smoothed RTT used in RTT estimation [RFC6298]. However, smoothed RTT retransmission). RACK uses a quarter of minimum RTT because Linux
can be significantly inflated by orders of magnitude due to TCP used the same factor in its implementation to delay Early
congestion and buffer-bloat, which would result in an overly Retransmit [RFC5827] to reduce spurious loss detections in the
conservative reordering window and slow loss detection. Furthermore, presence of reordering, and experience shows that this seems to work
RACK uses a quarter of minimum RTT because Linux TCP uses the same reasonably well. We have evaluated using the smoothed RTT (SRTT from
factor in its implementation to delay Early Retransmit [RFC5827] to
reduce spurious loss detections in the presence of reordering, and
experience shows that this seems to work reasonably well.
One potential improvement is to further adapt the reordering window [RFC6298] RTT estimation) or the most recently measured RTT
by measuring the degree of reordering in time, instead of packet (RACK.RTT) using an experiment similar to that in the Performance
distances. But that requires storing the delivery timestamp of each Evaluation section. They do not make any significant difference in
packet. Some scoreboard implementations currently merge SACKed terms of total recovery latency.
packets together to support TSO (TCP Segmentation Offload) for faster
scoreboard indexing. Supporting per-packet delivery timestamps is One potential improvement would be to further adapt the reordering
difficult in such implementations. However, we acknowledge that the window by measuring the degree of reordering in time, instead of
current metric can be improved by further research. 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 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] and nonstandard ones [RFC5681][RFC6675][RFC5827][RFC4653], as well as some nonstandard
[FACK][THIN-STREAM]. While RACK can be a supplemental loss detection ones [FACK][THIN-STREAM]. While RACK can be a supplemental loss
on top of these algorithms, this is not necessary, because the RACK detection mechanism on top of these algorithms, this is not
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
a different approach, by using only one ACK event and a reordering a different approach, by using only one ACK event and a reordering
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
skipping to change at page 16, line 34 skipping to change at page 16, line 49
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, we RECOMMEND
TCP implementations use both RACK and the algorithm specified in TCP implementations use both RACK and the algorithm specified in
Section 3.2 in [RFC5681] for compatibility. Section 3.2 in [RFC5681] for 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 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 solicit seither 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 can be numbers, and uses transmission time instead. Thus TLP could be
modified to retransmit the first unacknowledged packet, which can modified to retransmit the first unacknowledged packet, which could
improve application latency. improve application latency.
7.5. Interaction with congestion control 7.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 (e.g.
using [RFC6937]). using [RFC6937]).
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]. The distinction between retransmission timeout (RTO) in [RFC5681]. RACK applies equally to
fast recovery or RTO recovery is not necessary because RACK is purely fast recovery and RTO recovery because RACK is purely based on the
based on the transmission time order of packets. When a packet transmission time order of packets. When a packet retransmitted by
retransmitted by RTO is acknowledged, RACK will mark any unacked RTO is acknowledged, RACK will mark any unacked packet sent
packet sent sufficiently prior to the RTO as lost, because at least sufficiently prior to the RTO as lost, because at least one RTT has
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
detection interacts with congestion control: suppose a TCP sender has
a congestion window (cwnd) of 20 packets on a SACK-enabled
connection. It sends 10 data packets and all of them are lost.
Without RACK, the sender would time out, reset cwnd to 1, and
retransmit first packet. It would take another four round trips (1 +
2 + 4 + 3 = 10) to retransmit all the 10 lost packets using slow
start. The recovery latency would be RTO + 4*RTT, with an ending
cwnd of 4 packets due to congestion window validation.
With RACK, a sender would send the TLP after 2*RTT and get a DUPACK.
If the sender implements Proportional Rate Reduction [RFC6937] it
would slow start to retransmit the remaining 9 lost packets since the
number of packets in flight (0) is lower than the slow start
threshold (10). The slow start would again take another four round
trips (1 + 2 + 4 + 3 = 10). The recovery latency would be 2*RTT +
4*RTT, with an ending cwnd set to the slow start threshold of 10
packets.
In both cases, the sender after the recovery would be in congestion
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
second in RFC6298) or if the RTT is large. The former case is common
in local area networks, data-center networks, or content distribution
networks with deep deployments. The latter case is more common in
developing regions with highly congested and/or high-latency
networks. The ending congestion window after recovery also impacts
subsequent data transfer.
7.6. TLP recovery detection with delayed ACKs 7.6. TLP recovery detection with delayed ACKs
Delayed ACKs complicate the detection of reparies 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 loss detection in the case of a delayed ACK the sender's TLP recovery detection
algorithm (in step (4)(a)(ii), above) can use the D-SACK information algorithm (see above) can use the D-SACK information to infer that
to infer that the original and TLP retransmission both arrived at the the original and TLP retransmission both arrived at the receiver.
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 is prudent. then reducing cwnd can be prudent.
However, in practice sending a single byte of data turned out to be
problematic to implement and more fragile than necessary. Instead we
use a full segment to probe but have to add complexity to compensate
for the probe itself masking losses.
7.7. RACK for other transport protocols 7.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 skip step 3 and simplify if the protocol can support unique can be simplified by skipping step 3 if the protocol can support a
transmission or packet identifier (e.g. TCP echo options). For unique transmission or packet identifier (e.g. TCP echo options).
example, the QUIC protocol implements RACK [QUIC-LR] . For example, the QUIC protocol implements RACK [QUIC-LR].
8. Experiments and Performance Evaluations 8. Experiments and Performance Evaluations
RACK and TLP have been deployed at Google including the connections RACK and TLP have been deployed at Google, for both connections to
to the users in the Internet and internally. We conducted an users in the Internet and internally. We conducted a performance
performance evaluation experiment on RACK and TLP on a small set of evaluation experiment for RACK and TLP on a small set of Google Web
Google Web servers in western-europe that serve most European and servers in Western Europe that serve mostly European and some African
some African countries. The length of the experiments was five days countries. The experiment lasted three days in March 2017. The
(one weekend plus 3 weekdays) in October 2016, where the servers were servers were divided evenly into four groups of roughly 5.3 million
divided evenly into three groups. flows each:
Group 1 (control): RACK off, TLP off Group 1 (control): RACK off, TLP off, RFC 3517 on
Group 2: RACK on, TLP off, RFC 3517 on
Group 2: RACK on, TLP off Group 3: RACK on, TLP on, RFC 3517 on
Group 3: RACK on, TLP on Group 4: RACK on, TLP on, RFC 3517 off
All groups use Linux using the Cubic congestion control with an All groups used Linux with CUBIC congestion control, an initial
initial window of 10 packets and fq/pacing qdisc. In term of congestion window of 10 packets, and the fq/pacing qdisc. In terms
specific recovery features, all of them enable RFC3517 (Conservative of specific recovery features, all groups enabled RFC5682 (F-RTO) but
SACK-based recovery) and RFC5682 (F-RTO) but disable FACK because it disabled FACK because it is not an IETF RFC. FACK was excluded
is not an IETF RFC. The goal of this setup is to compare RACK and because the goal of this setup is to compare RACK and TLP to RFC-
TLP to RFC-based loss recoveries instead of Linux-based recoveries. based loss recoveries. Since TLP depends on either FACK or RACK, we
could not run another group that enables TLP only (with both RACK and
FACK disabled). Group 4 is to test whether RACK plus TLP can
completely replace the DupThresh-based [RFC3517].
The servers sit behind a load-balancer that distributes the The servers sit behind a load balancer that distributes the
connections evenly across the three groups. connections evenly across the four groups.
Each group handles similar amount of connections and send and receive Each group handles a similar number of connections and sends and
similar amount of data. We compare total amount of time spent in receives similar amounts of data. We compare total time spent in
loss recovery across groups. The recovery time is from when the loss recovery across groups. The recovery time is measured from when
recovery and retransmit starts, till the remote has acknowledge the recovery and retransmission starts, until the remote host has
beyond the highest sequence at the time the recovery starts. acknowledged the highest sequence (SND.NXT) at the time the recovery
Therefore the recovery includes both fast recoveries and timeout started. Therefore the recovery includes both fast recoveries and
recoveries. Our data shows that Group 2 recovery latency is only 2% timeout recoveries.
lower than the Group 1 recovery latency. But Group 3 recovery
latency is 25% lower than Group 1 by reducing 40% of the RTOs Our data shows that Group 2 recovery latency is only 0.3% lower than
triggered recoveries! Therefore it is very important to implement the Group 1 recovery latency. But Group 3 recovery latency is 25%
both TLP and RACK for performance. lower than Group 1 due to a 40% reduction in RTO-triggered
recoveries! Therefore it is important to implement both TLP and RACK
for performance. Group 4's total recovery latency is 0.02% lower
than Group 3's, indicating that RACK plus TLP can successfully
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 connectivities in western-europe is fairly of network coverage. The connectivity in Western Europe is fairly
good therefore loss recovery is not a performance bottleneck. We good, therefore loss recovery is not a major performance bottleneck.
plan to expand our experiments in regions with worse connectivities, We plan to expand our experiments to regions with worse connectivity,
in particular on networks with strong traffic policing. We also plan in particular on networks with strong traffic policing.
to add the fourth group to disable RFC3517 to use solely RACK and TLP
only to see if RACK plus TLP can completely replace all other SACK
based recoveries.
9. Security Considerations 9. 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
skipping to change at page 19, line 29 skipping to change at page 20, line 21
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 11. 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, and Jana Iyengar Dumazet, Randy Stewart, Van Jacobson, Ian Swett, Rick Jones, and Jana
contributed to the algorithm and the implementations in Linux, Iyengar contributed to the draft and the implementations in Linux,
FreeBSD and QUIC. FreeBSD and QUIC.
12. References 12. References
12.1. Normative References 12.1. Normative References
[RFC793] Postel, J., "Transmission Control Protocol", September [RFC793] Postel, J., "Transmission Control Protocol", September
1981. 1981.
[RFC2018] Mathis, M. and J. Mahdavi, "TCP Selective Acknowledgment [RFC2018] Mathis, M. and J. Mahdavi, "TCP Selective Acknowledgment
skipping to change at page 21, line 30 skipping to change at page 22, line 20
[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.
[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 ,
2016. 2016.
12.3. URIs
[1] https://tools.ietf.org/html/rfc6298
[2] https://tools.ietf.org/html/rfc5682
[3] https://tools.ietf.org/html/rfc5681
[4] https://tools.ietf.org/html/rfc6298
[5] https://tools.ietf.org/html/rfc6298
[6] https://tools.ietf.org/html/rfc5681
[7] https://tools.ietf.org/html/rfc2883
[8] https://tools.ietf.org/html/rfc2018
[9] https://tools.ietf.org/html/rfc2018
[10] https://tools.ietf.org/html/rfc5681
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
 End of changes. 82 change blocks. 
237 lines changed or deleted 248 lines changed or added

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