Refactor of QUIC's rtt storage and calculation to have a single RttStats

net/quic/congestion_control/tcp_cubic_sender.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/congestion_control/tcp_cubic_sender.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
+#include "net/quic/congestion_control/rtt_stats.h"
 
 using std::max;
 using std::min;
 
 namespace net {
 
 namespace {
 // Constants based on TCP defaults.
 // The minimum cwnd based on RFC 3782 (TCP NewReno) for cwnd reductions on a
 // fast retransmission.  The cwnd after a timeout is still 1.
 const QuicTcpCongestionWindow kMinimumCongestionWindow = 2;
 const int64 kHybridStartLowWindow = 16;
 const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
 const QuicByteCount kDefaultReceiveWindow = 64000;
 const int64 kInitialCongestionWindow = 10;
 const int kMaxBurstLength = 3;
-// Constants used for RTT calculation.
-const int kInitialRttMs = 100;  // At a typical RTT 100 ms.
-const float kAlpha = 0.125f;
-const float kOneMinusAlpha = (1 - kAlpha);
-const float kBeta = 0.25f;
-const float kOneMinusBeta = (1 - kBeta);
 };  // namespace
 
 TcpCubicSender::TcpCubicSender(
     const QuicClock* clock,
+    const RttStats* rtt_stats,
     bool reno,
     QuicTcpCongestionWindow max_tcp_congestion_window,
     QuicConnectionStats* stats)
     : hybrid_slow_start_(clock),
       cubic_(clock, stats),
+      rtt_stats_(rtt_stats),
       reno_(reno),
       congestion_window_count_(0),
       receive_window_(kDefaultReceiveWindow),
       bytes_in_flight_(0),
       prr_out_(0),
       prr_delivered_(0),
       ack_count_since_loss_(0),
       bytes_in_flight_before_loss_(0),
       update_end_sequence_number_(true),
       end_sequence_number_(0),
       largest_sent_sequence_number_(0),
       largest_acked_sequence_number_(0),
       largest_sent_at_last_cutback_(0),
       congestion_window_(kInitialCongestionWindow),
       slowstart_threshold_(max_tcp_congestion_window),
-      max_tcp_congestion_window_(max_tcp_congestion_window),
-      delay_min_(QuicTime::Delta::Zero()),
-      smoothed_rtt_(QuicTime::Delta::Zero()),
-      mean_deviation_(QuicTime::Delta::Zero()) {
+      max_tcp_congestion_window_(max_tcp_congestion_window) {
 }
 
 TcpCubicSender::~TcpCubicSender() {
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.FinalTcpCwnd", congestion_window_);
 }
 
 void TcpCubicSender::SetFromConfig(const QuicConfig& config, bool is_server) {
   if (is_server) {
     // Set the initial window size.
     congestion_window_ = config.server_initial_congestion_window();
@@ skipping 144 matching lines @@
   return SendWindow() - bytes_in_flight_;
 }
 
 QuicByteCount TcpCubicSender::SendWindow() {
   // What's the current send window in bytes.
   return min(receive_window_, GetCongestionWindow());
 }
 
 QuicBandwidth TcpCubicSender::BandwidthEstimate() const {
   return QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(),
-                                              SmoothedRtt());
-}
-
-QuicTime::Delta TcpCubicSender::SmoothedRtt() const {
-  if (smoothed_rtt_.IsZero()) {
-    return QuicTime::Delta::FromMilliseconds(kInitialRttMs);
-  }
-  return smoothed_rtt_;
+                                              rtt_stats_->SmoothedRtt());
 }
 
 QuicTime::Delta TcpCubicSender::RetransmissionDelay() const {
+  if (!rtt_stats_->HasUpdates()) {
+    return QuicTime::Delta::Zero();
+  }
   return QuicTime::Delta::FromMicroseconds(
-      smoothed_rtt_.ToMicroseconds() + 4 * mean_deviation_.ToMicroseconds());
+      rtt_stats_->SmoothedRtt().ToMicroseconds() +
+      4 * rtt_stats_->mean_deviation().ToMicroseconds());
 }
 
 QuicByteCount TcpCubicSender::GetCongestionWindow() const {
   return congestion_window_ * kMaxSegmentSize;
 }
 
 bool TcpCubicSender::IsCwndLimited() const {
   const QuicByteCount congestion_window_bytes = congestion_window_ *
       kMaxSegmentSize;
   if (bytes_in_flight_ >= congestion_window_bytes) {
@@ skipping 46 matching lines @@
     ++congestion_window_count_;
     if (congestion_window_count_ >= congestion_window_) {
       ++congestion_window_;
       congestion_window_count_ = 0;
     }
 
     DVLOG(1) << "Reno; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_
              << " congestion window count: " << congestion_window_count_;
   } else {
-    congestion_window_ = min(
-        max_tcp_congestion_window_,
-        cubic_.CongestionWindowAfterAck(congestion_window_, delay_min_));
+    congestion_window_ = min(max_tcp_congestion_window_,
+                             cubic_.CongestionWindowAfterAck(
+                                 congestion_window_, rtt_stats_->min_rtt()));
     DVLOG(1) << "Cubic; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_;
   }
 }
 
 void TcpCubicSender::OnRetransmissionTimeout(bool packets_retransmitted) {
   bytes_in_flight_ = 0;
   largest_sent_at_last_cutback_ = 0;
   if (packets_retransmitted) {
     cubic_.Reset();
     congestion_window_ = kMinimumCongestionWindow;
   }
 }
 
 void TcpCubicSender::UpdateRtt(QuicTime::Delta rtt) {
-  if (rtt.IsInfinite() || rtt.IsZero()) {
-    DVLOG(1) << "Ignoring rtt, because it's "
-             << (rtt.IsZero() ? "Zero" : "Infinite");
-    return;
-  }
-  // RTT can't be negative.
-  DCHECK_LT(0, rtt.ToMicroseconds());
-
-  // TODO(pwestin): Discard delay samples right after fast recovery,
-  // during 1 second?.
-
-  // First time call or link delay decreases.
-  if (delay_min_.IsZero() || delay_min_ > rtt) {
-    delay_min_ = rtt;
-  }
-  // First time call.
-  if (smoothed_rtt_.IsZero()) {
-    smoothed_rtt_ = rtt;
-    mean_deviation_ = QuicTime::Delta::FromMicroseconds(
-        rtt.ToMicroseconds() / 2);
-  } else {
-    mean_deviation_ = QuicTime::Delta::FromMicroseconds(
-        kOneMinusBeta * mean_deviation_.ToMicroseconds() +
-        kBeta *
-            std::abs(smoothed_rtt_.ToMicroseconds() - rtt.ToMicroseconds()));
-    smoothed_rtt_ = QuicTime::Delta::FromMicroseconds(
-        kOneMinusAlpha * smoothed_rtt_.ToMicroseconds() +
-        kAlpha * rtt.ToMicroseconds());
-    DVLOG(1) << "Cubic; smoothed_rtt_:" << smoothed_rtt_.ToMicroseconds()
-             << " mean_deviation_:" << mean_deviation_.ToMicroseconds();
-  }
-
   // Hybrid start triggers when cwnd is larger than some threshold.
   if (congestion_window_ <= slowstart_threshold_ &&
       congestion_window_ >= kHybridStartLowWindow) {
     if (!hybrid_slow_start_.started()) {
       // Time to start the hybrid slow start.
       hybrid_slow_start_.Reset(end_sequence_number_);
     }
-    hybrid_slow_start_.Update(rtt, delay_min_);
+    hybrid_slow_start_.Update(rtt, rtt_stats_->min_rtt());
     if (hybrid_slow_start_.Exit()) {
       slowstart_threshold_ = congestion_window_;
     }
   }
 }
 
 }  // namespace net