Ensure that BBR does not drop to exceedingly low pacing rates during the STARTUP phase. Protected …

net/quic/core/congestion_control/bbr_sender_test.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/bbr_sender.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 
@@ skipping 60 matching lines @@
         bbr_sender_(&simulator_,
                     "BBR sender",
                     "Receiver",
                     Perspective::IS_CLIENT,
                     42),
         receiver_(&simulator_,
                   "Receiver",
                   "BBR sender",
                   Perspective::IS_SERVER,
                   42) {
+    FLAGS_quic_bbr_faster_startup = true;
+
     rtt_stats_ = bbr_sender_.connection()->sent_packet_manager().GetRttStats();
     sender_ = new BbrSender(simulator_.GetClock(), rtt_stats_,
                             QuicSentPacketManagerPeer::GetUnackedPacketMap(
                                 QuicConnectionPeer::GetSentPacketManager(
                                     bbr_sender_.connection(), kDefaultPathId)),
                             kInitialCongestionWindowPackets,
                             kDefaultMaxCongestionWindowPackets, &random_);
     QuicConnectionPeer::SetSendAlgorithm(bbr_sender_.connection(),
                                          kDefaultPathId, sender_);
 
@@ skipping 135 matching lines @@
 
 // Test the number of losses incurred by the startup phase in a situation when
 // the buffer is less than BDP.
 TEST_F(BbrSenderTest, PacketLossOnSmallBufferStartup) {
   CreateSmallBufferSetup();
 
   DriveOutOfStartup();
   float loss_rate =
       static_cast<float>(bbr_sender_.connection()->GetStats().packets_lost) /
       bbr_sender_.connection()->GetStats().packets_sent;
-  EXPECT_LE(loss_rate, 0.20);
+  EXPECT_LE(loss_rate, 0.27);
 }
 
 // Ensures the code transitions loss recovery states correctly (NOT_IN_RECOVERY
 // -> CONSERVATION -> GROWTH -> NOT_IN_RECOVERY).
 TEST_F(BbrSenderTest, RecoveryStates) {
   const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(10);
   bool simulator_result;
   CreateSmallBufferSetup();
 
   bbr_sender_.AddBytesToTransfer(100 * 1024 * 1024);
@@ skipping 176 matching lines @@
   bbr_sender_.AddBytesToTransfer(1.3 * kTestBdp);
   simulator_result = simulator_.RunUntilOrTimeout(
       [this]() { return sender_->ExportDebugState().gain_cycle_index == 1; },
       timeout);
   ASSERT_TRUE(simulator_result);
   simulator_.RunFor(0.75 * sender_->ExportDebugState().min_rtt);
   EXPECT_EQ(BbrSender::PROBE_BW, sender_->ExportDebugState().mode);
   EXPECT_EQ(2, sender_->ExportDebugState().gain_cycle_index);
 }
 
+// Ensure that the pacing rate does not drop at startup.
+TEST_F(BbrSenderTest, NoBandwidthDropOnStartup) {
+  CreateDefaultSetup();
+
+  const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(5);
+  bool simulator_result;
+
+  QuicBandwidth initial_rate = QuicBandwidth::FromBytesAndTimeDelta(
+      kInitialCongestionWindowPackets * kDefaultTCPMSS,
+      QuicTime::Delta::FromMicroseconds(rtt_stats_->initial_rtt_us()));
+  EXPECT_GE(sender_->PacingRate(0), initial_rate);
+
+  // Send a packet.
+  bbr_sender_.AddBytesToTransfer(1000);
+  simulator_result = simulator_.RunUntilOrTimeout(
+      [this]() { return receiver_.bytes_received() == 1000; }, timeout);
+  ASSERT_TRUE(simulator_result);
+  EXPECT_GE(sender_->PacingRate(0), initial_rate);
+
+  // Wait for a while.
+  simulator_.RunFor(QuicTime::Delta::FromSeconds(2));
+  EXPECT_GE(sender_->PacingRate(0), initial_rate);
+
+  // Send another packet.
+  bbr_sender_.AddBytesToTransfer(1000);
+  simulator_result = simulator_.RunUntilOrTimeout(
+      [this]() { return receiver_.bytes_received() == 2000; }, timeout);
+  ASSERT_TRUE(simulator_result);
+  EXPECT_GE(sender_->PacingRate(0), initial_rate);
+}
+
 }  // namespace test
 }  // namespace net