content/renderer/scheduler/renderer_task_queue_selector.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_RENDERER_SCHEDULER_RENDERER_TASK_QUEUE_SELECTOR_H
   6 #define CONTENT_RENDERER_SCHEDULER_RENDERER_TASK_QUEUE_SELECTOR_H
   7
   8 #include <set>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/threading/thread_checker.h"
  12 #include "content/common/content_export.h"
  13 #include "content/renderer/scheduler/task_queue_selector.h"
  14
  15 namespace content {
  16
  17 // A RendererTaskQueueSelector is a TaskQueueSelector which is used by the
  18 // RendererScheduler to enable prioritization of particular task queues.
  19 class CONTENT_EXPORT RendererTaskQueueSelector
  20     : NON_EXPORTED_BASE(public TaskQueueSelector) {
  21  public:
  22   enum QueuePriority {
  23     // Queues with control priority will run before any other queue, and will
  24     // explicitly starve other queues. Typically this should only be used for
  25     // private queues which perform control operations.
  26     CONTROL_PRIORITY,
  27     // Queues with high priority will be selected preferentially over normal or
  28     // best effort queues. The selector will ensure that high priority queues
  29     // cannot completely starve normal priority queues.
  30     HIGH_PRIORITY,
  31     // Queues with normal priority are the default.
  32     NORMAL_PRIORITY,
  33     // Queues with best effort priority will only be run if all other queues are
  34     // empty. They can be starved by the other queues.
  35     BEST_EFFORT_PRIORITY,
  36     // Must be the last entry.
  37     QUEUE_PRIORITY_COUNT,
  38     FIRST_QUEUE_PRIORITY = CONTROL_PRIORITY,
  39   };
  40
  41   RendererTaskQueueSelector();
  42   ~RendererTaskQueueSelector() override;
  43
  44   // Set the priority of |queue_index| to |priority|.
  45   void SetQueuePriority(size_t queue_index, QueuePriority priority);
  46
  47   // Enable the |queue_index| with a priority of |priority|. By default all
  48   // queues are enabled with normal priority.
  49   void EnableQueue(size_t queue_index, QueuePriority priority);
  50
  51   // Disable the |queue_index|.
  52   void DisableQueue(size_t queue_index);
  53
  54   // TaskQueueSelector implementation:
  55   void RegisterWorkQueues(
  56       const std::vector<const base::TaskQueue*>& work_queues) override;
  57   bool SelectWorkQueueToService(size_t* out_queue_index) override;
  58   void AsValueInto(base::debug::TracedValue* state) const override;
  59
  60  private:
  61   // Returns true if queueA contains an older task than queueB.
  62   static bool IsOlder(const base::TaskQueue* queueA,
  63                       const base::TaskQueue* queueB);
  64
  65   // Returns the priority which is next after |priority|.
  66   static QueuePriority NextPriority(QueuePriority priority);
  67
  68   static const char* PriorityToString(QueuePriority priority);
  69
  70   // Return true if |out_queue_index| indicates the index of the queue with
  71   // the oldest pending task from the set of queues of |priority|, or
  72   // false if all queues of that priority are empty.
  73   bool ChooseOldestWithPriority(QueuePriority priority,
  74                                 size_t* out_queue_index) const;
  75
  76   // Returns true if |queue_index| is enabled with the given |priority|.
  77   bool QueueEnabledWithPriority(size_t queue_index,
  78                                 QueuePriority priority) const;
  79
  80   // Called whenever the selector chooses a task queue for execution with the
  81   // priority |priority|.
  82   void DidSelectQueueWithPriority(QueuePriority priority);
  83
  84   // Number of high priority tasks which can be run before a normal priority
  85   // task should be selected to prevent starvation.
  86   // TODO(rmcilroy): Check if this is a good value.
  87   static const size_t kMaxStarvationTasks = 5;
  88
  89   base::ThreadChecker main_thread_checker_;
  90   std::vector<const base::TaskQueue*> work_queues_;
  91   std::set<size_t> queue_priorities_[QUEUE_PRIORITY_COUNT];
  92   size_t starvation_count_;
  93   DISALLOW_COPY_AND_ASSIGN(RendererTaskQueueSelector);
  94 };
  95
  96 }  // namespace content
  97
  98 #endif  // CONTENT_RENDERER_SCHEDULER_RENDERER_TASK_QUEUE_SELECTOR_H