From 82931001c2e79d2f9dd53fdc2d9ed2d22a977e9c Mon Sep 17 00:00:00 2001 From: minyue-webrtc Date: Wed, 23 Aug 2017 13:26:08 +0200 Subject: [PATCH] Use small BWE period when there is a true network degradation. Bug: webrtc:8105 Change-Id: I751b89194f3fdb10ea41c6f9e48e38edefcbef1a Reviewed-on: https://chromium-review.googlesource.com/616724 Commit-Queue: Minyue Li Reviewed-by: Michael T Reviewed-by: Stefan Holmer Cr-Commit-Position: refs/heads/master@{#19469} --- .../delay_based_bwe_unittest.cc | 9 ----- .../aimd_rate_control.cc | 18 +++++++--- .../aimd_rate_control_unittest.cc | 33 ++++++++++++++----- 3 files changed, 37 insertions(+), 23 deletions(-) diff --git a/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc b/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc index ce55be46ce..a4513685ec 100644 --- a/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc +++ b/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc @@ -139,15 +139,6 @@ TEST_F(DelayBasedBweTest, ProbeDetectionSlowerArrivalHighBitrate) { kTargetUtilizationFraction * 4000000u, 10000u); } -TEST_F(DelayBasedBweTest, GetExpectedBwePeriodMs) { - int64_t default_interval_ms = bitrate_estimator_->GetExpectedBwePeriodMs(); - EXPECT_GT(default_interval_ms, 0); - CapacityDropTestHelper(1, true, 333, 0); - int64_t interval_ms = bitrate_estimator_->GetExpectedBwePeriodMs(); - EXPECT_GT(interval_ms, 0); - EXPECT_NE(interval_ms, default_interval_ms); -} - TEST_F(DelayBasedBweTest, InitialBehavior) { InitialBehaviorTestHelper(730000); } diff --git a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.cc b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.cc index d46732c26c..dc6f02d8c6 100644 --- a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.cc +++ b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control.cc @@ -136,13 +136,12 @@ int AimdRateControl::GetNearMaxIncreaseRateBps() const { } int AimdRateControl::GetExpectedBandwidthPeriodMs() const { - constexpr int kMinPeriodMs = 2000; - constexpr int kDefaultPeriodMs = 3000; + constexpr int kMinPeriodMs = 500; constexpr int kMaxPeriodMs = 50000; int increase_rate = GetNearMaxIncreaseRateBps(); if (!last_decrease_) - return kDefaultPeriodMs; + return kMinPeriodMs; return std::min(kMaxPeriodMs, std::max(1000 * static_cast(*last_decrease_) / @@ -211,8 +210,17 @@ uint32_t AimdRateControl::ChangeBitrate(uint32_t new_bitrate_bps, if (bitrate_is_initialized_ && incoming_bitrate_bps < current_bitrate_bps_) { - last_decrease_ = - rtc::Optional(current_bitrate_bps_ - new_bitrate_bps); + constexpr float kDegradationFactor = 0.9f; + if (new_bitrate_bps < + kDegradationFactor * beta_ * current_bitrate_bps_) { + // If bitrate decreases more than a normal back off after overuse, it + // indicates a real network degradation. We do not let such a decrease + // to determine the bandwidth estimation period. + last_decrease_ = rtc::Optional(); + } else { + last_decrease_ = rtc::Optional( + current_bitrate_bps_ - new_bitrate_bps); + } } if (incoming_bitrate_kbps < avg_max_bitrate_kbps_ - 3 * std_max_bit_rate) { diff --git a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc index e90c5500b3..cf6b5a51d7 100644 --- a/webrtc/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc +++ b/webrtc/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc @@ -18,9 +18,8 @@ namespace { constexpr int64_t kClockInitialTime = 123456; -constexpr int kMinBwePeriodMs = 2000; +constexpr int kMinBwePeriodMs = 500; constexpr int kMaxBwePeriodMs = 50000; -constexpr int kDefaultPeriodMs = 3000; // After an overuse, we back off to 85% to the received bitrate. constexpr double kFractionAfterOveruse = 0.85; @@ -82,7 +81,8 @@ TEST(AimdRateControlTest, GetIncreaseRateAndBandwidthPeriod) { states.simulated_clock->TimeInMilliseconds()); EXPECT_NEAR(14000, states.aimd_rate_control->GetNearMaxIncreaseRateBps(), 1000); - EXPECT_EQ(3000, states.aimd_rate_control->GetExpectedBandwidthPeriodMs()); + EXPECT_EQ(kMinBwePeriodMs, + states.aimd_rate_control->GetExpectedBandwidthPeriodMs()); } TEST(AimdRateControlTest, BweLimitedByAckedBitrate) { @@ -124,15 +124,15 @@ TEST(AimdRateControlTest, BweNotLimitedByDecreasingAckedBitrate) { EXPECT_EQ(new_estimate, prev_estimate); } -TEST(AimdRateControlTest, DefaultPeriodUntilFirstOveruse) { +TEST(AimdRateControlTest, MinPeriodUntilFirstOveruse) { auto states = CreateAimdRateControlStates(); states.aimd_rate_control->SetStartBitrate(300000); - EXPECT_EQ(kDefaultPeriodMs, + EXPECT_EQ(kMinBwePeriodMs, states.aimd_rate_control->GetExpectedBandwidthPeriodMs()); states.simulated_clock->AdvanceTimeMilliseconds(100); - UpdateRateControl(states, BandwidthUsage::kBwOverusing, 100000, + UpdateRateControl(states, BandwidthUsage::kBwOverusing, 280000, states.simulated_clock->TimeInMilliseconds()); - EXPECT_NE(kDefaultPeriodMs, + EXPECT_NE(kMinBwePeriodMs, states.aimd_rate_control->GetExpectedBandwidthPeriodMs()); } @@ -152,6 +152,21 @@ TEST(AimdRateControlTest, ExpectedPeriodAfter20kbpsDropAnd5kbpsIncrease) { EXPECT_EQ(4000, states.aimd_rate_control->GetExpectedBandwidthPeriodMs()); } +TEST(AimdRateControlTest, MinPeriodAfterLargeBitrateDecrease) { + auto states = CreateAimdRateControlStates(); + constexpr int kInitialBitrate = 110000; + states.aimd_rate_control->SetEstimate( + kInitialBitrate, states.simulated_clock->TimeInMilliseconds()); + states.simulated_clock->AdvanceTimeMilliseconds(100); + // Make such a large drop in bitrate that should be treated as network + // degradation. + constexpr int kAckedBitrate = kInitialBitrate * 3 / 4 / kFractionAfterOveruse; + UpdateRateControl(states, BandwidthUsage::kBwOverusing, kAckedBitrate, + states.simulated_clock->TimeInMilliseconds()); + EXPECT_EQ(kMinBwePeriodMs, + states.aimd_rate_control->GetExpectedBandwidthPeriodMs()); +} + TEST(AimdRateControlTest, BandwidthPeriodIsNotBelowMin) { auto states = CreateAimdRateControlStates(); constexpr int kInitialBitrate = 10000; @@ -167,12 +182,12 @@ TEST(AimdRateControlTest, BandwidthPeriodIsNotBelowMin) { TEST(AimdRateControlTest, BandwidthPeriodIsNotAboveMax) { auto states = CreateAimdRateControlStates(); - constexpr int kInitialBitrate = 10010000; + constexpr int kInitialBitrate = 50000000; states.aimd_rate_control->SetEstimate( kInitialBitrate, states.simulated_clock->TimeInMilliseconds()); states.simulated_clock->AdvanceTimeMilliseconds(100); // Make a large (10 Mbps) bitrate drop to 10 kbps. - constexpr int kAckedBitrate = 10000 / kFractionAfterOveruse; + constexpr int kAckedBitrate = 40000000 / kFractionAfterOveruse; UpdateRateControl(states, BandwidthUsage::kBwOverusing, kAckedBitrate, states.simulated_clock->TimeInMilliseconds()); EXPECT_EQ(kMaxBwePeriodMs,