components/scheduler/child/prioritizing_task_queue_selector_unittest.cc

   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 #include "components/scheduler/child/prioritizing_task_queue_selector.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/memory/scoped_vector.h"
  10 #include "base/pending_task.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace scheduler {
  15
  16 class MockObserver : public TaskQueueSelector::Observer {
  17  public:
  18   MockObserver() {}
  19   virtual ~MockObserver() {}
  20
  21   MOCK_METHOD0(OnTaskQueueEnabled, void());
  22
  23  private:
  24   DISALLOW_COPY_AND_ASSIGN(MockObserver);
  25 };
  26
  27 class PrioritizingTaskQueueSelectorForTest
  28     : public PrioritizingTaskQueueSelector {
  29  public:
  30   PrioritizingTaskQueueSelectorForTest() {}
  31   ~PrioritizingTaskQueueSelectorForTest() override {}
  32
  33   using PrioritizingTaskQueueSelector::DisableQueueInternal;
  34 };
  35
  36 class PrioritizingTaskQueueSelectorTest : public testing::Test {
  37  public:
  38   PrioritizingTaskQueueSelectorTest()
  39       : test_closure_(
  40             base::Bind(&PrioritizingTaskQueueSelectorTest::TestFunction)) {}
  41   ~PrioritizingTaskQueueSelectorTest() override {}
  42
  43   std::vector<base::PendingTask> GetTasks(int count) {
  44     std::vector<base::PendingTask> tasks;
  45     for (int i = 0; i < count; i++) {
  46       base::PendingTask task = base::PendingTask(FROM_HERE, test_closure_);
  47       task.sequence_num = i;
  48       tasks.push_back(task);
  49     }
  50     return tasks;
  51   }
  52
  53   void PushTasks(const std::vector<base::PendingTask>& tasks,
  54                  const size_t queue_indices[]) {
  55     for (size_t i = 0; i < tasks.size(); i++) {
  56       task_queues_[queue_indices[i]]->push(tasks[i]);
  57     }
  58   }
  59
  60   std::vector<size_t> PopTasks() {
  61     std::vector<size_t> order;
  62     size_t chosen_queue_index;
  63     while (selector_.SelectWorkQueueToService(&chosen_queue_index)) {
  64       order.push_back(chosen_queue_index);
  65       task_queues_[chosen_queue_index]->pop();
  66     }
  67     return order;
  68   }
  69
  70   static void TestFunction() {}
  71
  72  protected:
  73   void SetUp() final {
  74     std::vector<const base::TaskQueue*> const_task_queues;
  75     for (size_t i = 0; i < kTaskQueueCount; i++) {
  76       scoped_ptr<base::TaskQueue> task_queue(new base::TaskQueue());
  77       const_task_queues.push_back(task_queue.get());
  78       task_queues_.push_back(task_queue.release());
  79     }
  80     selector_.RegisterWorkQueues(const_task_queues);
  81     for (size_t i = 0; i < kTaskQueueCount; i++)
  82       EXPECT_TRUE(selector_.IsQueueEnabled(i)) << i;
  83   }
  84
  85   const size_t kTaskQueueCount = 5;
  86   base::Closure test_closure_;
  87   PrioritizingTaskQueueSelectorForTest selector_;
  88   ScopedVector<base::TaskQueue> task_queues_;
  89 };
  90
  91 TEST_F(PrioritizingTaskQueueSelectorTest, TestDefaultPriority) {
  92   std::vector<base::PendingTask> tasks = GetTasks(5);
  93   size_t queue_order[] = {4, 3, 2, 1, 0};
  94   PushTasks(tasks, queue_order);
  95   EXPECT_THAT(PopTasks(), testing::ElementsAre(4, 3, 2, 1, 0));
  96 }
  97
  98 TEST_F(PrioritizingTaskQueueSelectorTest, TestHighPriority) {
  99   std::vector<base::PendingTask> tasks = GetTasks(5);
 100   size_t queue_order[] = {0, 1, 2, 3, 4};
 101   PushTasks(tasks, queue_order);
 102   selector_.SetQueuePriority(2, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
 103   EXPECT_THAT(PopTasks(), testing::ElementsAre(2, 0, 1, 3, 4));
 104 }
 105
 106 TEST_F(PrioritizingTaskQueueSelectorTest, TestBestEffortPriority) {
 107   std::vector<base::PendingTask> tasks = GetTasks(5);
 108   size_t queue_order[] = {0, 1, 2, 3, 4};
 109   PushTasks(tasks, queue_order);
 110   selector_.SetQueuePriority(
 111       0, PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
 112   selector_.SetQueuePriority(2, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
 113   EXPECT_THAT(PopTasks(), testing::ElementsAre(2, 1, 3, 4, 0));
 114 }
 115
 116 TEST_F(PrioritizingTaskQueueSelectorTest, TestControlPriority) {
 117   std::vector<base::PendingTask> tasks = GetTasks(5);
 118   size_t queue_order[] = {0, 1, 2, 3, 4};
 119   PushTasks(tasks, queue_order);
 120   selector_.SetQueuePriority(4,
 121                              PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
 122   EXPECT_TRUE(selector_.IsQueueEnabled(4));
 123   selector_.SetQueuePriority(2, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
 124   EXPECT_TRUE(selector_.IsQueueEnabled(2));
 125   EXPECT_THAT(PopTasks(), testing::ElementsAre(4, 2, 0, 1, 3));
 126 }
 127
 128 TEST_F(PrioritizingTaskQueueSelectorTest,
 129        TestDisableReturnsTrueIfQueueWasEnabled) {
 130   selector_.EnableQueue(1, PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
 131   EXPECT_TRUE(selector_.DisableQueueInternal(1));
 132 }
 133
 134 TEST_F(PrioritizingTaskQueueSelectorTest,
 135        TestDisableReturnsFalseIfQueueWasAlreadyDisabled) {
 136   selector_.DisableQueue(1);
 137   EXPECT_FALSE(selector_.DisableQueueInternal(1));
 138 }
 139
 140 TEST_F(PrioritizingTaskQueueSelectorTest, TestDisableEnable) {
 141   MockObserver mock_observer;
 142   selector_.SetTaskQueueSelectorObserver(&mock_observer);
 143
 144   std::vector<base::PendingTask> tasks = GetTasks(5);
 145   size_t queue_order[] = {0, 1, 2, 3, 4};
 146   PushTasks(tasks, queue_order);
 147   selector_.DisableQueue(2);
 148   EXPECT_FALSE(selector_.IsQueueEnabled(2));
 149   selector_.DisableQueue(4);
 150   EXPECT_FALSE(selector_.IsQueueEnabled(4));
 151   EXPECT_THAT(PopTasks(), testing::ElementsAre(0, 1, 3));
 152
 153   EXPECT_CALL(mock_observer, OnTaskQueueEnabled()).Times(2);
 154   selector_.EnableQueue(2, PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
 155   EXPECT_THAT(PopTasks(), testing::ElementsAre(2));
 156   selector_.EnableQueue(4, PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
 157   EXPECT_THAT(PopTasks(), testing::ElementsAre(4));
 158 }
 159
 160 TEST_F(PrioritizingTaskQueueSelectorTest, TestEmptyQueues) {
 161   size_t chosen_queue_index = 0;
 162   EXPECT_FALSE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 163
 164   // Test only disabled queues.
 165   std::vector<base::PendingTask> tasks = GetTasks(1);
 166   size_t queue_order[] = {0};
 167   PushTasks(tasks, queue_order);
 168   selector_.DisableQueue(0);
 169   EXPECT_FALSE(selector_.IsQueueEnabled(0));
 170   EXPECT_FALSE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 171 }
 172
 173 TEST_F(PrioritizingTaskQueueSelectorTest, TestDelay) {
 174   std::vector<base::PendingTask> tasks = GetTasks(5);
 175   tasks[0].delayed_run_time =
 176       base::TimeTicks() + base::TimeDelta::FromMilliseconds(200);
 177   tasks[3].delayed_run_time =
 178       base::TimeTicks() + base::TimeDelta::FromMilliseconds(100);
 179   size_t queue_order[] = {0, 1, 2, 3, 4};
 180   PushTasks(tasks, queue_order);
 181   EXPECT_THAT(PopTasks(), testing::ElementsAre(1, 2, 4, 3, 0));
 182 }
 183
 184 TEST_F(PrioritizingTaskQueueSelectorTest, TestControlStarvesOthers) {
 185   std::vector<base::PendingTask> tasks = GetTasks(4);
 186   size_t queue_order[] = {0, 1, 2, 3};
 187   PushTasks(tasks, queue_order);
 188   selector_.SetQueuePriority(3,
 189                              PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
 190   selector_.SetQueuePriority(2, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
 191   selector_.SetQueuePriority(
 192       1, PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
 193   for (int i = 0; i < 100; i++) {
 194     size_t chosen_queue_index = 0;
 195     EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 196     EXPECT_EQ(3ul, chosen_queue_index);
 197     // Don't remove task from queue to simulate all queues still being full.
 198   }
 199 }
 200
 201 TEST_F(PrioritizingTaskQueueSelectorTest, TestHighPriorityDoesNotStarveNormal) {
 202   std::vector<base::PendingTask> tasks = GetTasks(3);
 203   size_t queue_order[] = {0, 1, 2};
 204   PushTasks(tasks, queue_order);
 205   selector_.SetQueuePriority(2, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
 206   selector_.SetQueuePriority(
 207       1, PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
 208   size_t counts[] = {0, 0, 0};
 209   for (int i = 0; i < 100; i++) {
 210     size_t chosen_queue_index = 0;
 211     EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 212     counts[chosen_queue_index]++;
 213     // Don't remove task from queue to simulate all queues still being full.
 214   }
 215   EXPECT_GT(counts[0], 0ul);        // Check high doesn't starve normal.
 216   EXPECT_GT(counts[2], counts[0]);  // Check high gets more chance to run.
 217   EXPECT_EQ(0ul, counts[1]);        // Check best effort is starved.
 218 }
 219
 220 TEST_F(PrioritizingTaskQueueSelectorTest, TestBestEffortGetsStarved) {
 221   std::vector<base::PendingTask> tasks = GetTasks(2);
 222   size_t queue_order[] = {0, 1};
 223   PushTasks(tasks, queue_order);
 224   selector_.SetQueuePriority(
 225       0, PrioritizingTaskQueueSelector::BEST_EFFORT_PRIORITY);
 226   selector_.SetQueuePriority(1, PrioritizingTaskQueueSelector::NORMAL_PRIORITY);
 227   size_t chosen_queue_index = 0;
 228   for (int i = 0; i < 100; i++) {
 229     EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 230     EXPECT_EQ(1ul, chosen_queue_index);
 231     // Don't remove task from queue to simulate all queues still being full.
 232   }
 233   selector_.SetQueuePriority(1, PrioritizingTaskQueueSelector::HIGH_PRIORITY);
 234   for (int i = 0; i < 100; i++) {
 235     EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 236     EXPECT_EQ(1ul, chosen_queue_index);
 237     // Don't remove task from queue to simulate all queues still being full.
 238   }
 239   selector_.SetQueuePriority(1,
 240                              PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
 241   for (int i = 0; i < 100; i++) {
 242     EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 243     EXPECT_EQ(1ul, chosen_queue_index);
 244     // Don't remove task from queue to simulate all queues still being full.
 245   }
 246 }
 247
 248 }  // namespace scheduler