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

Tune BWE to be more sensitive on low capacity networks.

Browse Source 
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}
This commit is contained in:
stefan
2016-08-04 06:42:07 -07:00
committed by Commit bot
parent 171c7fef0a
commit db7543809e
7 changed files with 44 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/modules/congestion_controller/delay_based_bwe_unittest.cc
View File

@ -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) {

9
webrtc/modules/remote_bitrate_estimator/overuse_detector.cc
View File

@ -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),

6
webrtc/modules/remote_bitrate_estimator/overuse_detector_unittest.cc
View File

@ -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)

2
webrtc/modules/remote_bitrate_estimator/test/bwe.h
View File

@ -109,7 +109,7 @@ class LinkedSet {
std::list<PacketIdentifierNode*> list_;
};
const int kMinBitrateKbps = 50;
const int kMinBitrateKbps = 10;
const int kMaxBitrateKbps = 2500;
class BweSender : public Module {

34
webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc
View File

@ -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<int>((kKappa * delta_s *
(kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat)) /
(kTauOMs * kTauOMs) +
0.5f);
int original_increase = static_cast<int>(
(kKappa * delta_s *
(kTheta - (bitrate_kbps_ - kMinNadaBitrateKbps) * x_hat)) /
(kTauOMs * kTauOMs) +
0.5f);
bitrate_kbps_ = bitrate_kbps_ + smoothing_factor * original_increase;
}

4
webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h
View File

@ -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.

22
webrtc/modules/remote_bitrate_estimator/test/estimators/nada_unittest.cc
View File

@ -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<size_t>(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<size_t>(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<size_t>(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<size_t>(kMinBitrateKbps);
size_t receiving_rate =
static_cast<size_t>(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();