content: Add RendererScheduler.

content/renderer/scheduler/renderer_scheduler_selector.cc

Index: content/renderer/scheduler/renderer_scheduler_selector.cc
diff --git a/content/renderer/scheduler/renderer_scheduler_selector.cc b/content/renderer/scheduler/renderer_scheduler_selector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b6c458931b45541c87b8f70e110c64ad4746ced8
--- /dev/null
+++ b/content/renderer/scheduler/renderer_scheduler_selector.cc
@@ -0,0 +1,124 @@
+// Copyright 2014 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 "content/renderer/scheduler/renderer_scheduler_selector.h"
+
+#include "base/logging.h"
+#include "base/pending_task.h"
+
+namespace content {
+
+RendererSchedulerSelector::RendererSchedulerSelector() {
+}
+
+RendererSchedulerSelector::~RendererSchedulerSelector() {
+}
+
+void RendererSchedulerSelector::RegisterWorkQueues(
+    const std::vector<const base::TaskQueue*>& work_queues) {
+  main_thread_checker_.CalledOnValidThread();
+  DCHECK_LT(work_queues.size(),

[alexclarke, 2014/10/24 14:37:26]

Maybe add a comment, I had to read this several times to understand what it was
guarding against.

[rmcilroy, 2014/10/24 14:58:29]

No longer applicable.

+      sizeof(queue_priorities_[kNormalPriority]) * CHAR_BIT);
+  work_queues_ = work_queues;
+  // By default, all work queues are set to normal priority.
+  queue_priorities_[kControlPriority] = 0;
+  queue_priorities_[kHighPriority] = 0;
+  queue_priorities_[kNormalPriority] = (1 << work_queues.size()) - 1;

[alexclarke, 2014/10/24 14:37:26]

Is there a reason to use work_queues.size() instead of kQueuePriorityCount?

Alternatively should we assert that work_queues.size() == kQueuePriorityCount? 
Or should that be >= ?

[rmcilroy, 2014/10/24 14:58:29]

No longer applicable (plus work_queues.size() is never equal to
kQueuePriorityCount - there can be many more queues than there are priority
levels).

+  queue_priorities_[kBestEffortPriority] = 0;
+}
+
+size_t RendererSchedulerSelector::PrioritiesMaskFromQueueIndex(
+    size_t queue_index) const {
+  return 1 << queue_index;
+}
+
+void RendererSchedulerSelector::SetQueuePriority(size_t queue_index,
+                                                 QueuePriority priority) {
+  main_thread_checker_.CalledOnValidThread();
+  DCHECK_LT(queue_index, work_queues_.size());
+  DCHECK_LT(priority, kQueuePriorityCount);
+  DisableQueue(queue_index);
+  queue_priorities_[priority] |= PrioritiesMaskFromQueueIndex(queue_index);
+}
+
+void RendererSchedulerSelector::EnableQueue(size_t queue_index,
+                                            QueuePriority priority) {
+  SetQueuePriority(queue_index, priority);
+}
+
+void RendererSchedulerSelector::DisableQueue(size_t queue_index) {
+  main_thread_checker_.CalledOnValidThread();
+  DCHECK_LT(queue_index, work_queues_.size());
+
+  for (auto priority: { kControlPriority,

[alexclarke, 2014/10/24 14:37:26]

fyi: gcc doesn't like this, although I do (apart from the auto).

I had to change this to the less elegant:

for (QueuePriority priority = kControlPriority;
     priority < kQueuePriorityCount;
     priority = static_cast<QueuePriority>(static_cast<int>(priority) + 1)) {

[rmcilroy, 2014/10/24 14:58:29]

I changed it to a static array.

[rmcilroy, 2014/10/24 14:58:29]

Modified this to be a ranged for on a static const array instead. 

+                        kHighPriority,
+                        kNormalPriority,
+                        kBestEffortPriority }) {
+    queue_priorities_[priority] &= ~PrioritiesMaskFromQueueIndex(queue_index);
+  }
+}
+
+bool RendererSchedulerSelector::QueueEnabledWithPriority(
+    size_t queue_index,
+    QueuePriority priority) const {
+  DCHECK_LT(queue_index, work_queues_.size());
+  DCHECK_LT(priority, kQueuePriorityCount);
+  return queue_priorities_[priority] &
+      PrioritiesMaskFromQueueIndex(queue_index);
+}
+
+bool RendererSchedulerSelector::ChooseOldestWithPriority(
+    QueuePriority priority,
+    size_t* out_queue_index) const {
+  bool found_non_empty_queue = false;
+  size_t chosen_queue = 0;
+  for (size_t i = 0; i < work_queues_.size(); i++) {
+    if (work_queues_[i]->empty() ||
+        !QueueEnabledWithPriority(i, priority)) {
+      continue;
+    }
+    // Note: the comparison between |chosen_queue| and |i| is correct due to the
+    // fact that the PendingTask operator inverts comparison for priority queue.
+    if (!found_non_empty_queue ||
+        work_queues_[chosen_queue]->front() < work_queues_[i]->front()) {
+      found_non_empty_queue = true;
+      chosen_queue = i;
+    }
+  }
+
+  if (found_non_empty_queue) {
+    *out_queue_index = chosen_queue;
+  }
+  return found_non_empty_queue;
+}
+
+bool RendererSchedulerSelector::SelectWorkQueueToService(
+    size_t* out_queue_index) {
+  main_thread_checker_.CalledOnValidThread();
+  DCHECK(work_queues_.size());
+  // Always service the control queue if it has any work.
+  if (ChooseOldestWithPriority(kControlPriority, out_queue_index)) {
+    return true;
+  }
+  // Select from the normal priority queue if we are starving it.
+  if (normal_queue_starvation_count_ >= kMaxStarvationTasks &&
+      ChooseOldestWithPriority(kNormalPriority, out_queue_index)) {
+    normal_queue_starvation_count_ = 0;
+    return true;
+  }
+  // Otherwise choose in priority order.
+  for (auto priority: { kHighPriority, kNormalPriority, kBestEffortPriority }) {
+    if (ChooseOldestWithPriority(priority, out_queue_index)) {
+      if (priority == kHighPriority) {
+        normal_queue_starvation_count_++;
+      } else {
+        normal_queue_starvation_count_ = 0;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace content