Land Recent QUIC Changes.

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 20 matching lines @@
 
 // Only exponentially back off the handshake timer 5 times due to a timeout.
 static const size_t kMaxHandshakeRetransmissionBackoffs = 5;
 static const size_t 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;
 
+// Number of samples before we force a new recent min rtt to be captured.
+static const size_t kNumMinRttSamplesAfterQuiescence = 2;
+
 bool HasCryptoHandshake(const TransmissionInfo& transmission_info) {
   if (transmission_info.retransmittable_frames == NULL) {
     return false;
   }
   return transmission_info.retransmittable_frames->HasCryptoHandshake() ==
       IS_HANDSHAKE;
 }
 
 }  // namespace
 
@@ skipping 113 matching lines @@
   QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
   while (it != unacked_packets_.end()) {
     QuicPacketSequenceNumber sequence_number = it->first;
     if (sequence_number > received_info.largest_observed) {
       // These packets are still in flight.
       break;
     }
 
     if (IsAwaitingPacket(received_info, sequence_number)) {
       // Remove any packets not being tracked by the send algorithm, allowing
       // the high water mark to be raised if necessary.

[wtc, 2014/05/19 18:58:40]

I'm wondering if this comment needs to be updated, now that the function has
been changed from IsSentAndNotPending to IsForRttOnly.

[Ian Swett, 2014/05/19 20:20:41]

It could be updated.  A better comment might be "Remove any rtt only packets
less than or equal to the largest observed, since they will not produce an RTT
measurement."

[ramant (doing other things), 2014/05/20 03:22:32]

Done.

[ramant (doing other things), 2014/05/20 03:22:32]

Updated the comment per Ian.

-      if (QuicUnackedPacketMap::IsSentAndNotPending(it->second)) {
+      if (QuicUnackedPacketMap::IsForRttOnly(it->second)) {
         it = MarkPacketHandled(sequence_number, delta_largest_observed);
       } else {
         // Consider it multiple nacks when there is a gap between the missing
         // packet and the largest observed, since the purpose of a nack
         // threshold is to tolerate re-ordering.  This handles both StretchAcks
         // and Forward Acks.
         // The nack count only increases when the largest observed increases.
         size_t min_nacks = received_info.largest_observed - sequence_number;
         // Truncated acks can nack the largest observed, so use a min of 1.
         if (min_nacks == 0) {
@@ skipping 68 matching lines @@
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     const RetransmittableFrames* frames =
         it->second.retransmittable_frames;
     if (frames != NULL && frames->encryption_level() == ENCRYPTION_NONE) {
       // Once you're forward secure, no unencrypted packets will be sent, crypto
       // or otherwise. Unencrypted packets are neutered and abandoned, to ensure
       // they are not retransmitted or considered lost from a congestion control
       // perspective.
       pending_retransmissions_.erase(it->first);
-      // TODO(ianswett): This may cause packets to linger forever in the
-      // UnackedPacketMap.
-      unacked_packets_.NeuterPacket(it->first);
       unacked_packets_.SetNotPending(it->first);
+      // TODO(ianswett): Clean this up so UnackedPacketMap maintains the correct
+      // invariants between the various transmissions for NeuterPacket.
+      SequenceNumberSet all_transmissions = *it->second.all_transmissions;
+      for (SequenceNumberSet::const_iterator all_it = all_transmissions.begin();
+           all_it != all_transmissions.end(); ++all_it) {
+        unacked_packets_.NeuterPacket(*all_it);
+      }
     }
   }
 }
 
 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 == NULL);
@@ skipping 155 matching lines @@
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   DCHECK_LT(0u, sequence_number);
   LOG_IF(DFATAL, bytes == 0) << "Cannot send empty packets.";
   // In rare circumstances, the packet could be serialized, sent, and then acked
   // before OnPacketSent is called.
   if (!unacked_packets_.IsUnacked(sequence_number)) {
     return false;
   }
 
-  // Only track packets as pending that the send algorithm wants us to track.
-  if (!send_algorithm_->OnPacketSent(sent_time,
-                                     unacked_packets_.bytes_in_flight(),
-                                     sequence_number,
-                                     bytes,
-                                     has_retransmittable_data)) {
-    unacked_packets_.SetSent(sequence_number, sent_time, bytes, false);
-    // Do not reset the retransmission timer, since the packet isn't tracked.
-    return false;
+  if (unacked_packets_.bytes_in_flight() == 0) {
+    // TODO(ianswett): Consider being less aggressive to force a new
+    // recent_min_rtt, likely by not discarding a relatively new sample.
+    DVLOG(1) << "Sampling a new recent min rtt within 2 samples. currently:"
+             << rtt_stats_.recent_min_rtt().ToMilliseconds() << "ms";
+    rtt_stats_.SampleNewRecentMinRtt(kNumMinRttSamplesAfterQuiescence);
   }
 
-  const bool set_retransmission_timer = !unacked_packets_.HasPendingPackets();
+  // Only track packets as pending that the send algorithm wants us to track.
+  const bool pending =
+      send_algorithm_->OnPacketSent(sent_time,
+                                    unacked_packets_.bytes_in_flight(),
+                                    sequence_number,
+                                    bytes,
+                                    has_retransmittable_data);
+  unacked_packets_.SetSent(sequence_number, sent_time, bytes, pending);
 
-  unacked_packets_.SetSent(sequence_number, sent_time, bytes, true);
-
-  // Reset the retransmission timer anytime a packet is sent in tail loss probe
-  // mode or before the crypto handshake has completed.
-  return set_retransmission_timer || GetRetransmissionMode() != RTO_MODE;
+  // Reset the retransmission timer anytime a pending packet is sent.
+  return pending;
 }
 
 void QuicSentPacketManager::OnRetransmissionTimeout() {
   DCHECK(unacked_packets_.HasPendingPackets());
   // Handshake retransmission, timer based loss detection, TLP, and RTO are
   // implemented with a single alarm. The handshake alarm is set when the
   // handshake has not completed, the loss alarm is set when the loss detection
   // algorithm says to, and the TLP and  RTO alarms are set after that.
   // The TLP alarm is always set to run for under an RTO.
   switch (GetRetransmissionMode()) {
@@ skipping 295 matching lines @@
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net