net/quic/congestion_control/pacing_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/pacing_sender.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "net/quic/quic_protocol.h"
  10 #include "net/quic/test_tools/mock_clock.h"
  11 #include "net/quic/test_tools/quic_test_utils.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using testing::Return;
  15 using testing::StrictMock;
  16 using testing::_;
  17
  18 namespace net {
  19 namespace test {
  20
  21 const QuicByteCount kBytesInFlight = 1024;
  22 const int kInitialBurstPackets = 10;
  23
  24 class PacingSenderTest : public ::testing::Test {
  25  protected:
  26   PacingSenderTest()
  27       : zero_time_(QuicTime::Delta::Zero()),
  28         infinite_time_(QuicTime::Delta::Infinite()),
  29         sequence_number_(1),
  30         mock_sender_(new StrictMock<MockSendAlgorithm>()),
  31         pacing_sender_(new PacingSender(mock_sender_,
  32                                         QuicTime::Delta::FromMilliseconds(1),
  33                                         0)) {
  34     // Pick arbitrary time.
  35     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(9));
  36   }
  37
  38   ~PacingSenderTest() override {}
  39
  40   void InitPacingRate(QuicPacketCount burst_size, QuicBandwidth bandwidth) {
  41     pacing_sender_.reset();
  42     mock_sender_ = new StrictMock<MockSendAlgorithm>();
  43     pacing_sender_.reset(new PacingSender(
  44         mock_sender_, QuicTime::Delta::FromMilliseconds(1), burst_size));
  45     EXPECT_CALL(*mock_sender_, PacingRate()).WillRepeatedly(Return(bandwidth));
  46   }
  47
  48   void CheckPacketIsSentImmediately(HasRetransmittableData retransmittable_data,
  49                                     QuicByteCount bytes_in_flight) {
  50     // In order for the packet to be sendable, the underlying sender must
  51     // permit it to be sent immediately.
  52     for (int i = 0; i < 2; ++i) {
  53       EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), bytes_in_flight,
  54                                                retransmittable_data))
  55           .WillOnce(Return(zero_time_));
  56       // Verify that the packet can be sent immediately.
  57       EXPECT_EQ(zero_time_,
  58                 pacing_sender_->TimeUntilSend(clock_.Now(), bytes_in_flight,
  59                                               retransmittable_data));
  60     }
  61
  62     // Actually send the packet.
  63     EXPECT_CALL(*mock_sender_,
  64                 OnPacketSent(clock_.Now(), bytes_in_flight, sequence_number_,
  65                              kMaxPacketSize, retransmittable_data));
  66     pacing_sender_->OnPacketSent(clock_.Now(), bytes_in_flight,
  67                                  sequence_number_++, kMaxPacketSize,
  68                                  retransmittable_data);
  69   }
  70
  71   void CheckPacketIsSentImmediately() {
  72     CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA, kBytesInFlight);
  73   }
  74
  75   void CheckAckIsSentImmediately() {
  76     CheckPacketIsSentImmediately(NO_RETRANSMITTABLE_DATA, kBytesInFlight);
  77   }
  78
  79   void CheckPacketIsDelayed(QuicTime::Delta delay) {
  80     // In order for the packet to be sendable, the underlying sender must
  81     // permit it to be sent immediately.
  82     for (int i = 0; i < 2; ++i) {
  83       EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
  84                                                kBytesInFlight,
  85                                                HAS_RETRANSMITTABLE_DATA))
  86           .WillOnce(Return(zero_time_));
  87       // Verify that the packet is delayed.
  88       EXPECT_EQ(delay.ToMicroseconds(),
  89                 pacing_sender_->TimeUntilSend(
  90                     clock_.Now(), kBytesInFlight,
  91                     HAS_RETRANSMITTABLE_DATA).ToMicroseconds());
  92     }
  93   }
  94
  95   void UpdateRtt() {
  96     EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
  97     SendAlgorithmInterface::CongestionVector empty_map;
  98     pacing_sender_->OnCongestionEvent(true, kBytesInFlight, empty_map,
  99                                       empty_map);
 100   }
 101
 102   const QuicTime::Delta zero_time_;
 103   const QuicTime::Delta infinite_time_;
 104   MockClock clock_;
 105   QuicPacketSequenceNumber sequence_number_;
 106   StrictMock<MockSendAlgorithm>* mock_sender_;
 107   scoped_ptr<PacingSender> pacing_sender_;
 108 };
 109
 110 TEST_F(PacingSenderTest, NoSend) {
 111   for (int i = 0; i < 2; ++i) {
 112     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
 113                                              kBytesInFlight,
 114                                              HAS_RETRANSMITTABLE_DATA))
 115         .WillOnce(Return(infinite_time_));
 116     EXPECT_EQ(infinite_time_,
 117               pacing_sender_->TimeUntilSend(clock_.Now(),
 118                                             kBytesInFlight,
 119                                             HAS_RETRANSMITTABLE_DATA));
 120   }
 121 }
 122
 123 TEST_F(PacingSenderTest, SendNow) {
 124   for (int i = 0; i < 2; ++i) {
 125     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
 126                                              kBytesInFlight,
 127                                              HAS_RETRANSMITTABLE_DATA))
 128         .WillOnce(Return(zero_time_));
 129     EXPECT_EQ(zero_time_,
 130               pacing_sender_->TimeUntilSend(clock_.Now(),
 131                                             kBytesInFlight,
 132                                             HAS_RETRANSMITTABLE_DATA));
 133   }
 134 }
 135
 136 TEST_F(PacingSenderTest, VariousSending) {
 137   // Configure pacing rate of 1 packet per 1 ms, no initial burst.
 138   InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
 139                         kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 140
 141   // Now update the RTT and verify that packets are actually paced.
 142   UpdateRtt();
 143
 144   CheckPacketIsSentImmediately();
 145   CheckPacketIsSentImmediately();
 146
 147   // The first packet was a "make up", then we sent two packets "into the
 148   // future", so the delay should be 2.
 149   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 150
 151   // Wake up on time.
 152   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
 153   CheckPacketIsSentImmediately();
 154   CheckPacketIsSentImmediately();
 155   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 156   CheckAckIsSentImmediately();
 157
 158   // Wake up late.
 159   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(4));
 160   CheckPacketIsSentImmediately();
 161   CheckPacketIsSentImmediately();
 162   CheckPacketIsSentImmediately();
 163   CheckPacketIsSentImmediately();
 164   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 165
 166   // Wake up really late.
 167   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(8));
 168   CheckPacketIsSentImmediately();
 169   CheckPacketIsSentImmediately();
 170   CheckPacketIsSentImmediately();
 171   CheckPacketIsSentImmediately();
 172   CheckPacketIsSentImmediately();
 173   CheckPacketIsSentImmediately();
 174   CheckPacketIsSentImmediately();
 175   CheckPacketIsSentImmediately();
 176   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 177
 178   // Wake up really late again, but application pause partway through.
 179   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(8));
 180   CheckPacketIsSentImmediately();
 181   CheckPacketIsSentImmediately();
 182   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(100));
 183   CheckPacketIsSentImmediately();
 184   CheckPacketIsSentImmediately();
 185   CheckPacketIsSentImmediately();
 186   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 187
 188   // Wake up too early.
 189   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 190
 191   // Wake up early, but after enough time has passed to permit a send.
 192   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
 193   CheckPacketIsSentImmediately();
 194   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 195 }
 196
 197 TEST_F(PacingSenderTest, InitialBurst) {
 198   // Configure pacing rate of 1 packet per 1 ms.
 199   InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
 200                          kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 201
 202   // Update the RTT and verify that the first 10 packets aren't paced.
 203   UpdateRtt();
 204
 205   // Send 10 packets, and verify that they are not paced.
 206   for (int i = 0 ; i < kInitialBurstPackets; ++i) {
 207     CheckPacketIsSentImmediately();
 208   }
 209
 210   // The first packet was a "make up", then we sent two packets "into the
 211   // future", so the delay should be 2ms.
 212   CheckPacketIsSentImmediately();
 213   CheckPacketIsSentImmediately();
 214   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 215
 216   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
 217   CheckPacketIsSentImmediately();
 218
 219   // Next time TimeUntilSend is called with no bytes in flight, pacing should
 220   // allow a packet to be sent, and when it's sent, the tokens are refilled.
 221   CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA, 0);
 222   for (int i = 0; i < kInitialBurstPackets - 1; ++i) {
 223     CheckPacketIsSentImmediately();
 224   }
 225
 226   // The first packet was a "make up", then we sent two packets "into the
 227   // future", so the delay should be 2ms.
 228   CheckPacketIsSentImmediately();
 229   CheckPacketIsSentImmediately();
 230   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 231 }
 232
 233 TEST_F(PacingSenderTest, InitialBurstNoRttMeasurement) {
 234   // Configure pacing rate of 1 packet per 1 ms.
 235   InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
 236                          kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 237
 238   // Send 10 packets, and verify that they are not paced.
 239   for (int i = 0 ; i < kInitialBurstPackets; ++i) {
 240     CheckPacketIsSentImmediately();
 241   }
 242
 243   // The first packet was a "make up", then we sent two packets "into the
 244   // future", so the delay should be 2ms.
 245   CheckPacketIsSentImmediately();
 246   CheckPacketIsSentImmediately();
 247   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 248
 249
 250   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
 251   CheckPacketIsSentImmediately();
 252
 253   // Next time TimeUntilSend is called with no bytes in flight, the tokens
 254   // should be refilled and there should be no delay.
 255   CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA, 0);
 256   // Send 10 packets, and verify that they are not paced.
 257   for (int i = 0; i < kInitialBurstPackets - 1; ++i) {
 258     CheckPacketIsSentImmediately();
 259   }
 260
 261   // The first packet was a "make up", then we sent two packets "into the
 262   // future", so the delay should be 2ms.
 263   CheckPacketIsSentImmediately();
 264   CheckPacketIsSentImmediately();
 265   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 266 }
 267
 268 TEST_F(PacingSenderTest, FastSending) {
 269   // Ensure the pacing sender paces, even when the inter-packet spacing is less
 270   // than the pacing granularity.
 271   InitPacingRate(10,
 272                  QuicBandwidth::FromBytesAndTimeDelta(
 273                      2 * kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 274
 275   // Update the RTT and verify that the first 10 packets aren't paced.
 276   UpdateRtt();
 277
 278   // Send 10 packets, and verify that they are not paced.
 279   for (int i = 0; i < kInitialBurstPackets; ++i) {
 280     CheckPacketIsSentImmediately();
 281   }
 282
 283   // The first packet was a "make up", then we sent two packets "into the
 284   // future", since it's 2 packets/ms, so the delay should be 1.5ms.
 285   CheckPacketIsSentImmediately();
 286   CheckPacketIsSentImmediately();
 287   CheckPacketIsSentImmediately();
 288   CheckPacketIsDelayed(QuicTime::Delta::FromMicroseconds(1500));
 289
 290   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
 291   CheckPacketIsSentImmediately();
 292
 293   // Next time TimeUntilSend is called with no bytes in flight, the tokens
 294   // should be refilled and there should be no delay.
 295   CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA, 0);
 296   for (int i = 0; i < kInitialBurstPackets - 1; ++i) {
 297     CheckPacketIsSentImmediately();
 298   }
 299
 300   // The first packet was a "make up", then we sent two packets "into the
 301   // future", so the delay should be 1.5ms.
 302   CheckPacketIsSentImmediately();
 303   CheckPacketIsSentImmediately();
 304   CheckPacketIsSentImmediately();
 305   CheckPacketIsDelayed(QuicTime::Delta::FromMicroseconds(1500));
 306 }
 307
 308 }  // namespace test
 309 }  // namespace net