mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add TaskQueueStdlib experiment.

Browse source 
Bug: webrtc:14389
Change-Id: I23c6e0ae675748ec35a99c334104dd2654995a33
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/265802
Commit-Queue: Ali Tofigh <alito@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Reviewed-by: Jonas Oreland <jonaso@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37888}
This commit is contained in:
Ali Tofigh 2022-08-23 12:57:16 +02:00 committed by WebRTC LUCI CQ
parent 5aa3b073ad
commit 83db78e854
14 changed files with 113 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
api/create_peerconnection_factory.cc
View file

@ -40,19 +40,20 @@ rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
rtc::scoped_refptr<AudioProcessing> audio_processing,
AudioFrameProcessor* audio_frame_processor,
std::unique_ptr<FieldTrialsView> field_trials) {
if (!field_trials) {
field_trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
}
PeerConnectionFactoryDependencies dependencies;
dependencies.network_thread = network_thread;
dependencies.worker_thread = worker_thread;
dependencies.signaling_thread = signaling_thread;
dependencies.task_queue_factory = CreateDefaultTaskQueueFactory();
dependencies.task_queue_factory =
CreateDefaultTaskQueueFactory(field_trials.get());
dependencies.call_factory = CreateCallFactory();
dependencies.event_log_factory = std::make_unique<RtcEventLogFactory>(
dependencies.task_queue_factory.get());
if (field_trials) {
dependencies.trials = std::move(field_trials);
} else {
dependencies.trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
}
if (network_thread) {
// TODO(bugs.webrtc.org/13145): Add an rtc::SocketFactory* argument.

19
api/task_queue/BUILD.gn
View file

@ -61,7 +61,9 @@ rtc_library("task_queue_test") {
]
} else {
deps = [
":default_task_queue_factory",
":task_queue",
"../../api:field_trials_view",
"../../api/units:time_delta",
"../../rtc_base:refcount",
"../../rtc_base:rtc_event",
@ -81,11 +83,26 @@ rtc_library("default_task_queue_factory") {
poisonous = [ "default_task_queue" ]
}
sources = [ "default_task_queue_factory.h" ]
deps = [ ":task_queue" ]
deps = [
":task_queue",
"../../api:field_trials_view",
"../../rtc_base/memory:always_valid_pointer",
]
if (rtc_enable_libevent) {
if (is_android) {
sources +=
[ "default_task_queue_factory_stdlib_or_libevent_experiment.cc" ]
deps += [
"../../api/transport:field_trial_based_config",
"../../rtc_base:logging",
"../../rtc_base:rtc_task_queue_libevent",
"../../rtc_base:rtc_task_queue_stdlib",
]
} else {
sources += [ "default_task_queue_factory_libevent.cc" ]
deps += [ "../../rtc_base:rtc_task_queue_libevent" ]
}
} else if (is_mac || is_ios) {
sources += [ "default_task_queue_factory_gcd.cc" ]
deps += [ "../../rtc_base:rtc_task_queue_gcd" ]

4
api/task_queue/default_task_queue_factory.h
View file

@ -12,11 +12,13 @@
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
namespace webrtc {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory();
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
const FieldTrialsView* field_trials = nullptr);
} // namespace webrtc

4
api/task_queue/default_task_queue_factory_gcd.cc
View file

@ -9,12 +9,14 @@
*/
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "rtc_base/task_queue_gcd.h"
namespace webrtc {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
const FieldTrialsView* field_trials) {
return CreateTaskQueueGcdFactory();
}

4
api/task_queue/default_task_queue_factory_libevent.cc
View file

@ -9,12 +9,14 @@
*/
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "rtc_base/task_queue_libevent.h"
namespace webrtc {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
const FieldTrialsView* field_trials) {
return CreateTaskQueueLibeventFactory();
}

4
api/task_queue/default_task_queue_factory_stdlib.cc
View file

@ -9,12 +9,14 @@
*/
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "rtc_base/task_queue_stdlib.h"
namespace webrtc {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
const FieldTrialsView* field_trials) {
return CreateTaskQueueStdlibFactory();
}

38
api/task_queue/default_task_queue_factory_stdlib_or_libevent_experiment.cc Normal file
View file

@ -0,0 +1,38 @@
/*
* Copyright 2022 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/transport/field_trial_based_config.h"
#include "rtc_base/logging.h"
#include "rtc_base/memory/always_valid_pointer.h"
#include "rtc_base/task_queue_libevent.h"
#include "rtc_base/task_queue_stdlib.h"
namespace webrtc {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
const FieldTrialsView* field_trials_view) {
AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig> field_trials(
field_trials_view);
if (field_trials->IsEnabled("WebRTC-TaskQueue-ReplaceLibeventWithStdlib")) {
RTC_LOG(LS_INFO) << "WebRTC-TaskQueue-ReplaceLibeventWithStdlib: "
<< "using TaskQueueStdlibFactory.";
return CreateTaskQueueStdlibFactory();
}
RTC_LOG(LS_INFO) << "WebRTC-TaskQueue-ReplaceLibeventWithStdlib: "
<< "using TaskQueueLibeventFactory.";
return CreateTaskQueueLibeventFactory();
}
} // namespace webrtc

4
api/task_queue/default_task_queue_factory_win.cc
View file

@ -9,12 +9,14 @@
*/
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "rtc_base/task_queue_win.h"
namespace webrtc {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
const FieldTrialsView* field_trials) {
return CreateTaskQueueWinFactory();
}

23
api/task_queue/task_queue_test.cc
View file

@ -13,6 +13,7 @@
#include "absl/cleanup/cleanup.h"
#include "absl/strings/string_view.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/units/time_delta.h"
#include "rtc_base/event.h"
#include "rtc_base/ref_counter.h"
@ -29,13 +30,13 @@ std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue(
}
TEST_P(TaskQueueTest, Construct) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
auto queue = CreateTaskQueue(factory, "Construct");
EXPECT_FALSE(queue->IsCurrent());
}
TEST_P(TaskQueueTest, PostAndCheckCurrent) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
rtc::Event event;
auto queue = CreateTaskQueue(factory, "PostAndCheckCurrent");
@ -53,7 +54,7 @@ TEST_P(TaskQueueTest, PostAndCheckCurrent) {
}
TEST_P(TaskQueueTest, PostCustomTask) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
rtc::Event ran;
auto queue = CreateTaskQueue(factory, "PostCustomImplementation");
@ -72,7 +73,7 @@ TEST_P(TaskQueueTest, PostCustomTask) {
}
TEST_P(TaskQueueTest, PostDelayedZero) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
rtc::Event event;
auto queue = CreateTaskQueue(factory, "PostDelayedZero");
@ -81,7 +82,7 @@ TEST_P(TaskQueueTest, PostDelayedZero) {
}
TEST_P(TaskQueueTest, PostFromQueue) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
rtc::Event event;
auto queue = CreateTaskQueue(factory, "PostFromQueue");
@ -91,7 +92,7 @@ TEST_P(TaskQueueTest, PostFromQueue) {
}
TEST_P(TaskQueueTest, PostDelayed) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
rtc::Event event;
auto queue =
CreateTaskQueue(factory, "PostDelayed", TaskQueueFactory::Priority::HIGH);
@ -113,7 +114,7 @@ TEST_P(TaskQueueTest, PostDelayed) {
}
TEST_P(TaskQueueTest, PostMultipleDelayed) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
auto queue = CreateTaskQueue(factory, "PostMultipleDelayed");
std::vector<rtc::Event> events(100);
@ -132,7 +133,7 @@ TEST_P(TaskQueueTest, PostMultipleDelayed) {
}
TEST_P(TaskQueueTest, PostDelayedAfterDestruct) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
rtc::Event run;
rtc::Event deleted;
auto queue = CreateTaskQueue(factory, "PostDelayedAfterDestruct");
@ -147,7 +148,7 @@ TEST_P(TaskQueueTest, PostDelayedAfterDestruct) {
}
TEST_P(TaskQueueTest, PostAndReuse) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
rtc::Event event;
auto post_queue = CreateTaskQueue(factory, "PostQueue");
auto reply_queue = CreateTaskQueue(factory, "ReplyQueue");
@ -203,7 +204,7 @@ TEST_P(TaskQueueTest, PostALot) {
rtc::Event event_;
};
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
static constexpr int kTaskCount = 0xffff;
rtc::Event posting_done;
BlockingCounter all_destroyed(kTaskCount);
@ -247,7 +248,7 @@ TEST_P(TaskQueueTest, PostALot) {
// unit test, run it under TSan or some other tool that is able to
// directly detect data races.
TEST_P(TaskQueueTest, PostTwoWithSharedUnprotectedState) {
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
struct SharedState {
// First task will set this value to 1 and second will assert it.
int state = 0;

7
api/task_queue/task_queue_test.h
View file

@ -13,6 +13,7 @@
#include <functional>
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "test/gtest.h"
@ -31,9 +32,9 @@ namespace webrtc {
// INSTANTIATE_TEST_SUITE_P(My, TaskQueueTest, Values(CreateMyFactory));
//
// } // namespace
class TaskQueueTest : public ::testing::TestWithParam<
std::function<std::unique_ptr<TaskQueueFactory>()>> {
};
class TaskQueueTest
: public ::testing::TestWithParam<std::function<
std::unique_ptr<TaskQueueFactory>(const FieldTrialsView*)>> {};
} // namespace webrtc

1
rtc_base/BUILD.gn
View file

@ -1752,6 +1752,7 @@ if (rtc_include_tests) {
":threading",
":timeutils",
"../api:array_view",
"../api:field_trials_view",
"../api:make_ref_counted",
"../api/task_queue",
"../api/task_queue:pending_task_safety_flag",

8
rtc_base/thread_unittest.cc
View file

@ -12,6 +12,7 @@
#include <memory>
#include "api/field_trials_view.h"
#include "api/task_queue/task_queue_factory.h"
#include "api/task_queue/task_queue_test.h"
#include "api/units/time_delta.h"
@ -1138,11 +1139,16 @@ class ThreadFactory : public webrtc::TaskQueueFactory {
}
};
std::unique_ptr<webrtc::TaskQueueFactory> CreateDefaultThreadFactory(
const webrtc::FieldTrialsView*) {
return std::make_unique<ThreadFactory>();
}
using ::webrtc::TaskQueueTest;
INSTANTIATE_TEST_SUITE_P(RtcThread,
TaskQueueTest,
::testing::Values(std::make_unique<ThreadFactory>));
::testing::Values(CreateDefaultThreadFactory));
} // namespace
} // namespace rtc

13
rtc_tools/video_replay.cc
View file

@ -340,21 +340,22 @@ class RtpReplayer final {
// Replay a rtp dump with an optional json configuration.
static void Replay(const std::string& replay_config_path,
const std::string& rtp_dump_path) {
webrtc::RtcEventLogNull event_log;
Call::Config call_config(&event_log);
call_config.trials = new FieldTrialBasedConfig();
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory =
webrtc::CreateDefaultTaskQueueFactory();
webrtc::CreateDefaultTaskQueueFactory(call_config.trials);
auto worker_thread = task_queue_factory->CreateTaskQueue(
"worker_thread", TaskQueueFactory::Priority::NORMAL);
rtc::Event sync_event(/*manual_reset=*/false,
/*initially_signalled=*/false);
webrtc::RtcEventLogNull event_log;
Call::Config call_config(&event_log);
call_config.task_queue_factory = task_queue_factory.get();
call_config.trials = new FieldTrialBasedConfig();
std::unique_ptr<Call> call;
std::unique_ptr<StreamState> stream_state;
// Creation of the streams must happen inside a task queue because it is
// resued as a worker thread.
std::unique_ptr<Call> call;
std::unique_ptr<StreamState> stream_state;
worker_thread->PostTask([&]() {
call.reset(Call::Create(call_config));

3
sdk/objc/api/peerconnection/RTCPeerConnectionFactory.mm
View file

@ -173,8 +173,9 @@
if (webrtc::field_trial::IsEnabled("WebRTC-Network-UseNWPathMonitor")) {
dependencies.network_monitor_factory = webrtc::CreateNetworkMonitorFactory();
}
dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
dependencies.trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
dependencies.task_queue_factory =
webrtc::CreateDefaultTaskQueueFactory(dependencies.trials.get());
cricket::MediaEngineDependencies media_deps;
media_deps.adm = std::move(audioDeviceModule);
media_deps.task_queue_factory = dependencies.task_queue_factory.get();