relnote: Use event_time instead of ApproximateNow() in QUIC cubic code. Protected by --quic_use_eve…

net/quic/core/congestion_control/cubic_bytes_test.cc

 // Copyright (c) 2015 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/cubic_bytes.h"
 
 #include <cstdint>
 
 #include "base/logging.h"
 #include "net/quic/core/quic_flags.h"
@@ skipping 65 matching lines @@
   // Convex growth.
   const QuicTime::Delta rtt_min = hundred_ms_;
   int64_t rtt_min_ms = rtt_min.ToMilliseconds();
   float rtt_min_s = rtt_min_ms / 1000.0;
   QuicByteCount current_cwnd = 10 * kDefaultTCPMSS;
   const QuicByteCount initial_cwnd = current_cwnd;
 
   clock_.AdvanceTime(one_ms_);
   const QuicTime initial_time = clock_.ApproximateNow();
   const QuicByteCount expected_first_cwnd = RenoCwndInBytes(current_cwnd);
-  current_cwnd =
-      cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+  current_cwnd = cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd,
+                                                 rtt_min, initial_time);
   ASSERT_EQ(expected_first_cwnd, current_cwnd);
 
   // Normal TCP phase.
   // The maximum number of expected Reno RTTs is calculated by
   // finding the point where the cubic curve and the reno curve meet.
   const int max_reno_rtts =
       FLAGS_quic_fix_cubic_bytes_quantization
           ? std::sqrt(kNConnectionAlpha /
                       (.4 * rtt_min_s * rtt_min_s * rtt_min_s)) -
                 2
           : std::sqrt(kNConnectionAlpha /
                       (.4 * rtt_min_s * rtt_min_s * rtt_min_s)) -
                 1;
   for (int i = 0; i < max_reno_rtts; ++i) {
     // Alternatively, we expect it to increase by one, every time we
     // receive current_cwnd/Alpha acks back.  (This is another way of
     // saying we expect cwnd to increase by approximately Alpha once
     // we receive current_cwnd number ofacks back).
     const uint64_t num_acks_this_epoch =
         current_cwnd / kDefaultTCPMSS / kNConnectionAlpha;
     const QuicByteCount initial_cwnd_this_epoch = current_cwnd;
     for (QuicPacketCount n = 0; n < num_acks_this_epoch; ++n) {
       // Call once per ACK.
       const QuicByteCount expected_next_cwnd = RenoCwndInBytes(current_cwnd);
-      current_cwnd = cubic_.CongestionWindowAfterAck(kDefaultTCPMSS,
-                                                     current_cwnd, rtt_min);
+      current_cwnd = cubic_.CongestionWindowAfterAck(
+          kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
       ASSERT_EQ(expected_next_cwnd, current_cwnd);
     }
     // Our byte-wise Reno implementation is an estimate.  We expect
     // the cwnd to increase by approximately one MSS every
     // cwnd/kDefaultTCPMSS/Alpha acks, but it may be off by as much as
     // half a packet for smaller values of current_cwnd.
     const QuicByteCount cwnd_change_this_epoch =
         current_cwnd - initial_cwnd_this_epoch;
     ASSERT_NEAR(kDefaultTCPMSS, cwnd_change_this_epoch, kDefaultTCPMSS / 2);
     clock_.AdvanceTime(hundred_ms_);
   }
 
   if (!FLAGS_quic_fix_cubic_bytes_quantization) {
     // Because our byte-wise Reno under-estimates the cwnd, we switch to
     // conservative increases for a few acks before switching to true
     // cubic increases.
     for (int i = 0; i < 3; ++i) {
       const QuicByteCount next_expected_cwnd =
           ConservativeCwndInBytes(current_cwnd);
-      current_cwnd = cubic_.CongestionWindowAfterAck(kDefaultTCPMSS,
-                                                     current_cwnd, rtt_min);
+      current_cwnd = cubic_.CongestionWindowAfterAck(
+          kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
       ASSERT_EQ(next_expected_cwnd, current_cwnd);
     }
   }
 
   for (int i = 0; i < 54; ++i) {
     const uint64_t max_acks_this_epoch = current_cwnd / kDefaultTCPMSS;
     const QuicByteCount expected_cwnd = CubicConvexCwndInBytes(
         initial_cwnd, rtt_min, (clock_.ApproximateNow() - initial_time));
-    current_cwnd =
-        cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+    current_cwnd = cubic_.CongestionWindowAfterAck(
+        kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
     ASSERT_EQ(expected_cwnd, current_cwnd);
 
     for (QuicPacketCount n = 1; n < max_acks_this_epoch; ++n) {
       // Call once per ACK.
-      ASSERT_EQ(current_cwnd, cubic_.CongestionWindowAfterAck(
-                                  kDefaultTCPMSS, current_cwnd, rtt_min));
+      ASSERT_EQ(
+          current_cwnd,
+          cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min,
+                                          clock_.ApproximateNow()));
     }
     clock_.AdvanceTime(hundred_ms_);
   }
   const QuicByteCount expected_cwnd = CubicConvexCwndInBytes(
       initial_cwnd, rtt_min, (clock_.ApproximateNow() - initial_time));
-  current_cwnd =
-      cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+  current_cwnd = cubic_.CongestionWindowAfterAck(
+      kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
   ASSERT_EQ(expected_cwnd, current_cwnd);
 }
 
 TEST_F(CubicBytesTest, AboveOrigin) {
   if (!FLAGS_quic_fix_cubic_convex_mode &&
       FLAGS_quic_fix_cubic_bytes_quantization) {
     // Without convex mode fixed, the behavior of the algorithm does
     // not fit the exact pattern of this test.
     // TODO(jokulik): Once the convex mode fix becomes default, this
     // test can be replaced with the better AboveOriginTighterBounds
     // test.
     return;
   }
   // Convex growth.
   const QuicTime::Delta rtt_min = hundred_ms_;
   QuicByteCount current_cwnd = 10 * kDefaultTCPMSS;
   // Without the signed-integer, cubic-convex fix, we start out in the
   // wrong mode.
   QuicPacketCount expected_cwnd =
       FLAGS_quic_fix_cubic_convex_mode
           ? RenoCwndInBytes(current_cwnd)
           : ConservativeCwndInBytes(current_cwnd);
   // Initialize the state.
   clock_.AdvanceTime(one_ms_);
-  ASSERT_EQ(expected_cwnd, cubic_.CongestionWindowAfterAck(
-                               kDefaultTCPMSS, current_cwnd, rtt_min));
+  ASSERT_EQ(expected_cwnd,
+            cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd,
+                                            rtt_min, clock_.ApproximateNow()));
   current_cwnd = expected_cwnd;
   const QuicPacketCount initial_cwnd = expected_cwnd;
   // Normal TCP phase.
   for (int i = 0; i < 48; ++i) {
     for (QuicPacketCount n = 1;
          n < current_cwnd / kDefaultTCPMSS / kNConnectionAlpha; ++n) {
       // Call once per ACK.
-      ASSERT_NEAR(current_cwnd, cubic_.CongestionWindowAfterAck(
-                                    kDefaultTCPMSS, current_cwnd, rtt_min),
-                  kDefaultTCPMSS);
+      ASSERT_NEAR(
+          current_cwnd,
+          cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min,
+                                          clock_.ApproximateNow()),
+          kDefaultTCPMSS);
     }
     clock_.AdvanceTime(hundred_ms_);
-    current_cwnd =
-        cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+    current_cwnd = cubic_.CongestionWindowAfterAck(
+        kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
     if (FLAGS_quic_fix_cubic_convex_mode) {
       // When we fix convex mode and the uint64 arithmetic, we
       // increase the expected_cwnd only after after the first 100ms,
       // rather than after the initial 1ms.
       expected_cwnd += kDefaultTCPMSS;
       ASSERT_NEAR(expected_cwnd, current_cwnd, kDefaultTCPMSS);
     } else {
       ASSERT_NEAR(expected_cwnd, current_cwnd, kDefaultTCPMSS);
       expected_cwnd += kDefaultTCPMSS;
     }
   }
   // Cubic phase.
   for (int i = 0; i < 52; ++i) {
     for (QuicPacketCount n = 1; n < current_cwnd / kDefaultTCPMSS; ++n) {
       // Call once per ACK.
-      ASSERT_NEAR(current_cwnd, cubic_.CongestionWindowAfterAck(
-                                    kDefaultTCPMSS, current_cwnd, rtt_min),
-                  kDefaultTCPMSS);
+      ASSERT_NEAR(
+          current_cwnd,
+          cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min,
+                                          clock_.ApproximateNow()),
+          kDefaultTCPMSS);
     }
     clock_.AdvanceTime(hundred_ms_);
-    current_cwnd =
-        cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+    current_cwnd = cubic_.CongestionWindowAfterAck(
+        kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
   }
   // Total time elapsed so far; add min_rtt (0.1s) here as well.
   float elapsed_time_s = 10.0f + 0.1f;
   // |expected_cwnd| is initial value of cwnd + K * t^3, where K = 0.4.
   expected_cwnd =
       initial_cwnd / kDefaultTCPMSS +
       (elapsed_time_s * elapsed_time_s * elapsed_time_s * 410) / 1024;
   // Without the convex mode fix, the result is off by one.
   if (!FLAGS_quic_fix_cubic_convex_mode) {
     ++expected_cwnd;
@@ skipping 19 matching lines @@
 
   // Start the test with an artificially large cwnd to prevent Reno
   // from over-taking cubic.
   QuicByteCount current_cwnd = 1000 * kDefaultTCPMSS;
   const QuicByteCount initial_cwnd = current_cwnd;
   const QuicTime::Delta rtt_min = hundred_ms_;
   clock_.AdvanceTime(one_ms_);
   QuicTime initial_time = clock_.ApproximateNow();
 
   // Start the epoch and then artificially advance the time.
-  current_cwnd =
-      cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+  current_cwnd = cubic_.CongestionWindowAfterAck(
+      kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(600));
-  current_cwnd =
-      cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+  current_cwnd = cubic_.CongestionWindowAfterAck(
+      kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
 
   // We expect the algorithm to perform only non-zero, fine-grained cubic
   // increases on every ack in this case.
   for (int i = 0; i < 100; ++i) {
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
     const QuicByteCount expected_cwnd = CubicConvexCwndInBytes(
         initial_cwnd, rtt_min, (clock_.ApproximateNow() - initial_time));
-    const QuicByteCount next_cwnd =
-        cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+    const QuicByteCount next_cwnd = cubic_.CongestionWindowAfterAck(
+        kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
     // Make sure we are performing cubic increases.
     ASSERT_EQ(expected_cwnd, next_cwnd);
     // Make sure that these are non-zero, less-than-packet sized
     // increases.
     ASSERT_GT(next_cwnd, current_cwnd);
     const QuicByteCount cwnd_delta = next_cwnd - current_cwnd;
     ASSERT_GT(kDefaultTCPMSS * .1, cwnd_delta);
 
     current_cwnd = next_cwnd;
   }
 }
 
 TEST_F(CubicBytesTest, LossEvents) {
   const QuicTime::Delta rtt_min = hundred_ms_;
   QuicByteCount current_cwnd = 422 * kDefaultTCPMSS;
   // Without the signed-integer, cubic-convex fix, we mistakenly
   // increment cwnd after only one_ms_ and a single ack.
   QuicPacketCount expected_cwnd =
       FLAGS_quic_fix_cubic_convex_mode
           ? RenoCwndInBytes(current_cwnd)
           : current_cwnd + kDefaultTCPMSS / 2;
   // Initialize the state.
   clock_.AdvanceTime(one_ms_);
-  EXPECT_EQ(expected_cwnd, cubic_.CongestionWindowAfterAck(
-                               kDefaultTCPMSS, current_cwnd, rtt_min));
+  EXPECT_EQ(expected_cwnd,
+            cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd,
+                                            rtt_min, clock_.ApproximateNow()));
   expected_cwnd = static_cast<QuicPacketCount>(current_cwnd * kNConnectionBeta);
   EXPECT_EQ(expected_cwnd,
             cubic_.CongestionWindowAfterPacketLoss(current_cwnd));
   expected_cwnd = static_cast<QuicPacketCount>(current_cwnd * kNConnectionBeta);
   EXPECT_EQ(expected_cwnd,
             cubic_.CongestionWindowAfterPacketLoss(current_cwnd));
 }
 
 TEST_F(CubicBytesTest, BelowOrigin) {
   // Concave growth.
   const QuicTime::Delta rtt_min = hundred_ms_;
   QuicByteCount current_cwnd = 422 * kDefaultTCPMSS;
   // Without the signed-integer, cubic-convex fix, we mistakenly
   // increment cwnd after only one_ms_ and a single ack.
   QuicPacketCount expected_cwnd =
       FLAGS_quic_fix_cubic_convex_mode
           ? RenoCwndInBytes(current_cwnd)
           : current_cwnd + kDefaultTCPMSS / 2;
   // Initialize the state.
   clock_.AdvanceTime(one_ms_);
-  EXPECT_EQ(expected_cwnd, cubic_.CongestionWindowAfterAck(
-                               kDefaultTCPMSS, current_cwnd, rtt_min));
+  EXPECT_EQ(expected_cwnd,
+            cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd,
+                                            rtt_min, clock_.ApproximateNow()));
   expected_cwnd = static_cast<QuicPacketCount>(current_cwnd * kNConnectionBeta);
   EXPECT_EQ(expected_cwnd,
             cubic_.CongestionWindowAfterPacketLoss(current_cwnd));
   current_cwnd = expected_cwnd;
   // First update after loss to initialize the epoch.
-  current_cwnd =
-      cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+  current_cwnd = cubic_.CongestionWindowAfterAck(
+      kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
   // Cubic phase.
   for (int i = 0; i < 40; ++i) {
     clock_.AdvanceTime(hundred_ms_);
-    current_cwnd =
-        cubic_.CongestionWindowAfterAck(kDefaultTCPMSS, current_cwnd, rtt_min);
+    current_cwnd = cubic_.CongestionWindowAfterAck(
+        kDefaultTCPMSS, current_cwnd, rtt_min, clock_.ApproximateNow());
   }
   expected_cwnd = 553632;
   EXPECT_EQ(expected_cwnd, current_cwnd);
 }
 
 }  // namespace test
 }  // namespace net