Change QUIC's RTO implementation. Protected by FLAGS_quic_use_new_rto.

net/quic/quic_sent_packet_manager.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_sent_packet_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 14 matching lines @@
 // values less than or equal to 0.
 int32 FLAGS_quic_recent_min_rtt_window_s = 60;
 
 namespace {
 static const int64 kDefaultRetransmissionTimeMs = 500;
 // TCP RFC calls for 1 second RTO however Linux differs from this default and
 // define the minimum RTO to 200ms, we will use the same until we have data to
 // support a higher or lower value.
 static const int64 kMinRetransmissionTimeMs = 200;
 static const int64 kMaxRetransmissionTimeMs = 60000;
+// Maximum number of exponential backoffs used for RTO timeouts.
 static const size_t kMaxRetransmissions = 10;
+// Maximum number of packets retransmitted upon an RTO.
+static const size_t kMaxRetransmissionsOnTimeout = 2;
 
 // Ensure the handshake timer isnt't faster than 10ms.
 // This limits the tenth retransmitted packet to 10s after the initial CHLO.
 static const int64 kMinHandshakeTimeoutMs = 10;
 
 // Sends up to two tail loss probes before firing an RTO,
 // per draft RFC draft-dukkipati-tcpm-tcp-loss-probe.
 static const size_t kDefaultMaxTailLossProbes = 2;
 static const int64 kMinTailLossProbeTimeoutMs = 10;
 
@@ skipping 179 matching lines @@
 
   // If we have received a truncated ack, then we need to clear out some
   // previous transmissions to allow the peer to actually ACK new packets.
   if (ack_frame.is_truncated) {
     unacked_packets_.ClearAllPreviousRetransmissions();
   }
 
   // Anytime we are making forward progress and have a new RTT estimate, reset
   // the backoff counters.
   if (rtt_updated) {
+    // If the ack acknowledges data sent prior to the RTO,the RTO was spurious.
+    if (FLAGS_quic_use_new_rto && consecutive_rto_count_ > 0 &&
+        ack_frame.largest_observed >= first_rto_transmission_) {
+      send_algorithm_->OnRetransmissionTimeout(true);
+    }
     // Reset all retransmit counters any time a new packet is acked.
     consecutive_rto_count_ = 0;
     consecutive_tlp_count_ = 0;
     consecutive_crypto_retransmission_count_ = 0;
   }
 
   if (debug_delegate_ != nullptr) {
     debug_delegate_->OnIncomingAck(ack_frame, ack_receive_time,
                                    unacked_packets_.largest_observed(),
                                    rtt_updated, GetLeastUnacked());
@@ skipping 113 matching lines @@
     }
   }
 }
 
 void QuicSentPacketManager::MarkForRetransmission(
     QuicPacketSequenceNumber sequence_number,
     TransmissionType transmission_type) {
   const TransmissionInfo& transmission_info =
       unacked_packets_.GetTransmissionInfo(sequence_number);
   LOG_IF(DFATAL, transmission_info.retransmittable_frames == nullptr);
-  if (transmission_type != TLP_RETRANSMISSION) {
+  // Both TLP and the new RTO leave the packets in flight and let the loss
+  // detection decide if packets are lost.
+  if (transmission_type != TLP_RETRANSMISSION &&
+      (!FLAGS_quic_use_new_rto || transmission_type != RTO_RETRANSMISSION)) {
     unacked_packets_.RemoveFromInFlight(sequence_number);
   }
   // TODO(ianswett): Currently the RTO can fire while there are pending NACK
   // retransmissions for the same data, which is not ideal.
   if (ContainsKey(pending_retransmissions_, sequence_number)) {
     return;
   }
 
   pending_retransmissions_[sequence_number] = transmission_type;
 }
 
 void QuicSentPacketManager::RecordSpuriousRetransmissions(
     const SequenceNumberList& all_transmissions,
     QuicPacketSequenceNumber acked_sequence_number) {
-  if (acked_sequence_number < first_rto_transmission_) {
+  if (!FLAGS_quic_use_new_rto &&
+      acked_sequence_number < first_rto_transmission_) {
     // Cancel all pending RTO transmissions and restore their in flight status.
     // Replace SRTT with latest_rtt and increase the variance to prevent
     // a spurious RTO from happening again.
     rtt_stats_.ExpireSmoothedMetrics();
     for (PendingRetransmissionMap::const_iterator it =
              pending_retransmissions_.begin();
          it != pending_retransmissions_.end(); ++it) {
       DCHECK_EQ(it->second, RTO_RETRANSMISSION);
       unacked_packets_.RestoreInFlight(it->first);
     }
@@ skipping 222 matching lines @@
       // If no tail loss probe can be sent, because there are no retransmittable
       // packets, execute a conventional RTO to abandon old packets.
       ++stats_->tlp_count;
       ++consecutive_tlp_count_;
       pending_timer_transmission_count_ = 1;
       // TLPs prefer sending new data instead of retransmitting data, so
       // give the connection a chance to write before completing the TLP.
       return;
     case RTO_MODE:
       ++stats_->rto_count;
-      RetransmitAllPackets();
+      if (FLAGS_quic_use_new_rto) {
+        RetransmitRtoPackets();
+      } else {
+        RetransmitAllPackets();
+      }
       return;
   }
 }
 
 void QuicSentPacketManager::RetransmitCryptoPackets() {
   DCHECK_EQ(HANDSHAKE_MODE, GetRetransmissionMode());
   ++consecutive_crypto_retransmission_count_;
   bool packet_retransmitted = false;
   QuicPacketSequenceNumber sequence_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
@@ skipping 25 matching lines @@
       DCHECK_NE(IS_HANDSHAKE, it->retransmittable_frames->HasCryptoHandshake());
     }
     MarkForRetransmission(sequence_number, TLP_RETRANSMISSION);
     return true;
   }
   DLOG(FATAL)
     << "No retransmittable packets, so RetransmitOldestPacket failed.";
   return false;
 }
 
