admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make the stable target rate always less or equal than the target rate

Browse Source 
This behavior seems to conform to expectations from the rate allocators,
using this signal to chose which layers to enable and then distributing
the remaining bandwidth to the activated layers.

Bug: webrtc:10126
Change-Id: If0e1b27dc672ec2fbb30a5f5ac734e5ed4b42e45
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/151306
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Florent Castelli <orphis@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29065}
This commit is contained in:
Florent Castelli 2019-09-04 14:58:32 +02:00 committed by Commit Bot
parent 52a8da38f9
commit 1067d31022
4 changed files with 18 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
modules/bitrate_controller/send_side_bandwidth_estimation.cc
View File

@ -112,10 +112,10 @@ LinkCapacityTracker::LinkCapacityTracker()
LinkCapacityTracker::~LinkCapacityTracker() {}
void LinkCapacityTracker::OnOveruse(DataRate acknowledged_rate,
void LinkCapacityTracker::OnOveruse(DataRate delay_based_bitrate,
Timestamp at_time) {
capacity_estimate_bps_ =
std::min(capacity_estimate_bps_, acknowledged_rate.bps<double>());
std::min(capacity_estimate_bps_, delay_based_bitrate.bps<double>());
last_link_capacity_update_ = at_time;
}
@ -327,11 +327,10 @@ void SendSideBandwidthEstimation::UpdateReceiverEstimate(Timestamp at_time,
void SendSideBandwidthEstimation::UpdateDelayBasedEstimate(Timestamp at_time,
DataRate bitrate) {
if (acknowledged_rate_) {
if (bitrate < delay_based_bitrate_) {
link_capacity_.OnOveruse(*acknowledged_rate_, at_time);
}
if (bitrate < delay_based_bitrate_) {
link_capacity_.OnOveruse(bitrate, at_time);
}
delay_based_bitrate_ = bitrate;
CapBitrateToThresholds(at_time, current_bitrate_);
}

2
modules/bitrate_controller/send_side_bandwidth_estimation.h
View File

@ -35,7 +35,7 @@ class LinkCapacityTracker {
public:
LinkCapacityTracker();
~LinkCapacityTracker();
void OnOveruse(DataRate acknowledged_rate, Timestamp at_time);
void OnOveruse(DataRate delay_based_bitrate, Timestamp at_time);
void OnStartingRate(DataRate start_rate);
void OnRateUpdate(DataRate acknowledged, Timestamp at_time);
void OnRttBackoff(DataRate backoff_rate, Timestamp at_time);

4
modules/congestion_controller/goog_cc/goog_cc_network_control.cc
View File

@ -632,8 +632,8 @@ void GoogCcNetworkController::MaybeTriggerOnNetworkChanged(
TargetTransferRate target_rate_msg;
target_rate_msg.at_time = at_time;
target_rate_msg.target_rate = target_rate;
target_rate_msg.stable_target_rate =
bandwidth_estimation_->GetEstimatedLinkCapacity();
target_rate_msg.stable_target_rate = std::min(
bandwidth_estimation_->GetEstimatedLinkCapacity(), target_rate);
target_rate_msg.network_estimate.at_time = at_time;
target_rate_msg.network_estimate.round_trip_time = TimeDelta::ms(rtt_ms);
target_rate_msg.network_estimate.bandwidth = last_raw_target_rate_;

18
modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc
View File

@ -508,18 +508,20 @@ TEST_F(GoogCcNetworkControllerTest, StableEstimateDoesNotVaryInSteadyState) {
// Measure variation in steady state.
for (int i = 0; i < 20; ++i) {
min_stable_target =
std::min(min_stable_target, client->stable_target_rate());
max_stable_target =
std::max(max_stable_target, client->stable_target_rate());
min_target = std::min(min_target, client->link_capacity());
max_target = std::max(max_target, client->link_capacity());
auto stable_target_rate = client->stable_target_rate();
auto target_rate = client->link_capacity();
EXPECT_LE(stable_target_rate, target_rate);
min_stable_target = std::min(min_stable_target, stable_target_rate);
max_stable_target = std::max(max_stable_target, stable_target_rate);
min_target = std::min(min_target, target_rate);
max_target = std::max(max_target, target_rate);
s.RunFor(TimeDelta::seconds(1));
}
// We expect no variation under the trial in steady state.
EXPECT_GT(min_stable_target / max_stable_target, 0.95);
// We should expect drops by at least 15% (default backoff.)
EXPECT_LT(min_target / max_target, 0.85);
// We should expect the stable target to be more stable than the immediate one
EXPECT_GE(min_stable_target / max_stable_target, min_target / max_target);
}
TEST_F(GoogCcNetworkControllerTest,