zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Always sends probes when they are generated.

Browse Source 
This changes makes the usage of the new probe controller reflect how the
old probe controller was used. That is probes are now sent as soon as
they are generated. This is to avoid regressions in performance doe to
the timing of the sent probes.

Bug: chromium:868776
Change-Id: I722585689258c9b01e8f1dc47249b284a05a2793
Reviewed-on: https://webrtc-review.googlesource.com/91441
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24175}
This commit is contained in:
Sebastian Jansson
2018-08-02 16:27:28 +02:00
committed by Commit Bot
parent dc6e68b4a7
commit da2ec40590
8 changed files with 283 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

219
modules/congestion_controller/goog_cc/probe_controller_unittest.cc
View File

@ -47,11 +47,11 @@ class ProbeControllerTest : public ::testing::Test {
}
~ProbeControllerTest() override {}
void SetNetworkAvailable(bool available) {
std::vector<ProbeClusterConfig> SetNetworkAvailable(bool available) {
NetworkAvailability msg;
msg.at_time = Timestamp::ms(NowMs());
msg.network_available = available;
probe_controller_->OnNetworkAvailability(msg);
return probe_controller_->OnNetworkAvailability(msg);
}
int64_t NowMs() { return clock_.TimeInMilliseconds(); }
@ -61,183 +61,165 @@ class ProbeControllerTest : public ::testing::Test {
};
TEST_F(ProbeControllerTest, InitiatesProbingAtStart) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_GE(probe_controller_->GetAndResetPendingProbes().size(), 2u);
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_GE(probes.size(), 2u);
}
TEST_F(ProbeControllerTest, ProbeOnlyWhenNetworkIsUp) {
SetNetworkAvailable(false);
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 0u);
SetNetworkAvailable(true);
EXPECT_GE(probe_controller_->GetAndResetPendingProbes().size(), 2u);
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probes.size(), 0u);
probes = SetNetworkAvailable(true);
EXPECT_GE(probes.size(), 2u);
}
TEST_F(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
// Long enough to time out exponential probing.
clock_.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
probe_controller_->SetEstimatedBitrate(kStartBitrateBps, NowMs());
probe_controller_->Process(NowMs());
EXPECT_GE(probe_controller_->GetAndResetPendingProbes().size(), 2u);
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps + 100, NowMs());
EXPECT_EQ(
probe_controller_->GetAndResetPendingProbes()[0].target_data_rate.bps(),
kMaxBitrateBps + 100);
probes = probe_controller_->SetEstimatedBitrate(kStartBitrateBps, NowMs());
probes = probe_controller_->Process(NowMs());
probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps + 100, NowMs());
EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrateBps + 100);
}
TEST_F(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncreaseAtMaxBitrate) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
// Long enough to time out exponential probing.
clock_.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
probe_controller_->SetEstimatedBitrate(kStartBitrateBps, NowMs());
probe_controller_->Process(NowMs());
EXPECT_GE(probe_controller_->GetAndResetPendingProbes().size(), 2u);
probe_controller_->SetEstimatedBitrate(kMaxBitrateBps, NowMs());
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps + 100, NowMs());
EXPECT_EQ(
probe_controller_->GetAndResetPendingProbes()[0].target_data_rate.bps(),
kMaxBitrateBps + 100);
probes = probe_controller_->SetEstimatedBitrate(kStartBitrateBps, NowMs());
probes = probe_controller_->Process(NowMs());
probes = probe_controller_->SetEstimatedBitrate(kMaxBitrateBps, NowMs());
probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps + 100, NowMs());
EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrateBps + 100);
}
TEST_F(ProbeControllerTest, TestExponentialProbing) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->GetAndResetPendingProbes();
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
// Repeated probe should only be sent when estimated bitrate climbs above
// 0.7 * 6 * kStartBitrateBps = 1260.
probe_controller_->SetEstimatedBitrate(1000, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 0u);
probes = probe_controller_->SetEstimatedBitrate(1000, NowMs());
EXPECT_EQ(probes.size(), 0u);
probe_controller_->SetEstimatedBitrate(1800, NowMs());
EXPECT_EQ(
probe_controller_->GetAndResetPendingProbes()[0].target_data_rate.bps(),
2 * 1800);
probes = probe_controller_->SetEstimatedBitrate(1800, NowMs());
EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * 1800);
}
TEST_F(ProbeControllerTest, TestExponentialProbingTimeout) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->GetAndResetPendingProbes();
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
// Advance far enough to cause a time out in waiting for probing result.
clock_.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
probe_controller_->Process(NowMs());
probes = probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(1800, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 0u);
probes = probe_controller_->SetEstimatedBitrate(1800, NowMs());
EXPECT_EQ(probes.size(), 0u);
}
TEST_F(ProbeControllerTest, RequestProbeInAlr) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_GE(probe_controller_->GetAndResetPendingProbes().size(), 2u);
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_GE(probes.size(), 2u);
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
probe_controller_->SetAlrStartTimeMs(clock_.TimeInMilliseconds());
clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(250, NowMs());
probe_controller_->RequestProbe(NowMs());
probes = probe_controller_->Process(NowMs());
probes = probe_controller_->SetEstimatedBitrate(250, NowMs());
probes = probe_controller_->RequestProbe(NowMs());
std::vector<ProbeClusterConfig> probes =
probe_controller_->GetAndResetPendingProbes();
EXPECT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500);
}
TEST_F(ProbeControllerTest, RequestProbeWhenAlrEndedRecently) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 2u);
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
probe_controller_->SetAlrStartTimeMs(absl::nullopt);
clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(250, NowMs());
probes = probe_controller_->Process(NowMs());
probes = probe_controller_->SetEstimatedBitrate(250, NowMs());
probe_controller_->SetAlrEndedTimeMs(clock_.TimeInMilliseconds());
clock_.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs - 1);
probe_controller_->RequestProbe(NowMs());
probes = probe_controller_->RequestProbe(NowMs());
std::vector<ProbeClusterConfig> probes =
probe_controller_->GetAndResetPendingProbes();
EXPECT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500);
}
TEST_F(ProbeControllerTest, RequestProbeWhenAlrNotEndedRecently) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 2u);
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
probe_controller_->SetAlrStartTimeMs(absl::nullopt);
clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(250, NowMs());
probes = probe_controller_->Process(NowMs());
probes = probe_controller_->SetEstimatedBitrate(250, NowMs());
probe_controller_->SetAlrEndedTimeMs(clock_.TimeInMilliseconds());
clock_.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs + 1);
probe_controller_->RequestProbe(NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 0u);
probes = probe_controller_->RequestProbe(NowMs());
EXPECT_EQ(probes.size(), 0u);
}
TEST_F(ProbeControllerTest, RequestProbeWhenBweDropNotRecent) {
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 2u);
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
probe_controller_->SetAlrStartTimeMs(clock_.TimeInMilliseconds());
clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(250, NowMs());
probes = probe_controller_->Process(NowMs());
probes = probe_controller_->SetEstimatedBitrate(250, NowMs());
clock_.AdvanceTimeMilliseconds(kBitrateDropTimeoutMs + 1);
probe_controller_->RequestProbe(NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 0u);
probes = probe_controller_->RequestProbe(NowMs());
EXPECT_EQ(probes.size(), 0u);
}
TEST_F(ProbeControllerTest, PeriodicProbing) {
probe_controller_->EnablePeriodicAlrProbing(true);
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 2u);
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probes.size(), 2u);
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
int64_t start_time = clock_.TimeInMilliseconds();
// Expect the controller to send a new probe after 5s has passed.
probe_controller_->SetAlrStartTimeMs(start_time);
clock_.AdvanceTimeMilliseconds(5000);
probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
std::vector<ProbeClusterConfig> probes =
probe_controller_->GetAndResetPendingProbes();
probes = probe_controller_->Process(NowMs());
EXPECT_EQ(probes.size(), 1u);
EXPECT_EQ(probes[0].target_data_rate.bps(), 1000);
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
// The following probe should be sent at 10s into ALR.
probe_controller_->SetAlrStartTimeMs(start_time);
clock_.AdvanceTimeMilliseconds(4000);
probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 0u);
probes = probe_controller_->Process(NowMs());
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probes.size(), 0u);
probe_controller_->SetAlrStartTimeMs(start_time);
clock_.AdvanceTimeMilliseconds(1000);
probe_controller_->Process(NowMs());
probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 1u);
probes = probe_controller_->Process(NowMs());
EXPECT_EQ(probes.size(), 1u);
probes = probe_controller_->SetEstimatedBitrate(500, NowMs());
EXPECT_EQ(probes.size(), 0u);
}
TEST_F(ProbeControllerTest, PeriodicProbingAfterReset) {
@ -246,42 +228,39 @@ TEST_F(ProbeControllerTest, PeriodicProbingAfterReset) {
probe_controller_->SetAlrStartTimeMs(alr_start_time);
probe_controller_->EnablePeriodicAlrProbing(true);
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
auto probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
probe_controller_->Reset(NowMs());
clock_.AdvanceTimeMilliseconds(10000);
probe_controller_->Process(NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 2u);
probes = probe_controller_->Process(NowMs());
// Since bitrates are not yet set, no probe is sent event though we are in ALR
// mode.
EXPECT_EQ(probes.size(), 0u);
probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 2u);
probes = probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
kMaxBitrateBps, NowMs());
EXPECT_EQ(probes.size(), 2u);
// Make sure we use |kStartBitrateBps| as the estimated bitrate
// until SetEstimatedBitrate is called with an updated estimate.
clock_.AdvanceTimeMilliseconds(10000);
probe_controller_->Process(NowMs());
EXPECT_EQ(
probe_controller_->GetAndResetPendingProbes()[0].target_data_rate.bps(),
kStartBitrateBps * 2);
probes = probe_controller_->Process(NowMs());
EXPECT_EQ(probes[0].target_data_rate.bps(), kStartBitrateBps * 2);
}
TEST_F(ProbeControllerTest, TestExponentialProbingOverflow) {
const int64_t kMbpsMultiplier = 1000000;
probe_controller_->SetBitrates(kMinBitrateBps, 10 * kMbpsMultiplier,
100 * kMbpsMultiplier, NowMs());
probe_controller_->SetEstimatedBitrate(60 * kMbpsMultiplier, NowMs());
auto probes = probe_controller_->SetBitrates(
kMinBitrateBps, 10 * kMbpsMultiplier, 100 * kMbpsMultiplier, NowMs());
// Verify that probe bitrate is capped at the specified max bitrate.
EXPECT_EQ(
probe_controller_->GetAndResetPendingProbes()[2].target_data_rate.bps(),
100 * kMbpsMultiplier);
probes =
probe_controller_->SetEstimatedBitrate(60 * kMbpsMultiplier, NowMs());
EXPECT_EQ(probes[0].target_data_rate.bps(), 100 * kMbpsMultiplier);
// Verify that repeated probes aren't sent.
probe_controller_->SetEstimatedBitrate(100 * kMbpsMultiplier, NowMs());
EXPECT_EQ(probe_controller_->GetAndResetPendingProbes().size(), 0u);
probes =
probe_controller_->SetEstimatedBitrate(100 * kMbpsMultiplier, NowMs());
EXPECT_EQ(probes.size(), 0u);
}
} // namespace test