Allow the number of connections QUIC's send algorithms simulate to

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"
@@ skipping 18 matching lines @@
     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),
       stats_(stats),
       reno_(reno),
+      num_connections_(2),
       congestion_window_count_(0),
       receive_window_(kDefaultSocketReceiveBuffer),
       prr_out_(0),
       prr_delivered_(0),
       ack_count_since_loss_(0),
       bytes_in_flight_before_loss_(0),
       largest_sent_sequence_number_(0),
       largest_acked_sequence_number_(0),
       largest_sent_at_last_cutback_(0),
       congestion_window_(kInitialCongestionWindow),
@@ skipping 21 matching lines @@
       congestion_window_ = min(kMaxInitialWindow,
                                config.ReceivedInitialCongestionWindow());
     }
   }
   if (config.HasReceivedSocketReceiveBuffer()) {
     // Set the initial socket receive buffer size in bytes.
     receive_window_ = config.ReceivedSocketReceiveBuffer();
   }
 }
 
+void TcpCubicSender::SetNumEmulatedConnections(int num_connections) {
+  num_connections_ = num_connections;
+  cubic_.SetNumConnections(num_connections);
+}
+
 void TcpCubicSender::OnIncomingQuicCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback,
     QuicTime feedback_receive_time) {
   if (feedback.type == kTCP) {
     receive_window_ = feedback.tcp.receive_window;
   }
 }
 
 void TcpCubicSender::OnCongestionEvent(
     bool rtt_updated,
@@ skipping 176 matching lines @@
     }
     DVLOG(1) << "Slow start; congestion window: " << congestion_window_
              << " slowstart threshold: " << slowstart_threshold_;
     return;
   }
   if (congestion_window_ >= max_tcp_congestion_window_) {
     return;
   }
   // Congestion avoidance
   if (reno_) {
-    // Classic Reno congestion avoidance provided for testing.
-
+    // Classic Reno congestion avoidance.
     ++congestion_window_count_;
-    if (congestion_window_count_ >= congestion_window_) {
+    // Divide by num_connections to smoothly increase the CWND at a faster
+    // rate than conventional Reno.
+    if (congestion_window_count_ * num_connections_ >= 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(
@@ skipping 64 matching lines @@
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 CongestionControlType TcpCubicSender::GetCongestionControlType() const {
   return reno_ ? kReno : kCubic;
 }
 
 }  // namespace net