Add a new QUIC Ack Decimation mode that is reordering tolerant. Protected by FLAG_quic_ack_decimati…

net/quic/quic_connection.cc

 // Copyright (c) 2012 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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 
 #include <algorithm>
@@ skipping 260 matching lines @@
       should_last_packet_instigate_acks_(false),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
       max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       save_crypto_packets_as_termination_packets_(false),
       silent_close_enabled_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
       num_retransmittable_packets_received_since_last_ack_sent_(0),
+      last_ack_had_missing_packets_(false),
       num_packets_received_since_last_ack_sent_(0),
       stop_waiting_count_(0),
-      ack_decimation_enabled_(false),
+      ack_mode_(TCP_ACKING),
       delay_setting_retransmission_alarm_(false),
       pending_retransmission_alarm_(false),
       arena_(),
       ack_alarm_(helper->CreateAlarm(arena_.New<AckAlarm>(this), &arena_)),
       retransmission_alarm_(
           helper->CreateAlarm(arena_.New<RetransmissionAlarm>(this), &arena_)),
       send_alarm_(helper->CreateAlarm(arena_.New<SendAlarm>(this), &arena_)),
       resume_writes_alarm_(
           helper->CreateAlarm(arena_.New<SendAlarm>(this), &arena_)),
       timeout_alarm_(
@@ skipping 114 matching lines @@
   if (config.HasClientSentConnectionOption(kMTUH, perspective_)) {
     SetMtuDiscoveryTarget(kMtuDiscoveryTargetPacketSizeHigh);
   }
   if (config.HasClientSentConnectionOption(kMTUL, perspective_)) {
     SetMtuDiscoveryTarget(kMtuDiscoveryTargetPacketSizeLow);
   }
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSetFromConfig(config);
   }
   if (config.HasClientSentConnectionOption(kACKD, perspective_)) {
-    ack_decimation_enabled_ = true;
+    ack_mode_ = ACK_DECIMATION;
+  }
+  if (FLAGS_quic_ack_decimation2 &&
+      config.HasClientSentConnectionOption(kAKD2, perspective_)) {
+    ack_mode_ = ACK_DECIMATION_WITH_REORDERING;
   }
 }
 
 void QuicConnection::OnSendConnectionState(
     const CachedNetworkParameters& cached_network_params) {
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSendConnectionState(cached_network_params);
   }
 }
 
@@ skipping 597 matching lines @@
   ++num_packets_received_since_last_ack_sent_;
   // Always send an ack every 20 packets in order to allow the peer to discard
   // information from the SentPacketManager and provide an RTT measurement.
   if (num_packets_received_since_last_ack_sent_ >=
       kMaxPacketsReceivedBeforeAckSend) {
     ack_queued_ = true;
   }
 
   // Determine whether the newly received packet was missing before recording
   // the received packet.
-  if (was_missing) {
+  // Ack decimation with reordering relies on the timer to send an ack, but if
+  // missing packets we reported in the previous ack, send an ack immediately.
+  if (was_missing && (ack_mode_ != ACK_DECIMATION_WITH_REORDERING ||
+                      last_ack_had_missing_packets_)) {
     ack_queued_ = true;
   }
 
   if (should_last_packet_instigate_acks_ && !ack_queued_) {
     ++num_retransmittable_packets_received_since_last_ack_sent_;
-    if (ack_decimation_enabled_ &&
+    if (ack_mode_ != TCP_ACKING &&
         last_header_.packet_number > kMinReceivedBeforeAckDecimation) {
       // Ack up to 10 packets at once.
       if (num_retransmittable_packets_received_since_last_ack_sent_ >=
           kMaxRetransmittablePacketsBeforeAck) {
         ack_queued_ = true;
       } else if (!ack_alarm_->IsSet()) {
         // Wait the minimum of a quarter min_rtt and the delayed ack time.
         QuicTime::Delta ack_delay = QuicTime::Delta::Min(
             sent_packet_manager_.DelayedAckTime(),
             sent_packet_manager_.GetRttStats()->min_rtt().Multiply(0.25));
         ack_alarm_->Set(clock_->ApproximateNow().Add(ack_delay));
       }
     } else {
       // Ack with a timer or every 2 packets by default.
       if (num_retransmittable_packets_received_since_last_ack_sent_ >=
           kDefaultRetransmittablePacketsBeforeAck) {
         ack_queued_ = true;
       } else if (!ack_alarm_->IsSet()) {
         ack_alarm_->Set(clock_->ApproximateNow().Add(
             sent_packet_manager_.DelayedAckTime()));
       }
     }
 
     // If there are new missing packets to report, send an ack immediately.
-    // TODO(ianswett): Consider allowing 1ms of reordering for the
-    // ack decimation experiment.
     if (received_packet_manager_.HasNewMissingPackets()) {
-      ack_queued_ = true;
+      if (ack_mode_ == ACK_DECIMATION_WITH_REORDERING) {
+        // Wait the minimum of an eighth min_rtt and the existing ack time.
+        QuicTime ack_time = clock_->ApproximateNow().Add(
+            sent_packet_manager_.GetRttStats()->min_rtt().Multiply(0.125));
+        if (!ack_alarm_->IsSet() || ack_alarm_->deadline() > ack_time) {
+          ack_alarm_->Cancel();
+          ack_alarm_->Set(ack_time);
+        }
+      } else {
+        ack_queued_ = true;
+      }
     }
   }
 
   if (ack_queued_) {
     ack_alarm_->Cancel();
   }
 }
 
 void QuicConnection::ClearLastFrames() {
   should_last_packet_instigate_acks_ = false;
@@ skipping 765 matching lines @@
   packet_generator_.AddControlFrame(QuicFrame(QuicPingFrame()));
   // Send PING frame immediately, without checking for congestion window bounds.
   packet_generator_.FlushAllQueuedFrames();
 }
 
 void QuicConnection::SendAck() {
   ack_alarm_->Cancel();
   ack_queued_ = false;
   stop_waiting_count_ = 0;
   num_retransmittable_packets_received_since_last_ack_sent_ = 0;
+  last_ack_had_missing_packets_ = received_packet_manager_.HasMissingPackets();
   num_packets_received_since_last_ack_sent_ = 0;
 
   packet_generator_.SetShouldSendAck(true);
 }
 
 void QuicConnection::OnRetransmissionTimeout() {
   if (!sent_packet_manager_.HasUnackedPackets()) {
     return;
   }
 
@@ skipping 630 matching lines @@
 void QuicConnection::OnPathClosed(QuicPathId path_id) {
   // Stop receiving packets on this path.
   framer_.OnPathClosed(path_id);
 }
 
 bool QuicConnection::ack_frame_updated() const {
   return received_packet_manager_.ack_frame_updated();
 }
 
 }  // namespace net