From 348b08ac3e0bd49385115ceaa8740a63a91bf0c8 Mon Sep 17 00:00:00 2001 From: Danil Chapovalov Date: Thu, 17 Jan 2019 13:07:25 +0100 Subject: [PATCH] Introduce webrtc::TaskQueue and TaskQueueFactory interfaces Bug: webrtc:10191 Change-Id: Ia2fff34cb260d904f25f7263051695f1c004a53b Reviewed-on: https://webrtc-review.googlesource.com/c/117360 Commit-Queue: Danil Chapovalov Reviewed-by: Karl Wiberg Cr-Commit-Position: refs/heads/master@{#26295} --- DEPS | 1 + api/task_queue/BUILD.gn | 20 +++++++ api/task_queue/task_queue_base.cc | 35 ++++++++++++ api/task_queue/task_queue_base.h | 83 ++++++++++++++++++++++++++++ api/task_queue/task_queue_factory.h | 35 ++++++++++++ api/task_queue/task_queue_priority.h | 21 +++++++ rtc_base/task_queue.h | 7 +-- 7 files changed, 197 insertions(+), 5 deletions(-) create mode 100644 api/task_queue/task_queue_base.cc create mode 100644 api/task_queue/task_queue_base.h create mode 100644 api/task_queue/task_queue_factory.h create mode 100644 api/task_queue/task_queue_priority.h diff --git a/DEPS b/DEPS index 978d72e49f..92a1c81f93 100644 --- a/DEPS +++ b/DEPS @@ -1428,6 +1428,7 @@ include_rules = [ "+rtc_tools", # Abseil whitelist. Keep this in sync with abseil-in-webrtc.md. + "+absl/base/attributes.h", "+absl/container/inlined_vector.h", "+absl/memory/memory.h", "+absl/meta/type_traits.h", diff --git a/api/task_queue/BUILD.gn b/api/task_queue/BUILD.gn index e9dfe66ef7..d058291944 100644 --- a/api/task_queue/BUILD.gn +++ b/api/task_queue/BUILD.gn @@ -12,5 +12,25 @@ rtc_source_set("task_queue") { visibility = [ "*" ] public = [ "queued_task.h", + "task_queue_priority.h", + ] +} + +# TODO(bugs.webrtc.org/10191): Merge the target into task_queue target above +# when support for link-time injection is dropped. +rtc_source_set("task_queue_factory") { + visibility = [ "*" ] + public = [ + "task_queue_base.h", + "task_queue_factory.h", + ] + sources = [ + "task_queue_base.cc", + ] + + deps = [ + ":task_queue", + "//third_party/abseil-cpp/absl/base:core_headers", + "//third_party/abseil-cpp/absl/strings", ] } diff --git a/api/task_queue/task_queue_base.cc b/api/task_queue/task_queue_base.cc new file mode 100644 index 0000000000..409eb49bf5 --- /dev/null +++ b/api/task_queue/task_queue_base.cc @@ -0,0 +1,35 @@ +/* + * Copyright 2019 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 "api/task_queue/task_queue_base.h" + +#include "absl/base/attributes.h" + +namespace webrtc { +namespace { + +ABSL_CONST_INIT thread_local TaskQueueBase* current = nullptr; + +} // namespace + +TaskQueueBase* TaskQueueBase::Current() { + return current; +} + +TaskQueueBase::CurrentTaskQueueSetter::CurrentTaskQueueSetter( + TaskQueueBase* task_queue) + : previous_(current) { + current = task_queue; +} + +TaskQueueBase::CurrentTaskQueueSetter::~CurrentTaskQueueSetter() { + current = previous_; +} + +} // namespace webrtc diff --git a/api/task_queue/task_queue_base.h b/api/task_queue/task_queue_base.h new file mode 100644 index 0000000000..a5163fe4d6 --- /dev/null +++ b/api/task_queue/task_queue_base.h @@ -0,0 +1,83 @@ +/* + * Copyright 2019 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. + */ +#ifndef API_TASK_QUEUE_TASK_QUEUE_BASE_H_ +#define API_TASK_QUEUE_TASK_QUEUE_BASE_H_ + +#include + +#include "api/task_queue/queued_task.h" + +namespace webrtc { + +// Asynchronously executes tasks in a way that guarantees that they're executed +// in FIFO order and that tasks never overlap. Tasks may always execute on the +// same worker thread and they may not. To DCHECK that tasks are executing on a +// known task queue, use IsCurrent(). +class TaskQueueBase { + public: + // Starts destruction of the task queue. + // On return ensures no task are running and no new tasks are able to start + // on the task queue. + // Responsible for deallocation. Deallocation may happen syncrhoniously during + // Delete or asynchronously after Delete returns. + // Code not running on the TaskQueue should not make any assumption when + // TaskQueue is deallocated and thus should not call any methods after Delete. + // Code running on the TaskQueue should not call Delete, but can assume + // TaskQueue still exists and may call other methods, e.g. PostTask. + virtual void Delete() = 0; + + // Schedules a task to execute. Tasks are executed in FIFO order. + // If |task->Run()| returns true, task is deleted on the task queue + // before next QueuedTask starts executing. + // When a TaskQueue is deleted, pending tasks will not be executed but they + // will be deleted. The deletion of tasks may happen synchronously on the + // TaskQueue or it may happen asynchronously after TaskQueue is deleted. + // This may vary from one implementation to the next so assumptions about + // lifetimes of pending tasks should not be made. + virtual void PostTask(std::unique_ptr task) = 0; + + // Schedules a task to execute a specified number of milliseconds from when + // the call is made. The precision should be considered as "best effort" + // and in some cases, such as on Windows when all high precision timers have + // been used up, can be off by as much as 15 millseconds. + virtual void PostDelayedTask(std::unique_ptr task, + uint32_t milliseconds) = 0; + + // Until all TaskQueue implementations switch to using CurrentTaskQueueSetter + // below, this function may return nullptr even if code is executed by a + // TaskQueue. Keep using rtc::TaskQueue::Current() until bugs.webrtc.org/10191 + // is resolved. + static TaskQueueBase* Current(); + bool IsCurrent() const { return Current() == this; } + + protected: + class CurrentTaskQueueSetter { + public: + explicit CurrentTaskQueueSetter(TaskQueueBase* task_queue); + CurrentTaskQueueSetter(const CurrentTaskQueueSetter&) = delete; + CurrentTaskQueueSetter& operator=(const CurrentTaskQueueSetter&) = delete; + ~CurrentTaskQueueSetter(); + + private: + TaskQueueBase* const previous_; + }; + + // Users of the TaskQueue should call Delete instead of directly deleting + // this object. + virtual ~TaskQueueBase() = default; +}; + +struct TaskQueueDeleter { + void operator()(TaskQueueBase* task_queue) const { task_queue->Delete(); } +}; + +} // namespace webrtc + +#endif // API_TASK_QUEUE_TASK_QUEUE_BASE_H_ diff --git a/api/task_queue/task_queue_factory.h b/api/task_queue/task_queue_factory.h new file mode 100644 index 0000000000..682713856e --- /dev/null +++ b/api/task_queue/task_queue_factory.h @@ -0,0 +1,35 @@ +/* + * Copyright 2019 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. + */ +#ifndef API_TASK_QUEUE_TASK_QUEUE_FACTORY_H_ +#define API_TASK_QUEUE_TASK_QUEUE_FACTORY_H_ + +#include + +#include "absl/strings/string_view.h" +#include "api/task_queue/task_queue_base.h" +#include "api/task_queue/task_queue_priority.h" + +namespace webrtc { + +class TaskQueueFactory { + public: + // TaskQueue priority levels. On some platforms these will map to thread + // priorities, on others such as Mac and iOS, GCD queue priorities. + using Priority = ::webrtc::TaskQueuePriority; + + virtual ~TaskQueueFactory() = default; + virtual std::unique_ptr CreateTaskQueue( + absl::string_view name, + Priority priority) const = 0; +}; + +} // namespace webrtc + +#endif // API_TASK_QUEUE_TASK_QUEUE_FACTORY_H_ diff --git a/api/task_queue/task_queue_priority.h b/api/task_queue/task_queue_priority.h new file mode 100644 index 0000000000..a8696ec149 --- /dev/null +++ b/api/task_queue/task_queue_priority.h @@ -0,0 +1,21 @@ +/* + * Copyright 2019 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. + */ +#ifndef API_TASK_QUEUE_TASK_QUEUE_PRIORITY_H_ +#define API_TASK_QUEUE_TASK_QUEUE_PRIORITY_H_ + +namespace webrtc { + +// TODO(bugs.webrtc.org/10191): Move as member class of TaskQueueFactory when +// rtc::TaskQueue would be able to depende on it. +enum class TaskQueuePriority { NORMAL = 0, HIGH, LOW }; + +} // namespace webrtc + +#endif // API_TASK_QUEUE_TASK_QUEUE_PRIORITY_H_ diff --git a/rtc_base/task_queue.h b/rtc_base/task_queue.h index 41fcf41953..43497deb9d 100644 --- a/rtc_base/task_queue.h +++ b/rtc_base/task_queue.h @@ -18,6 +18,7 @@ #include "absl/memory/memory.h" #include "api/task_queue/queued_task.h" +#include "api/task_queue/task_queue_priority.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/scoped_ref_ptr.h" #include "rtc_base/system/rtc_export.h" @@ -142,11 +143,7 @@ class RTC_LOCKABLE RTC_EXPORT TaskQueue { public: // TaskQueue priority levels. On some platforms these will map to thread // priorities, on others such as Mac and iOS, GCD queue priorities. - enum class Priority { - NORMAL = 0, - HIGH, - LOW, - }; + using Priority = ::webrtc::TaskQueuePriority; explicit TaskQueue(const char* queue_name, Priority priority = Priority::NORMAL);