generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Increased kMaxRampUpDelayMs (120 to 240s).

Browse Source 
Add support for triggering on encode rsd metric if its thresholds are configured. Added unit tests.

BUG=1577
R=mflodman@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/16649004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6410 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
asapersson@webrtc.org 2014-06-12 08:46:46 +00:00
parent 276637b107
commit 2881ab1e36
3 changed files with 162 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
webrtc/video_engine/include/vie_base.h
View File

@ -69,8 +69,8 @@ struct CpuOveruseOptions {
enable_encode_usage_method(false),
low_encode_usage_threshold_percent(60),
high_encode_usage_threshold_percent(90),
low_encode_time_rsd_threshold(0),
high_encode_time_rsd_threshold(0),
low_encode_time_rsd_threshold(-1),
high_encode_time_rsd_threshold(-1),
frame_timeout_interval_ms(1500),
min_frame_samples(120),
min_process_count(3),
@ -84,8 +84,12 @@ struct CpuOveruseOptions {
bool enable_encode_usage_method;
int low_encode_usage_threshold_percent; // Threshold for triggering underuse.
int high_encode_usage_threshold_percent; // Threshold for triggering overuse.
int low_encode_time_rsd_threshold; // Threshold for triggering underuse.
int high_encode_time_rsd_threshold; // Threshold for triggering overuse.
int low_encode_time_rsd_threshold; // Additional threshold for triggering
// underuse (used in addition to
// threshold above if configured).
int high_encode_time_rsd_threshold; // Additional threshold for triggering
// overuse (used in addition to
// threshold above if configured).
// General settings.
int frame_timeout_interval_ms; // The maximum allowed interval between two
// frames before resetting estimations.

45
webrtc/video_engine/overuse_frame_detector.cc
View File

@ -38,7 +38,7 @@ const float kWeightFactorMean = 0.98f;
const int kQuickRampUpDelayMs = 10 * 1000;
// Delay between rampup attempts. Initially uses standard, scales up to max.
const int kStandardRampUpDelayMs = 30 * 1000;
const int kMaxRampUpDelayMs = 120 * 1000;
const int kMaxRampUpDelayMs = 240 * 1000;
// Expontential back-off factor, to prevent annoying up-down behaviour.
const double kRampUpBackoffFactor = 2.0;
@ -126,7 +126,7 @@ class OveruseFrameDetector::EncodeTimeAvg {
filtered_encode_time_ms_->Apply(exp, encode_time_ms);
}
int filtered_encode_time_ms() const {
int Value() const {
return static_cast<int>(filtered_encode_time_ms_->Value() + 0.5);
}
@ -175,7 +175,7 @@ class OveruseFrameDetector::EncodeUsage {
filtered_encode_time_ms_->Apply(exp, encode_time_ms);
}
int UsageInPercent() const {
int Value() const {
if (count_ < static_cast<uint32_t>(options_.min_frame_samples)) {
return static_cast<int>(InitialUsageInPercent() + 0.5f);
}
@ -186,6 +186,7 @@ class OveruseFrameDetector::EncodeUsage {
return static_cast<int>(encode_usage_percent + 0.5);
}
private:
float InitialUsageInPercent() const {
// Start in between the underuse and overuse threshold.
return (options_.low_encode_usage_threshold_percent +
@ -196,7 +197,6 @@ class OveruseFrameDetector::EncodeUsage {
return InitialUsageInPercent() * kInitialSampleDiffMs / 100;
}
private:
const float kWeightFactorFrameDiff;
const float kWeightFactorEncodeTime;
const float kInitialSampleDiffMs;
@ -295,13 +295,13 @@ class OveruseFrameDetector::EncodeTimeRsd {
return static_cast<int>(filtered_rsd_->Value() + 0.5);
}
private:
float InitialValue() const {
// Start in between the underuse and overuse threshold.
return (options_.low_encode_time_rsd_threshold +
options_.high_encode_time_rsd_threshold) / 2.0f;
return std::max(((options_.low_encode_time_rsd_threshold +
options_.high_encode_time_rsd_threshold) / 2.0f), 0.0f);
}
private:
const float kWeightFactor;
uint32_t count_; // Number of encode samples since last reset.
CpuOveruseOptions options_;
@ -358,7 +358,7 @@ class OveruseFrameDetector::CaptureQueueDelay {
return delay_ms_;
}
int filtered_delay_ms_per_s() const {
int Value() const {
return static_cast<int>(filtered_delay_ms_per_s_->Value() + 0.5);
}
@ -419,11 +419,10 @@ void OveruseFrameDetector::GetCpuOveruseMetrics(
CpuOveruseMetrics* metrics) const {
CriticalSectionScoped cs(crit_.get());
metrics->capture_jitter_ms = static_cast<int>(capture_deltas_.StdDev() + 0.5);
metrics->avg_encode_time_ms = encode_time_->filtered_encode_time_ms();
metrics->avg_encode_time_ms = encode_time_->Value();
metrics->encode_rsd = encode_rsd_->Value();
metrics->encode_usage_percent = encode_usage_->UsageInPercent();
metrics->capture_queue_delay_ms_per_s =
capture_queue_delay_->filtered_delay_ms_per_s();
metrics->encode_usage_percent = encode_usage_->Value();
metrics->capture_queue_delay_ms_per_s = capture_queue_delay_->Value();
}
int32_t OveruseFrameDetector::TimeUntilNextProcess() {
@ -544,7 +543,7 @@ int32_t OveruseFrameDetector::Process() {
in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_;
LOG(LS_INFO) << " Frame stats: capture avg: " << capture_deltas_.Mean()
<< " capture stddev " << capture_deltas_.StdDev()
<< " encode usage " << encode_usage_->UsageInPercent()
<< " encode usage " << encode_usage_->Value()
<< " encode rsd " << encode_rsd_->Value()
<< " rampup delay " << rampup_delay;
return 0;
@ -556,8 +555,14 @@ bool OveruseFrameDetector::IsOverusing() {
overusing = capture_deltas_.StdDev() >=
options_.high_capture_jitter_threshold_ms;
} else if (options_.enable_encode_usage_method) {
overusing = encode_usage_->UsageInPercent() >=
options_.high_encode_usage_threshold_percent;
bool encode_usage_overuse =
encode_usage_->Value() >= options_.high_encode_usage_threshold_percent;
bool encode_rsd_overuse = false;
if (options_.high_encode_time_rsd_threshold > 0) {
encode_rsd_overuse =
(encode_rsd_->Value() >= options_.high_encode_time_rsd_threshold);
}
overusing = encode_usage_overuse || encode_rsd_overuse;
}
if (overusing) {
@ -578,8 +583,14 @@ bool OveruseFrameDetector::IsUnderusing(int64_t time_now) {
underusing = capture_deltas_.StdDev() <
options_.low_capture_jitter_threshold_ms;
} else if (options_.enable_encode_usage_method) {
underusing = encode_usage_->UsageInPercent() <
options_.low_encode_usage_threshold_percent;
bool encode_usage_underuse =
encode_usage_->Value() < options_.low_encode_usage_threshold_percent;
bool encode_rsd_underuse = true;
if (options_.low_encode_time_rsd_threshold > 0) {
encode_rsd_underuse =
(encode_rsd_->Value() < options_.low_encode_time_rsd_threshold);
}
underusing = encode_usage_underuse && encode_rsd_underuse;
}
return underusing;
}

131
webrtc/video_engine/overuse_frame_detector_unittest.cc
View File

@ -71,6 +71,12 @@ class OveruseFrameDetectorTest : public ::testing::Test {
options_.high_encode_usage_threshold_percent) / 2.0f) + 0.5;
}
int InitialEncodeRsd() {
return std::max(
((options_.low_encode_time_rsd_threshold +
options_.high_encode_time_rsd_threshold) / 2.0f) + 0.5f, 0.0f);
}
void InsertFramesWithInterval(
size_t num_frames, int interval_ms, int width, int height) {
while (num_frames-- > 0) {
@ -111,7 +117,19 @@ class OveruseFrameDetectorTest : public ::testing::Test {
}
}
void TriggerNormalUsageWithEncodeUsage() {
void TriggerOveruseWithEncodeRsd(int num_times) {
const int kEncodeTimeMs1 = 10;
const int kEncodeTimeMs2 = 25;
for (int i = 0; i < num_times; ++i) {
InsertAndEncodeFramesWithInterval(
200, kFrameInterval33ms, kWidth, kHeight, kEncodeTimeMs1);
InsertAndEncodeFramesWithInterval(
10, kFrameInterval33ms, kWidth, kHeight, kEncodeTimeMs2);
overuse_detector_->Process();
}
}
void TriggerNormalUsageWithEncodeTime() {
const int kEncodeTimeMs = 5;
InsertAndEncodeFramesWithInterval(
1000, kFrameInterval33ms, kWidth, kHeight, kEncodeTimeMs);
@ -136,25 +154,37 @@ class OveruseFrameDetectorTest : public ::testing::Test {
return metrics.encode_usage_percent;
}
int EncodeRsd() {
CpuOveruseMetrics metrics;
overuse_detector_->GetCpuOveruseMetrics(&metrics);
return metrics.encode_rsd;
}
CpuOveruseOptions options_;
scoped_ptr<SimulatedClock> clock_;
scoped_ptr<MockCpuOveruseObserver> observer_;
scoped_ptr<OveruseFrameDetector> overuse_detector_;
};
// enable_capture_jitter_method = true;
// CaptureJitterMs() > high_capture_jitter_threshold_ms => overuse.
// CaptureJitterMs() < low_capture_jitter_threshold_ms => underuse.
TEST_F(OveruseFrameDetectorTest, TriggerOveruse) {
// capture_jitter > high => overuse
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
TriggerOveruse(options_.high_threshold_consecutive_count);
}
TEST_F(OveruseFrameDetectorTest, OveruseAndRecover) {
// capture_jitter > high => overuse
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
TriggerOveruse(options_.high_threshold_consecutive_count);
// capture_jitter < low => underuse
EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
TriggerNormalUsage();
}
TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverNoObserver) {
TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithNoObserver) {
overuse_detector_->SetObserver(NULL);
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
TriggerOveruse(options_.high_threshold_consecutive_count);
@ -162,8 +192,9 @@ TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverNoObserver) {
TriggerNormalUsage();
}
TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverDisabled) {
TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithMethodDisabled) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = false;
overuse_detector_->SetOptions(options_);
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
TriggerOveruse(options_.high_threshold_consecutive_count);
@ -221,6 +252,7 @@ TEST_F(OveruseFrameDetectorTest, GetCpuOveruseMetrics) {
EXPECT_GT(metrics.avg_encode_time_ms, 0);
EXPECT_GT(metrics.encode_usage_percent, 0);
EXPECT_GE(metrics.capture_queue_delay_ms_per_s, 0);
EXPECT_GE(metrics.encode_rsd, 0);
}
TEST_F(OveruseFrameDetectorTest, CaptureJitter) {
@ -332,7 +364,7 @@ TEST_F(OveruseFrameDetectorTest, EncodedUsage) {
const int kEncodeTimeMs = 5;
InsertAndEncodeFramesWithInterval(
1000, kFrameInterval33ms, kWidth, kHeight, kEncodeTimeMs);
EXPECT_EQ(15, EncodeUsagePercent());
EXPECT_EQ(kEncodeTimeMs * 100 / kFrameInterval33ms, EncodeUsagePercent());
}
TEST_F(OveruseFrameDetectorTest, EncodeUsageResetAfterChangingThreshold) {
@ -345,10 +377,14 @@ TEST_F(OveruseFrameDetectorTest, EncodeUsageResetAfterChangingThreshold) {
EXPECT_EQ(InitialEncodeUsage(), EncodeUsagePercent());
}
// enable_encode_usage_method = true;
// EncodeUsagePercent() > high_encode_usage_threshold_percent => overuse.
// EncodeUsagePercent() < low_encode_usage_threshold_percent => underuse.
TEST_F(OveruseFrameDetectorTest, TriggerOveruseWithEncodeUsage) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = true;
overuse_detector_->SetOptions(options_);
// usage > high => overuse
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
TriggerOveruseWithEncodeUsage(options_.high_threshold_consecutive_count);
}
@ -357,9 +393,94 @@ TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithEncodeUsage) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = true;
overuse_detector_->SetOptions(options_);
// usage > high => overuse
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
TriggerOveruseWithEncodeUsage(options_.high_threshold_consecutive_count);
// usage < low => underuse
EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
TriggerNormalUsageWithEncodeUsage();
TriggerNormalUsageWithEncodeTime();
}
TEST_F(OveruseFrameDetectorTest,
OveruseAndRecoverWithEncodeUsageMethodDisabled) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = false;
overuse_detector_->SetOptions(options_);
// usage > high => overuse
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(0);
TriggerOveruseWithEncodeUsage(options_.high_threshold_consecutive_count);
// usage < low => underuse
EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
TriggerNormalUsageWithEncodeTime();
}
TEST_F(OveruseFrameDetectorTest, EncodeRsdResetAfterChangingThreshold) {
EXPECT_EQ(InitialEncodeRsd(), EncodeRsd());
options_.high_encode_time_rsd_threshold = 100;
overuse_detector_->SetOptions(options_);
EXPECT_EQ(InitialEncodeRsd(), EncodeRsd());
options_.low_encode_time_rsd_threshold = 20;
overuse_detector_->SetOptions(options_);
EXPECT_EQ(InitialEncodeRsd(), EncodeRsd());
}
// enable_encode_usage_method = true;
// low/high_encode_time_rsd_threshold >= 0
// EncodeUsagePercent() > high_encode_usage_threshold_percent ||
// EncodeRsd() > high_encode_time_rsd_threshold => overuse.
// EncodeUsagePercent() < low_encode_usage_threshold_percent &&
// EncodeRsd() < low_encode_time_rsd_threshold => underuse.
TEST_F(OveruseFrameDetectorTest, TriggerOveruseWithEncodeRsd) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = true;
options_.high_encode_time_rsd_threshold = 80;
overuse_detector_->SetOptions(options_);
// rsd > high, usage < high => overuse
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
TriggerOveruseWithEncodeRsd(options_.high_threshold_consecutive_count);
EXPECT_LT(EncodeUsagePercent(), options_.high_encode_usage_threshold_percent);
}
TEST_F(OveruseFrameDetectorTest, OveruseAndRecoverWithEncodeRsd) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = true;
options_.low_encode_time_rsd_threshold = 20;
options_.high_encode_time_rsd_threshold = 80;
overuse_detector_->SetOptions(options_);
// rsd > high, usage < high => overuse
EXPECT_CALL(*(observer_.get()), OveruseDetected()).Times(1);
TriggerOveruseWithEncodeRsd(options_.high_threshold_consecutive_count);
EXPECT_LT(EncodeUsagePercent(), options_.high_encode_usage_threshold_percent);
// rsd < low, usage < low => underuse
EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(testing::AtLeast(1));
TriggerNormalUsageWithEncodeTime();
}
TEST_F(OveruseFrameDetectorTest, NoUnderuseWithEncodeRsd_UsageGtLowThreshold) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = true;
options_.low_encode_usage_threshold_percent = 1;
options_.low_encode_time_rsd_threshold = 20;
options_.high_encode_time_rsd_threshold = 90;
overuse_detector_->SetOptions(options_);
// rsd < low, usage > low => no underuse
EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
TriggerNormalUsageWithEncodeTime();
EXPECT_LT(EncodeRsd(), options_.low_encode_time_rsd_threshold);
EXPECT_GT(EncodeUsagePercent(), options_.low_encode_usage_threshold_percent);
}
TEST_F(OveruseFrameDetectorTest, NoUnderuseWithEncodeRsd_RsdGtLowThreshold) {
options_.enable_capture_jitter_method = false;
options_.enable_encode_usage_method = true;
options_.low_encode_usage_threshold_percent = 20;
options_.low_encode_time_rsd_threshold = 1;
options_.high_encode_time_rsd_threshold = 90;
overuse_detector_->SetOptions(options_);
// rsd > low, usage < low => no underuse
EXPECT_CALL(*(observer_.get()), NormalUsage()).Times(0);
TriggerNormalUsageWithEncodeTime();
EXPECT_GT(EncodeRsd(), options_.low_encode_time_rsd_threshold);
EXPECT_LT(EncodeUsagePercent(), options_.low_encode_usage_threshold_percent);
}
} // namespace webrtc