From db7543809e3e8a52c80a81aa49d0bc34a9670c00 Mon Sep 17 00:00:00 2001 From: stefan Date: Thu, 4 Aug 2016 06:42:07 -0700 Subject: [PATCH] Tune BWE to be more sensitive on low capacity networks. Also lowering the min bitrate for simulations to be able to better capture this issue in the BweFeedbackTest.Choke200kbps30kbps200kbps performance test. BUG=webrtc:6105 NOTRY=true NOPRESUBMIT=true Review-Url: https://codereview.webrtc.org/2201093006 Cr-Commit-Position: refs/heads/master@{#13639} --- .../delay_based_bwe_unittest.cc | 2 +- .../overuse_detector.cc | 9 ++--- .../overuse_detector_unittest.cc | 6 ++-- .../remote_bitrate_estimator/test/bwe.h | 2 +- .../test/estimators/nada.cc | 34 +++++++++++-------- .../test/estimators/nada.h | 4 +-- .../test/estimators/nada_unittest.cc | 22 ++++++------ 7 files changed, 44 insertions(+), 35 deletions(-) diff --git a/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc b/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc index ce0a32d4b0..3228b6252d 100644 --- a/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc +++ b/webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc @@ -217,7 +217,7 @@ TEST_F(DelayBasedBweTest, CapacityDropOneStreamWrap) { } TEST_F(DelayBasedBweTest, CapacityDropTwoStreamsWrap) { - CapacityDropTestHelper(2, true, 567, 0); + CapacityDropTestHelper(2, true, 767, 0); } TEST_F(DelayBasedBweTest, CapacityDropThreeStreamsWrap) { diff --git a/webrtc/modules/remote_bitrate_estimator/overuse_detector.cc b/webrtc/modules/remote_bitrate_estimator/overuse_detector.cc index 2f1ce36c30..477fc15f09 100644 --- a/webrtc/modules/remote_bitrate_estimator/overuse_detector.cc +++ b/webrtc/modules/remote_bitrate_estimator/overuse_detector.cc @@ -19,6 +19,7 @@ #include "webrtc/base/checks.h" #include "webrtc/base/common.h" +#include "webrtc/base/logging.h" #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h" #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h" #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" @@ -59,11 +60,11 @@ bool ReadExperimentConstants(double* k_up, double* k_down) { } OveruseDetector::OveruseDetector(const OverUseDetectorOptions& options) - // Experiment is on by default, but can be disabled with finch by setting - // the field trial string to "WebRTC-AdaptiveBweThreshold/Disabled/". + // Experiment is on by default, but can be disabled with finch by setting + // the field trial string to "WebRTC-AdaptiveBweThreshold/Disabled/". : in_experiment_(!AdaptiveThresholdExperimentIsDisabled()), - k_up_(0.004), - k_down_(0.00006), + k_up_(0.0087), + k_down_(0.039), overusing_time_threshold_(100), options_(options), threshold_(12.5), diff --git a/webrtc/modules/remote_bitrate_estimator/overuse_detector_unittest.cc b/webrtc/modules/remote_bitrate_estimator/overuse_detector_unittest.cc index 1094585c72..9f42d9f80a 100644 --- a/webrtc/modules/remote_bitrate_estimator/overuse_detector_unittest.cc +++ b/webrtc/modules/remote_bitrate_estimator/overuse_detector_unittest.cc @@ -331,7 +331,7 @@ TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance30Kbit3fps) { EXPECT_EQ(0, unique_overuse); int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, sigma_ms, drift_per_frame_ms); - EXPECT_EQ(21, frames_until_overuse); + EXPECT_EQ(20, frames_until_overuse); } TEST_F(OveruseDetectorTest, LowGaussianVarianceFastDrift30Kbit3fps) { @@ -393,7 +393,7 @@ TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance100Kbit5fps) { EXPECT_EQ(0, unique_overuse); int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, sigma_ms, drift_per_frame_ms); - EXPECT_EQ(21, frames_until_overuse); + EXPECT_EQ(20, frames_until_overuse); } #if defined(WEBRTC_ANDROID) @@ -433,7 +433,7 @@ TEST_F(OveruseDetectorTest, MAYBE_LowGaussianVariance100Kbit10fps) { EXPECT_EQ(0, unique_overuse); int frames_until_overuse = RunUntilOveruse(packets_per_frame, packet_size, frame_duration_ms, sigma_ms, drift_per_frame_ms); - EXPECT_EQ(21, frames_until_overuse); + EXPECT_EQ(20, frames_until_overuse); } #if defined(WEBRTC_ANDROID) diff --git a/webrtc/modules/remote_bitrate_estimator/test/bwe.h b/webrtc/modules/remote_bitrate_estimator/test/bwe.h index fc3018f996..b811773eec 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/bwe.h +++ b/webrtc/modules/remote_bitrate_estimator/test/bwe.h @@ -109,7 +109,7 @@ class LinkedSet { std::list list_; }; -const int kMinBitrateKbps = 50; +const int kMinBitrateKbps = 10; const int kMaxBitrateKbps = 2500; class BweSender : public Module { diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc index b91ee6df0b..326fb42b9f 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc +++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc @@ -28,6 +28,13 @@ namespace webrtc { namespace testing { namespace bwe { +namespace { +// Used as an upper bound for calling AcceleratedRampDown. +const float kMaxCongestionSignalMs = + 40.0f + NadaBweSender::kMinNadaBitrateKbps / 15; +} // namespace + +const int NadaBweSender::kMinNadaBitrateKbps = 50; const int64_t NadaBweReceiver::kReceivingRateTimeWindowMs = 500; NadaBweReceiver::NadaBweReceiver(int flow_id) @@ -160,11 +167,10 @@ NadaBweSender::NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock) } NadaBweSender::NadaBweSender(BitrateObserver* observer, Clock* clock) - : BweSender(kMinBitrateKbps), // Referred as "Reference Rate" = R_n. + : BweSender(kMinNadaBitrateKbps), // Referred as "Reference Rate" = R_n. clock_(clock), observer_(observer), - original_operating_mode_(true) { -} + original_operating_mode_(true) {} NadaBweSender::~NadaBweSender() { } @@ -213,23 +219,23 @@ void NadaBweSender::GiveFeedback(const FeedbackPacket& feedback) { if (fb.congestion_signal() == fb.est_queuing_delay_signal_ms() && fb.est_queuing_delay_signal_ms() < kQueuingDelayUpperBoundMs && fb.exp_smoothed_delay_ms() < - kMinBitrateKbps / kProportionalityDelayBits && + kMinNadaBitrateKbps / kProportionalityDelayBits && fb.derivative() < kDerivativeUpperBound && - fb.receiving_rate() > kMinBitrateKbps) { + fb.receiving_rate() > kMinNadaBitrateKbps) { AcceleratedRampUp(fb); } else if (fb.congestion_signal() > kMaxCongestionSignalMs || fb.exp_smoothed_delay_ms() > kMaxCongestionSignalMs) { AcceleratedRampDown(fb); } else { double bitrate_reference = - (2.0 * bitrate_kbps_) / (kMaxBitrateKbps + kMinBitrateKbps); + (2.0 * bitrate_kbps_) / (kMaxBitrateKbps + kMinNadaBitrateKbps); double smoothing_factor = pow(bitrate_reference, 0.75); GradualRateUpdate(fb, delta_s, smoothing_factor); } } bitrate_kbps_ = std::min(bitrate_kbps_, kMaxBitrateKbps); - bitrate_kbps_ = std::max(bitrate_kbps_, kMinBitrateKbps); + bitrate_kbps_ = std::max(bitrate_kbps_, kMinNadaBitrateKbps); observer_->OnNetworkChanged(1000 * bitrate_kbps_, 0, rtt_ms); } @@ -271,14 +277,14 @@ void NadaBweSender::GradualRateUpdate(const NadaFeedback& fb, float x_hat = fb.congestion_signal() + kEta * kTauOMs * fb.derivative(); - float kTheta = - kPriorityWeight * (kMaxBitrateKbps - kMinBitrateKbps) * kReferenceDelayMs; + float kTheta = kPriorityWeight * (kMaxBitrateKbps - kMinNadaBitrateKbps) * + kReferenceDelayMs; - int original_increase = - static_cast((kKappa * delta_s * - (kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat)) / - (kTauOMs * kTauOMs) + - 0.5f); + int original_increase = static_cast( + (kKappa * delta_s * + (kTheta - (bitrate_kbps_ - kMinNadaBitrateKbps) * x_hat)) / + (kTauOMs * kTauOMs) + + 0.5f); bitrate_kbps_ = bitrate_kbps_ + smoothing_factor * original_increase; } diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h index 2a33440bc3..c2c4f59b3c 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h +++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h @@ -64,6 +64,8 @@ class NadaBweReceiver : public BweReceiver { class NadaBweSender : public BweSender { public: + static const int kMinNadaBitrateKbps; + NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock); NadaBweSender(BitrateObserver* observer, Clock* clock); virtual ~NadaBweSender(); @@ -91,8 +93,6 @@ class NadaBweSender : public BweSender { private: Clock* const clock_; BitrateObserver* const observer_; - // Used as an upper bound for calling AcceleratedRampDown. - const float kMaxCongestionSignalMs = 40.0f + kMinBitrateKbps / 15; // Referred as R_min, default initialization for bitrate R_n. int64_t last_feedback_ms_ = 0; // Referred as delta_0, initialized as an upper bound. diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc index ec008ffb7f..7feaeedf4c 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc +++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc @@ -170,7 +170,7 @@ class NadaFbGenerator { TEST_F(NadaSenderSideTest, AcceleratedRampUp) { const int64_t kRefSignalMs = 1; const int64_t kOneWayDelayMs = 50; - int original_bitrate = 2 * kMinBitrateKbps; + int original_bitrate = 2 * NadaBweSender::kMinNadaBitrateKbps; size_t receiving_rate = static_cast(original_bitrate); int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; @@ -202,7 +202,7 @@ TEST_F(NadaSenderSideTest, AcceleratedRampUp) { // Verify if AcceleratedRampDown is called and if bitrate decreases. TEST_F(NadaSenderSideTest, AcceleratedRampDown) { const int64_t kOneWayDelayMs = 50; - int original_bitrate = 3 * kMinBitrateKbps; + int original_bitrate = 3 * NadaBweSender::kMinNadaBitrateKbps; size_t receiving_rate = static_cast(original_bitrate); int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; @@ -219,7 +219,8 @@ TEST_F(NadaSenderSideTest, AcceleratedRampDown) { // Updates the bitrate according to the receiving rate and other constant // parameters. nada_sender_.AcceleratedRampDown(congested_fb); - int bitrate_2_kbps = std::max(nada_sender_.bitrate_kbps(), kMinBitrateKbps); + int bitrate_2_kbps = + std::max(nada_sender_.bitrate_kbps(), NadaBweSender::kMinNadaBitrateKbps); EXPECT_EQ(bitrate_2_kbps, bitrate_1_kbps); } @@ -227,7 +228,7 @@ TEST_F(NadaSenderSideTest, GradualRateUpdate) { const int64_t kDeltaSMs = 20; const int64_t kRefSignalMs = 20; const int64_t kOneWayDelayMs = 50; - int original_bitrate = 2 * kMinBitrateKbps; + int original_bitrate = 2 * NadaBweSender::kMinNadaBitrateKbps; size_t receiving_rate = static_cast(original_bitrate); int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; @@ -254,7 +255,8 @@ TEST_F(NadaSenderSideTest, GradualRateUpdate) { TEST_F(NadaSenderSideTest, VeryLowBandwith) { const int64_t kOneWayDelayMs = 50; - size_t receiving_rate = static_cast(kMinBitrateKbps); + size_t receiving_rate = + static_cast(NadaBweSender::kMinNadaBitrateKbps); int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; NadaFeedback extremely_congested_fb = @@ -262,7 +264,7 @@ TEST_F(NadaSenderSideTest, VeryLowBandwith) { NadaFeedback congested_fb = NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms); - nada_sender_.set_bitrate_kbps(5 * kMinBitrateKbps); + nada_sender_.set_bitrate_kbps(5 * NadaBweSender::kMinNadaBitrateKbps); nada_sender_.set_original_operating_mode(true); for (int i = 0; i < 100; ++i) { // Trigger GradualRateUpdate mode. @@ -270,10 +272,10 @@ TEST_F(NadaSenderSideTest, VeryLowBandwith) { } // The original implementation doesn't allow the bitrate to stay at kMin, // even if the congestion signal is very high. - EXPECT_GE(nada_sender_.bitrate_kbps(), kMinBitrateKbps); + EXPECT_GE(nada_sender_.bitrate_kbps(), NadaBweSender::kMinNadaBitrateKbps); nada_sender_.set_original_operating_mode(false); - nada_sender_.set_bitrate_kbps(5 * kMinBitrateKbps); + nada_sender_.set_bitrate_kbps(5 * NadaBweSender::kMinNadaBitrateKbps); for (int i = 0; i < 1000; ++i) { int previous_bitrate = nada_sender_.bitrate_kbps(); @@ -281,7 +283,7 @@ TEST_F(NadaSenderSideTest, VeryLowBandwith) { nada_sender_.GiveFeedback(congested_fb); EXPECT_LE(nada_sender_.bitrate_kbps(), previous_bitrate); } - EXPECT_EQ(nada_sender_.bitrate_kbps(), kMinBitrateKbps); + EXPECT_EQ(nada_sender_.bitrate_kbps(), NadaBweSender::kMinNadaBitrateKbps); } // Sending bitrate should increase and reach its Max bound. @@ -303,7 +305,7 @@ TEST_F(NadaSenderSideTest, VeryHighBandwith) { EXPECT_EQ(nada_sender_.bitrate_kbps(), kMaxBitrateKbps); nada_sender_.set_original_operating_mode(false); - nada_sender_.set_bitrate_kbps(kMinBitrateKbps); + nada_sender_.set_bitrate_kbps(NadaBweSender::kMinNadaBitrateKbps); for (int i = 0; i < 100; ++i) { int previous_bitrate = nada_sender_.bitrate_kbps();