1 /*
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10 #include "modules/congestion_controller/goog_cc/probe_controller.h"
11
12 #include <memory>
13
14 #include "api/units/data_rate.h"
15 #include "api/units/time_delta.h"
16 #include "api/units/timestamp.h"
17 #include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
18 #include "rtc_base/logging.h"
19 #include "system_wrappers/include/clock.h"
20 #include "test/explicit_key_value_config.h"
21 #include "test/gmock.h"
22 #include "test/gtest.h"
23
24 using ::testing::NiceMock;
25
26 namespace webrtc {
27 namespace test {
28
29 namespace {
30
31 constexpr DataRate kMinBitrate = DataRate::BitsPerSec(100);
32 constexpr DataRate kStartBitrate = DataRate::BitsPerSec(300);
33 constexpr DataRate kMaxBitrate = DataRate::BitsPerSec(10000);
34
35 constexpr TimeDelta kExponentialProbingTimeout = TimeDelta::Seconds(5);
36
37 constexpr TimeDelta kAlrProbeInterval = TimeDelta::Seconds(5);
38 constexpr TimeDelta kAlrEndedTimeout = TimeDelta::Seconds(3);
39 constexpr TimeDelta kBitrateDropTimeout = TimeDelta::Seconds(5);
40 } // namespace
41
42 class ProbeControllerFixture {
43 public:
ProbeControllerFixture(absl::string_view field_trials="")44 explicit ProbeControllerFixture(absl::string_view field_trials = "")
45 : field_trial_config_(field_trials), clock_(100000000L) {}
46
CreateController()47 std::unique_ptr<ProbeController> CreateController() {
48 return std::make_unique<ProbeController>(&field_trial_config_,
49 &mock_rtc_event_log);
50 }
51
CurrentTime()52 Timestamp CurrentTime() { return clock_.CurrentTime(); }
AdvanceTime(TimeDelta delta)53 void AdvanceTime(TimeDelta delta) { clock_.AdvanceTime(delta); }
54
55 ExplicitKeyValueConfig field_trial_config_;
56 SimulatedClock clock_;
57 NiceMock<MockRtcEventLog> mock_rtc_event_log;
58 };
59
TEST(ProbeControllerTest,InitiatesProbingAtStart)60 TEST(ProbeControllerTest, InitiatesProbingAtStart) {
61 ProbeControllerFixture fixture;
62 std::unique_ptr<ProbeController> probe_controller =
63 fixture.CreateController();
64
65 auto probes = probe_controller->SetBitrates(
66 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
67 EXPECT_GE(probes.size(), 2u);
68 }
69
TEST(ProbeControllerTest,SetsDefaultTargetDurationAndTargetProbeCount)70 TEST(ProbeControllerTest, SetsDefaultTargetDurationAndTargetProbeCount) {
71 ProbeControllerFixture fixture;
72 std::unique_ptr<ProbeController> probe_controller =
73 fixture.CreateController();
74 std::vector<ProbeClusterConfig> probes = probe_controller->SetBitrates(
75 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
76 ASSERT_GE(probes.size(), 2u);
77
78 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(15));
79 EXPECT_EQ(probes[0].target_probe_count, 5);
80 }
81
TEST(ProbeControllerTest,FieldTrialsOverrideDefaultTargetDurationAndTargetProbeCount)82 TEST(ProbeControllerTest,
83 FieldTrialsOverrideDefaultTargetDurationAndTargetProbeCount) {
84 ProbeControllerFixture fixture(
85 "WebRTC-Bwe-ProbingBehavior/"
86 "min_probe_packets_sent:2,min_probe_duration:123ms/");
87 std::unique_ptr<ProbeController> probe_controller =
88 fixture.CreateController();
89 std::vector<ProbeClusterConfig> probes = probe_controller->SetBitrates(
90 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
91 ASSERT_GE(probes.size(), 2u);
92
93 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(123));
94 EXPECT_EQ(probes[0].target_probe_count, 2);
95 }
96
TEST(ProbeControllerTest,ProbeOnlyWhenNetworkIsUp)97 TEST(ProbeControllerTest, ProbeOnlyWhenNetworkIsUp) {
98 ProbeControllerFixture fixture;
99 std::unique_ptr<ProbeController> probe_controller =
100 fixture.CreateController();
101 auto probes = probe_controller->OnNetworkAvailability(
102 {.at_time = fixture.CurrentTime(), .network_available = false});
103 probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate,
104 kMaxBitrate, fixture.CurrentTime());
105 EXPECT_TRUE(probes.empty());
106 probes = probe_controller->OnNetworkAvailability(
107 {.at_time = fixture.CurrentTime(), .network_available = true});
108 EXPECT_GE(probes.size(), 2u);
109 }
110
TEST(ProbeControllerTest,CanConfigureInitialProbeRateFactor)111 TEST(ProbeControllerTest, CanConfigureInitialProbeRateFactor) {
112 ProbeControllerFixture fixture("WebRTC-Bwe-ProbingConfiguration/p1:2,p2:3/");
113 std::unique_ptr<ProbeController> probe_controller =
114 fixture.CreateController();
115 auto probes = probe_controller->SetBitrates(
116 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
117 EXPECT_EQ(probes.size(), 2u);
118 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate * 2);
119 EXPECT_EQ(probes[1].target_data_rate, kStartBitrate * 3);
120 }
121
TEST(ProbeControllerTest,DisableSecondInitialProbeIfRateFactorZero)122 TEST(ProbeControllerTest, DisableSecondInitialProbeIfRateFactorZero) {
123 ProbeControllerFixture fixture("WebRTC-Bwe-ProbingConfiguration/p1:2,p2:0/");
124 std::unique_ptr<ProbeController> probe_controller =
125 fixture.CreateController();
126 auto probes = probe_controller->SetBitrates(
127 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
128 EXPECT_EQ(probes.size(), 1u);
129 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate * 2);
130 }
131
TEST(ProbeControllerTest,InitiatesProbingOnMaxBitrateIncrease)132 TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) {
133 ProbeControllerFixture fixture;
134 std::unique_ptr<ProbeController> probe_controller =
135 fixture.CreateController();
136 auto probes = probe_controller->SetBitrates(
137 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
138 // Long enough to time out exponential probing.
139 fixture.AdvanceTime(kExponentialProbingTimeout);
140 probes = probe_controller->SetEstimatedBitrate(
141 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited,
142 fixture.CurrentTime());
143 probes = probe_controller->Process(fixture.CurrentTime());
144 probes = probe_controller->SetBitrates(
145 kMinBitrate, kStartBitrate, kMaxBitrate + DataRate::BitsPerSec(100),
146 fixture.CurrentTime());
147 EXPECT_EQ(probes.size(), 1u);
148 EXPECT_EQ(probes[0].target_data_rate.bps(), kMaxBitrate.bps() + 100);
149 }
150
TEST(ProbeControllerTest,ProbesOnMaxAllocatedBitrateIncreaseOnlyWhenInAlr)151 TEST(ProbeControllerTest, ProbesOnMaxAllocatedBitrateIncreaseOnlyWhenInAlr) {
152 ProbeControllerFixture fixture;
153 std::unique_ptr<ProbeController> probe_controller =
154 fixture.CreateController();
155 auto probes = probe_controller->SetBitrates(
156 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
157 probes = probe_controller->SetEstimatedBitrate(
158 kMaxBitrate - DataRate::BitsPerSec(1),
159 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime());
160
161 // Wait long enough to time out exponential probing.
162 fixture.AdvanceTime(kExponentialProbingTimeout);
163 probes = probe_controller->Process(fixture.CurrentTime());
164 EXPECT_TRUE(probes.empty());
165
166 // Probe when in alr.
167 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
168 probes = probe_controller->OnMaxTotalAllocatedBitrate(
169 kMaxBitrate + DataRate::BitsPerSec(1), fixture.CurrentTime());
170 EXPECT_EQ(probes.size(), 2u);
171 EXPECT_EQ(probes.at(0).target_data_rate, kMaxBitrate);
172
173 // Do not probe when not in alr.
174 probe_controller->SetAlrStartTimeMs(absl::nullopt);
175 probes = probe_controller->OnMaxTotalAllocatedBitrate(
176 kMaxBitrate + DataRate::BitsPerSec(2), fixture.CurrentTime());
177 EXPECT_TRUE(probes.empty());
178 }
179
TEST(ProbeControllerTest,CanDisableProbingOnMaxTotalAllocatedBitrateIncrease)180 TEST(ProbeControllerTest, CanDisableProbingOnMaxTotalAllocatedBitrateIncrease) {
181 ProbeControllerFixture fixture(
182 "WebRTC-Bwe-ProbingConfiguration/"
183 "probe_max_allocation:false/");
184 std::unique_ptr<ProbeController> probe_controller =
185 fixture.CreateController();
186
187 auto probes = probe_controller->SetBitrates(
188 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
189 probes = probe_controller->SetEstimatedBitrate(
190 kMaxBitrate - DataRate::BitsPerSec(1),
191 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime());
192 fixture.AdvanceTime(kExponentialProbingTimeout);
193 probes = probe_controller->Process(fixture.CurrentTime());
194 ASSERT_TRUE(probes.empty());
195 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
196
197 // Do no probe, since probe_max_allocation:false.
198 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
199 probes = probe_controller->OnMaxTotalAllocatedBitrate(
200 kMaxBitrate + DataRate::BitsPerSec(1), fixture.CurrentTime());
201 EXPECT_TRUE(probes.empty());
202 }
203
TEST(ProbeControllerTest,InitiatesProbingOnMaxBitrateIncreaseAtMaxBitrate)204 TEST(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncreaseAtMaxBitrate) {
205 ProbeControllerFixture fixture;
206 std::unique_ptr<ProbeController> probe_controller =
207 fixture.CreateController();
208 auto probes = probe_controller->SetBitrates(
209 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
210 // Long enough to time out exponential probing.
211 fixture.AdvanceTime(kExponentialProbingTimeout);
212 probes = probe_controller->SetEstimatedBitrate(
213 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited,
214 fixture.CurrentTime());
215 probes = probe_controller->Process(fixture.CurrentTime());
216 probes = probe_controller->SetEstimatedBitrate(
217 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited,
218 fixture.CurrentTime());
219 probes = probe_controller->SetBitrates(
220 kMinBitrate, kStartBitrate, kMaxBitrate + DataRate::BitsPerSec(100),
221 fixture.CurrentTime());
222 EXPECT_EQ(probes.size(), 1u);
223 EXPECT_EQ(probes[0].target_data_rate,
224 kMaxBitrate + DataRate::BitsPerSec(100));
225 }
226
TEST(ProbeControllerTest,TestExponentialProbing)227 TEST(ProbeControllerTest, TestExponentialProbing) {
228 ProbeControllerFixture fixture;
229 std::unique_ptr<ProbeController> probe_controller =
230 fixture.CreateController();
231 auto probes = probe_controller->SetBitrates(
232 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
233
234 // Repeated probe should only be sent when estimated bitrate climbs above
235 // 0.7 * 6 * kStartBitrate = 1260.
236 probes = probe_controller->SetEstimatedBitrate(
237 DataRate::BitsPerSec(1000), BandwidthLimitedCause::kDelayBasedLimited,
238 fixture.CurrentTime());
239 EXPECT_TRUE(probes.empty());
240
241 probes = probe_controller->SetEstimatedBitrate(
242 DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited,
243 fixture.CurrentTime());
244 EXPECT_EQ(probes.size(), 1u);
245 EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * 1800);
246 }
247
TEST(ProbeControllerTest,TestExponentialProbingTimeout)248 TEST(ProbeControllerTest, TestExponentialProbingTimeout) {
249 ProbeControllerFixture fixture;
250 std::unique_ptr<ProbeController> probe_controller =
251 fixture.CreateController();
252 auto probes = probe_controller->SetBitrates(
253 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
254 // Advance far enough to cause a time out in waiting for probing result.
255 fixture.AdvanceTime(kExponentialProbingTimeout);
256 probes = probe_controller->Process(fixture.CurrentTime());
257
258 probes = probe_controller->SetEstimatedBitrate(
259 DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited,
260 fixture.CurrentTime());
261 EXPECT_TRUE(probes.empty());
262 }
263
TEST(ProbeControllerTest,RequestProbeInAlr)264 TEST(ProbeControllerTest, RequestProbeInAlr) {
265 ProbeControllerFixture fixture;
266 std::unique_ptr<ProbeController> probe_controller =
267 fixture.CreateController();
268 auto probes = probe_controller->SetBitrates(
269 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
270 EXPECT_GE(probes.size(), 2u);
271 probes = probe_controller->SetEstimatedBitrate(
272 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
273 fixture.CurrentTime());
274
275 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
276 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
277 probes = probe_controller->Process(fixture.CurrentTime());
278 probes = probe_controller->SetEstimatedBitrate(
279 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited,
280 fixture.CurrentTime());
281 probes = probe_controller->RequestProbe(fixture.CurrentTime());
282
283 EXPECT_EQ(probes.size(), 1u);
284 EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500);
285 }
286
TEST(ProbeControllerTest,RequestProbeWhenAlrEndedRecently)287 TEST(ProbeControllerTest, RequestProbeWhenAlrEndedRecently) {
288 ProbeControllerFixture fixture;
289 std::unique_ptr<ProbeController> probe_controller =
290 fixture.CreateController();
291 auto probes = probe_controller->SetBitrates(
292 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
293 EXPECT_EQ(probes.size(), 2u);
294 probes = probe_controller->SetEstimatedBitrate(
295 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
296 fixture.CurrentTime());
297
298 probe_controller->SetAlrStartTimeMs(absl::nullopt);
299 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
300 probes = probe_controller->Process(fixture.CurrentTime());
301 probes = probe_controller->SetEstimatedBitrate(
302 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited,
303 fixture.CurrentTime());
304 probe_controller->SetAlrEndedTimeMs(fixture.CurrentTime().ms());
305 fixture.AdvanceTime(kAlrEndedTimeout - TimeDelta::Millis(1));
306 probes = probe_controller->RequestProbe(fixture.CurrentTime());
307
308 EXPECT_EQ(probes.size(), 1u);
309 EXPECT_EQ(probes[0].target_data_rate.bps(), 0.85 * 500);
310 }
311
TEST(ProbeControllerTest,RequestProbeWhenAlrNotEndedRecently)312 TEST(ProbeControllerTest, RequestProbeWhenAlrNotEndedRecently) {
313 ProbeControllerFixture fixture;
314 std::unique_ptr<ProbeController> probe_controller =
315 fixture.CreateController();
316 auto probes = probe_controller->SetBitrates(
317 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
318 EXPECT_EQ(probes.size(), 2u);
319 probes = probe_controller->SetEstimatedBitrate(
320 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
321 fixture.CurrentTime());
322
323 probe_controller->SetAlrStartTimeMs(absl::nullopt);
324 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
325 probes = probe_controller->Process(fixture.CurrentTime());
326 probes = probe_controller->SetEstimatedBitrate(
327 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited,
328 fixture.CurrentTime());
329 probe_controller->SetAlrEndedTimeMs(fixture.CurrentTime().ms());
330 fixture.AdvanceTime(kAlrEndedTimeout + TimeDelta::Millis(1));
331 probes = probe_controller->RequestProbe(fixture.CurrentTime());
332 EXPECT_TRUE(probes.empty());
333 }
334
TEST(ProbeControllerTest,RequestProbeWhenBweDropNotRecent)335 TEST(ProbeControllerTest, RequestProbeWhenBweDropNotRecent) {
336 ProbeControllerFixture fixture;
337 std::unique_ptr<ProbeController> probe_controller =
338 fixture.CreateController();
339 auto probes = probe_controller->SetBitrates(
340 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
341 EXPECT_EQ(probes.size(), 2u);
342 probes = probe_controller->SetEstimatedBitrate(
343 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
344 fixture.CurrentTime());
345
346 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
347 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
348 probes = probe_controller->Process(fixture.CurrentTime());
349 probes = probe_controller->SetEstimatedBitrate(
350 DataRate::BitsPerSec(250), BandwidthLimitedCause::kDelayBasedLimited,
351 fixture.CurrentTime());
352 fixture.AdvanceTime(kBitrateDropTimeout + TimeDelta::Millis(1));
353 probes = probe_controller->RequestProbe(fixture.CurrentTime());
354 EXPECT_TRUE(probes.empty());
355 }
356
TEST(ProbeControllerTest,PeriodicProbing)357 TEST(ProbeControllerTest, PeriodicProbing) {
358 ProbeControllerFixture fixture;
359 std::unique_ptr<ProbeController> probe_controller =
360 fixture.CreateController();
361 probe_controller->EnablePeriodicAlrProbing(true);
362 auto probes = probe_controller->SetBitrates(
363 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
364 EXPECT_EQ(probes.size(), 2u);
365 probes = probe_controller->SetEstimatedBitrate(
366 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
367 fixture.CurrentTime());
368
369 Timestamp start_time = fixture.CurrentTime();
370
371 // Expect the controller to send a new probe after 5s has passed.
372 probe_controller->SetAlrStartTimeMs(start_time.ms());
373 fixture.AdvanceTime(TimeDelta::Seconds(5));
374 probes = probe_controller->Process(fixture.CurrentTime());
375 EXPECT_EQ(probes.size(), 1u);
376 EXPECT_EQ(probes[0].target_data_rate.bps(), 1000);
377
378 probes = probe_controller->SetEstimatedBitrate(
379 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
380 fixture.CurrentTime());
381
382 // The following probe should be sent at 10s into ALR.
383 probe_controller->SetAlrStartTimeMs(start_time.ms());
384 fixture.AdvanceTime(TimeDelta::Seconds(4));
385 probes = probe_controller->Process(fixture.CurrentTime());
386 probes = probe_controller->SetEstimatedBitrate(
387 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
388 fixture.CurrentTime());
389 EXPECT_TRUE(probes.empty());
390
391 probe_controller->SetAlrStartTimeMs(start_time.ms());
392 fixture.AdvanceTime(TimeDelta::Seconds(1));
393 probes = probe_controller->Process(fixture.CurrentTime());
394 EXPECT_EQ(probes.size(), 1u);
395 probes = probe_controller->SetEstimatedBitrate(
396 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
397 fixture.CurrentTime());
398 EXPECT_TRUE(probes.empty());
399 }
400
TEST(ProbeControllerTest,PeriodicProbingAfterReset)401 TEST(ProbeControllerTest, PeriodicProbingAfterReset) {
402 ProbeControllerFixture fixture;
403 std::unique_ptr<ProbeController> probe_controller =
404 fixture.CreateController();
405 Timestamp alr_start_time = fixture.CurrentTime();
406
407 probe_controller->SetAlrStartTimeMs(alr_start_time.ms());
408 probe_controller->EnablePeriodicAlrProbing(true);
409 auto probes = probe_controller->SetBitrates(
410 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
411 probe_controller->Reset(fixture.CurrentTime());
412
413 fixture.AdvanceTime(TimeDelta::Seconds(10));
414 probes = probe_controller->Process(fixture.CurrentTime());
415 // Since bitrates are not yet set, no probe is sent event though we are in ALR
416 // mode.
417 EXPECT_TRUE(probes.empty());
418
419 probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate,
420 kMaxBitrate, fixture.CurrentTime());
421 EXPECT_EQ(probes.size(), 2u);
422
423 // Make sure we use `kStartBitrateBps` as the estimated bitrate
424 // until SetEstimatedBitrate is called with an updated estimate.
425 fixture.AdvanceTime(TimeDelta::Seconds(10));
426 probes = probe_controller->Process(fixture.CurrentTime());
427 EXPECT_EQ(probes.size(), 1u);
428 EXPECT_EQ(probes[0].target_data_rate, kStartBitrate * 2);
429 }
430
TEST(ProbeControllerTest,TestExponentialProbingOverflow)431 TEST(ProbeControllerTest, TestExponentialProbingOverflow) {
432 ProbeControllerFixture fixture;
433 std::unique_ptr<ProbeController> probe_controller =
434 fixture.CreateController();
435 const DataRate kMbpsMultiplier = DataRate::KilobitsPerSec(1000);
436 auto probes = probe_controller->SetBitrates(kMinBitrate, 10 * kMbpsMultiplier,
437 100 * kMbpsMultiplier,
438 fixture.CurrentTime());
439 // Verify that probe bitrate is capped at the specified max bitrate.
440 probes = probe_controller->SetEstimatedBitrate(
441 60 * kMbpsMultiplier, BandwidthLimitedCause::kDelayBasedLimited,
442 fixture.CurrentTime());
443 EXPECT_EQ(probes.size(), 1u);
444 EXPECT_EQ(probes[0].target_data_rate, 100 * kMbpsMultiplier);
445 // Verify that repeated probes aren't sent.
446 probes = probe_controller->SetEstimatedBitrate(
447 100 * kMbpsMultiplier, BandwidthLimitedCause::kDelayBasedLimited,
448 fixture.CurrentTime());
449 EXPECT_TRUE(probes.empty());
450 }
451
TEST(ProbeControllerTest,TestAllocatedBitrateCap)452 TEST(ProbeControllerTest, TestAllocatedBitrateCap) {
453 ProbeControllerFixture fixture;
454 std::unique_ptr<ProbeController> probe_controller =
455 fixture.CreateController();
456 const DataRate kMbpsMultiplier = DataRate::KilobitsPerSec(1000);
457 const DataRate kMaxBitrate = 100 * kMbpsMultiplier;
458 auto probes = probe_controller->SetBitrates(
459 kMinBitrate, 10 * kMbpsMultiplier, kMaxBitrate, fixture.CurrentTime());
460
461 // Configure ALR for periodic probing.
462 probe_controller->EnablePeriodicAlrProbing(true);
463 Timestamp alr_start_time = fixture.CurrentTime();
464 probe_controller->SetAlrStartTimeMs(alr_start_time.ms());
465
466 DataRate estimated_bitrate = kMaxBitrate / 10;
467 probes = probe_controller->SetEstimatedBitrate(
468 estimated_bitrate, BandwidthLimitedCause::kDelayBasedLimited,
469 fixture.CurrentTime());
470
471 // Set a max allocated bitrate below the current estimate.
472 DataRate max_allocated = estimated_bitrate - 1 * kMbpsMultiplier;
473 probes = probe_controller->OnMaxTotalAllocatedBitrate(max_allocated,
474 fixture.CurrentTime());
475 EXPECT_TRUE(probes.empty()); // No probe since lower than current max.
476
477 // Probes such as ALR capped at 2x the max allocation limit.
478 fixture.AdvanceTime(TimeDelta::Seconds(5));
479 probes = probe_controller->Process(fixture.CurrentTime());
480 EXPECT_EQ(probes.size(), 1u);
481 EXPECT_EQ(probes[0].target_data_rate, 2 * max_allocated);
482
483 // Remove allocation limit.
484 EXPECT_TRUE(
485 probe_controller
486 ->OnMaxTotalAllocatedBitrate(DataRate::Zero(), fixture.CurrentTime())
487 .empty());
488 fixture.AdvanceTime(TimeDelta::Seconds(5));
489 probes = probe_controller->Process(fixture.CurrentTime());
490 EXPECT_EQ(probes.size(), 1u);
491 EXPECT_EQ(probes[0].target_data_rate, estimated_bitrate * 2);
492 }
493
TEST(ProbeControllerTest,ConfigurableProbingFieldTrial)494 TEST(ProbeControllerTest, ConfigurableProbingFieldTrial) {
495 ProbeControllerFixture fixture(
496 "WebRTC-Bwe-ProbingConfiguration/"
497 "p1:2,p2:5,step_size:3,further_probe_threshold:0.8,"
498 "alloc_p1:2,alloc_p2,min_probe_packets_sent:2/");
499 std::unique_ptr<ProbeController> probe_controller =
500 fixture.CreateController();
501
502 auto probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate,
503 DataRate::KilobitsPerSec(5000),
504 fixture.CurrentTime());
505 EXPECT_EQ(probes.size(), 2u);
506 EXPECT_EQ(probes[0].target_data_rate.bps(), 600);
507 EXPECT_EQ(probes[0].target_probe_count, 2);
508 EXPECT_EQ(probes[1].target_data_rate.bps(), 1500);
509 EXPECT_EQ(probes[1].target_probe_count, 2);
510
511 // Repeated probe should only be sent when estimated bitrate climbs above
512 // 0.8 * 5 * kStartBitrateBps = 1200.
513 probes = probe_controller->SetEstimatedBitrate(
514 DataRate::BitsPerSec(1100), BandwidthLimitedCause::kDelayBasedLimited,
515 fixture.CurrentTime());
516 EXPECT_EQ(probes.size(), 0u);
517
518 probes = probe_controller->SetEstimatedBitrate(
519 DataRate::BitsPerSec(1250), BandwidthLimitedCause::kDelayBasedLimited,
520 fixture.CurrentTime());
521 EXPECT_EQ(probes.size(), 1u);
522 EXPECT_EQ(probes[0].target_data_rate.bps(), 3 * 1250);
523
524 fixture.AdvanceTime(TimeDelta::Seconds(5));
525 probes = probe_controller->Process(fixture.CurrentTime());
526
527 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
528 probes = probe_controller->OnMaxTotalAllocatedBitrate(
529 DataRate::KilobitsPerSec(200), fixture.CurrentTime());
530 EXPECT_EQ(probes.size(), 1u);
531 EXPECT_EQ(probes[0].target_data_rate.bps(), 400'000);
532 }
533
TEST(ProbeControllerTest,LimitAlrProbeWhenLossBasedBweLimited)534 TEST(ProbeControllerTest, LimitAlrProbeWhenLossBasedBweLimited) {
535 ProbeControllerFixture fixture(
536 "WebRTC-Bwe-ProbingConfiguration/"
537 "limit_probe_target_rate_to_loss_bwe:true/");
538 std::unique_ptr<ProbeController> probe_controller =
539 fixture.CreateController();
540 probe_controller->EnablePeriodicAlrProbing(true);
541 auto probes = probe_controller->SetBitrates(
542 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
543 probes = probe_controller->SetEstimatedBitrate(
544 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
545 fixture.CurrentTime());
546 // Expect the controller to send a new probe after 5s has passed.
547 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
548 fixture.AdvanceTime(TimeDelta::Seconds(5));
549 probes = probe_controller->Process(fixture.CurrentTime());
550 ASSERT_EQ(probes.size(), 1u);
551
552 probes = probe_controller->SetEstimatedBitrate(
553 DataRate::BitsPerSec(500),
554 BandwidthLimitedCause::kLossLimitedBweIncreasing, fixture.CurrentTime());
555 fixture.AdvanceTime(TimeDelta::Seconds(6));
556 probes = probe_controller->Process(fixture.CurrentTime());
557 ASSERT_EQ(probes.size(), 1u);
558 EXPECT_EQ(probes[0].target_data_rate, 1.5 * DataRate::BitsPerSec(500));
559
560 probes = probe_controller->SetEstimatedBitrate(
561 1.5 * DataRate::BitsPerSec(500),
562 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime());
563 fixture.AdvanceTime(TimeDelta::Seconds(6));
564 probes = probe_controller->Process(fixture.CurrentTime());
565 ASSERT_FALSE(probes.empty());
566 EXPECT_GT(probes[0].target_data_rate, 1.5 * 1.5 * DataRate::BitsPerSec(500));
567 }
568
TEST(ProbeControllerTest,PeriodicProbeAtUpperNetworkStateEstimate)569 TEST(ProbeControllerTest, PeriodicProbeAtUpperNetworkStateEstimate) {
570 ProbeControllerFixture fixture(
571 "WebRTC-Bwe-ProbingConfiguration/network_state_interval:5s/");
572 std::unique_ptr<ProbeController> probe_controller =
573 fixture.CreateController();
574
575 auto probes = probe_controller->SetBitrates(
576 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
577 probes = probe_controller->SetEstimatedBitrate(
578 DataRate::BitsPerSec(5000), BandwidthLimitedCause::kDelayBasedLimited,
579 fixture.CurrentTime());
580 // Expect the controller to send a new probe after 5s has passed.
581 NetworkStateEstimate state_estimate;
582 state_estimate.link_capacity_upper = DataRate::KilobitsPerSec(6);
583 probe_controller->SetNetworkStateEstimate(state_estimate);
584
585 fixture.AdvanceTime(TimeDelta::Seconds(5));
586 probes = probe_controller->Process(fixture.CurrentTime());
587 ASSERT_EQ(probes.size(), 1u);
588 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper);
589 fixture.AdvanceTime(TimeDelta::Seconds(5));
590 probes = probe_controller->Process(fixture.CurrentTime());
591 ASSERT_EQ(probes.size(), 1u);
592 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper);
593 }
594
TEST(ProbeControllerTest,LimitProbeAtUpperNetworkStateEstimateIfLossBasedLimited)595 TEST(ProbeControllerTest,
596 LimitProbeAtUpperNetworkStateEstimateIfLossBasedLimited) {
597 ProbeControllerFixture fixture(
598 "WebRTC-Bwe-ProbingConfiguration/"
599 "network_state_interval:5s,limit_probe_target_rate_to_loss_bwe:true/");
600 std::unique_ptr<ProbeController> probe_controller =
601 fixture.CreateController();
602
603 auto probes = probe_controller->SetBitrates(
604 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
605 probes = probe_controller->SetEstimatedBitrate(
606 DataRate::BitsPerSec(500), BandwidthLimitedCause::kDelayBasedLimited,
607 fixture.CurrentTime());
608 // Expect the controller to send a new probe after 5s has passed.
609 NetworkStateEstimate state_estimate;
610 state_estimate.link_capacity_upper = DataRate::BitsPerSec(700);
611 probe_controller->SetNetworkStateEstimate(state_estimate);
612 fixture.AdvanceTime(TimeDelta::Seconds(5));
613 probes = probe_controller->Process(fixture.CurrentTime());
614 ASSERT_EQ(probes.size(), 1u);
615
616 probes = probe_controller->SetEstimatedBitrate(
617 DataRate::BitsPerSec(500),
618 BandwidthLimitedCause::kLossLimitedBweIncreasing, fixture.CurrentTime());
619 // Expect the controller to send a new probe after 5s has passed.
620 fixture.AdvanceTime(TimeDelta::Seconds(5));
621 probes = probe_controller->Process(fixture.CurrentTime());
622 ASSERT_FALSE(probes.empty());
623 EXPECT_EQ(probes[0].target_data_rate, DataRate::BitsPerSec(700));
624 }
625
TEST(ProbeControllerTest,AlrProbesLimitedByNetworkStateEstimate)626 TEST(ProbeControllerTest, AlrProbesLimitedByNetworkStateEstimate) {
627 ProbeControllerFixture fixture(
628 "WebRTC-Bwe-ProbingConfiguration/network_state_interval:5s/");
629 std::unique_ptr<ProbeController> probe_controller =
630 fixture.CreateController();
631 probe_controller->EnablePeriodicAlrProbing(true);
632 auto probes = probe_controller->SetBitrates(
633 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
634 probes = probe_controller->SetEstimatedBitrate(
635 DataRate::KilobitsPerSec(6), BandwidthLimitedCause::kDelayBasedLimited,
636 fixture.CurrentTime());
637 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
638
639 fixture.AdvanceTime(TimeDelta::Seconds(5));
640 probes = probe_controller->Process(fixture.CurrentTime());
641 ASSERT_EQ(probes.size(), 1u);
642 EXPECT_EQ(probes[0].target_data_rate, kMaxBitrate);
643
644 NetworkStateEstimate state_estimate;
645 state_estimate.link_capacity_upper = DataRate::BitsPerSec(8000);
646 probe_controller->SetNetworkStateEstimate(state_estimate);
647 fixture.AdvanceTime(TimeDelta::Seconds(5));
648 probes = probe_controller->Process(fixture.CurrentTime());
649 ASSERT_EQ(probes.size(), 1u);
650 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper);
651 }
652
TEST(ProbeControllerTest,CanSetLongerProbeDurationAfterNetworkStateEstimate)653 TEST(ProbeControllerTest, CanSetLongerProbeDurationAfterNetworkStateEstimate) {
654 ProbeControllerFixture fixture(
655 "WebRTC-Bwe-ProbingConfiguration/"
656 "network_state_interval:5s,network_state_probe_duration:100ms/");
657 std::unique_ptr<ProbeController> probe_controller =
658 fixture.CreateController();
659
660 auto probes = probe_controller->SetBitrates(
661 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
662 probes = probe_controller->SetEstimatedBitrate(
663 DataRate::KilobitsPerSec(5), BandwidthLimitedCause::kDelayBasedLimited,
664 fixture.CurrentTime());
665 ASSERT_FALSE(probes.empty());
666 EXPECT_LT(probes[0].target_duration, TimeDelta::Millis(100));
667
668 NetworkStateEstimate state_estimate;
669 state_estimate.link_capacity_upper = DataRate::KilobitsPerSec(6);
670 probe_controller->SetNetworkStateEstimate(state_estimate);
671 fixture.AdvanceTime(TimeDelta::Seconds(5));
672 probes = probe_controller->Process(fixture.CurrentTime());
673 ASSERT_EQ(probes.size(), 1u);
674 EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(100));
675 }
676
TEST(ProbeControllerTest,ProbeInAlrIfLossBasedIncreasing)677 TEST(ProbeControllerTest, ProbeInAlrIfLossBasedIncreasing) {
678 ProbeControllerFixture fixture(
679 "WebRTC-Bwe-ProbingConfiguration/"
680 "limit_probe_target_rate_to_loss_bwe:true/");
681 std::unique_ptr<ProbeController> probe_controller =
682 fixture.CreateController();
683 auto probes = probe_controller->SetBitrates(
684 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
685 probe_controller->EnablePeriodicAlrProbing(true);
686 probes = probe_controller->SetEstimatedBitrate(
687 kStartBitrate, BandwidthLimitedCause::kLossLimitedBweIncreasing,
688 fixture.CurrentTime());
689
690 // Wait long enough to time out exponential probing.
691 fixture.AdvanceTime(kExponentialProbingTimeout);
692 probes = probe_controller->Process(fixture.CurrentTime());
693 ASSERT_TRUE(probes.empty());
694
695 // Probe when in alr.
696 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
697 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
698 probes = probe_controller->Process(fixture.CurrentTime());
699 ASSERT_EQ(probes.size(), 1u);
700 EXPECT_EQ(probes.at(0).target_data_rate, 1.5 * kStartBitrate);
701 }
702
TEST(ProbeControllerTest,ProbeFurtherInAlrIfLossBasedIncreasing)703 TEST(ProbeControllerTest, ProbeFurtherInAlrIfLossBasedIncreasing) {
704 ProbeControllerFixture fixture(
705 "WebRTC-Bwe-ProbingConfiguration/"
706 "limit_probe_target_rate_to_loss_bwe:true/");
707 std::unique_ptr<ProbeController> probe_controller =
708 fixture.CreateController();
709 auto probes = probe_controller->SetBitrates(
710 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
711 probe_controller->EnablePeriodicAlrProbing(true);
712 probes = probe_controller->SetEstimatedBitrate(
713 kStartBitrate, BandwidthLimitedCause::kLossLimitedBweIncreasing,
714 fixture.CurrentTime());
715
716 // Wait long enough to time out exponential probing.
717 fixture.AdvanceTime(kExponentialProbingTimeout);
718 probes = probe_controller->Process(fixture.CurrentTime());
719 ASSERT_TRUE(probes.empty());
720
721 // Probe when in alr.
722 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
723 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
724 probes = probe_controller->Process(fixture.CurrentTime());
725 ASSERT_EQ(probes.size(), 1u);
726 ASSERT_EQ(probes.at(0).target_data_rate, 1.5 * kStartBitrate);
727
728 probes = probe_controller->SetEstimatedBitrate(
729 1.5 * kStartBitrate, BandwidthLimitedCause::kLossLimitedBweIncreasing,
730 fixture.CurrentTime());
731 ASSERT_EQ(probes.size(), 1u);
732 EXPECT_EQ(probes[0].target_data_rate, 1.5 * 1.5 * kStartBitrate);
733 }
734
TEST(ProbeControllerTest,NotProbeWhenInAlrIfLossBasedDecreases)735 TEST(ProbeControllerTest, NotProbeWhenInAlrIfLossBasedDecreases) {
736 ProbeControllerFixture fixture(
737 "WebRTC-Bwe-ProbingConfiguration/"
738 "network_state_interval:5s,limit_probe_target_rate_to_loss_bwe:true/");
739 std::unique_ptr<ProbeController> probe_controller =
740 fixture.CreateController();
741 auto probes = probe_controller->SetBitrates(
742 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
743 probe_controller->EnablePeriodicAlrProbing(true);
744 probes = probe_controller->SetEstimatedBitrate(
745 kStartBitrate, BandwidthLimitedCause::kLossLimitedBweDecreasing,
746 fixture.CurrentTime());
747
748 // Wait long enough to time out exponential probing.
749 fixture.AdvanceTime(kExponentialProbingTimeout);
750 probes = probe_controller->Process(fixture.CurrentTime());
751 ASSERT_TRUE(probes.empty());
752
753 // Not probe in alr when loss based estimate decreases.
754 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
755 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
756 probes = probe_controller->Process(fixture.CurrentTime());
757 EXPECT_TRUE(probes.empty());
758 }
759
TEST(ProbeControllerTest,NotProbeIfLossBasedIncreasingOutsideAlr)760 TEST(ProbeControllerTest, NotProbeIfLossBasedIncreasingOutsideAlr) {
761 ProbeControllerFixture fixture(
762 "WebRTC-Bwe-ProbingConfiguration/"
763 "limit_probe_target_rate_to_loss_bwe:true/");
764 std::unique_ptr<ProbeController> probe_controller =
765 fixture.CreateController();
766 auto probes = probe_controller->SetBitrates(
767 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
768 probe_controller->EnablePeriodicAlrProbing(true);
769 probes = probe_controller->SetEstimatedBitrate(
770 kStartBitrate, BandwidthLimitedCause::kLossLimitedBweIncreasing,
771 fixture.CurrentTime());
772
773 // Wait long enough to time out exponential probing.
774 fixture.AdvanceTime(kExponentialProbingTimeout);
775 probes = probe_controller->Process(fixture.CurrentTime());
776 ASSERT_TRUE(probes.empty());
777
778 probe_controller->SetAlrStartTimeMs(absl::nullopt);
779 fixture.AdvanceTime(kAlrProbeInterval + TimeDelta::Millis(1));
780 probes = probe_controller->Process(fixture.CurrentTime());
781 EXPECT_TRUE(probes.empty());
782 }
783
TEST(ProbeControllerTest,ProbeFurtherWhenLossBasedIsSameAsDelayBasedEstimate)784 TEST(ProbeControllerTest, ProbeFurtherWhenLossBasedIsSameAsDelayBasedEstimate) {
785 ProbeControllerFixture fixture(
786 "WebRTC-Bwe-ProbingConfiguration/"
787 "network_state_interval:5s,limit_probe_target_rate_to_loss_bwe:true/");
788 std::unique_ptr<ProbeController> probe_controller =
789 fixture.CreateController();
790
791 auto probes = probe_controller->SetBitrates(
792 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
793 ASSERT_FALSE(probes.empty());
794
795 // Need to wait at least one second before process can trigger a new probe.
796 fixture.AdvanceTime(TimeDelta::Millis(1100));
797 probes = probe_controller->Process(fixture.CurrentTime());
798 ASSERT_TRUE(probes.empty());
799
800 NetworkStateEstimate state_estimate;
801 state_estimate.link_capacity_upper = 5 * kStartBitrate;
802 probe_controller->SetNetworkStateEstimate(state_estimate);
803 fixture.AdvanceTime(TimeDelta::Seconds(5));
804 probes = probe_controller->Process(fixture.CurrentTime());
805 ASSERT_FALSE(probes.empty());
806
807 DataRate probe_target_rate = probes[0].target_data_rate;
808 EXPECT_LT(probe_target_rate, state_estimate.link_capacity_upper);
809 // Expect that more probes are sent if BWE is the same as delay based
810 // estimate.
811 probes = probe_controller->SetEstimatedBitrate(
812 probe_target_rate, BandwidthLimitedCause::kDelayBasedLimited,
813 fixture.CurrentTime());
814 ASSERT_FALSE(probes.empty());
815 EXPECT_EQ(probes[0].target_data_rate, 2 * probe_target_rate);
816 }
817
TEST(ProbeControllerTest,ProbeIfEstimateLowerThanNetworkStateEstimate)818 TEST(ProbeControllerTest, ProbeIfEstimateLowerThanNetworkStateEstimate) {
819 // Periodic probe every 1 second if estimate is lower than 50% of the
820 // NetworkStateEstimate.
821 ProbeControllerFixture fixture(
822 "WebRTC-Bwe-ProbingConfiguration/est_lower_than_network_interval:1s,"
823 "est_lower_than_network_ratio:0.5,limit_probe_"
824 "target_rate_to_loss_bwe:true/");
825 std::unique_ptr<ProbeController> probe_controller =
826 fixture.CreateController();
827
828 auto probes = probe_controller->SetBitrates(
829 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
830 probes = probe_controller->SetEstimatedBitrate(
831 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited,
832 fixture.CurrentTime());
833 // Need to wait at least one second before process can trigger a new probe.
834 fixture.AdvanceTime(TimeDelta::Millis(1100));
835 probes = probe_controller->Process(fixture.CurrentTime());
836 EXPECT_TRUE(probes.empty());
837
838 NetworkStateEstimate state_estimate;
839 state_estimate.link_capacity_upper = kStartBitrate;
840 probe_controller->SetNetworkStateEstimate(state_estimate);
841 probes = probe_controller->Process(fixture.CurrentTime());
842 EXPECT_TRUE(probes.empty());
843
844 state_estimate.link_capacity_upper = kStartBitrate * 3;
845 probe_controller->SetNetworkStateEstimate(state_estimate);
846 probes = probe_controller->Process(fixture.CurrentTime());
847 ASSERT_EQ(probes.size(), 1u);
848 EXPECT_GT(probes[0].target_data_rate, kStartBitrate);
849
850 // If network state not increased, send another probe.
851 fixture.AdvanceTime(TimeDelta::Millis(1100));
852 probes = probe_controller->Process(fixture.CurrentTime());
853 EXPECT_FALSE(probes.empty());
854
855 // Stop probing if estimate increase. We might probe further here though.
856 probes = probe_controller->SetEstimatedBitrate(
857 2 * kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited,
858 fixture.CurrentTime());
859 // No more periodic probes.
860 fixture.AdvanceTime(TimeDelta::Millis(1100));
861 probes = probe_controller->Process(fixture.CurrentTime());
862 EXPECT_TRUE(probes.empty());
863 }
864
TEST(ProbeControllerTest,DontProbeFurtherWhenLossLimited)865 TEST(ProbeControllerTest, DontProbeFurtherWhenLossLimited) {
866 ProbeControllerFixture fixture(
867 "WebRTC-Bwe-ProbingConfiguration/"
868 "network_state_interval:5s,limit_probe_target_rate_to_loss_bwe:true/");
869 std::unique_ptr<ProbeController> probe_controller =
870 fixture.CreateController();
871
872 auto probes = probe_controller->SetBitrates(
873 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
874 ASSERT_FALSE(probes.empty());
875
876 // Need to wait at least one second before process can trigger a new probe.
877 fixture.AdvanceTime(TimeDelta::Millis(1100));
878 probes = probe_controller->Process(fixture.CurrentTime());
879 EXPECT_TRUE(probes.empty());
880
881 NetworkStateEstimate state_estimate;
882 state_estimate.link_capacity_upper = 3 * kStartBitrate;
883 probe_controller->SetNetworkStateEstimate(state_estimate);
884 fixture.AdvanceTime(TimeDelta::Seconds(5));
885 probes = probe_controller->Process(fixture.CurrentTime());
886 EXPECT_FALSE(probes.empty());
887 EXPECT_LT(probes[0].target_data_rate, state_estimate.link_capacity_upper);
888 // Expect that no more probes are sent immediately if BWE is loss limited.
889 probes = probe_controller->SetEstimatedBitrate(
890 probes[0].target_data_rate,
891 BandwidthLimitedCause::kLossLimitedBweDecreasing, fixture.CurrentTime());
892 EXPECT_TRUE(probes.empty());
893 }
894
TEST(ProbeControllerTest,ProbeFurtherWhenDelayBasedLimited)895 TEST(ProbeControllerTest, ProbeFurtherWhenDelayBasedLimited) {
896 ProbeControllerFixture fixture(
897 "WebRTC-Bwe-ProbingConfiguration/"
898 "network_state_interval:5s,limit_probe_target_rate_to_loss_bwe:true/");
899 std::unique_ptr<ProbeController> probe_controller =
900 fixture.CreateController();
901
902 auto probes = probe_controller->SetBitrates(
903 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
904 ASSERT_FALSE(probes.empty());
905
906 // Need to wait at least one second before process can trigger a new probe.
907 fixture.AdvanceTime(TimeDelta::Millis(1100));
908 probes = probe_controller->Process(fixture.CurrentTime());
909 EXPECT_TRUE(probes.empty());
910
911 NetworkStateEstimate state_estimate;
912 state_estimate.link_capacity_upper = 3 * kStartBitrate;
913 probe_controller->SetNetworkStateEstimate(state_estimate);
914 fixture.AdvanceTime(TimeDelta::Seconds(5));
915 probes = probe_controller->Process(fixture.CurrentTime());
916 EXPECT_FALSE(probes.empty());
917 EXPECT_LT(probes[0].target_data_rate, state_estimate.link_capacity_upper);
918 // Since the probe was successfull, expect to continue probing.
919 probes = probe_controller->SetEstimatedBitrate(
920 probes[0].target_data_rate, BandwidthLimitedCause::kDelayBasedLimited,
921 fixture.CurrentTime());
922 EXPECT_FALSE(probes.empty());
923 EXPECT_EQ(probes[0].target_data_rate, state_estimate.link_capacity_upper);
924 }
925
TEST(ProbeControllerTest,ProbeFurtherIfNetworkStateEstimateIncreaseAfterProbeSent)926 TEST(ProbeControllerTest,
927 ProbeFurtherIfNetworkStateEstimateIncreaseAfterProbeSent) {
928 ProbeControllerFixture fixture(
929 "WebRTC-Bwe-ProbingConfiguration/"
930 "network_state_interval:5s,limit_probe_target_rate_to_loss_bwe:true/");
931 std::unique_ptr<ProbeController> probe_controller =
932 fixture.CreateController();
933 auto probes = probe_controller->SetBitrates(
934 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
935 ASSERT_FALSE(probes.empty());
936 NetworkStateEstimate state_estimate;
937 state_estimate.link_capacity_upper = 1.2 * probes[0].target_data_rate / 2;
938 probe_controller->SetNetworkStateEstimate(state_estimate);
939 // No immediate further probing since probe result is low.
940 probes = probe_controller->SetEstimatedBitrate(
941 probes[0].target_data_rate / 2, BandwidthLimitedCause::kDelayBasedLimited,
942 fixture.CurrentTime());
943 ASSERT_TRUE(probes.empty());
944
945 fixture.AdvanceTime(TimeDelta::Seconds(5));
946 probes = probe_controller->Process(fixture.CurrentTime());
947 ASSERT_FALSE(probes.empty());
948 EXPECT_LE(probes[0].target_data_rate, state_estimate.link_capacity_upper);
949 // If the network state estimate increase above the threshold to probe
950 // further, and the probe suceeed, expect a new probe.
951 state_estimate.link_capacity_upper = 3 * kStartBitrate;
952 probe_controller->SetNetworkStateEstimate(state_estimate);
953 probes = probe_controller->SetEstimatedBitrate(
954 probes[0].target_data_rate, BandwidthLimitedCause::kDelayBasedLimited,
955 fixture.CurrentTime());
956 EXPECT_FALSE(probes.empty());
957
958 // But no more probes if estimate is close to the link capacity.
959 probes = probe_controller->SetEstimatedBitrate(
960 state_estimate.link_capacity_upper * 0.9,
961 BandwidthLimitedCause::kDelayBasedLimited, fixture.CurrentTime());
962 EXPECT_TRUE(probes.empty());
963 }
964
TEST(ProbeControllerTest,SkipAlrProbeIfEstimateLargerThanMaxProbe)965 TEST(ProbeControllerTest, SkipAlrProbeIfEstimateLargerThanMaxProbe) {
966 ProbeControllerFixture fixture(
967 "WebRTC-Bwe-ProbingConfiguration/"
968 "skip_if_est_larger_than_fraction_of_max:0.9/");
969 std::unique_ptr<ProbeController> probe_controller =
970 fixture.CreateController();
971 probe_controller->EnablePeriodicAlrProbing(true);
972 auto probes = probe_controller->SetBitrates(
973 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
974 ASSERT_FALSE(probes.empty());
975
976 probes = probe_controller->SetEstimatedBitrate(
977 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited,
978 fixture.CurrentTime());
979 EXPECT_TRUE(probes.empty());
980
981 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
982 fixture.AdvanceTime(TimeDelta::Seconds(10));
983 probes = probe_controller->Process(fixture.CurrentTime());
984 EXPECT_TRUE(probes.empty());
985
986 // But if the max rate increase, A new probe is sent.
987 probes = probe_controller->SetBitrates(
988 kMinBitrate, kStartBitrate, 2 * kMaxBitrate, fixture.CurrentTime());
989 EXPECT_FALSE(probes.empty());
990 }
991
TEST(ProbeControllerTest,SkipAlrProbeIfEstimateLargerThanFractionOfMaxAllocated)992 TEST(ProbeControllerTest,
993 SkipAlrProbeIfEstimateLargerThanFractionOfMaxAllocated) {
994 ProbeControllerFixture fixture(
995 "WebRTC-Bwe-ProbingConfiguration/"
996 "skip_if_est_larger_than_fraction_of_max:1.0/");
997 std::unique_ptr<ProbeController> probe_controller =
998 fixture.CreateController();
999 probe_controller->EnablePeriodicAlrProbing(true);
1000 auto probes = probe_controller->SetBitrates(
1001 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
1002 ASSERT_FALSE(probes.empty());
1003 probes = probe_controller->SetEstimatedBitrate(
1004 kMaxBitrate / 2, BandwidthLimitedCause::kDelayBasedLimited,
1005 fixture.CurrentTime());
1006
1007 fixture.AdvanceTime(TimeDelta::Seconds(10));
1008 probe_controller->SetAlrStartTimeMs(fixture.CurrentTime().ms());
1009 probes = probe_controller->OnMaxTotalAllocatedBitrate(kMaxBitrate / 2,
1010 fixture.CurrentTime());
1011 // No probes since total allocated is not higher than the current estimate.
1012 EXPECT_TRUE(probes.empty());
1013 fixture.AdvanceTime(TimeDelta::Seconds(2));
1014 probes = probe_controller->Process(fixture.CurrentTime());
1015 EXPECT_TRUE(probes.empty());
1016
1017 // But if the max allocated increase, A new probe is sent.
1018 probes = probe_controller->OnMaxTotalAllocatedBitrate(
1019 kMaxBitrate / 2 + DataRate::BitsPerSec(1), fixture.CurrentTime());
1020 EXPECT_FALSE(probes.empty());
1021 }
1022
TEST(ProbeControllerTest,SkipNetworkStateProbeIfEstimateLargerThanMaxProbe)1023 TEST(ProbeControllerTest, SkipNetworkStateProbeIfEstimateLargerThanMaxProbe) {
1024 ProbeControllerFixture fixture(
1025 "WebRTC-Bwe-ProbingConfiguration/"
1026 "network_state_interval:2s,skip_if_est_larger_than_fraction_of_max:0.9/");
1027 std::unique_ptr<ProbeController> probe_controller =
1028 fixture.CreateController();
1029 auto probes = probe_controller->SetBitrates(
1030 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
1031 ASSERT_FALSE(probes.empty());
1032
1033 probe_controller->SetNetworkStateEstimate(
1034 {.link_capacity_upper = 2 * kMaxBitrate});
1035 probes = probe_controller->SetEstimatedBitrate(
1036 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited,
1037 fixture.CurrentTime());
1038 EXPECT_TRUE(probes.empty());
1039
1040 fixture.AdvanceTime(TimeDelta::Seconds(10));
1041 probes = probe_controller->Process(fixture.CurrentTime());
1042 EXPECT_TRUE(probes.empty());
1043 }
1044
TEST(ProbeControllerTest,SendsProbeIfNetworkStateEstimateLowerThanMaxProbe)1045 TEST(ProbeControllerTest, SendsProbeIfNetworkStateEstimateLowerThanMaxProbe) {
1046 ProbeControllerFixture fixture(
1047 "WebRTC-Bwe-ProbingConfiguration/"
1048 "network_state_interval:2s,skip_if_est_larger_than_fraction_of_max:0.9,"
1049 "/");
1050 std::unique_ptr<ProbeController> probe_controller =
1051 fixture.CreateController();
1052 auto probes = probe_controller->SetBitrates(
1053 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
1054 ASSERT_FALSE(probes.empty());
1055 probe_controller->SetNetworkStateEstimate(
1056 {.link_capacity_upper = 2 * kMaxBitrate});
1057 probes = probe_controller->SetEstimatedBitrate(
1058 kMaxBitrate, BandwidthLimitedCause::kDelayBasedLimited,
1059 fixture.CurrentTime());
1060 EXPECT_TRUE(probes.empty());
1061
1062 // Need to wait at least two seconds before process can trigger a new probe.
1063 fixture.AdvanceTime(TimeDelta::Millis(2100));
1064
1065 probes = probe_controller->SetEstimatedBitrate(
1066 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited,
1067 fixture.CurrentTime());
1068 EXPECT_TRUE(probes.empty());
1069 probe_controller->SetNetworkStateEstimate(
1070 {.link_capacity_upper = 2 * kStartBitrate});
1071 probes = probe_controller->Process(fixture.CurrentTime());
1072 EXPECT_FALSE(probes.empty());
1073 }
1074
TEST(ProbeControllerTest,DontSendProbeIfNetworkStateEstimateIsZero)1075 TEST(ProbeControllerTest, DontSendProbeIfNetworkStateEstimateIsZero) {
1076 ProbeControllerFixture fixture(
1077 "WebRTC-Bwe-ProbingConfiguration/"
1078 "network_state_interval:5s,limit_probe_target_rate_to_loss_bwe:true/");
1079 std::unique_ptr<ProbeController> probe_controller =
1080 fixture.CreateController();
1081 auto probes = probe_controller->SetBitrates(
1082 kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
1083 probes = probe_controller->SetEstimatedBitrate(
1084 kStartBitrate, BandwidthLimitedCause::kDelayBasedLimited,
1085 fixture.CurrentTime());
1086 probe_controller->SetNetworkStateEstimate(
1087 {.link_capacity_upper = kStartBitrate});
1088 // Need to wait at least one second before process can trigger a new probe.
1089 fixture.AdvanceTime(TimeDelta::Millis(1100));
1090 probes = probe_controller->Process(fixture.CurrentTime());
1091 ASSERT_TRUE(probes.empty());
1092
1093 probe_controller->SetNetworkStateEstimate(
1094 {.link_capacity_upper = DataRate::Zero()});
1095 probes = probe_controller->Process(fixture.CurrentTime());
1096 EXPECT_TRUE(probes.empty());
1097 fixture.AdvanceTime(TimeDelta::Seconds(6));
1098 probes = probe_controller->Process(fixture.CurrentTime());
1099 EXPECT_TRUE(probes.empty());
1100 }
1101 } // namespace test
1102 } // namespace webrtc
1103