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