src/net/quic/congestion_control/inter_arrival_sender_test.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/logging.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "base/stl_util.h"
   8 #include "net/quic/congestion_control/inter_arrival_sender.h"
   9 #include "net/quic/test_tools/mock_clock.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using std::pair;
  13
  14 namespace net {
  15 namespace test {
  16
  17 class InterArrivalSenderTest : public ::testing::Test {
  18  protected:
  19   InterArrivalSenderTest()
  20      : rtt_(QuicTime::Delta::FromMilliseconds(60)),
  21        one_ms_(QuicTime::Delta::FromMilliseconds(1)),
  22        one_s_(QuicTime::Delta::FromMilliseconds(1000)),
  23        nine_ms_(QuicTime::Delta::FromMilliseconds(9)),
  24        send_start_time_(send_clock_.Now()),
  25        sender_(&send_clock_),
  26        sequence_number_(1),
  27        acked_sequence_number_(1),
  28        feedback_sequence_number_(1) {
  29     send_clock_.AdvanceTime(one_ms_);
  30     receive_clock_.AdvanceTime(one_ms_);
  31   }
  32
  33   virtual ~InterArrivalSenderTest() {
  34     STLDeleteValues(&sent_packets_);
  35   }
  36
  37   void SendAvailableCongestionWindow() {
  38     while (sender_.TimeUntilSend(send_clock_.Now(),
  39         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero()) {
  40       QuicByteCount bytes_in_packet = kDefaultMaxPacketSize;
  41       sent_packets_[sequence_number_] =
  42           new class SendAlgorithmInterface::SentPacket(
  43               bytes_in_packet, send_clock_.Now());
  44
  45       sender_.OnPacketSent(send_clock_.Now(), sequence_number_, bytes_in_packet,
  46                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
  47       sequence_number_++;
  48     }
  49     EXPECT_FALSE(sender_.TimeUntilSend(send_clock_.Now(),
  50         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
  51   }
  52
  53   void AckNPackets(int n) {
  54     for (int i = 0; i < n; ++i) {
  55       sender_.OnIncomingAck(
  56           acked_sequence_number_++, kDefaultMaxPacketSize, rtt_);
  57     }
  58   }
  59
  60   void SendDelaySpikeFeedbackMessage(QuicTime::Delta spike_time) {
  61     QuicCongestionFeedbackFrame feedback;
  62     feedback.type = kInterArrival;
  63     feedback.inter_arrival.accumulated_number_of_lost_packets = 0;
  64     receive_clock_.AdvanceTime(spike_time);
  65     QuicTime receive_time = receive_clock_.ApproximateNow();
  66     feedback.inter_arrival.received_packet_times.insert(
  67         pair<QuicPacketSequenceNumber, QuicTime>(
  68             feedback_sequence_number_, receive_time));
  69     feedback_sequence_number_++;
  70
  71     // We need to send feedback for 2 packets since they where sent at the
  72     // same time.
  73     feedback.inter_arrival.received_packet_times.insert(
  74         pair<QuicPacketSequenceNumber, QuicTime>(
  75             feedback_sequence_number_, receive_time));
  76     feedback_sequence_number_++;
  77
  78     sender_.OnIncomingQuicCongestionFeedbackFrame(feedback, send_clock_.Now(),
  79                                                   sent_packets_);
  80   }
  81
  82   void SendFeedbackMessageNPackets(int n,
  83                                    QuicTime::Delta delta_odd,
  84                                    QuicTime::Delta delta_even) {
  85     QuicCongestionFeedbackFrame feedback;
  86     feedback.type = kInterArrival;
  87     feedback.inter_arrival.accumulated_number_of_lost_packets = 0;
  88     for (int i = 0; i < n; ++i) {
  89       if (feedback_sequence_number_ % 2) {
  90         receive_clock_.AdvanceTime(delta_even);
  91       } else {
  92         receive_clock_.AdvanceTime(delta_odd);
  93       }
  94       QuicTime receive_time = receive_clock_.ApproximateNow();
  95       feedback.inter_arrival.received_packet_times.insert(
  96           pair<QuicPacketSequenceNumber, QuicTime>(
  97               feedback_sequence_number_, receive_time));
  98       feedback_sequence_number_++;
  99     }
 100     sender_.OnIncomingQuicCongestionFeedbackFrame(feedback, send_clock_.Now(),
 101                                                   sent_packets_);
 102   }
 103
 104   QuicTime::Delta SenderDeltaSinceStart() {
 105     return send_clock_.ApproximateNow().Subtract(send_start_time_);
 106   }
 107
 108   const QuicTime::Delta rtt_;
 109   const QuicTime::Delta one_ms_;
 110   const QuicTime::Delta one_s_;
 111   const QuicTime::Delta nine_ms_;
 112   MockClock send_clock_;
 113   MockClock receive_clock_;
 114   const QuicTime send_start_time_;
 115   InterArrivalSender sender_;
 116   QuicPacketSequenceNumber sequence_number_;
 117   QuicPacketSequenceNumber acked_sequence_number_;
 118   QuicPacketSequenceNumber feedback_sequence_number_;
 119   SendAlgorithmInterface::SentPacketsMap sent_packets_;
 120 };
 121
 122 TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
 123   QuicCongestionFeedbackFrame feedback;
 124   // At startup make sure we can send.
 125   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 126       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 127
 128   // Send 5 bursts.
 129   for (int i = 0; i < 4; ++i) {
 130     SendAvailableCongestionWindow();
 131     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 132         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 133     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 134         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 135   }
 136   SendAvailableCongestionWindow();
 137
 138   // We have now sent our probe.
 139   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
 140       HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
 141
 142   AckNPackets(10);
 143   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
 144   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 145       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 146   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 147       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 148
 149   // We should now have our probe rate.
 150   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
 151   int64 probe_rate = kDefaultMaxPacketSize * 9 * kNumMicrosPerSecond /
 152       acc_arrival_time.ToMicroseconds();
 153   EXPECT_NEAR(0.7f * probe_rate,
 154               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 155   DLOG(INFO) << "After probe";
 156   // Send 50 bursts, make sure that we move fast in the beginning.
 157   for (int i = 0; i < 50; ++i) {
 158     SendAvailableCongestionWindow();
 159     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 160         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 161     send_clock_.AdvanceTime(time_until_send);
 162     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 163         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 164     AckNPackets(2);
 165     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 166   }
 167   EXPECT_NEAR(0.875f * probe_rate,
 168               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 169   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 600, 10);
 170
 171   // Send 50 bursts, make sure that we slow down towards the probe rate.
 172   for (int i = 0; i < 50; ++i) {
 173     SendAvailableCongestionWindow();
 174     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 175         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 176     send_clock_.AdvanceTime(time_until_send);
 177     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 178         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 179     AckNPackets(2);
 180     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 181   }
 182   EXPECT_NEAR(0.95f * probe_rate,
 183               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 184   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 1100, 10);
 185
 186   // Send 50 bursts, make sure that we move very slow close to the probe rate.
 187   for (int i = 0; i < 50; ++i) {
 188     SendAvailableCongestionWindow();
 189     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 190         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 191     send_clock_.AdvanceTime(time_until_send);
 192     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 193         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 194     AckNPackets(2);
 195     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 196   }
 197   EXPECT_NEAR(0.99f * probe_rate,
 198               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 199   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 1560, 10);
 200   DLOG(INFO) << "Near available channel estimate";
 201
 202   // Send 50 bursts, make sure that we move very slow close to the probe rate.
 203   for (int i = 0; i < 50; ++i) {
 204     SendAvailableCongestionWindow();
 205     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 206         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 207     send_clock_.AdvanceTime(time_until_send);
 208     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 209         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 210     AckNPackets(2);
 211     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 212   }
 213   EXPECT_NEAR(1.00f * probe_rate,
 214               sender_.BandwidthEstimate().ToBytesPerSecond(), 2000);
 215   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 2000, 100);
 216   DLOG(INFO) << "At available channel estimate";
 217
 218   // Send 50 bursts, make sure that we move very slow close to the probe rate.
 219   for (int i = 0; i < 50; ++i) {
 220     SendAvailableCongestionWindow();
 221     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 222         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 223     send_clock_.AdvanceTime(time_until_send);
 224     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 225         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 226     AckNPackets(2);
 227     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 228   }
 229   EXPECT_NEAR(1.01f * probe_rate,
 230               sender_.BandwidthEstimate().ToBytesPerSecond(), 2000);
 231   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 2500, 100);
 232
 233   // Send 50 bursts, make sure that we accelerate after the probe rate.
 234   for (int i = 0; i < 50; ++i) {
 235     SendAvailableCongestionWindow();
 236     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 237         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 238     send_clock_.AdvanceTime(time_until_send);
 239     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 240         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 241     AckNPackets(2);
 242     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 243   }
 244   EXPECT_NEAR(1.01f * probe_rate,
 245               sender_.BandwidthEstimate().ToBytesPerSecond(), 2000);
 246   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 2900, 100);
 247
 248   // Send 50 bursts, make sure that we accelerate after the probe rate.
 249   for (int i = 0; i < 50; ++i) {
 250     SendAvailableCongestionWindow();
 251     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 252         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 253     send_clock_.AdvanceTime(time_until_send);
 254     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 255         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 256     AckNPackets(2);
 257     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 258   }
 259   EXPECT_NEAR(1.03f * probe_rate,
 260               sender_.BandwidthEstimate().ToBytesPerSecond(), 2000);
 261   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 3400, 100);
 262
 263   int64 max_rate = kDefaultMaxPacketSize * kNumMicrosPerSecond /
 264       one_ms_.ToMicroseconds();
 265
 266   int64 halfway_rate = probe_rate + (max_rate - probe_rate) / 2;
 267
 268   // Send until we reach halfway point.
 269   for (int i = 0; i < 570; ++i) {
 270     SendAvailableCongestionWindow();
 271     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 272         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 273     send_clock_.AdvanceTime(time_until_send);
 274     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 275         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 276     AckNPackets(2);
 277     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 278   }
 279   EXPECT_NEAR(halfway_rate,
 280               sender_.BandwidthEstimate().ToBytesPerSecond(), 5000);
 281   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 6600, 100);
 282   DLOG(INFO) << "Near halfway point";
 283
 284   // Send until we reach max channel capacity.
 285   for (int i = 0; i < 1500; ++i) {
 286     SendAvailableCongestionWindow();
 287     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 288         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 289     send_clock_.AdvanceTime(time_until_send);
 290     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 291         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 292     AckNPackets(2);
 293     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 294   }
 295   EXPECT_NEAR(max_rate,
 296               sender_.BandwidthEstimate().ToBytesPerSecond(), 5000);
 297   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 10000, 200);
 298 }
 299
 300 TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
 301   QuicCongestionFeedbackFrame feedback;
 302   // At startup make sure we can send.
 303   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 304       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 305
 306   // Send 5 bursts.
 307   for (int i = 0; i < 4; ++i) {
 308     SendAvailableCongestionWindow();
 309     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 310         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 311     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 312         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 313   }
 314   SendAvailableCongestionWindow();
 315
 316   // We have now sent our probe.
 317   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
 318       HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
 319
 320   AckNPackets(10);
 321   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
 322   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 323       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 324   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 325       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 326
 327   // We should now have our probe rate.
 328   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
 329   int64 probe_rate = kDefaultMaxPacketSize * 9 * kNumMicrosPerSecond /
 330       acc_arrival_time.ToMicroseconds();
 331   EXPECT_NEAR(0.7f * probe_rate,
 332               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 333
 334   // Send 50 bursts, make sure that we move fast in the beginning.
 335   for (int i = 0; i < 50; ++i) {
 336     SendAvailableCongestionWindow();
 337     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 338         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 339     send_clock_.AdvanceTime(time_until_send);
 340     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 341         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 342     AckNPackets(2);
 343     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 344   }
 345   EXPECT_NEAR(0.875f * probe_rate,
 346               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 347   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 600, 10);
 348
 349   SendAvailableCongestionWindow();
 350   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 351       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 352   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 353       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 354   AckNPackets(2);
 355
 356   int64 rate_at_introduced_delay_spike = 0.875f * probe_rate;
 357   QuicTime::Delta spike_time = QuicTime::Delta::FromMilliseconds(100);
 358   SendDelaySpikeFeedbackMessage(spike_time);
 359
 360   // Backing as much as we can, currently 90%.
 361   EXPECT_NEAR(0.1f * rate_at_introduced_delay_spike,
 362               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 363   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 610, 10);
 364
 365   // Run until we are catched up after our introduced delay spike.
 366   while (send_clock_.Now() < receive_clock_.Now()) {
 367     SendAvailableCongestionWindow();
 368     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 369         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 370     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 371         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 372     AckNPackets(2);
 373     SendFeedbackMessageNPackets(2, one_ms_, one_ms_);
 374   }
 375   // Expect that we go back to 67% of the rate before the spike.
 376   EXPECT_NEAR(0.67f * rate_at_introduced_delay_spike,
 377               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 378   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 820, 10);
 379
 380   // Send 100 bursts, make sure that we slow down towards the rate we had
 381   // before the spike.
 382   for (int i = 0; i < 100; ++i) {
 383     SendAvailableCongestionWindow();
 384     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 385         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 386     send_clock_.AdvanceTime(time_until_send);
 387     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 388         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 389     AckNPackets(2);
 390     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 391   }
 392   EXPECT_NEAR(0.97f * rate_at_introduced_delay_spike,
 393               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 394   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 2100, 10);
 395 }
 396
 397 TEST_F(InterArrivalSenderTest, DelaySpikeFollowedByImmediateDrain) {
 398   QuicCongestionFeedbackFrame feedback;
 399   // At startup make sure we can send.
 400   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 401       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 402
 403   // Send 5 bursts.
 404   for (int i = 0; i < 4; ++i) {
 405     SendAvailableCongestionWindow();
 406     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 407         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 408     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 409         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 410   }
 411   SendAvailableCongestionWindow();
 412
 413   // We have now sent our probe.
 414   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
 415       HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
 416
 417   AckNPackets(10);
 418   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
 419   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 420       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 421   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 422       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 423
 424   // We should now have our probe rate.
 425   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
 426   int64 probe_rate = kDefaultMaxPacketSize * 9 * kNumMicrosPerSecond /
 427       acc_arrival_time.ToMicroseconds();
 428   EXPECT_NEAR(0.7f * probe_rate,
 429               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 430
 431   // Send 50 bursts, make sure that we move fast in the beginning.
 432   for (int i = 0; i < 50; ++i) {
 433     SendAvailableCongestionWindow();
 434     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 435         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 436     send_clock_.AdvanceTime(time_until_send);
 437     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 438         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 439     AckNPackets(2);
 440     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
 441   }
 442   EXPECT_NEAR(0.875f * probe_rate,
 443               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 444   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 600, 10);
 445
 446   SendAvailableCongestionWindow();
 447   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 448       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 449   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 450       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 451   AckNPackets(2);
 452
 453   int64 rate_at_introduced_delay_spike = 0.875f * probe_rate;
 454   QuicTime::Delta spike_time = QuicTime::Delta::FromMilliseconds(100);
 455   SendDelaySpikeFeedbackMessage(spike_time);
 456
 457   // Backing as much as we can, currently 90%.
 458   EXPECT_NEAR(0.1f * rate_at_introduced_delay_spike,
 459               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 460   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 610, 10);
 461
 462   // Move send time forward.
 463   send_clock_.AdvanceTime(spike_time);
 464   // Make sure our clocks are aligned again.
 465   receive_clock_.AdvanceTime(send_clock_.Now().Subtract(receive_clock_.Now()));
 466
 467   SendAvailableCongestionWindow();
 468   AckNPackets(2);
 469   SendFeedbackMessageNPackets(2, one_ms_, one_ms_);
 470   // We should now be back where we introduced the delay spike.
 471   EXPECT_NEAR(rate_at_introduced_delay_spike,
 472               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 473   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 710, 10);
 474 }
 475
 476 TEST_F(InterArrivalSenderTest, MinBitrateDueToDelay) {
 477   QuicBandwidth expected_min_bitrate = QuicBandwidth::FromKBitsPerSecond(10);
 478   QuicCongestionFeedbackFrame feedback;
 479   // At startup make sure we can send.
 480   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 481       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 482
 483   // Send 5 bursts.
 484   for (int i = 0; i < 4; ++i) {
 485     SendAvailableCongestionWindow();
 486     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 487         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 488     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 489         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 490   }
 491   SendAvailableCongestionWindow();
 492
 493   AckNPackets(10);
 494
 495   // One second spread per packet is expected to result in an estimate at
 496   // our minimum bitrate.
 497   SendFeedbackMessageNPackets(10, one_s_, one_s_);
 498   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 499       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 500   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 501       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 502   EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
 503 }
 504
 505 TEST_F(InterArrivalSenderTest, MinBitrateDueToLoss) {
 506   QuicBandwidth expected_min_bitrate = QuicBandwidth::FromKBitsPerSecond(10);
 507   QuicCongestionFeedbackFrame feedback;
 508   // At startup make sure we can send.
 509   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 510       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 511
 512   // Send 5 bursts.
 513   for (int i = 0; i < 4; ++i) {
 514     SendAvailableCongestionWindow();
 515     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 516         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 517     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 518         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 519   }
 520   SendAvailableCongestionWindow();
 521
 522   AckNPackets(10);
 523   SendFeedbackMessageNPackets(10, nine_ms_, nine_ms_);
 524   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
 525       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 526   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 527       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 528
 529   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(81);
 530   int64 probe_rate = kDefaultMaxPacketSize * 9 * kNumMicrosPerSecond /
 531       acc_arrival_time.ToMicroseconds();
 532   EXPECT_NEAR(0.7f * probe_rate,
 533               sender_.BandwidthEstimate().ToBytesPerSecond(), 1000);
 534
 535   for (int i = 0; i < 15; ++i) {
 536     SendAvailableCongestionWindow();
 537     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 538         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 539     send_clock_.AdvanceTime(time_until_send);
 540     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 541         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 542     sender_.OnIncomingLoss(send_clock_.Now());
 543     sender_.OnIncomingAck(acked_sequence_number_, kDefaultMaxPacketSize, rtt_);
 544     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
 545     SendFeedbackMessageNPackets(2, nine_ms_, nine_ms_);
 546   }
 547   // Test that our exponentail back off stop at expected_min_bitrate.
 548   EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
 549
 550   for (int i = 0; i < 50; ++i) {
 551     SendAvailableCongestionWindow();
 552     QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
 553         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
 554     send_clock_.AdvanceTime(time_until_send);
 555     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
 556         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 557     sender_.OnIncomingLoss(send_clock_.Now());
 558     sender_.OnIncomingAck(acked_sequence_number_, kDefaultMaxPacketSize, rtt_);
 559     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
 560     SendFeedbackMessageNPackets(2, nine_ms_, nine_ms_);
 561
 562     // Make sure our bitrate is fixed at the expected_min_bitrate.
 563     EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
 564   }
 565 }
 566
 567 }  // namespace test
 568 }  // namespace net