Land Recent QUIC Changes

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"
 
 namespace net {
 
 namespace {
 // Constants based on TCP defaults.
 const int64 kHybridStartLowWindow = 16;
 const QuicByteCount kMaxSegmentSize = kMaxPacketSize;
 const QuicByteCount kDefaultReceiveWindow = 64000;
 const int64 kInitialCongestionWindow = 10;
 const int64 kMaxCongestionWindow = 10000;
 const int kMaxBurstLength = 3;
+const int kInitialRttMs = 60;  // At a typical RTT 60 ms.
 };
 
 TcpCubicSender::TcpCubicSender(const QuicClock* clock, bool reno)
     : hybrid_slow_start_(clock),
       cubic_(clock),
       reno_(reno),
       congestion_window_count_(0),
       receiver_congestion_window_(kDefaultReceiveWindow),
       last_received_accumulated_number_of_lost_packets_(0),
       bytes_in_flight_(0),
@@ skipping 50 matching lines @@
   // Sanity, make sure that we don't end up with an empty window.
   if (congestion_window_ == 0) {
     congestion_window_ = 1;
   }
   DLOG(INFO) << "Incoming loss; congestion window:" << congestion_window_;
 }
 
 void TcpCubicSender::SentPacket(QuicTime /*sent_time*/,
                                 QuicPacketSequenceNumber sequence_number,
                                 QuicByteCount bytes,
-                                bool is_retransmission,
-                                bool has_retransmittable_data) {
-  if (!is_retransmission && has_retransmittable_data) {
-    bytes_in_flight_ += bytes;
-  }
+                                bool is_retransmission) {
+  bytes_in_flight_ += bytes;
   if (!is_retransmission && update_end_sequence_number_) {
     end_sequence_number_ = sequence_number;
     if (AvailableCongestionWindow() == 0) {
       update_end_sequence_number_ = false;
       DLOG(INFO) << "Stop update end sequence number @" << sequence_number;
     }
   }
 }
 
+void TcpCubicSender::AbandoningPacket(QuicPacketSequenceNumber sequence_number,
+                                      QuicByteCount abandoned_bytes) {
+  bytes_in_flight_ -= abandoned_bytes;
+}
+
 QuicTime::Delta TcpCubicSender::TimeUntilSend(QuicTime now,
-                                              bool is_retransmission) {
-  if (is_retransmission) {
-    // For TCP we can always send a retransmission immediately.
+                                              bool is_retransmission,
+                                              bool has_retransmittable_data) {
+  if (is_retransmission || !has_retransmittable_data) {
+    // For TCP we can always send a retransmission and/or an ACK immediately.
     return QuicTime::Delta::Zero();
   }
   if (AvailableCongestionWindow() == 0) {
     return QuicTime::Delta::Infinite();
   }
   return QuicTime::Delta::Zero();
 }
 
 QuicByteCount TcpCubicSender::AvailableCongestionWindow() {
   if (bytes_in_flight_ > CongestionWindow()) {
     return 0;
   }
   return CongestionWindow() - bytes_in_flight_;
 }
 
 QuicByteCount TcpCubicSender::CongestionWindow() {
   // What's the current congestion window in bytes.
   return std::min(receiver_congestion_window_,
                   congestion_window_ * kMaxSegmentSize);
 }
 
 QuicBandwidth TcpCubicSender::BandwidthEstimate() {
   // TODO(pwestin): make a long term estimate, based on RTT and loss rate? or
   // instantaneous estimate?
   // Throughput ~= (1/RTT)*sqrt(3/2p)
   return QuicBandwidth::Zero();
 }
 
+QuicTime::Delta TcpCubicSender::SmoothedRtt() {
+  // TODO(satyamshekhar): Return the smoothed averaged RTT.
+  if (delay_min_.IsZero()) {
+    return QuicTime::Delta::FromMilliseconds(kInitialRttMs);
+  }
+  return delay_min_;
+}
+
 void TcpCubicSender::Reset() {
   delay_min_ = QuicTime::Delta::Zero();
   hybrid_slow_start_.Restart();
 }
 
 bool TcpCubicSender::IsCwndLimited() const {
   const QuicByteCount congestion_window_bytes = congestion_window_ *
       kMaxSegmentSize;
   if (bytes_in_flight_ >= congestion_window_bytes) {
     return true;
@@ skipping 42 matching lines @@
   }
 }
 
 // TODO(pwestin): what is the timout value?
 void TcpCubicSender::OnTimeOut() {
   cubic_.Reset();
   congestion_window_ = 1;
 }
 
 void TcpCubicSender::AckAccounting(QuicTime::Delta rtt) {
-  if (rtt.ToMicroseconds() <= 0) {
-    // RTT can't be 0 or negative.
+  if (rtt.IsInfinite() || rtt.IsZero()) {
     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;
   }
   // 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_);
     if (hybrid_slow_start_.Exit()) {
       slowstart_threshold_ = congestion_window_;
     }
   }
 }
 
 }  // namespace net