+void QuicSentPacketManager::RetransmitRtoPackets() {
+  LOG_IF(DFATAL, pending_timer_transmission_count_ > 0)
+      << "Retransmissions already queued:" << pending_timer_transmission_count_;
+  // Mark two packets for retransmission.
+  QuicPacketSequenceNumber sequence_number = unacked_packets_.GetLeastUnacked();
+  for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
+       it != unacked_packets_.end(); ++it, ++sequence_number) {
+    if (it->retransmittable_frames != nullptr &&
+        pending_timer_transmission_count_ < kMaxRetransmissionsOnTimeout) {
+      MarkForRetransmission(sequence_number, RTO_RETRANSMISSION);
+      ++pending_timer_transmission_count_;
+    }
+    // Abandon non-retransmittable data that's in flight to ensure it doesn't
+    // fill up the congestion window.
+    if (it->retransmittable_frames == nullptr && it->in_flight &&
+        it->all_transmissions == nullptr) {
+      unacked_packets_.RemoveFromInFlight(sequence_number);
+    }
+  }
+  if (pending_timer_transmission_count_ > 0) {
+    if (consecutive_rto_count_ == 0) {
+      first_rto_transmission_ = unacked_packets_.largest_sent_packet() + 1;
+    }
+    ++consecutive_rto_count_;
+  }
+}
+
 void QuicSentPacketManager::RetransmitAllPackets() {
   DVLOG(1) << "RetransmitAllPackets() called with "
            << unacked_packets_.GetNumUnackedPacketsDebugOnly()
            << " unacked packets.";
   // Request retransmission of all retransmittable packets when the RTO
   // fires, and let the congestion manager decide how many to send
   // immediately and the remaining packets will be queued.
   // Abandon any non-retransmittable packets that are sufficiently old.
   bool packets_retransmitted = false;
   QuicPacketSequenceNumber sequence_number = unacked_packets_.GetLeastUnacked();
@@ skipping 277 matching lines @@
   // Set up a pacing sender with a 1 millisecond alarm granularity, the same as
   // the default granularity of the Linux kernel's FQ qdisc.
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMilliseconds(1),
                        kInitialUnpacedBurst));
 }
 
 }  // namespace net