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

Add acked bandwidth estimator config for sample uncertainty in ALR.

Browse Source 
Change-Id: Ie01d66d459f704e7fa99b439dd6f917e4e41cead
Bug: webrtc:10698
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/139106
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Christoffer Rodbro <crodbro@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28105}
This commit is contained in:
Christoffer Rodbro
2019-05-29 13:54:20 +02:00
committed by Commit Bot
parent 7eb0a5e210
commit b3b3e3f632
7 changed files with 48 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.cc
View File

@ -38,7 +38,7 @@ AcknowledgedBitrateEstimator::~AcknowledgedBitrateEstimator() {}
AcknowledgedBitrateEstimator::AcknowledgedBitrateEstimator(
const WebRtcKeyValueConfig* key_value_config,
std::unique_ptr<BitrateEstimator> bitrate_estimator)
: bitrate_estimator_(std::move(bitrate_estimator)) {}
: in_alr_(false), bitrate_estimator_(std::move(bitrate_estimator)) {}
void AcknowledgedBitrateEstimator::IncomingPacketFeedbackVector(
const std::vector<PacketFeedback>& packet_feedback_vector) {
@ -50,7 +50,8 @@ void AcknowledgedBitrateEstimator::IncomingPacketFeedbackVector(
MaybeExpectFastRateChange(packet.send_time_ms);
int acknowledged_estimate = rtc::dchecked_cast<int>(packet.payload_size);
acknowledged_estimate += packet.unacknowledged_data;
bitrate_estimator_->Update(packet.arrival_time_ms, acknowledged_estimate);
bitrate_estimator_->Update(packet.arrival_time_ms, acknowledged_estimate,
in_alr_);
}
}
}
@ -80,6 +81,10 @@ void AcknowledgedBitrateEstimator::SetAlrEndedTimeMs(
alr_ended_time_ms_.emplace(alr_ended_time_ms);
}
void AcknowledgedBitrateEstimator::SetAlr(bool in_alr) {
in_alr_ = in_alr;
}
void AcknowledgedBitrateEstimator::MaybeExpectFastRateChange(
int64_t packet_send_time_ms) {
if (alr_ended_time_ms_ && packet_send_time_ms > *alr_ended_time_ms_) {

2
modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h
View File

@ -39,11 +39,13 @@ class AcknowledgedBitrateEstimator {
absl::optional<uint32_t> PeekBps() const;
absl::optional<DataRate> bitrate() const;
absl::optional<DataRate> PeekRate() const;
void SetAlr(bool in_alr);
void SetAlrEndedTimeMs(int64_t alr_ended_time_ms);
private:
void MaybeExpectFastRateChange(int64_t packet_arrival_time_ms);
absl::optional<int64_t> alr_ended_time_ms_;
bool in_alr_;
std::unique_ptr<BitrateEstimator> bitrate_estimator_;
};

38
modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc
View File

@ -36,7 +36,7 @@ constexpr size_t kPayloadSize = 10;
class MockBitrateEstimator : public BitrateEstimator {
public:
using BitrateEstimator::BitrateEstimator;
MOCK_METHOD2(Update, void(int64_t now_ms, int bytes));
MOCK_METHOD3(Update, void(int64_t now_ms, int bytes, bool in_alr));
MOCK_CONST_METHOD0(bitrate_bps, absl::optional<uint32_t>());
MOCK_METHOD0(ExpectFastRateChange, void());
};
@ -77,25 +77,25 @@ TEST(TestAcknowledgedBitrateEstimator, DontAddPacketsWhichAreNotInSendHistory) {
std::vector<PacketFeedback> packet_feedback_vector;
packet_feedback_vector.push_back(
PacketFeedback(kFirstArrivalTimeMs, kSequenceNumber));
EXPECT_CALL(*states.mock_bitrate_estimator, Update(_, _)).Times(0);
EXPECT_CALL(*states.mock_bitrate_estimator, Update(_, _, _)).Times(0);
states.acknowledged_bitrate_estimator->IncomingPacketFeedbackVector(
packet_feedback_vector);
}
TEST(TestAcknowledgedBitrateEstimator, UpdateBandwith) {
TEST(TestAcknowledgedBitrateEstimator, UpdateBandwidth) {
auto states = CreateTestStates();
auto packet_feedback_vector = CreateFeedbackVector();
{
InSequence dummy;
EXPECT_CALL(
*states.mock_bitrate_estimator,
Update(packet_feedback_vector[0].arrival_time_ms,
static_cast<int>(packet_feedback_vector[0].payload_size)))
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[0].arrival_time_ms,
static_cast<int>(packet_feedback_vector[0].payload_size),
/*in_alr*/ false))
.Times(1);
EXPECT_CALL(
*states.mock_bitrate_estimator,
Update(packet_feedback_vector[1].arrival_time_ms,
static_cast<int>(packet_feedback_vector[1].payload_size)))
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[1].arrival_time_ms,
static_cast<int>(packet_feedback_vector[1].payload_size),
/*in_alr*/ false))
.Times(1);
}
states.acknowledged_bitrate_estimator->IncomingPacketFeedbackVector(
@ -107,17 +107,17 @@ TEST(TestAcknowledgedBitrateEstimator, ExpectFastRateChangeWhenLeftAlr) {
auto packet_feedback_vector = CreateFeedbackVector();
{
InSequence dummy;
EXPECT_CALL(
*states.mock_bitrate_estimator,
Update(packet_feedback_vector[0].arrival_time_ms,
static_cast<int>(packet_feedback_vector[0].payload_size)))
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[0].arrival_time_ms,
static_cast<int>(packet_feedback_vector[0].payload_size),
/*in_alr*/ false))
.Times(1);
EXPECT_CALL(*states.mock_bitrate_estimator, ExpectFastRateChange())
.Times(1);
EXPECT_CALL(
*states.mock_bitrate_estimator,
Update(packet_feedback_vector[1].arrival_time_ms,
static_cast<int>(packet_feedback_vector[1].payload_size)))
EXPECT_CALL(*states.mock_bitrate_estimator,
Update(packet_feedback_vector[1].arrival_time_ms,
static_cast<int>(packet_feedback_vector[1].payload_size),
/*in_alr*/ false))
.Times(1);
}
states.acknowledged_bitrate_estimator->SetAlrEndedTimeMs(kFirstArrivalTimeMs +

19
modules/congestion_controller/goog_cc/bitrate_estimator.cc
View File

@ -42,6 +42,7 @@ BitrateEstimator::BitrateEstimator(const WebRtcKeyValueConfig* key_value_config)
kMinRateWindowMs,
kMaxRateWindowMs),
uncertainty_scale_("scale", 10.0),
uncertainty_scale_in_alr_("scale_alr", 10.0),
uncertainty_symmetry_cap_("symmetry_cap", DataRate::Zero()),
estimate_floor_("floor", DataRate::Zero()),
current_window_ms_(0),
@ -49,15 +50,15 @@ BitrateEstimator::BitrateEstimator(const WebRtcKeyValueConfig* key_value_config)
bitrate_estimate_kbps_(-1.0f),
bitrate_estimate_var_(50.0f) {
// E.g WebRTC-BweThroughputWindowConfig/initial_window_ms:350,window_ms:250/
ParseFieldTrial(
{&initial_window_ms_, &noninitial_window_ms_, &uncertainty_scale_,
&uncertainty_symmetry_cap_, &estimate_floor_},
key_value_config->Lookup(kBweThroughputWindowConfig));
ParseFieldTrial({&initial_window_ms_, &noninitial_window_ms_,
&uncertainty_scale_, &uncertainty_scale_in_alr_,
&uncertainty_symmetry_cap_, &estimate_floor_},
key_value_config->Lookup(kBweThroughputWindowConfig));
}
BitrateEstimator::~BitrateEstimator() = default;
void BitrateEstimator::Update(int64_t now_ms, int bytes) {
void BitrateEstimator::Update(int64_t now_ms, int bytes, bool in_alr) {
int rate_window_ms = noninitial_window_ms_.Get();
// We use a larger window at the beginning to get a more stable sample that
// we can use to initialize the estimate.
@ -75,9 +76,13 @@ void BitrateEstimator::Update(int64_t now_ms, int bytes) {
// current estimate. With low values of uncertainty_symmetry_cap_ we add more
// uncertainty to increases than to decreases. For higher values we approach
// symmetry.
float scale = uncertainty_scale_;
if (in_alr && bitrate_sample_kbps < bitrate_estimate_kbps_) {
// Optionally use higher uncertainty for samples obtained during ALR.
scale = uncertainty_scale_in_alr_;
}
float sample_uncertainty =
uncertainty_scale_ *
std::abs(bitrate_estimate_kbps_ - bitrate_sample_kbps) /
scale * std::abs(bitrate_estimate_kbps_ - bitrate_sample_kbps) /
(bitrate_estimate_kbps_ +
std::min(bitrate_sample_kbps,
uncertainty_symmetry_cap_.Get().kbps<float>()));

3
modules/congestion_controller/goog_cc/bitrate_estimator.h
View File

@ -29,7 +29,7 @@ class BitrateEstimator {
public:
explicit BitrateEstimator(const WebRtcKeyValueConfig* key_value_config);
virtual ~BitrateEstimator();
virtual void Update(int64_t now_ms, int bytes);
virtual void Update(int64_t now_ms, int bytes, bool in_alr);
virtual absl::optional<uint32_t> bitrate_bps() const;
absl::optional<uint32_t> PeekBps() const;
@ -42,6 +42,7 @@ class BitrateEstimator {
FieldTrialConstrained<int> initial_window_ms_;
FieldTrialConstrained<int> noninitial_window_ms_;
FieldTrialParameter<double> uncertainty_scale_;
FieldTrialParameter<double> uncertainty_scale_in_alr_;
FieldTrialParameter<DataRate> uncertainty_symmetry_cap_;
FieldTrialParameter<DataRate> estimate_floor_;
int64_t current_window_ms_;

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

@ -261,6 +261,9 @@ NetworkControlUpdate GoogCcNetworkController::OnSentPacket(
SentPacket sent_packet) {
alr_detector_->OnBytesSent(sent_packet.size.bytes(),
sent_packet.send_time.ms());
acknowledged_bitrate_estimator_->SetAlr(
alr_detector_->GetApplicationLimitedRegionStartTime().has_value());
if (!first_packet_sent_) {
first_packet_sent_ = true;
// Initialize feedback time to send time to allow estimation of RTT until
@ -507,12 +510,12 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback(
absl::optional<int64_t> alr_start_time =
alr_detector_->GetApplicationLimitedRegionStartTime();
if (previously_in_alr && !alr_start_time.has_value()) {
if (previously_in_alr_ && !alr_start_time.has_value()) {
int64_t now_ms = report.feedback_time.ms();
acknowledged_bitrate_estimator_->SetAlrEndedTimeMs(now_ms);
probe_controller_->SetAlrEndedTimeMs(now_ms);
}
previously_in_alr = alr_start_time.has_value();
previously_in_alr_ = alr_start_time.has_value();
acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector(
received_feedback_vector);
auto acknowledged_bitrate = acknowledged_bitrate_estimator_->bitrate();

2
modules/congestion_controller/goog_cc/goog_cc_network_control.h
View File

@ -129,7 +129,7 @@ class GoogCcNetworkController : public NetworkControllerInterface {
DataRate max_padding_rate_;
DataRate max_total_allocated_bitrate_;
bool previously_in_alr = false;
bool previously_in_alr_ = false;
absl::optional<DataSize> current_data_window_;