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

Allow injection of network estimator into GoogCC.

Browse Source 
Bug: webrtc:10498
Change-Id: Ie9225411db201dfcfa0a37a3c40992acbdc215bb
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/132402
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Christoffer Rodbro <crodbro@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27624}
This commit is contained in:
Sebastian Jansson
2019-04-15 15:42:25 +02:00
committed by Commit Bot
parent ef86d1413e
commit df88cc014a
19 changed files with 191 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
modules/congestion_controller/goog_cc/delay_based_bwe.cc
View File

@ -14,9 +14,9 @@
#include <cstdint>
#include <cstdio>
#include <string>
#include <utility>
#include "absl/memory/memory.h"
#include "api/transport/network_types.h" // For PacedPacketInfo
#include "logging/rtc_event_log/events/rtc_event.h"
#include "logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h"
#include "logging/rtc_event_log/rtc_event_log.h"
@ -117,6 +117,7 @@ DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector(
const std::vector<PacketFeedback>& packet_feedback_vector,
absl::optional<DataRate> acked_bitrate,
absl::optional<DataRate> probe_bitrate,
absl::optional<NetworkStateEstimate> network_estimate,
bool in_alr,
Timestamp at_time) {
RTC_DCHECK(std::is_sorted(packet_feedback_vector.begin(),
@ -158,7 +159,9 @@ DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector(
// against building very large network queues.
return Result();
}
rate_control_.SetNetworkStateEstimate(network_estimate);
return MaybeUpdateEstimate(acked_bitrate, probe_bitrate,
std::move(network_estimate),
recovered_from_overuse, in_alr, at_time);
}
@ -202,6 +205,7 @@ void DelayBasedBwe::IncomingPacketFeedback(
DelayBasedBwe::Result DelayBasedBwe::MaybeUpdateEstimate(
absl::optional<DataRate> acked_bitrate,
absl::optional<DataRate> probe_bitrate,
absl::optional<NetworkStateEstimate> state_estimate,
bool recovered_from_overuse,
bool in_alr,
Timestamp at_time) {

14
modules/congestion_controller/goog_cc/delay_based_bwe.h
View File

@ -18,6 +18,7 @@
#include "absl/types/optional.h"
#include "api/network_state_predictor.h"
#include "api/transport/network_types.h"
#include "api/transport/webrtc_key_value_config.h"
#include "modules/congestion_controller/goog_cc/delay_increase_detector_interface.h"
#include "modules/congestion_controller/goog_cc/probe_bitrate_estimator.h"
@ -53,6 +54,7 @@ class DelayBasedBwe {
const std::vector<PacketFeedback>& packet_feedback_vector,
absl::optional<DataRate> acked_bitrate,
absl::optional<DataRate> probe_bitrate,
absl::optional<NetworkStateEstimate> network_estimate,
bool in_alr,
Timestamp at_time);
void OnRttUpdate(TimeDelta avg_rtt);
@ -66,11 +68,13 @@ class DelayBasedBwe {
friend class GoogCcStatePrinter;
void IncomingPacketFeedback(const PacketFeedback& packet_feedback,
Timestamp at_time);
Result MaybeUpdateEstimate(absl::optional<DataRate> acked_bitrate,
absl::optional<DataRate> probe_bitrate,
bool recovered_from_overuse,
bool in_alr,
Timestamp at_time);
Result MaybeUpdateEstimate(
absl::optional<DataRate> acked_bitrate,
absl::optional<DataRate> probe_bitrate,
absl::optional<NetworkStateEstimate> state_estimate,
bool recovered_from_overuse,
bool in_alr,
Timestamp at_time);
// Updates the current remote rate estimate and returns true if a valid
// estimate exists.
bool UpdateEstimate(Timestamp now,

14
modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc
View File

@ -29,9 +29,10 @@ constexpr Timestamp kDummyTimestamp = Timestamp::Seconds<1000>();
TEST_F(DelayBasedBweTest, NoCrashEmptyFeedback) {
std::vector<PacketFeedback> packet_feedback_vector;
bitrate_estimator_->IncomingPacketFeedbackVector(packet_feedback_vector,
absl::nullopt, absl::nullopt,
false, kDummyTimestamp);
bitrate_estimator_->IncomingPacketFeedbackVector(
packet_feedback_vector, /*acked_bitrate*/ absl::nullopt,
/*probe_bitrate*/ absl::nullopt, /*network_estimate*/ absl::nullopt,
/*in_alr*/ false, kDummyTimestamp);
}
TEST_F(DelayBasedBweTest, NoCrashOnlyLostFeedback) {
@ -42,9 +43,10 @@ TEST_F(DelayBasedBweTest, NoCrashOnlyLostFeedback) {
packet_feedback_vector.push_back(PacketFeedback(PacketFeedback::kNotReceived,
PacketFeedback::kNoSendTime,
1, 1500, PacedPacketInfo()));
bitrate_estimator_->IncomingPacketFeedbackVector(packet_feedback_vector,
absl::nullopt, absl::nullopt,
false, kDummyTimestamp);
bitrate_estimator_->IncomingPacketFeedbackVector(
packet_feedback_vector, /*acked_bitrate*/ absl::nullopt,
/*probe_bitrate*/ absl::nullopt, /*network_estimate*/ absl::nullopt,
/*in_alr*/ false, kDummyTimestamp);
}
TEST_F(DelayBasedBweTest, ProbeDetection) {

6
modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc
View File

@ -211,7 +211,8 @@ void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms,
DelayBasedBwe::Result result =
bitrate_estimator_->IncomingPacketFeedbackVector(
packets, acknowledged_bitrate_estimator_->bitrate(),
probe_bitrate_estimator_->FetchAndResetLastEstimatedBitrate(), false,
probe_bitrate_estimator_->FetchAndResetLastEstimatedBitrate(),
/*network_estimate*/ absl::nullopt, /*in_alr*/ false,
Timestamp::ms(clock_.TimeInMilliseconds()));
const uint32_t kDummySsrc = 0;
if (result.updated) {
@ -252,7 +253,8 @@ bool DelayBasedBweTest::GenerateAndProcessFrame(uint32_t ssrc,
DelayBasedBwe::Result result =
bitrate_estimator_->IncomingPacketFeedbackVector(
packets, acknowledged_bitrate_estimator_->bitrate(),
probe_bitrate_estimator_->FetchAndResetLastEstimatedBitrate(), false,
probe_bitrate_estimator_->FetchAndResetLastEstimatedBitrate(),
/*network_estimate*/ absl::nullopt, /*in_alr*/ false,
Timestamp::ms(clock_.TimeInMilliseconds()));
const uint32_t kDummySsrc = 0;
if (result.updated) {

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

@ -78,15 +78,12 @@ bool IsNotDisabled(const WebRtcKeyValueConfig* config, absl::string_view key) {
}
} // namespace
GoogCcNetworkController::GoogCcNetworkController(
RtcEventLog* event_log,
NetworkControllerConfig config,
bool feedback_only,
std::unique_ptr<NetworkStatePredictor> network_state_predictor)
GoogCcNetworkController::GoogCcNetworkController(NetworkControllerConfig config,
GoogCcConfig goog_cc_config)
: key_value_config_(config.key_value_config ? config.key_value_config
: &trial_based_config_),
event_log_(event_log),
packet_feedback_only_(feedback_only),
event_log_(config.event_log),
packet_feedback_only_(goog_cc_config.feedback_only),
safe_reset_on_route_change_("Enabled"),
safe_reset_acknowledged_rate_("ack"),
use_stable_bandwidth_estimate_(
@ -97,7 +94,8 @@ GoogCcNetworkController::GoogCcNetworkController(
IsNotDisabled(key_value_config_, "WebRTC-Bwe-MinAllocAsLowerBound")),
rate_control_settings_(
RateControlSettings::ParseFromKeyValueConfig(key_value_config_)),
probe_controller_(new ProbeController(key_value_config_, event_log)),
probe_controller_(
new ProbeController(key_value_config_, config.event_log)),
congestion_window_pushback_controller_(
rate_control_settings_.UseCongestionWindowPushback()
? absl::make_unique<CongestionWindowPushbackController>(
@ -106,10 +104,13 @@ GoogCcNetworkController::GoogCcNetworkController(
bandwidth_estimation_(
absl::make_unique<SendSideBandwidthEstimation>(event_log_)),
alr_detector_(absl::make_unique<AlrDetector>(key_value_config_)),
probe_bitrate_estimator_(new ProbeBitrateEstimator(event_log)),
probe_bitrate_estimator_(new ProbeBitrateEstimator(config.event_log)),
network_estimator_(std::move(goog_cc_config.network_state_estimator)),
network_state_predictor_(
std::move(goog_cc_config.network_state_predictor)),
delay_based_bwe_(new DelayBasedBwe(key_value_config_,
event_log_,
network_state_predictor.get())),
network_state_predictor_.get())),
acknowledged_bitrate_estimator_(
absl::make_unique<AcknowledgedBitrateEstimator>(key_value_config_)),
initial_config_(config),
@ -122,8 +123,7 @@ GoogCcNetworkController::GoogCcNetworkController(
DataRate::Zero())),
max_padding_rate_(config.stream_based_config.max_padding_rate.value_or(
DataRate::Zero())),
max_total_allocated_bitrate_(DataRate::Zero()),
network_state_predictor_(std::move(network_state_predictor)) {
max_total_allocated_bitrate_(DataRate::Zero()) {
RTC_DCHECK(config.constraints.at_time.IsFinite());
ParseFieldTrial(
{&safe_reset_on_route_change_, &safe_reset_acknowledged_rate_},
@ -170,6 +170,8 @@ NetworkControlUpdate GoogCcNetworkController::OnNetworkRouteChange(
acknowledged_bitrate_estimator_.reset(
new AcknowledgedBitrateEstimator(key_value_config_));
probe_bitrate_estimator_.reset(new ProbeBitrateEstimator(event_log_));
if (network_estimator_)
network_estimator_->OnRouteChange(msg);
delay_based_bwe_.reset(new DelayBasedBwe(key_value_config_, event_log_,
network_state_predictor_.get()));
bandwidth_estimation_->OnRouteChange();
@ -472,14 +474,20 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback(
report.feedback_time);
bandwidth_estimation_->IncomingPacketFeedbackVector(report);
if (network_estimator_)
network_estimator_->OnTransportPacketsFeedback(report);
NetworkControlUpdate update;
bool recovered_from_overuse = false;
bool backoff_in_alr = false;
DelayBasedBwe::Result result;
absl::optional<NetworkStateEstimate> network_estimate =
network_estimator_ ? network_estimator_->GetCurrentEstimate()
: absl::nullopt;
result = delay_based_bwe_->IncomingPacketFeedbackVector(
received_feedback_vector, acknowledged_bitrate, probe_bitrate,
alr_start_time.has_value(), report.feedback_time);
network_estimate, alr_start_time.has_value(), report.feedback_time);
if (result.updated) {
if (result.probe) {

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

@ -37,15 +37,16 @@
#include "rtc_base/experiments/rate_control_settings.h"
namespace webrtc {
struct GoogCcConfig {
std::unique_ptr<NetworkStateEstimator> network_state_estimator = nullptr;
std::unique_ptr<NetworkStatePredictor> network_state_predictor = nullptr;
bool feedback_only = false;
};
class GoogCcNetworkController : public NetworkControllerInterface {
public:
GoogCcNetworkController(
RtcEventLog* event_log,
NetworkControllerConfig config,
bool feedback_only,
std::unique_ptr<NetworkStatePredictor> network_state_predictor);
GoogCcNetworkController(NetworkControllerConfig config,
GoogCcConfig goog_cc_config);
~GoogCcNetworkController() override;
// NetworkControllerInterface
@ -91,6 +92,8 @@ class GoogCcNetworkController : public NetworkControllerInterface {
std::unique_ptr<SendSideBandwidthEstimation> bandwidth_estimation_;
std::unique_ptr<AlrDetector> alr_detector_;
std::unique_ptr<ProbeBitrateEstimator> probe_bitrate_estimator_;
std::unique_ptr<NetworkStateEstimator> network_estimator_;
std::unique_ptr<NetworkStatePredictor> network_state_predictor_;
std::unique_ptr<DelayBasedBwe> delay_based_bwe_;
std::unique_ptr<AcknowledgedBitrateEstimator> acknowledged_bitrate_estimator_;
@ -124,7 +127,6 @@ class GoogCcNetworkController : public NetworkControllerInterface {
absl::optional<DataSize> current_data_window_;
std::unique_ptr<NetworkStatePredictor> network_state_predictor_;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(GoogCcNetworkController);
};

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

@ -107,7 +107,7 @@ void UpdatesTargetRateBasedOnLinkCapacity(std::string test_name = "") {
class GoogCcNetworkControllerTest : public ::testing::Test {
protected:
GoogCcNetworkControllerTest()
: current_time_(Timestamp::ms(123456)), factory_(&event_log_, nullptr) {}
: current_time_(Timestamp::ms(123456)), factory_(&event_log_) {}
~GoogCcNetworkControllerTest() override {}
void SetUp() override {

2
modules/congestion_controller/goog_cc/test/goog_cc_printer.cc
View File

@ -60,7 +60,7 @@ NetworkControlUpdate GoogCcStatePrinter::GetState(Timestamp at_time) const {
GoogCcDebugFactory::GoogCcDebugFactory(RtcEventLog* event_log,
GoogCcStatePrinter* printer)
: GoogCcNetworkControllerFactory(event_log, nullptr), printer_(printer) {}
: GoogCcNetworkControllerFactory(event_log), printer_(printer) {}
std::unique_ptr<NetworkControllerInterface> GoogCcDebugFactory::Create(
NetworkControllerConfig config) {