mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-14 14:20:45 +01:00
865d94e452
This reverts commit e66e6a845b.
Reason for revert:
May cause BWE to increase on delay increase if link capacity estimate is too high.
Original change's description:
> Apply lower bound of delay based estimate in AimdRateControl::ClampBitrate
>
> This move the functionality of applying the lower bound of a network estimate to AimdRateControl::ClampBitrate instead of ChangeBitrate.
> The purpose is to be able to also clamp probe estimates set by AimdRateControl::SetEstimate as well.
>
> Bug: none
> Change-Id: I6a4d64d2e98bb99da06010e2edaf20dc42880e37
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/255823
> Reviewed-by: Per Kjellander <perkj@webrtc.org>
> Commit-Queue: Per Kjellander <perkj@webrtc.org>
> Reviewed-by: Diep Bui <diepbp@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#36219}
Bug: none
Change-Id: I8c65b1461160dbf3d35e50ef2cc6f9bc305c2b15
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/256011
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Reviewed-by: Diep Bui <diepbp@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36248}
428 lines
19 KiB
C++
428 lines
19 KiB
C++
/*
|
|
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
#include "modules/remote_bitrate_estimator/aimd_rate_control.h"
|
|
|
|
#include <memory>
|
|
|
|
#include "api/transport/field_trial_based_config.h"
|
|
#include "api/units/data_rate.h"
|
|
#include "system_wrappers/include/clock.h"
|
|
#include "test/field_trial.h"
|
|
#include "test/gtest.h"
|
|
|
|
namespace webrtc {
|
|
namespace {
|
|
|
|
constexpr int64_t kClockInitialTime = 123456;
|
|
|
|
constexpr int kMinBwePeriodMs = 2000;
|
|
constexpr int kDefaultPeriodMs = 3000;
|
|
constexpr int kMaxBwePeriodMs = 50000;
|
|
|
|
// After an overuse, we back off to 85% to the received bitrate.
|
|
constexpr double kFractionAfterOveruse = 0.85;
|
|
|
|
struct AimdRateControlStates {
|
|
std::unique_ptr<AimdRateControl> aimd_rate_control;
|
|
std::unique_ptr<SimulatedClock> simulated_clock;
|
|
FieldTrialBasedConfig field_trials;
|
|
};
|
|
|
|
AimdRateControlStates CreateAimdRateControlStates(bool send_side = false) {
|
|
AimdRateControlStates states;
|
|
states.aimd_rate_control.reset(
|
|
new AimdRateControl(&states.field_trials, send_side));
|
|
states.simulated_clock.reset(new SimulatedClock(kClockInitialTime));
|
|
return states;
|
|
}
|
|
absl::optional<DataRate> OptionalRateFromOptionalBps(
|
|
absl::optional<int> bitrate_bps) {
|
|
if (bitrate_bps) {
|
|
return DataRate::BitsPerSec(*bitrate_bps);
|
|
} else {
|
|
return absl::nullopt;
|
|
}
|
|
}
|
|
void UpdateRateControl(const AimdRateControlStates& states,
|
|
const BandwidthUsage& bandwidth_usage,
|
|
absl::optional<uint32_t> throughput_estimate,
|
|
int64_t now_ms) {
|
|
RateControlInput input(bandwidth_usage,
|
|
OptionalRateFromOptionalBps(throughput_estimate));
|
|
states.aimd_rate_control->Update(&input, Timestamp::Millis(now_ms));
|
|
}
|
|
void SetEstimate(const AimdRateControlStates& states, int bitrate_bps) {
|
|
states.aimd_rate_control->SetEstimate(DataRate::BitsPerSec(bitrate_bps),
|
|
states.simulated_clock->CurrentTime());
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TEST(AimdRateControlTest, MinNearMaxIncreaseRateOnLowBandwith) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kBitrate = 30000;
|
|
SetEstimate(states, kBitrate);
|
|
EXPECT_EQ(4000,
|
|
states.aimd_rate_control->GetNearMaxIncreaseRateBpsPerSecond());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, NearMaxIncreaseRateIs5kbpsOn90kbpsAnd200msRtt) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kBitrate = 90000;
|
|
SetEstimate(states, kBitrate);
|
|
EXPECT_EQ(5000,
|
|
states.aimd_rate_control->GetNearMaxIncreaseRateBpsPerSecond());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, NearMaxIncreaseRateIs5kbpsOn60kbpsAnd100msRtt) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kBitrate = 60000;
|
|
SetEstimate(states, kBitrate);
|
|
states.aimd_rate_control->SetRtt(TimeDelta::Millis(100));
|
|
EXPECT_EQ(5000,
|
|
states.aimd_rate_control->GetNearMaxIncreaseRateBpsPerSecond());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, GetIncreaseRateAndBandwidthPeriod) {
|
|
// Smoothing experiment disabled
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kBitrate = 300000;
|
|
SetEstimate(states, kBitrate);
|
|
UpdateRateControl(states, BandwidthUsage::kBwOverusing, kBitrate,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
EXPECT_NEAR(14000,
|
|
states.aimd_rate_control->GetNearMaxIncreaseRateBpsPerSecond(),
|
|
1000);
|
|
EXPECT_EQ(kDefaultPeriodMs,
|
|
states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, BweLimitedByAckedBitrate) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kAckedBitrate = 10000;
|
|
SetEstimate(states, kAckedBitrate);
|
|
while (states.simulated_clock->TimeInMilliseconds() - kClockInitialTime <
|
|
20000) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kAckedBitrate,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
ASSERT_TRUE(states.aimd_rate_control->ValidEstimate());
|
|
EXPECT_EQ(static_cast<uint32_t>(1.5 * kAckedBitrate + 10000),
|
|
states.aimd_rate_control->LatestEstimate().bps());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, BweNotLimitedByDecreasingAckedBitrate) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kAckedBitrate = 100000;
|
|
SetEstimate(states, kAckedBitrate);
|
|
while (states.simulated_clock->TimeInMilliseconds() - kClockInitialTime <
|
|
20000) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kAckedBitrate,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
ASSERT_TRUE(states.aimd_rate_control->ValidEstimate());
|
|
// If the acked bitrate decreases the BWE shouldn't be reduced to 1.5x
|
|
// what's being acked, but also shouldn't get to increase more.
|
|
uint32_t prev_estimate = states.aimd_rate_control->LatestEstimate().bps();
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kAckedBitrate / 2,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
uint32_t new_estimate = states.aimd_rate_control->LatestEstimate().bps();
|
|
EXPECT_NEAR(new_estimate, static_cast<uint32_t>(1.5 * kAckedBitrate + 10000),
|
|
2000);
|
|
EXPECT_EQ(new_estimate, prev_estimate);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, DefaultPeriodUntilFirstOveruse) {
|
|
// Smoothing experiment disabled
|
|
auto states = CreateAimdRateControlStates();
|
|
states.aimd_rate_control->SetStartBitrate(DataRate::KilobitsPerSec(300));
|
|
EXPECT_EQ(kDefaultPeriodMs,
|
|
states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
UpdateRateControl(states, BandwidthUsage::kBwOverusing, 280000,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
EXPECT_NE(kDefaultPeriodMs,
|
|
states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, ExpectedPeriodAfter20kbpsDropAnd5kbpsIncrease) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kInitialBitrate = 110000;
|
|
SetEstimate(states, kInitialBitrate);
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
// Make the bitrate drop by 20 kbps to get to 90 kbps.
|
|
// The rate increase at 90 kbps should be 5 kbps, so the period should be 4 s.
|
|
constexpr int kAckedBitrate =
|
|
(kInitialBitrate - 20000) / kFractionAfterOveruse;
|
|
UpdateRateControl(states, BandwidthUsage::kBwOverusing, kAckedBitrate,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
EXPECT_EQ(5000,
|
|
states.aimd_rate_control->GetNearMaxIncreaseRateBpsPerSecond());
|
|
EXPECT_EQ(4000, states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, BandwidthPeriodIsNotBelowMin) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kInitialBitrate = 10000;
|
|
SetEstimate(states, kInitialBitrate);
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
// Make a small (1.5 kbps) bitrate drop to 8.5 kbps.
|
|
UpdateRateControl(states, BandwidthUsage::kBwOverusing, kInitialBitrate - 1,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
EXPECT_EQ(kMinBwePeriodMs,
|
|
states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, BandwidthPeriodIsNotAboveMaxNoSmoothingExp) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kInitialBitrate = 10010000;
|
|
SetEstimate(states, kInitialBitrate);
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
// Make a large (10 Mbps) bitrate drop to 10 kbps.
|
|
constexpr int kAckedBitrate = 10000 / kFractionAfterOveruse;
|
|
UpdateRateControl(states, BandwidthUsage::kBwOverusing, kAckedBitrate,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
EXPECT_EQ(kMaxBwePeriodMs,
|
|
states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
|
|
}
|
|
|
|
TEST(AimdRateControlTest, SendingRateBoundedWhenThroughputNotEstimated) {
|
|
auto states = CreateAimdRateControlStates();
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kInitialBitrateBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
// AimdRateControl sets the initial bit rate to what it receives after
|
|
// five seconds has passed.
|
|
// TODO(bugs.webrtc.org/9379): The comment in the AimdRateControl does not
|
|
// match the constant.
|
|
constexpr int kInitializationTimeMs = 5000;
|
|
states.simulated_clock->AdvanceTimeMilliseconds(kInitializationTimeMs + 1);
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kInitialBitrateBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
for (int i = 0; i < 100; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, absl::nullopt,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
EXPECT_LE(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kInitialBitrateBps * 1.5 + 10000);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, EstimateDoesNotIncreaseInAlr) {
|
|
// When alr is detected, the delay based estimator is not allowed to increase
|
|
// bwe since there will be no feedback from the network if the new estimate
|
|
// is correct.
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-DontIncreaseDelayBasedBweInAlr/Enabled/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
SetEstimate(states, kInitialBitrateBps);
|
|
states.aimd_rate_control->SetInApplicationLimitedRegion(true);
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kInitialBitrateBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
ASSERT_EQ(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kInitialBitrateBps);
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, absl::nullopt,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
EXPECT_EQ(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kInitialBitrateBps);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, SetEstimateIncreaseBweInAlr) {
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-DontIncreaseDelayBasedBweInAlr/Enabled/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
SetEstimate(states, kInitialBitrateBps);
|
|
states.aimd_rate_control->SetInApplicationLimitedRegion(true);
|
|
ASSERT_EQ(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kInitialBitrateBps);
|
|
SetEstimate(states, 2 * kInitialBitrateBps);
|
|
EXPECT_EQ(states.aimd_rate_control->LatestEstimate().bps(),
|
|
2 * kInitialBitrateBps);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, SetEstimateClampedByNetworkEstimate) {
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
NetworkStateEstimate network_estimate;
|
|
network_estimate.link_capacity_upper = DataRate::KilobitsPerSec(400);
|
|
states.aimd_rate_control->SetNetworkStateEstimate(network_estimate);
|
|
SetEstimate(states, 500'000);
|
|
EXPECT_EQ(states.aimd_rate_control->LatestEstimate(),
|
|
network_estimate.link_capacity_upper);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, SetEstimateIgnoresNetworkEstimatesLowerThanCurrent) {
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-Bwe-EstimateBoundedIncrease/"
|
|
"ratio:0.85,ignore_acked:true,ignore_decr:true/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
states.aimd_rate_control->SetStartBitrate(DataRate::KilobitsPerSec(30));
|
|
NetworkStateEstimate network_estimate;
|
|
network_estimate.link_capacity_upper = DataRate::KilobitsPerSec(400);
|
|
states.aimd_rate_control->SetNetworkStateEstimate(network_estimate);
|
|
SetEstimate(states, 500'000);
|
|
ASSERT_EQ(states.aimd_rate_control->LatestEstimate(),
|
|
network_estimate.link_capacity_upper * 0.85);
|
|
|
|
NetworkStateEstimate lower_network_estimate;
|
|
lower_network_estimate.link_capacity_upper = DataRate::KilobitsPerSec(300);
|
|
states.aimd_rate_control->SetNetworkStateEstimate(lower_network_estimate);
|
|
SetEstimate(states, 500'000);
|
|
EXPECT_EQ(states.aimd_rate_control->LatestEstimate(),
|
|
network_estimate.link_capacity_upper * 0.85);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, EstimateIncreaseWhileNotInAlr) {
|
|
// Allow the estimate to increase as long as alr is not detected to ensure
|
|
// tha BWE can not get stuck at a certain bitrate.
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-DontIncreaseDelayBasedBweInAlr/Enabled/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
SetEstimate(states, kInitialBitrateBps);
|
|
states.aimd_rate_control->SetInApplicationLimitedRegion(false);
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kInitialBitrateBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
for (int i = 0; i < 100; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, absl::nullopt,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
EXPECT_GT(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kInitialBitrateBps);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, EstimateNotLimitedByNetworkEstimateIfDisabled) {
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-Bwe-EstimateBoundedIncrease/Disabled/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
SetEstimate(states, kInitialBitrateBps);
|
|
states.aimd_rate_control->SetInApplicationLimitedRegion(false);
|
|
NetworkStateEstimate network_estimate;
|
|
network_estimate.link_capacity_upper = DataRate::KilobitsPerSec(150);
|
|
states.aimd_rate_control->SetNetworkStateEstimate(network_estimate);
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, absl::nullopt,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
EXPECT_GT(states.aimd_rate_control->LatestEstimate(),
|
|
network_estimate.link_capacity_upper);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, EstimateLimitedByNetworkEstimateInAlrIfSet) {
|
|
// Even if alr is detected, the delay based estimator is allowed to increase
|
|
// up to a percentage of upper link capacity.
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-Bwe-EstimateBoundedIncrease/ratio:0.85,ignore_acked:true/"
|
|
"WebRTC-DontIncreaseDelayBasedBweInAlr/Enabled/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
SetEstimate(states, kInitialBitrateBps);
|
|
states.aimd_rate_control->SetInApplicationLimitedRegion(true);
|
|
|
|
NetworkStateEstimate network_estimate;
|
|
network_estimate.link_capacity_upper = DataRate::KilobitsPerSec(200);
|
|
states.aimd_rate_control->SetNetworkStateEstimate(network_estimate);
|
|
for (int i = 0; i < 100; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, absl::nullopt,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
EXPECT_EQ(states.aimd_rate_control->LatestEstimate(),
|
|
network_estimate.link_capacity_upper * 0.85);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, EstimateNotLoweredByNetworkEstimate) {
|
|
// The delay based estimator is allowed to increase up to a percentage of
|
|
// upper link capacity but does not decrease unless the delay detector
|
|
// discover an overuse.
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-Bwe-EstimateBoundedIncrease/"
|
|
"ratio:0.85,ignore_acked:true,ignore_decr:true/"
|
|
"WebRTC-DontIncreaseDelayBasedBweInAlr/Enabled/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
constexpr int kEstimatedThroughputBps = 30'000;
|
|
SetEstimate(states, kInitialBitrateBps);
|
|
|
|
NetworkStateEstimate network_estimate;
|
|
network_estimate.link_capacity_upper = DataRate::KilobitsPerSec(200);
|
|
states.aimd_rate_control->SetNetworkStateEstimate(network_estimate);
|
|
for (int i = 0; i < 100; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal,
|
|
kEstimatedThroughputBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
DataRate estimate_after_increase = states.aimd_rate_control->LatestEstimate();
|
|
ASSERT_EQ(estimate_after_increase,
|
|
network_estimate.link_capacity_upper * 0.85);
|
|
|
|
// A lower network estimate does not decrease the estimate immediately,
|
|
// but the estimate is not allowed to increase.
|
|
network_estimate.link_capacity_upper = DataRate::KilobitsPerSec(100);
|
|
network_estimate.link_capacity_lower = DataRate::KilobitsPerSec(80);
|
|
states.aimd_rate_control->SetNetworkStateEstimate(network_estimate);
|
|
for (int i = 0; i < 10; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal,
|
|
kEstimatedThroughputBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
EXPECT_EQ(states.aimd_rate_control->LatestEstimate(),
|
|
estimate_after_increase);
|
|
}
|
|
|
|
// If the detector detects and overuse, BWE drops to a value relative the
|
|
// network estimate.
|
|
UpdateRateControl(states, BandwidthUsage::kBwOverusing,
|
|
kEstimatedThroughputBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
EXPECT_LT(states.aimd_rate_control->LatestEstimate(),
|
|
network_estimate.link_capacity_lower);
|
|
EXPECT_GT(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kEstimatedThroughputBps);
|
|
}
|
|
|
|
TEST(AimdRateControlTest, EstimateDoesNotIncreaseInAlrIfNetworkEstimateNotSet) {
|
|
// When alr is detected, the delay based estimator is not allowed to increase
|
|
// bwe since there will be no feedback from the network if the new estimate
|
|
// is correct.
|
|
test::ScopedFieldTrials override_field_trials(
|
|
"WebRTC-Bwe-EstimateBoundedIncrease/ratio:0.85,ignore_acked:true/"
|
|
"WebRTC-DontIncreaseDelayBasedBweInAlr/Enabled/");
|
|
auto states = CreateAimdRateControlStates(/*send_side=*/true);
|
|
constexpr int kInitialBitrateBps = 123000;
|
|
SetEstimate(states, kInitialBitrateBps);
|
|
states.aimd_rate_control->SetInApplicationLimitedRegion(true);
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, kInitialBitrateBps,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
ASSERT_EQ(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kInitialBitrateBps);
|
|
|
|
for (int i = 0; i < 100; ++i) {
|
|
UpdateRateControl(states, BandwidthUsage::kBwNormal, absl::nullopt,
|
|
states.simulated_clock->TimeInMilliseconds());
|
|
states.simulated_clock->AdvanceTimeMilliseconds(100);
|
|
}
|
|
EXPECT_EQ(states.aimd_rate_control->LatestEstimate().bps(),
|
|
kInitialBitrateBps);
|
|
}
|
|
|
|
} // namespace webrtc
|