refactor calculatePacingRate function

Summary:
No need to pass the minimal interval any more since everywhere we just
pass the transportSettings value. Just that inside the function directly

Reviewed By: mjoras

Differential Revision: D16773023

fbshipit-source-id: 22ada4f25d565e97e7fce27371a0e2240bbfe8c0

quic/congestion_control/Bbr.cpp

@@ -273,12 +273,8 @@ void BbrCongestionController::updatePacing() noexcept {
     pacingWindow_ = std::max(pacingWindow_, targetPacingWindow);
   }
   // TODO: slower pacing if we are in STARTUP and loss has happened
-  std::tie(pacingInterval_, pacingBurstSize_) = calculatePacingRate(
+  std::tie(pacingInterval_, pacingBurstSize_) =
-      conn_,
+      calculatePacingRate(conn_, pacingWindow_, kMinCwndInMssForBbr, mrtt);
-      pacingWindow_,
-      kMinCwndInMssForBbr,
-      conn_.transportSettings.pacingTimerTickInterval,
-      mrtt);
 
   if (conn_.transportSettings.pacingEnabled && conn_.qLogger) {
     conn_.qLogger->addPacingMetricUpdate(pacingBurstSize_, pacingInterval_);

quic/congestion_control/CongestionControlFunctions.cpp

@@ -28,9 +28,8 @@ std::pair<std::chrono::microseconds, uint64_t> calculatePacingRate(
     const QuicConnectionStateBase& conn,
     uint64_t cwnd,
     uint64_t minCwndInMss,
-    std::chrono::microseconds minimalInterval,
     std::chrono::microseconds rtt) {
-  if (minimalInterval > rtt) {
+  if (conn.transportSettings.pacingTimerTickInterval > rtt) {
     // We cannot really pace in this case.
     return std::make_pair(
         0us, conn.transportSettings.writeConnectionDataPacketsLimit);
@@ -42,10 +41,12 @@ std::pair<std::chrono::microseconds, uint64_t> calculatePacingRate(
       conn.transportSettings.maxBurstPackets,
       static_cast<uint64_t>(std::ceil(
           static_cast<double>(cwndInPackets) *
-          static_cast<double>(minimalInterval.count()) /
+          static_cast<double>(
+              conn.transportSettings.pacingTimerTickInterval.count()) /
           static_cast<double>(rtt.count()))));
-  auto interval =
+  auto interval = timeMax(
-      timeMax(minimalInterval, rtt * burstPerInterval / cwndInPackets);
+      conn.transportSettings.pacingTimerTickInterval,
+      rtt * burstPerInterval / cwndInPackets);
   return std::make_pair(interval, burstPerInterval);
 }
 } // namespace quic

quic/congestion_control/CongestionControlFunctions.h

@@ -21,12 +21,10 @@ uint64_t boundedCwnd(
     uint64_t maxCwndInMss,
     uint64_t minCwndInMss) noexcept;
 
-// TODO: remove minimalInterval, use transportSettings from conn
 std::pair<std::chrono::microseconds, uint64_t> calculatePacingRate(
     const QuicConnectionStateBase& conn,
     uint64_t cwnd,
     uint64_t minCwndInMss,
-    std::chrono::microseconds minimalInterval,
     std::chrono::microseconds rtt);
 
 template <class T1, class T2>

quic/congestion_control/Copa.cpp

@@ -316,7 +316,6 @@ void Copa::updatePacing() noexcept {
       conn_,
       cwndBytes_ * 2,
       conn_.transportSettings.minCwndInMss,
-      conn_.transportSettings.pacingTimerTickInterval,
       conn_.lossState.srtt);
   if (pacingInterval_ == std::chrono::milliseconds::zero()) {
     return;

quic/congestion_control/QuicCubic.cpp

@@ -541,7 +541,6 @@ void Cubic::updatePacing() noexcept {
       conn_,
       cwndBytes_ * pacingGain(),
       conn_.transportSettings.minCwndInMss,
-      conn_.transportSettings.pacingTimerTickInterval,
       conn_.lossState.srtt);
   if (pacingInterval_ == std::chrono::milliseconds::zero()) {
     return;

quic/congestion_control/test/CongestionControlFunctionsTest.cpp

@@ -23,14 +23,16 @@ class CongestionControlFunctionsTest : public Test {};
 TEST_F(CongestionControlFunctionsTest, CalculatePacingRate) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
   conn.udpSendPacketLen = 1;
+  conn.transportSettings.pacingTimerTickInterval = 10ms;
   std::chrono::microseconds rtt(1000 * 100);
-  auto result = calculatePacingRate(
+  auto result =
-      conn, 50, conn.transportSettings.minCwndInMss, 10ms, rtt);
+      calculatePacingRate(conn, 50, conn.transportSettings.minCwndInMss, rtt);
   EXPECT_EQ(10ms, result.first);
   EXPECT_EQ(5, result.second);
 
-  auto result2 = calculatePacingRate(
+  conn.transportSettings.pacingTimerTickInterval = 1ms;
-      conn, 300, conn.transportSettings.minCwndInMss, 1ms, rtt);
+  auto result2 =
+      calculatePacingRate(conn, 300, conn.transportSettings.minCwndInMss, rtt);
   EXPECT_EQ(1ms, result2.first);
   EXPECT_EQ(3, result2.second);
 }
@@ -38,8 +40,9 @@ TEST_F(CongestionControlFunctionsTest, CalculatePacingRate) {
 TEST_F(CongestionControlFunctionsTest, MinPacingRate) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
   conn.udpSendPacketLen = 1;
+  conn.transportSettings.pacingTimerTickInterval = 1ms;
   auto result = calculatePacingRate(
-      conn, 100, conn.transportSettings.minCwndInMss, 1ms, 100000us);
+      conn, 100, conn.transportSettings.minCwndInMss, 100000us);
   EXPECT_EQ(1ms, result.first);
   EXPECT_EQ(1, result.second);
 }
@@ -47,8 +50,9 @@ TEST_F(CongestionControlFunctionsTest, MinPacingRate) {
 TEST_F(CongestionControlFunctionsTest, SmallCwnd) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
   conn.udpSendPacketLen = 1;
+  conn.transportSettings.pacingTimerTickInterval = 1ms;
   auto result = calculatePacingRate(
-      conn, 10, conn.transportSettings.minCwndInMss, 1ms, 100000us);
+      conn, 10, conn.transportSettings.minCwndInMss, 100000us);
   EXPECT_EQ(10ms, result.first);
   EXPECT_EQ(1, result.second);
 }
@@ -56,8 +60,9 @@ TEST_F(CongestionControlFunctionsTest, SmallCwnd) {
 TEST_F(CongestionControlFunctionsTest, RttSmallerThanInterval) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
   conn.udpSendPacketLen = 1;
-  auto result = calculatePacingRate(
+  conn.transportSettings.pacingTimerTickInterval = 10ms;
-      conn, 10, conn.transportSettings.minCwndInMss, 10ms, 1ms);
+  auto result =
+      calculatePacingRate(conn, 10, conn.transportSettings.minCwndInMss, 1ms);
   EXPECT_EQ(std::chrono::milliseconds::zero(), result.first);
   EXPECT_EQ(
       conn.transportSettings.writeConnectionDataPacketsLimit, result.second);