Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(445)

Unified Diff: base/task_scheduler/delayed_task_manager.cc

Issue 1806473002: TaskScheduler [9] Delayed Task Manager (Closed) Base URL: https://luckyluke-private.googlesource.com/src@s_5_worker_thread
Patch Set: self review Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: base/task_scheduler/delayed_task_manager.cc
diff --git a/base/task_scheduler/delayed_task_manager.cc b/base/task_scheduler/delayed_task_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..39891c77d11fa7f3471ffbfd7f92187552b2d44b
--- /dev/null
+++ b/base/task_scheduler/delayed_task_manager.cc
@@ -0,0 +1,162 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/task_scheduler/delayed_task_manager.h"
+
+#include <utility>
+
+#include "base/logging.h"
+#include "base/task_scheduler/utils.h"
+
+namespace base {
+namespace internal {
+
+struct DelayedTaskManager::DelayedTask {
+ DelayedTask(std::unique_ptr<Task> task,
+ scoped_refptr<Sequence> sequence,
+ PriorityQueue* priority_queue,
+ size_t index)
+ : task(std::move(task)),
+ sequence(std::move(sequence)),
+ priority_queue(priority_queue),
+ index(index) {}
+
+ DelayedTask(DelayedTask&& other)
+ : task(std::move(other.task)),
+ sequence(std::move(other.sequence)),
+ priority_queue(other.priority_queue),
+ index(other.index) {}
+
+ ~DelayedTask() = default;
+
+ DelayedTask& operator=(DelayedTask&& other) {
+ task = std::move(other.task);
+ sequence = std::move(other.sequence);
+ priority_queue = other.priority_queue;
+ index = other.index;
+ return *this;
+ }
+
+ std::unique_ptr<Task> task;
+
+ // The sequence and priority queue in which |task| is inserted once it
+ // becomes ripe for execution.
+ scoped_refptr<Sequence> sequence;
+ PriorityQueue* priority_queue;
+
+ // Ensures that tasks that have the same |delayed_run_time| are sorted
+ // according to the order in which they were added to the DelayedTaskManager.
+ size_t index;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DelayedTask);
+};
+
+DelayedTaskManager::DelayedTaskManager(
+ const Closure& on_next_delayed_run_time_updated)
+ : on_next_delayed_run_time_updated_(on_next_delayed_run_time_updated) {
+ DCHECK(!on_next_delayed_run_time_updated_.is_null());
+}
+
+DelayedTaskManager::~DelayedTaskManager() = default;
+
+void DelayedTaskManager::AddDelayedTask(std::unique_ptr<Task> task,
+ scoped_refptr<Sequence> sequence,
+ PriorityQueue* priority_queue) {
+ DCHECK(task);
+ DCHECK(sequence);
+ DCHECK(priority_queue);
+
+ const TimeTicks new_task_delayed_run_time = task->delayed_run_time;
+ TimeTicks existing_next_delayed_run_time;
gab 2016/04/11 18:28:30 How about s/existing_next_delayed_run_time/current
fdoray 2016/04/11 19:57:05 Done.
+
+ {
+ AutoSchedulerLock auto_lock(lock_);
+
+ if (!delayed_tasks_.empty()) {
+ existing_next_delayed_run_time =
+ delayed_tasks_.top().task->delayed_run_time;
+ }
+
+ delayed_tasks_.emplace(std::move(task), std::move(sequence), priority_queue,
+ next_delayed_task_index_++);
+ }
+
+ if (existing_next_delayed_run_time.is_null() ||
+ new_task_delayed_run_time < existing_next_delayed_run_time) {
+ on_next_delayed_run_time_updated_.Run();
+ }
+}
+
+void DelayedTaskManager::PostReadyTasks() {
+ const TimeTicks now = Now();
+
+ // Move delayed tasks that are ready for execution into |ready_tasks|. Don't
+ // post them right away to avoid imposing an unecessary lock dependency on
+ // PostTaskNowHelper.
+ std::vector<DelayedTask> ready_tasks;
+
+ {
+ AutoSchedulerLock auto_lock(lock_);
+ while (!delayed_tasks_.empty() &&
+ delayed_tasks_.top().task->delayed_run_time <= now) {
+ // The const_cast for std::move is almost okay since we're immediately
gab 2016/04/11 18:28:30 "almost okay" sound weird here, how about: // The
fdoray 2016/04/11 19:57:06 Done.
+ // moving it to |ready_tasks|. See DelayedTaskComparator::operator() for
+ // why it's almost.
+ ready_tasks.emplace_back(
+ std::move(const_cast<DelayedTask&>(delayed_tasks_.top())));
+ delayed_tasks_.pop();
+ }
+ }
+
+ // Post delayed tasks that are ready for execution.
+ for (auto& delayed_task : ready_tasks) {
+ PostTaskNowHelper(std::move(delayed_task.task),
+ std::move(delayed_task.sequence),
+ delayed_task.priority_queue);
+ }
+}
+
+TimeTicks DelayedTaskManager::GetNextDelayedRunTime() const {
+ AutoSchedulerLock auto_lock(lock_);
+
+ if (delayed_tasks_.empty())
+ return TimeTicks();
+
+ return delayed_tasks_.top().task->delayed_run_time;
+}
+
+// In std::priority_queue, the largest element is on top. Therefore, this
+// comparator returns true if the delayed run time of |right| is earlier than
+// the delayed run time of |left|.
+bool DelayedTaskManager::DelayedTaskComparator::operator()(
+ const DelayedTask& left,
+ const DelayedTask& right) const {
+#ifndef NDEBUG
+ // Due to STL consistency checks in Windows and const_cast'ing right before
+ // popping the DelayedTask, a null task can be passed to this comparator in
+ // Debug builds. To satisfy these consistency checks, this comparator
+ // considers null tasks to be the larger than anything.
+ DCHECK(left.task || right.task);
+ if (!left.task)
+ return false;
+ if (!right.task)
+ return true;
+#else
+ DCHECK(left.task);
+ DCHECK(right.task);
+#endif // NDEBUG
+ if (left.task->delayed_run_time > right.task->delayed_run_time)
+ return true;
+ if (left.task->delayed_run_time < right.task->delayed_run_time)
+ return false;
+ return left.index > right.index;
+}
+
+TimeTicks DelayedTaskManager::Now() const {
+ return TimeTicks::Now();
+}
+
+} // namespace internal
+} // namespace base

Powered by Google App Engine
This is Rietveld 408576698