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

net/quic/congestion_control/inter_arrival_sender.cc

 // Copyright (c) 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/congestion_control/inter_arrival_sender.h"
 
 #include <algorithm>
 
 #include "base/stl_util.h"
+#include "net/quic/congestion_control/rtt_stats.h"
 
 using std::max;
 using std::min;
 
 namespace net {
 
 namespace {
 const int64 kProbeBitrateKBytesPerSecond = 1200;  // 9.6 Mbit/s
 const float kPacketLossBitrateReduction = 0.7f;
 const float kUncertainSafetyMargin = 0.7f;
 const float kMaxBitrateReduction = 0.9f;
 const float kMinBitrateReduction = 0.05f;
 const uint64 kMinBitrateKbit = 10;
-const int kInitialRttMs = 60;  // At a typical RTT 60 ms.
-const float kAlpha = 0.125f;
-const float kOneMinusAlpha = 1 - kAlpha;
 
 static const int kHistoryPeriodMs = 5000;
 static const int kBitrateSmoothingPeriodMs = 1000;
 static const int kMinBitrateSmoothingPeriodMs = 500;
 
 }  // namespace
 
-InterArrivalSender::InterArrivalSender(const QuicClock* clock)
+InterArrivalSender::InterArrivalSender(const QuicClock* clock,
+                                       const RttStats* rtt_stats)
     : clock_(clock),
+      rtt_stats_(rtt_stats),
       probing_(true),
       max_segment_size_(kDefaultMaxPacketSize),
       current_bandwidth_(QuicBandwidth::Zero()),
       smoothed_rtt_(QuicTime::Delta::Zero()),
       channel_estimator_(new ChannelEstimator()),
       bitrate_ramp_up_(new InterArrivalBitrateRampUp(clock)),
       overuse_detector_(new InterArrivalOveruseDetector()),
       probe_(new InterArrivalProbe(max_segment_size_)),
       state_machine_(new InterArrivalStateMachine(clock)),
       paced_sender_(new PacedSender(QuicBandwidth::FromKBytesPerSecond(
@@ skipping 253 matching lines @@
       break;
   }
   bandwidth_usage_state_ = new_bandwidth_usage_state;
 }
 
 QuicBandwidth InterArrivalSender::BandwidthEstimate() const {
   return current_bandwidth_;
 }
 
 void InterArrivalSender::UpdateRtt(QuicTime::Delta rtt) {
-  // RTT can't be negative.
-  DCHECK_LE(0, rtt.ToMicroseconds());
-
-  if (rtt.IsInfinite()) {
-    return;
-  }
-
-  if (smoothed_rtt_.IsZero()) {
-    smoothed_rtt_ = rtt;
-  } else {
-    smoothed_rtt_ = QuicTime::Delta::FromMicroseconds(
-        kOneMinusAlpha * smoothed_rtt_.ToMicroseconds() +
-        kAlpha * rtt.ToMicroseconds());
-  }
-  state_machine_->set_rtt(smoothed_rtt_);
-}
-
-QuicTime::Delta InterArrivalSender::SmoothedRtt() const {
-  if (smoothed_rtt_.IsZero()) {
-    return QuicTime::Delta::FromMilliseconds(kInitialRttMs);
-  }
-  return smoothed_rtt_;
+  state_machine_->set_rtt(rtt_stats_->SmoothedRtt());
 }
 
 QuicTime::Delta InterArrivalSender::RetransmissionDelay() const {
   // TODO(pwestin): Calculate and return retransmission delay.
   // Use 2 * the smoothed RTT for now.
-  return smoothed_rtt_.Add(smoothed_rtt_);
+  return rtt_stats_->SmoothedRtt().Multiply(2);
 }
 
 QuicByteCount InterArrivalSender::GetCongestionWindow() const {
   return 0;
 }
 
 void InterArrivalSender::EstimateNewBandwidth(QuicTime feedback_receive_time,
                                               QuicBandwidth sent_bandwidth) {
   QuicBandwidth new_bandwidth = bitrate_ramp_up_->GetNewBitrate(sent_bandwidth);
   if (current_bandwidth_ == new_bandwidth) {
@@ skipping 28 matching lines @@
   }
   if (estimated_congestion_delay >= back_down_congestion_delay_) {
     // Do nothing, our estimated delay have increased.
     DVLOG(1) << "Current delay estimate is higher than before draining";
     return;
   }
   DCHECK(back_down_time_.IsInitialized());
   QuicTime::Delta buffer_reduction =
       back_down_congestion_delay_.Subtract(estimated_congestion_delay);
   QuicTime::Delta elapsed_time =
-      feedback_receive_time.Subtract(back_down_time_).Subtract(SmoothedRtt());
+      feedback_receive_time.Subtract(back_down_time_).Subtract(
+          rtt_stats_->SmoothedRtt());
 
   QuicBandwidth new_estimate = QuicBandwidth::Zero();
   if (buffer_reduction >= elapsed_time) {
     // We have drained more than the elapsed time... go back to our old rate.
     new_estimate = back_down_bandwidth_;
   } else {
     float fraction_of_rate =
         static_cast<float>(buffer_reduction.ToMicroseconds()) /
             elapsed_time.ToMicroseconds();  // < 1.0
 
@@ skipping 52 matching lines @@
 void InterArrivalSender::EstimateBandwidthAfterDelayEvent(
     QuicTime feedback_receive_time,
     QuicTime::Delta estimated_congestion_delay) {
   QuicByteCount estimated_byte_buildup =
       current_bandwidth_.ToBytesPerPeriod(estimated_congestion_delay);
 
   // To drain all build up buffer within one RTT we need to reduce the
   // bitrate with the following.
   // TODO(pwestin): this is a crude first implementation.
   int64 draining_rate_per_rtt = (estimated_byte_buildup *
-      kNumMicrosPerSecond) / SmoothedRtt().ToMicroseconds();
+      kNumMicrosPerSecond) / rtt_stats_->SmoothedRtt().ToMicroseconds();
 
   float decrease_factor =
       draining_rate_per_rtt / current_bandwidth_.ToBytesPerSecond();
 
   decrease_factor = max(decrease_factor, kMinBitrateReduction);
   decrease_factor = min(decrease_factor, kMaxBitrateReduction);
   back_down_congestion_delay_ = estimated_congestion_delay;
   QuicBandwidth new_target_bitrate =
       current_bandwidth_.Scale(1.0f - decrease_factor);
 
   // While in delay sensing mode send at least one packet per RTT.
   QuicBandwidth min_delay_bitrate =
-      QuicBandwidth::FromBytesAndTimeDelta(max_segment_size_, SmoothedRtt());
+      QuicBandwidth::FromBytesAndTimeDelta(max_segment_size_,
+                                           rtt_stats_->SmoothedRtt());
   new_target_bitrate = max(new_target_bitrate, min_delay_bitrate);
 
   ResetCurrentBandwidth(feedback_receive_time, new_target_bitrate);
 
   DVLOG(1) << "New bandwidth estimate after delay event:"
-      << current_bandwidth_.ToKBitsPerSecond()
-      << " Kbits/s min delay bitrate:"
-      << min_delay_bitrate.ToKBitsPerSecond()
-      << " Kbits/s RTT:"
-      << SmoothedRtt().ToMicroseconds()
-      << " us";
+      << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s min delay bitrate:"
+      << min_delay_bitrate.ToKBitsPerSecond() << " Kbits/s RTT:"
+      << rtt_stats_->SmoothedRtt().ToMicroseconds() << " us";
 }
 
 void InterArrivalSender::EstimateBandwidthAfterLossEvent(
     QuicTime feedback_receive_time) {
   ResetCurrentBandwidth(feedback_receive_time,
                         current_bandwidth_.Scale(kPacketLossBitrateReduction));
   DVLOG(1) << "New bandwidth estimate after loss event:"
-             << current_bandwidth_.ToKBitsPerSecond()
-             << " Kbits/s";
+             << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s";
 }
 
 void InterArrivalSender::ResetCurrentBandwidth(QuicTime feedback_receive_time,
                                                QuicBandwidth new_rate) {
   new_rate = max(new_rate,
                  QuicBandwidth::FromKBitsPerSecond(kMinBitrateKbit));
   QuicBandwidth channel_estimate = QuicBandwidth::Zero();
   ChannelEstimateState channel_estimator_state =
       channel_estimator_->GetChannelEstimate(&channel_estimate);
 
@@ skipping 29 matching lines @@
     if (now.Subtract(history_it->second->send_timestamp()) <= kHistoryPeriod) {
       return;
     }
     delete history_it->second;
     packet_history_map_.erase(history_it);
     history_it = packet_history_map_.begin();
   }
 }
 
 }  // namespace net