admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Propagate environment into OveruseFrameDetector

Browse Source 
Thus use propagated instead of global field trials.

Bug: webrtc:10335
Change-Id: I6b1923cc90a2054efc4d878a425b99536d60885c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/346560
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42041}
This commit is contained in:
Danil Chapovalov 2024-04-09 17:39:35 +02:00 committed by WebRTC LUCI CQ
parent cdbc58e654
commit 1c35107cdc
6 changed files with 46 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
video/adaptation/BUILD.gn
View File

@ -38,6 +38,7 @@ rtc_library("video_adaptation") {
"../../api:scoped_refptr",
"../../api:sequence_checker",
"../../api/adaptation:resource_adaptation_api",
"../../api/environment",
"../../api/task_queue:task_queue",
"../../api/units:data_rate",
"../../api/units:time_delta",
@ -65,7 +66,6 @@ rtc_library("video_adaptation") {
"../../rtc_base/synchronization:mutex",
"../../rtc_base/system:no_unique_address",
"../../rtc_base/task_utils:repeating_task",
"../../system_wrappers:field_trial",
"../../system_wrappers:system_wrappers",
"../../video:video_stream_encoder_interface",
"../../video/config:encoder_config",
@ -92,6 +92,8 @@ if (rtc_include_tests) {
":video_adaptation",
"../../api:field_trials_view",
"../../api:scoped_refptr",
"../../api/environment",
"../../api/environment:environment_factory",
"../../api/task_queue:task_queue",
"../../api/units:time_delta",
"../../api/units:timestamp",
@ -111,9 +113,7 @@ if (rtc_include_tests) {
"../../rtc_base:rtc_numerics",
"../../rtc_base:task_queue_for_test",
"../../rtc_base:threading",
"../../test:field_trial",
"../../test:rtc_expect_death",
"../../test:scoped_key_value_config",
"../../test:test_support",
"../../test/time_controller:time_controller",
]

16
video/adaptation/overuse_frame_detector.cc
View File

@ -20,13 +20,14 @@
#include <string>
#include <utility>
#include "api/environment/environment.h"
#include "api/field_trials_view.h"
#include "api/video/video_frame.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/exp_filter.h"
#include "rtc_base/time_utils.h"
#include "rtc_base/trace_event.h"
#include "system_wrappers/include/field_trial.h"
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
#include <mach/mach.h>
@ -431,7 +432,8 @@ class OverdoseInjector : public OveruseFrameDetector::ProcessingUsage {
} // namespace
std::unique_ptr<OveruseFrameDetector::ProcessingUsage>
OveruseFrameDetector::CreateProcessingUsage(const CpuOveruseOptions& options) {
OveruseFrameDetector::CreateProcessingUsage(const FieldTrialsView& field_trials,
const CpuOveruseOptions& options) {
std::unique_ptr<ProcessingUsage> instance;
if (options.filter_time_ms > 0) {
instance = std::make_unique<SendProcessingUsage2>(options);
@ -439,7 +441,7 @@ OveruseFrameDetector::CreateProcessingUsage(const CpuOveruseOptions& options) {
instance = std::make_unique<SendProcessingUsage1>(options);
}
std::string toggling_interval =
field_trial::FindFullName("WebRTC-ForceSimulatedOveruseIntervalMs");
field_trials.Lookup("WebRTC-ForceSimulatedOveruseIntervalMs");
if (!toggling_interval.empty()) {
int normal_period_ms = 0;
int overuse_period_ms = 0;
@ -466,8 +468,10 @@ OveruseFrameDetector::CreateProcessingUsage(const CpuOveruseOptions& options) {
}
OveruseFrameDetector::OveruseFrameDetector(
const Environment& env,
CpuOveruseMetricsObserver* metrics_observer)
: metrics_observer_(metrics_observer),
: env_(env),
metrics_observer_(metrics_observer),
num_process_times_(0),
// TODO(bugs.webrtc.org/9078): Use absl::optional
last_capture_time_us_(-1),
@ -481,7 +485,7 @@ OveruseFrameDetector::OveruseFrameDetector(
current_rampup_delay_ms_(kStandardRampUpDelayMs) {
task_checker_.Detach();
ParseFieldTrial({&filter_time_constant_},
field_trial::FindFullName("WebRTC-CpuLoadEstimator"));
env_.field_trials().Lookup("WebRTC-CpuLoadEstimator"));
}
OveruseFrameDetector::~OveruseFrameDetector() {}
@ -644,7 +648,7 @@ void OveruseFrameDetector::SetOptions(const CpuOveruseOptions& options) {
}
// Force reset with next frame.
num_pixels_ = 0;
usage_ = CreateProcessingUsage(options);
usage_ = CreateProcessingUsage(env_.field_trials(), options);
}
bool OveruseFrameDetector::IsOverusing(int usage_percent) {

6
video/adaptation/overuse_frame_detector.h
View File

@ -15,6 +15,7 @@
#include <memory>
#include "absl/types/optional.h"
#include "api/environment/environment.h"
#include "api/field_trials_view.h"
#include "api/sequence_checker.h"
#include "api/task_queue/task_queue_base.h"
@ -73,7 +74,8 @@ class OveruseFrameDetectorObserverInterface {
// check for overuse.
class OveruseFrameDetector {
public:
explicit OveruseFrameDetector(CpuOveruseMetricsObserver* metrics_observer);
OveruseFrameDetector(const Environment& env,
CpuOveruseMetricsObserver* metrics_observer);
virtual ~OveruseFrameDetector();
OveruseFrameDetector(const OveruseFrameDetector&) = delete;
@ -144,8 +146,10 @@ class OveruseFrameDetector {
void ResetAll(int num_pixels);
static std::unique_ptr<ProcessingUsage> CreateProcessingUsage(
const FieldTrialsView& field_trials,
const CpuOveruseOptions& options);
const Environment env_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker task_checker_;
// Owned by the task queue from where StartCheckForOveruse is called.
RepeatingTaskHandle check_overuse_task_ RTC_GUARDED_BY(task_checker_);

9
video/adaptation/overuse_frame_detector_unittest.cc
View File

@ -12,6 +12,8 @@
#include <memory>
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/video/encoded_image.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_adaptation_reason.h"
@ -22,7 +24,6 @@
#include "rtc_base/task_queue_for_test.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/scoped_key_value_config.h"
namespace webrtc {
@ -61,8 +62,9 @@ class CpuOveruseObserverImpl : public OveruseFrameDetectorObserverInterface {
class OveruseFrameDetectorUnderTest : public OveruseFrameDetector {
public:
explicit OveruseFrameDetectorUnderTest(
const Environment& env,
CpuOveruseMetricsObserver* metrics_observer)
: OveruseFrameDetector(metrics_observer) {}
: OveruseFrameDetector(env, metrics_observer) {}
~OveruseFrameDetectorUnderTest() {}
using OveruseFrameDetector::CheckForOveruse;
@ -75,7 +77,8 @@ class OveruseFrameDetectorTest : public ::testing::Test,
void SetUp() override {
observer_ = &mock_observer_;
options_.min_process_count = 0;
overuse_detector_ = std::make_unique<OveruseFrameDetectorUnderTest>(this);
overuse_detector_ = std::make_unique<OveruseFrameDetectorUnderTest>(
CreateEnvironment(), this);
// Unfortunately, we can't call SetOptions here, since that would break
// single-threading requirements in the RunOnTqNormalUsage test.
}

2
video/video_send_stream_impl.cc
View File

@ -355,7 +355,7 @@ std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
TaskQueueBase* encoder_queue_ptr = encoder_queue.get();
return std::make_unique<VideoStreamEncoder>(
env, num_cpu_cores, stats_proxy, encoder_settings,
std::make_unique<OveruseFrameDetector>(stats_proxy),
std::make_unique<OveruseFrameDetector>(env, stats_proxy),
FrameCadenceAdapterInterface::Create(
&env.clock(), encoder_queue_ptr, metronome,
/*worker_queue=*/TaskQueueBase::Current(), env.field_trials()),

39
video/video_stream_encoder_unittest.cc
View File

@ -227,8 +227,9 @@ class FakeNV12NativeBuffer : public webrtc::VideoFrameBuffer {
class CpuOveruseDetectorProxy : public OveruseFrameDetector {
public:
explicit CpuOveruseDetectorProxy(CpuOveruseMetricsObserver* metrics_observer)
: OveruseFrameDetector(metrics_observer),
CpuOveruseDetectorProxy(const Environment& env,
CpuOveruseMetricsObserver* metrics_observer)
: OveruseFrameDetector(env, metrics_observer),
last_target_framerate_fps_(-1),
framerate_updated_event_(true /* manual_reset */,
false /* initially_signaled */) {}
@ -389,6 +390,7 @@ auto FpsEqResolutionGt(const rtc::VideoSinkWants& other_wants) {
class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
public:
VideoStreamEncoderUnderTest(
const Environment& env,
TimeController* time_controller,
std::unique_ptr<FrameCadenceAdapterInterface> cadence_adapter,
std::unique_ptr<webrtc::TaskQueueBase, webrtc::TaskQueueDeleter>
@ -397,16 +399,15 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
const VideoStreamEncoderSettings& settings,
VideoStreamEncoder::BitrateAllocationCallbackType
allocation_callback_type,
const FieldTrialsView& field_trials,
int num_cores)
: VideoStreamEncoder(
CreateEnvironment(&field_trials, time_controller->GetClock()),
env,
num_cores,
stats_proxy,
settings,
std::unique_ptr<OveruseFrameDetector>(
overuse_detector_proxy_ =
new CpuOveruseDetectorProxy(stats_proxy)),
new CpuOveruseDetectorProxy(env, stats_proxy)),
std::move(cadence_adapter),
std::move(encoder_queue),
allocation_callback_type),
@ -710,13 +711,14 @@ class SimpleVideoStreamEncoderFactory {
std::unique_ptr<FrameCadenceAdapterInterface> zero_hertz_adapter,
std::unique_ptr<TaskQueueBase, TaskQueueDeleter> encoder_queue,
const FieldTrialsView* field_trials = nullptr) {
Environment env = CreateEnvironment(&field_trials_, field_trials,
time_controller_.GetClock());
auto result = std::make_unique<AdaptedVideoStreamEncoder>(
CreateEnvironment(&field_trials_, field_trials,
time_controller_.GetClock()),
env,
/*number_of_cores=*/1,
/*stats_proxy=*/stats_proxy_.get(), encoder_settings_,
std::make_unique<CpuOveruseDetectorProxy>(
/*stats_proxy=*/nullptr),
std::make_unique<CpuOveruseDetectorProxy>(env,
/*stats_proxy=*/nullptr),
std::move(zero_hertz_adapter), std::move(encoder_queue),
VideoStreamEncoder::BitrateAllocationCallbackType::
kVideoBitrateAllocation);
@ -886,7 +888,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
if (video_stream_encoder_)
video_stream_encoder_->Stop();
auto encoder_queue = GetTaskQueueFactory()->CreateTaskQueue(
auto encoder_queue = env_.task_queue_factory().CreateTaskQueue(
"EncoderQueue", TaskQueueFactory::Priority::NORMAL);
TaskQueueBase* encoder_queue_ptr = encoder_queue.get();
std::unique_ptr<FrameCadenceAdapterInterface> cadence_adapter =
@ -894,9 +896,10 @@ class VideoStreamEncoderTest : public ::testing::Test {
time_controller_.GetClock(), encoder_queue_ptr,
/*metronome=*/nullptr, /*worker_queue=*/nullptr, field_trials_);
video_stream_encoder_ = std::make_unique<VideoStreamEncoderUnderTest>(
&time_controller_, std::move(cadence_adapter), std::move(encoder_queue),
stats_proxy_.get(), video_send_config_.encoder_settings,
allocation_callback_type, field_trials_, num_cores);
env_, &time_controller_, std::move(cadence_adapter),
std::move(encoder_queue), stats_proxy_.get(),
video_send_config_.encoder_settings, allocation_callback_type,
num_cores);
video_stream_encoder_->SetSink(&sink_, /*rotation_applied=*/false);
video_stream_encoder_->SetSource(
&video_source_, webrtc::DegradationPreference::MAINTAIN_FRAMERATE);
@ -1627,12 +1630,12 @@ class VideoStreamEncoderTest : public ::testing::Test {
int64_t CurrentTimeMs() { return clock()->CurrentTime().ms(); }
protected:
virtual TaskQueueFactory* GetTaskQueueFactory() {
return time_controller_.GetTaskQueueFactory();
}
test::ScopedKeyValueConfig field_trials_;
GlobalSimulatedTimeController time_controller_{Timestamp::Micros(1234)};
const Environment env_ =
CreateEnvironment(&field_trials_,
time_controller_.GetClock(),
time_controller_.GetTaskQueueFactory());
VideoSendStream::Config video_send_config_;
VideoEncoderConfig video_encoder_config_;
int codec_width_;
@ -9428,7 +9431,7 @@ TEST(VideoStreamEncoderSimpleTest, CreateDestroy) {
// simply be deleted.
VideoStreamEncoder encoder(
env, 1, &stats_proxy, encoder_settings,
std::make_unique<CpuOveruseDetectorProxy>(&stats_proxy),
std::make_unique<CpuOveruseDetectorProxy>(env, &stats_proxy),
std::move(adapter), std::move(encoder_queue),
VideoStreamEncoder::BitrateAllocationCallbackType::
kVideoBitrateAllocation);