Repair the CWND reduction caused by spurious RTO's in QUIC's congestion

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 49 matching lines @@
                                              LossDetectionType loss_type)
     : unacked_packets_(),
       is_server_(is_server),
       clock_(clock),
       stats_(stats),
       debug_delegate_(NULL),
       send_algorithm_(
           SendAlgorithmInterface::Create(clock, &rtt_stats_, type, stats)),
       loss_algorithm_(LossDetectionInterface::Create(loss_type)),
       largest_observed_(0),
+      first_rto_transmission_(0),
       consecutive_rto_count_(0),
       consecutive_tlp_count_(0),
       consecutive_crypto_retransmission_count_(0),
       pending_tlp_transmission_(false),
       max_tail_loss_probes_(kDefaultMaxTailLossProbes),
       using_pacing_(false) {
 }
 
 QuicSentPacketManager::~QuicSentPacketManager() {
 }
@@ skipping 208 matching lines @@
   if (ContainsKey(pending_retransmissions_, sequence_number)) {
     return;
   }
 
   pending_retransmissions_[sequence_number] = transmission_type;
 }
 
 void QuicSentPacketManager::RecordSpuriousRetransmissions(
     const SequenceNumberSet& all_transmissions,
     QuicPacketSequenceNumber acked_sequence_number) {
+  if (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);
+    }
+    pending_retransmissions_.clear();
+    send_algorithm_->RevertRetransmissionTimeout();
+    first_rto_transmission_ = 0;
+    ++stats_->spurious_rto_count;
+  }
   for (SequenceNumberSet::const_iterator
            it = all_transmissions.upper_bound(acked_sequence_number),
            end = all_transmissions.end();
        it != end;
        ++it) {
     const TransmissionInfo& retransmit_info =
         unacked_packets_.GetTransmissionInfo(*it);
 
     stats_->bytes_spuriously_retransmitted += retransmit_info.bytes_sent;
     ++stats_->packets_spuriously_retransmitted;
@@ skipping 258 matching lines @@
     if (frames != NULL) {
       packets_retransmitted = true;
       MarkForRetransmission(sequence_number, RTO_RETRANSMISSION);
     } else {
       unacked_packets_.RemoveFromInFlight(sequence_number);
     }
   }
 
   send_algorithm_->OnRetransmissionTimeout(packets_retransmitted);
   if (packets_retransmitted) {
+    if (consecutive_rto_count_ == 0) {
+      first_rto_transmission_ = unacked_packets_.largest_sent_packet() + 1;
+    }
     ++consecutive_rto_count_;
   }
 }
 
 QuicSentPacketManager::RetransmissionTimeoutMode
     QuicSentPacketManager::GetRetransmissionMode() const {
   DCHECK(unacked_packets_.HasInFlightPackets());
   if (unacked_packets_.HasPendingCryptoPackets()) {
     return HANDSHAKE_MODE;
   }
@@ skipping 112 matching lines @@
       // Base the updated timer on the send time of the last packet.
       const QuicTime sent_time = unacked_packets_.GetLastPacketSentTime();
       const QuicTime tlp_time = sent_time.Add(GetTailLossProbeDelay());
       // Ensure the TLP timer never gets set to a time in the past.
       return QuicTime::Max(clock_->ApproximateNow(), tlp_time);
     }
     case RTO_MODE: {
       // The RTO is based on the first outstanding packet.
       const QuicTime sent_time =
           unacked_packets_.GetFirstInFlightPacketSentTime();
-      QuicTime rto_timeout = sent_time.Add(GetRetransmissionDelay());
-      // Always wait at least 1.5 * RTT from now.
-      QuicTime min_timeout = clock_->ApproximateNow().Add(
-          rtt_stats_.SmoothedRtt().Multiply(1.5));
-
-      return QuicTime::Max(min_timeout, rto_timeout);
+      QuicTime rto_time = sent_time.Add(GetRetransmissionDelay());
+      // Wait for TLP packets to be acked before an RTO fires.
+      QuicTime tlp_time =
+          unacked_packets_.GetLastPacketSentTime().Add(GetTailLossProbeDelay());
+      return QuicTime::Max(tlp_time, rto_time);
     }
   }
   DCHECK(false);
   return QuicTime::Zero();
 }
 
 const QuicTime::Delta QuicSentPacketManager::GetCryptoRetransmissionDelay()
     const {
   // This is equivalent to the TailLossProbeDelay, but slightly more aggressive
   // because crypto handshake messages don't incur a delayed ack time.
@@ skipping 58 matching lines @@
   }
 
   // Set up a pacing sender with a 5 millisecond alarm granularity.
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMilliseconds(5)));
 }
 
 }  // namespace net