From b4baf99a14f21352ac9fa0df5adbafd9ad0de9ba Mon Sep 17 00:00:00 2001 From: Lin Huang Date: Tue, 16 Jul 2019 00:22:26 -0700 Subject: [PATCH] Move xplat/quic from autosyncer to dirsync Summary: * remove quic from autosyncer * set up dirsync for quic * mirror source file for xplat/quic fbcode/quic Reviewed By: JunqiWang Differential Revision: D16254573 fbshipit-source-id: 24414d275de310b5d0cf6bb2702a203e5aed260c --- .../test/BbrBandwidthSamplerTest.cpp | 22 +----- quic/congestion_control/test/BbrTest.cpp | 56 +------------ quic/congestion_control/test/CopaTest.cpp | 67 ---------------- .../test/CubicStateTest.cpp | 21 +---- quic/congestion_control/test/CubicTest.cpp | 79 ------------------- quic/logging/FileQLogger.cpp | 10 --- quic/logging/FileQLogger.h | 5 +- quic/logging/test/QLoggerTest.cpp | 42 +--------- 8 files changed, 9 insertions(+), 293 deletions(-) diff --git a/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp b/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp index 8f4fe5d0d..1e2411988 100644 --- a/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp +++ b/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp @@ -122,35 +122,17 @@ TEST_F(BbrBandwidthSamplerTest, SampleExpiration) { TEST_F(BbrBandwidthSamplerTest, AppLimited) { QuicConnectionStateBase conn(QuicNodeType::Client); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; - BbrBandwidthSampler sampler(conn); EXPECT_FALSE(sampler.isAppLimited()); sampler.onAppLimited(); EXPECT_TRUE(sampler.isAppLimited()); CongestionController::AckEvent ackEvent; ackEvent.largestAckedPacket = ++conn.lossState.largestSent; - auto packet = - makeTestingWritePacket(*ackEvent.largestAckedPacket, 1000, 1000, false); + auto packet = makeTestingWritePacket( + *ackEvent.largestAckedPacket, 1000, 1000, false); ackEvent.ackedPackets.push_back(std::move(packet)); sampler.onPacketAcked(ackEvent, 0); EXPECT_FALSE(sampler.isAppLimited()); - - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 2); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, 0); - EXPECT_EQ(event->currentCwnd, 0); - EXPECT_EQ(event->congestionEvent, kCongestionAppLimited.str()); - - auto tmp2 = std::move(qLogger->logs[indices[1]]); - auto event2 = dynamic_cast(tmp2.get()); - EXPECT_EQ(event2->bytesInFlight, 0); - EXPECT_EQ(event2->currentCwnd, 0); - EXPECT_EQ(event2->congestionEvent, kCongestionAppUnlimited.str()); } TEST_F(BbrBandwidthSamplerTest, AppLimitedOutstandingPacket) { diff --git a/quic/congestion_control/test/BbrTest.cpp b/quic/congestion_control/test/BbrTest.cpp index 8ceefd37b..54ebf48b8 100644 --- a/quic/congestion_control/test/BbrTest.cpp +++ b/quic/congestion_control/test/BbrTest.cpp @@ -66,8 +66,6 @@ TEST_F(BbrTest, InitStates) { TEST_F(BbrTest, Recovery) { QuicConnectionStateBase conn(QuicNodeType::Client); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; conn.udpSendPacketLen = 1000; BbrCongestionController::BbrConfig config; conn.transportSettings.initCwndInMss = 500; // Make a really large initCwnd @@ -93,22 +91,6 @@ TEST_F(BbrTest, Recovery) { EXPECT_TRUE(bbr.inRecovery()); EXPECT_EQ(expectedRecoveryWindow, bbr.getCongestionWindow()); - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 1); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, inflightBytes); - EXPECT_EQ(event->currentCwnd, 449900); - EXPECT_EQ(event->congestionEvent, kCongestionPacketAck); - EXPECT_EQ( - event->state, - bbrStateToString(BbrCongestionController::BbrState::Startup)); - EXPECT_EQ( - event->recoveryState, - bbrRecoveryStateToString( - BbrCongestionController::RecoveryState::CONSERVATIVE)); - // Sleep 1ms to make next now() a bit far from previous now(). std::this_thread::sleep_for(1ms); @@ -427,8 +409,6 @@ TEST_F(BbrTest, NoLargestAckedPacketNoCrash) { TEST_F(BbrTest, AckAggregation) { QuicConnectionStateBase conn(QuicNodeType::Client); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; conn.udpSendPacketLen = 1000; BbrCongestionController::BbrConfig config; BbrCongestionController bbr(conn, config); @@ -466,23 +446,6 @@ TEST_F(BbrTest, AckAggregation) { }; sendAckGrow(true); - - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 1); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, 0); - EXPECT_EQ(event->currentCwnd, bbr.getCongestionWindow()); - EXPECT_EQ(event->congestionEvent, kCongestionPacketAck); - EXPECT_EQ( - event->state, - bbrStateToString(BbrCongestionController::BbrState::Startup)); - EXPECT_EQ( - event->recoveryState, - bbrRecoveryStateToString( - BbrCongestionController::RecoveryState::NOT_RECOVERY)); - // kStartupSlowGrowRoundLimit consecutive slow growth to leave Startup for (int i = 0; i <= kStartupSlowGrowRoundLimit; i++) { sendAckGrow(false); @@ -600,10 +563,6 @@ TEST_F(BbrTest, Pacing) { conn.udpSendPacketLen = 1000; conn.transportSettings.maxBurstPackets = std::numeric_limits::max(); - conn.transportSettings.pacingEnabled = true; - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; - BbrCongestionController::BbrConfig config; BbrCongestionController bbr(conn, config); bbr.setMinimalPacingInterval(1ms); @@ -661,22 +620,9 @@ TEST_F(BbrTest, Pacing) { }; // Take it to ProbeBw first - std::vector pacingRateVec; - for (uint32_t i = 0; i < kStartupSlowGrowRoundLimit + 2; i++) { + for (size_t i = 0; i < kStartupSlowGrowRoundLimit + 2; i++) { sendAckGrow(Clock::now()); - pacingRateVec.push_back(bbr.getPacingRate(Clock::now())); } - - std::vector indices = - getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), kStartupSlowGrowRoundLimit + 2); - for (uint32_t i = 0; i < kStartupSlowGrowRoundLimit + 2; i++) { - auto tmp = std::move(qLogger->logs[indices[i]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->pacingBurstSize, pacingRateVec[i]); - EXPECT_EQ(event->pacingInterval, bbr.getPacingInterval()); - } - for (size_t i = 0; i < 5; i++) { sendFunc(); } diff --git a/quic/congestion_control/test/CopaTest.cpp b/quic/congestion_control/test/CopaTest.cpp index 78eb9b44e..6616fba51 100644 --- a/quic/congestion_control/test/CopaTest.cpp +++ b/quic/congestion_control/test/CopaTest.cpp @@ -145,8 +145,6 @@ TEST_F(CopaTest, TestWritableBytes) { TEST_F(CopaTest, PersistentCongestion) { QuicServerConnectionState conn; Copa copa(conn); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; EXPECT_TRUE(copa.inSlowStart()); conn.lossState.largestSent = 5; @@ -154,16 +152,6 @@ TEST_F(CopaTest, PersistentCongestion) { uint32_t ackedSize = 10; auto pkt = createPacket(ackPacketNum, ackedSize, ackedSize); copa.onPacketSent(pkt); - - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 1); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, 10); - EXPECT_EQ(event->currentCwnd, kDefaultCwnd); - EXPECT_EQ(event->congestionEvent, kCongestionPacketSent.str()); - CongestionController::LossEvent loss; loss.persistentCongestion = true; loss.addLostPacket(pkt); @@ -177,8 +165,6 @@ TEST_F(CopaTest, PersistentCongestion) { TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) { QuicServerConnectionState conn; Copa copa(conn); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; EXPECT_TRUE(copa.inSlowStart()); auto originalWritableBytes = copa.getWritableBytes(); @@ -188,28 +174,11 @@ TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) { copa.onPacketSent(createPacket(ackPacketNum, ackedSize, ackedSize)); copa.onRemoveBytesFromInflight(2); EXPECT_EQ(copa.getWritableBytes(), originalWritableBytes - ackedSize + 2); - - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 2); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, ackedSize); - EXPECT_EQ(event->currentCwnd, kDefaultCwnd); - EXPECT_EQ(event->congestionEvent, kCongestionPacketSent.str()); - - auto tmp2 = std::move(qLogger->logs[indices[1]]); - auto event2 = dynamic_cast(tmp2.get()); - EXPECT_EQ(event2->bytesInFlight, ackedSize - 2); - EXPECT_EQ(event2->currentCwnd, kDefaultCwnd); - EXPECT_EQ(event2->congestionEvent, kRemoveInflight.str()); } TEST_F(CopaTest, TestSlowStartAck) { QuicServerConnectionState conn; Copa copa(conn); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; EXPECT_TRUE(copa.inSlowStart()); // initial cwnd = 10 packets EXPECT_EQ( @@ -244,15 +213,6 @@ TEST_F(CopaTest, TestSlowStartAck) { numPacketsInFlight--; EXPECT_EQ(copa.getBytesInFlight(), numPacketsInFlight * packetSize); - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 11); // mostly congestionPacketSent logs - auto tmp = std::move(qLogger->logs[indices[10]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, copa.getBytesInFlight()); - EXPECT_EQ(event->currentCwnd, kDefaultCwnd); - EXPECT_EQ(event->congestionEvent, kCongestionPacketAck.str()); - now += 50ms; packetNumToAck++; @@ -345,11 +305,6 @@ TEST_F(CopaTest, TestSteadyStateChanges) { TEST_F(CopaTest, TestVelocity) { QuicServerConnectionState conn; Copa copa(conn); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; - conn.transportSettings.pacingEnabled = true; - copa.setMinimalPacingInterval(10ms); - // lastCwnd = 9.8 packets auto now = Clock::now(); auto lastCwnd = exitSlowStart(copa, conn, now); @@ -364,23 +319,12 @@ TEST_F(CopaTest, TestVelocity) { now += 100ms; // velocity = 1, direction = 0 copa.onPacketAckOrLoss(createAckEvent(30, packetSize, now), folly::none); - auto logNow = Clock::now(); - uint64_t cwndChange = cwndChangeSteadyState(lastCwnd, velocity, packetSize, 0.5, conn); // cwnd = 9.8 + 1 / (0.5 * 9.8) = 10 packets EXPECT_EQ(copa.getCongestionWindow(), lastCwnd + cwndChange); lastCwnd = copa.getCongestionWindow(); - std::vector indices = - getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 3); - - auto tmp = std::move(qLogger->logs[indices[2]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->pacingBurstSize, copa.getPacingRate(logNow)); - EXPECT_EQ(event->pacingInterval, copa.getPacingInterval()); - // another ack, velocity = 1, direction 0 -> 1 now += 100ms; copa.onPacketAckOrLoss(createAckEvent(35, packetSize, now), folly::none); @@ -449,21 +393,10 @@ TEST_F(CopaTest, TestVelocity) { TEST_F(CopaTest, NoLargestAckedPacketNoCrash) { QuicServerConnectionState conn; Copa copa(conn); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; CongestionController::LossEvent loss; loss.largestLostPacketNum = 0; CongestionController::AckEvent ack; copa.onPacketAckOrLoss(ack, loss); - - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 1); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, copa.getBytesInFlight()); - EXPECT_EQ(event->currentCwnd, kDefaultCwnd); - EXPECT_EQ(event->congestionEvent, kCongestionPacketLoss.str()); } } // namespace test diff --git a/quic/congestion_control/test/CubicStateTest.cpp b/quic/congestion_control/test/CubicStateTest.cpp index 2d36f2317..fa9bbfd20 100644 --- a/quic/congestion_control/test/CubicStateTest.cpp +++ b/quic/congestion_control/test/CubicStateTest.cpp @@ -43,22 +43,12 @@ TEST_F(CubicStateTest, HystartAck) { TEST_F(CubicStateTest, HystartPace) { QuicConnectionStateBase conn(QuicNodeType::Client); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; conn.transportSettings.pacingEnabled = true; conn.lossState.srtt = 2000000us; TestingCubic cubic(conn); cubic.setMinimalPacingInterval(10ms); EXPECT_EQ(CubicStates::Hystart, cubic.state()); EXPECT_TRUE(cubic.canBePaced()); - - std::vector indices = - getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 1); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->pacingBurstSize, 1); - EXPECT_EQ(event->pacingInterval, 10ms); } // ======= Fast Recovery ======= @@ -144,24 +134,15 @@ TEST_F(CubicStateTest, SteadyLoss) { TEST_F(CubicStateTest, SteadyCanPace) { QuicConnectionStateBase conn(QuicNodeType::Client); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; conn.transportSettings.pacingEnabled = true; conn.lossState.srtt = 2000000us; TestingCubic cubic(conn); cubic.setStateForTest(CubicStates::Steady); EXPECT_FALSE(cubic.canBePaced()); - cubic.setMinimalPacingInterval(15ms); + cubic.setMinimalPacingInterval(10ms); EXPECT_TRUE(cubic.canBePaced()); conn.lossState.srtt = 1ms; EXPECT_FALSE(cubic.canBePaced()); - std::vector indices = - getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 1); - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->pacingBurstSize, 1); - EXPECT_EQ(event->pacingInterval, 15ms); } } // namespace test diff --git a/quic/congestion_control/test/CubicTest.cpp b/quic/congestion_control/test/CubicTest.cpp index 12c991a25..20a43aa0f 100644 --- a/quic/congestion_control/test/CubicTest.cpp +++ b/quic/congestion_control/test/CubicTest.cpp @@ -43,8 +43,6 @@ TEST_F(CubicTest, AckIncreaseWritable) { TEST_F(CubicTest, PersistentCongestion) { QuicConnectionStateBase conn(QuicNodeType::Client); - auto qLogger = std::make_shared(); - conn.qLogger = qLogger; Cubic cubic(conn, std::numeric_limits::max(), false); auto initCwnd = cubic.getWritableBytes(); auto packet = makeTestingWritePacket(0, 1000, 1000); @@ -76,83 +74,6 @@ TEST_F(CubicTest, PersistentCongestion) { cubic.onPacketSent(packet3); cubic.onPacketAckOrLoss( makeAck(2, 3000, Clock::now(), packet3.time), folly::none); - - std::vector indices = - getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger); - EXPECT_EQ(indices.size(), 9); - - auto tmp = std::move(qLogger->logs[indices[0]]); - auto event = dynamic_cast(tmp.get()); - EXPECT_EQ(event->bytesInFlight, 0); - EXPECT_EQ(event->currentCwnd, initCwnd); - EXPECT_EQ(event->congestionEvent, kRemoveInflight.str()); - EXPECT_EQ(event->state, cubicStateToString(CubicStates::Hystart)); - EXPECT_EQ(event->recoveryState, ""); - - auto tmp2 = std::move(qLogger->logs[indices[1]]); - auto event2 = dynamic_cast(tmp2.get()); - EXPECT_EQ(event2->bytesInFlight, 0); - EXPECT_EQ(event2->currentCwnd, 11088); - EXPECT_EQ(event2->congestionEvent, kCubicLoss.str()); - EXPECT_EQ(event2->state, cubicStateToString(CubicStates::FastRecovery)); - EXPECT_EQ(event2->recoveryState, ""); - - auto tmp3 = std::move(qLogger->logs[indices[2]]); - auto event3 = dynamic_cast(tmp3.get()); - EXPECT_EQ(event3->bytesInFlight, 0); - EXPECT_EQ(event3->currentCwnd, 2464); - EXPECT_EQ(event3->congestionEvent, kPersistentCongestion.str()); - EXPECT_EQ(event3->state, cubicStateToString(CubicStates::Hystart)); - EXPECT_EQ(event3->recoveryState, ""); - - auto tmp4 = std::move(qLogger->logs[indices[3]]); - auto event4 = dynamic_cast(tmp4.get()); - EXPECT_EQ(event4->bytesInFlight, 0); - EXPECT_EQ(event4->currentCwnd, cubic.getCongestionWindow()); - EXPECT_EQ(event4->congestionEvent, kCongestionPacketAck.str()); - EXPECT_EQ(event4->state, cubicStateToString(CubicStates::Steady)); - EXPECT_EQ(event4->recoveryState, ""); - - auto tmp5 = std::move(qLogger->logs[indices[4]]); - auto event5 = dynamic_cast(tmp5.get()); - EXPECT_EQ(event5->bytesInFlight, 0); - EXPECT_EQ(event5->currentCwnd, cubic.getCongestionWindow()); - EXPECT_EQ(event5->congestionEvent, kResetTimeToOrigin.str()); - EXPECT_EQ(event5->state, cubicStateToString(CubicStates::Steady)); - EXPECT_EQ(event5->recoveryState, ""); - - auto tmp6 = std::move(qLogger->logs[indices[5]]); - auto event6 = dynamic_cast(tmp6.get()); - EXPECT_EQ(event6->bytesInFlight, 0); - EXPECT_EQ(event6->currentCwnd, cubic.getCongestionWindow()); - EXPECT_EQ(event6->congestionEvent, kResetLastReductionTime.str()); - EXPECT_EQ(event6->state, cubicStateToString(CubicStates::Steady)); - EXPECT_EQ(event6->recoveryState, ""); - - auto tmp7 = std::move(qLogger->logs[indices[6]]); - auto event7 = dynamic_cast(tmp7.get()); - EXPECT_EQ(event7->bytesInFlight, 0); - EXPECT_EQ(event7->currentCwnd, cubic.getCongestionWindow()); - EXPECT_EQ(event7->congestionEvent, kCubicSteadyCwnd.str()); - EXPECT_EQ(event7->state, cubicStateToString(CubicStates::Steady)); - EXPECT_EQ(event7->recoveryState, ""); - - auto tmp8 = std::move(qLogger->logs[indices[7]]); - auto event8 = dynamic_cast(tmp8.get()); - EXPECT_EQ(event8->bytesInFlight, 0); - EXPECT_EQ(event8->currentCwnd, cubic.getCongestionWindow()); - EXPECT_EQ(event8->congestionEvent, kCwndNoChange.str()); - EXPECT_EQ(event8->state, cubicStateToString(CubicStates::Steady)); - EXPECT_EQ(event8->recoveryState, ""); - - auto tmp9 = std::move(qLogger->logs[indices[8]]); - auto event9 = dynamic_cast(tmp9.get()); - EXPECT_EQ(event9->bytesInFlight, 0); - EXPECT_EQ(event9->currentCwnd, cubic.getCongestionWindow()); - EXPECT_EQ(event9->congestionEvent, kCongestionPacketAck.str()); - EXPECT_EQ(event9->state, cubicStateToString(CubicStates::Steady)); - EXPECT_EQ(event9->recoveryState, ""); - EXPECT_EQ(currentCwnd, cubic.getWritableBytes()); } diff --git a/quic/logging/FileQLogger.cpp b/quic/logging/FileQLogger.cpp index ea2982d43..3dfa00cea 100644 --- a/quic/logging/FileQLogger.cpp +++ b/quic/logging/FileQLogger.cpp @@ -94,16 +94,6 @@ void FileQLogger::addCongestionMetricUpdate( refTime)); } -void FileQLogger::addPacingMetricUpdate( - uint64_t pacingBurstSizeIn, - std::chrono::microseconds pacingIntervalIn) { - auto refTime = std::chrono::duration_cast( - std::chrono::steady_clock::now() - refTimePoint); - - logs.push_back(std::make_unique( - pacingBurstSizeIn, pacingIntervalIn, refTime)); -} - folly::dynamic FileQLogger::toDynamic() const { folly::dynamic d = folly::dynamic::object; d["traces"] = folly::dynamic::array(); diff --git a/quic/logging/FileQLogger.h b/quic/logging/FileQLogger.h index 1c007e22b..3c57b2fb1 100644 --- a/quic/logging/FileQLogger.h +++ b/quic/logging/FileQLogger.h @@ -51,11 +51,8 @@ class FileQLogger : public QLogger { uint64_t bytesInFlight, uint64_t currentCwnd, std::string congestionEvent, - std::string state = "", + std::string state, std::string recoveryState = "") override; - void addPacingMetricUpdate( - uint64_t pacingBurstSizeIn, - std::chrono::microseconds pacingIntervalIn) override; void outputLogsToFile(const std::string& path, bool prettyJson); folly::dynamic toDynamic() const; }; diff --git a/quic/logging/test/QLoggerTest.cpp b/quic/logging/test/QLoggerTest.cpp index a42072733..c481e3739 100644 --- a/quic/logging/test/QLoggerTest.cpp +++ b/quic/logging/test/QLoggerTest.cpp @@ -117,7 +117,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) { q.addCongestionMetricUpdate( 20, 30, - kPersistentCongestion.str(), + cubicPersistentCongestion.str(), cubicStateToString(CubicStates::Steady).str(), bbrRecoveryStateToString( BbrCongestionController::RecoveryState::NOT_RECOVERY)); @@ -127,7 +127,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) { EXPECT_EQ(gotEvent->bytesInFlight, 20); EXPECT_EQ(gotEvent->currentCwnd, 30); - EXPECT_EQ(gotEvent->congestionEvent, kPersistentCongestion.str()); + EXPECT_EQ(gotEvent->congestionEvent, cubicPersistentCongestion.str()); EXPECT_EQ(gotEvent->state, cubicStateToString(CubicStates::Steady).str()); EXPECT_EQ( gotEvent->recoveryState, @@ -135,17 +135,6 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) { BbrCongestionController::RecoveryState::NOT_RECOVERY)); } -TEST_F(QLoggerTest, PacingMetricUpdateEvent) { - FileQLogger q; - q.addPacingMetricUpdate(10, 30us); - - std::unique_ptr p = std::move(q.logs[0]); - auto gotEvent = dynamic_cast(p.get()); - - EXPECT_EQ(gotEvent->pacingBurstSize, 10); - EXPECT_EQ(gotEvent->pacingInterval, 30us); -} - TEST_F(QLoggerTest, RegularPacketFollyDynamic) { folly::dynamic expected = folly::parseJson( R"({ @@ -675,7 +664,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) { "DEFAULT", { "bytes_in_flight": 20, - "congestion_event": "persistent congestion", + "congestion_event": "cubic persistent congestion", "current_cwnd": 30, "recovery_state": "", "state": "Steady" @@ -687,7 +676,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) { q.addCongestionMetricUpdate( 20, 30, - kPersistentCongestion.str(), + cubicPersistentCongestion.str(), cubicStateToString(CubicStates::Steady).str()); folly::dynamic gotDynamic = q.toDynamic(); gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time @@ -695,27 +684,4 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) { EXPECT_EQ(expected, gotEvents); } -TEST_F(QLoggerTest, PacingMetricUpdateFollyDynamic) { - folly::dynamic expected = folly::parseJson( - R"([ - [ - "0", - "METRIC_UPDATE", - "PACING_METRIC_UPDATE", - "DEFAULT", - { - "pacing_burst_size": 20, - "pacing_interval": 30 - } - ] - ])"); - - FileQLogger q; - q.addPacingMetricUpdate(20, 30us); - folly::dynamic gotDynamic = q.toDynamic(); - gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time - folly::dynamic gotEvents = gotDynamic["traces"][0]["events"]; - EXPECT_EQ(expected, gotEvents); -} - } // namespace quic::test