Landing Recent QUIC changes until May 20, 2017.

net/quic/core/congestion_control/bandwidth_sampler.cc

 // Copyright 2016 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/core/congestion_control/bandwidth_sampler.h"
 
 #include <algorithm>
 
 #include "net/quic/platform/api/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_flag_utils.h"
+#include "net/quic/platform/api/quic_flags.h"
 
 namespace net {
 BandwidthSampler::BandwidthSampler()
     : total_bytes_sent_(0),
       total_bytes_acked_(0),
       total_bytes_sent_at_last_acked_packet_(0),
       last_acked_packet_sent_time_(QuicTime::Zero()),
       last_acked_packet_ack_time_(QuicTime::Zero()),
       last_sent_packet_(0),
       is_app_limited_(false),
       end_of_app_limited_phase_(0),
-      connection_state_map_() {}
+      connection_state_map_(),
+      connection_state_map_new_(),
+      use_new_connection_state_map_(
+          FLAGS_quic_reloadable_flag_quic_faster_bandwidth_sampler) {}
 
 BandwidthSampler::~BandwidthSampler() {}
 
 void BandwidthSampler::OnPacketSent(
     QuicTime sent_time,
     QuicPacketNumber packet_number,
     QuicByteCount bytes,
     QuicByteCount bytes_in_flight,
     HasRetransmittableData has_retransmittable_data) {
   last_sent_packet_ = packet_number;
@@ skipping 12 matching lines @@
   // importantly at the beginning of the connection.
   if (bytes_in_flight == 0) {
     last_acked_packet_ack_time_ = sent_time;
     total_bytes_sent_at_last_acked_packet_ = total_bytes_sent_;
 
     // In this situation ack compression is not a concern, set send rate to
     // effectively infinite.
     last_acked_packet_sent_time_ = sent_time;
   }
 
+  if (use_new_connection_state_map_) {
+    if (!connection_state_map_new_.IsEmpty() &&
+        packet_number >
+            connection_state_map_new_.last_packet() + kMaxTrackedPackets) {
+      QUIC_BUG << "BandwidthSampler in-flight packet map has exceeded maximum "
+                  "number "
+                  "of tracked packets.";
+    }
+
+    bool success = connection_state_map_new_.Emplace(packet_number, sent_time,
+                                                     bytes, *this);
+    QUIC_BUG_IF(!success) << "BandwidthSampler failed to insert the packet "
+                             "into the map, most likely because it's already "
+                             "in it.";
+    return;
+  }
+
   DCHECK(connection_state_map_.find(packet_number) ==
          connection_state_map_.end());
   connection_state_map_.emplace(
       packet_number, ConnectionStateOnSentPacket(sent_time, bytes, *this));
 
   QUIC_BUG_IF(connection_state_map_.size() > kMaxTrackedPackets)
       << "BandwidthSampler in-flight packet map has exceeded maximum number "
          "of tracked packets.";
 }
 
 BandwidthSample BandwidthSampler::OnPacketAcknowledged(
     QuicTime ack_time,
     QuicPacketNumber packet_number) {
+  if (use_new_connection_state_map_) {
+    ConnectionStateOnSentPacket* sent_packet_pointer =
+        connection_state_map_new_.GetEntry(packet_number);
+    if (sent_packet_pointer == nullptr) {
+      // See the TODO below.
+      return BandwidthSample();
+    }
+    BandwidthSample sample = OnPacketAcknowledgedInner(ack_time, packet_number,
+                                                       *sent_packet_pointer);
+    connection_state_map_new_.Remove(packet_number);
+    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_faster_bandwidth_sampler, 1, 2);
+    return sample;
+  }
+
   auto it = connection_state_map_.find(packet_number);
   if (it == connection_state_map_.end()) {
     // TODO(vasilvv): currently, this can happen because the congestion
     // controller can be created while some of the handshake packets are still
     // in flight.  Once the sampler is fully integrated with unacked packet map,
     // this should be a QUIC_BUG equivalent.
     return BandwidthSample();
   }
-  const ConnectionStateOnSentPacket sent_packet = it->second;
+  BandwidthSample sample =
+      OnPacketAcknowledgedInner(ack_time, packet_number, it->second);
+  connection_state_map_.erase(it);
+  return sample;
+}
 
+BandwidthSample BandwidthSampler::OnPacketAcknowledgedInner(
+    QuicTime ack_time,
+    QuicPacketNumber packet_number,
+    const ConnectionStateOnSentPacket& sent_packet) {
   total_bytes_acked_ += sent_packet.size;
   total_bytes_sent_at_last_acked_packet_ = sent_packet.total_bytes_sent;
   last_acked_packet_sent_time_ = sent_packet.sent_time;
   last_acked_packet_ack_time_ = ack_time;
 
-  connection_state_map_.erase(it);
-
   // Exit app-limited phase once a packet that was sent while the connection is
   // not app-limited is acknowledged.
   if (is_app_limited_ && packet_number > end_of_app_limited_phase_) {
     is_app_limited_ = false;
   }
 
   // There might have been no packets acknowledged at the moment when the
   // current packet was sent. In that case, there is no bandwidth sample to
   // make.
   if (sent_packet.last_acked_packet_sent_time == QuicTime::Zero()) {
@@ skipping 29 matching lines @@
   // means that the RTT measurements here can be artificially high, especially
   // on low bandwidth connections.
   sample.rtt = ack_time - sent_packet.sent_time;
   // A sample is app-limited if the packet was sent during the app-limited
   // phase.
   sample.is_app_limited = sent_packet.is_app_limited;
   return sample;
 }
 
 void BandwidthSampler::OnPacketLost(QuicPacketNumber packet_number) {
+  if (use_new_connection_state_map_) {
+    // TODO(vasilvv): see the comment for the case of missing packets in
+    // BandwidthSampler::OnPacketAcknowledged on why this does not raise a
+    // QUIC_BUG when removal fails.
+    connection_state_map_new_.Remove(packet_number);
+    QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_faster_bandwidth_sampler, 2, 2);
+    return;
+  }
+
   auto it = connection_state_map_.find(packet_number);
   if (it == connection_state_map_.end()) {
     // TODO(vasilvv): see the comment for the same case in
     // BandwidthSampler::OnPacketAcknowledged.
     return;
   }
 
   connection_state_map_.erase(it);
 }
 
 void BandwidthSampler::OnAppLimited() {
   is_app_limited_ = true;
   end_of_app_limited_phase_ = last_sent_packet_;
 }
 
 void BandwidthSampler::RemoveObsoletePackets(QuicPacketNumber least_unacked) {
+  if (use_new_connection_state_map_) {
+    while (!connection_state_map_new_.IsEmpty() &&
+           connection_state_map_new_.first_packet() < least_unacked) {
+      connection_state_map_new_.Remove(
+          connection_state_map_new_.first_packet());
+    }
+    return;
+  }
   while (!connection_state_map_.empty() &&
          connection_state_map_.begin()->first < least_unacked) {
     connection_state_map_.pop_front();
   }
 }
 
 }  // namespace net