Adds a couple of simple micro benchmarks for the TaskQueueManager

content/renderer/scheduler/task_queue_manager_perftest.cc

+

[Sami, 2015/03/03 18:09:18]

Nit: extra blank line.

[alex clarke (OOO till 29th), 2015/03/04 11:38:06]

Done.

+// Copyright 2015 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/task_queue_manager.h"
+
+#include <functional>

[Sami, 2015/03/03 18:09:18]

I'm not sure we can use this yet. Lambdas by themselves are fine.

[alex clarke (OOO till 29th), 2015/03/04 11:38:06]

Done.

+#include "base/bind.h"
+#include "base/threading/thread.h"
+#include "content/renderer/scheduler/task_queue_selector.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/perf/perf_test.h"
+
+namespace content {
+
+namespace {
+
+class SelectorForTest : public TaskQueueSelector {
+ public:
+  SelectorForTest() {}
+
+  void RegisterWorkQueues(
+      const std::vector<const base::TaskQueue*>& work_queues) override {
+    work_queues_ = work_queues;
+  }
+
+  bool SelectWorkQueueToService(size_t* out_queue_index) override {
+    // Choose the oldest task, if any.
+    bool found_one = false;
+    for (size_t i = 0; i < work_queues_.size(); i++) {
+      if (work_queues_[i]->empty())
+        continue;
+      // Note: the < comparison is correct due to the fact that the PendingTask
+      // operator inverts its comparison operation in order to work well in a
+      // heap based priority queue.
+      if (!found_one ||
+          work_queues_[*out_queue_index]->front() < work_queues_[i]->front())
+        *out_queue_index = i;
+      found_one = true;
+    }
+    return found_one;

[Sami, 2015/03/03 18:09:18]

nit: This is guaranteed to be true because the selector won't be called unless
there is work to be done.

[alex clarke (OOO till 29th), 2015/03/04 11:38:06]

Sure.  I put a CHECK in there to hopefully make that more obvious.

+  }
+
+  void AsValueInto(base::trace_event::TracedValue* state) const override {}
+
+ private:
+  std::vector<const base::TaskQueue*> work_queues_;
+
+  DISALLOW_COPY_AND_ASSIGN(SelectorForTest);
+};
+
+}  // namespace
+
+class TaskQueueManagerPerfTest : public testing::Test {
+ protected:
+  void Initialize(size_t num_queues) {
+    num_queues_ = num_queues;
+    message_loop_.reset(new base::MessageLoop());
+    selector_ = make_scoped_ptr(new SelectorForTest);
+    manager_ = make_scoped_ptr(new TaskQueueManager(
+        num_queues, message_loop_->task_runner(), selector_.get()));
+  }
+
+  void Benchmark(const std::string& trace, std::function<void()> fn) {
+    base::TimeTicks start = base::TimeTicks::Now();
+    base::TimeTicks now;
+    unsigned long long num_iterations = 0;
+    do {
+      fn();
+      now = base::TimeTicks::Now();
+      num_iterations++;
+    } while (now - start < base::TimeDelta::FromSeconds(5));
+    perf_test::PrintResult(
+        "task", "", trace,
+        (now - start).InMicroseconds() / static_cast<double>(num_iterations),
+        "us/run", true);
+  }
+
+  void TestTask() {
+    // Post a variable number of tasks.
+    unsigned int num_posts = 1 + sequence_number_ % 8;
+    for (unsigned int i = 0; i < num_posts; i++) {
+      if (++sequence_number_ < 10000) {
+        // Choose a queue weighted towards queue 0.
+        unsigned int queue = sequence_number_ % (num_queues_ + 1);
+        if (queue == num_queues_) {
+          queue = 0;
+        }
+        base::TimeDelta delay(
+            base::TimeDelta::FromMilliseconds(sequence_number_ % 10));

[Sami, 2015/03/03 18:09:18]

I think you said this takes less than a millisecond to run, so most of these
delayed tasks wouldn't get a chance to fire, right? Should we make the delays
much smaller?

Also, this is pretty heavily biased towards delayed tasks (which can be fine
since the benchmarks mention delayed tasks specifically). I wonder if we should
instead do one run of top_25/key_mobile_sites and plug in the rough ratio of
delayed vs. non-delayed here?

[alex clarke (OOO till 29th), 2015/03/04 11:38:06]

No it takes much longer to complete than that.  Putting a printf in  TestTask
shows it posts 10000x before exiting.

[Sami, 2015/03/04 13:00:08]

We're counting tasks posted and not tasks run though. How many tasks do we end
up running before the test ends?
 

[alex clarke (OOO till 29th), 2015/03/04 16:34:20]

I changed it so that it runs all.  I don't see much difference in the results.

+        scoped_refptr<base::SingleThreadTaskRunner> runner =
+            manager_->TaskRunnerForQueue(queue);
+        runner->PostDelayedTask(FROM_HERE,

[Sami, 2015/03/03 18:09:18]

I'm worried this is a little too atypical workload since the number of posted
tasks is exponential. How deep are the task queues that you're seeing?

[alex clarke (OOO till 29th), 2015/03/04 11:38:06]

50 - 200 delayed tasks are common on heavy pages like the verge.  Typically
between 2-30 fire at the same time.  I've adjusted the code to limit the number
of tasks in flight.

+                                base::Bind(&TaskQueueManagerPerfTest::TestTask,
+                                           base::Unretained(this)),
+                                delay);
+      } else {
+        message_loop_->Quit();
+        return;
+      }
+    }
+  }
+
+  size_t num_queues_;
+  unsigned int sequence_number_;
+  scoped_ptr<SelectorForTest> selector_;
+  scoped_ptr<TaskQueueManager> manager_;
+  scoped_ptr<base::MessageLoop> message_loop_;
+};
+
+TEST_F(TaskQueueManagerPerfTest, RunTenThousandDelayedTasks_OneQueue) {
+  Initialize(1u);
+
+  Benchmark("post 10000 delayed tasks", [this]() {

[Sami, 2015/03/03 18:09:18]

Could you pass in the number of task queues as a modifier to make the results
unique?

[alex clarke (OOO till 29th), 2015/03/04 11:38:06]

Done.

+    sequence_number_ = 0;
+    TestTask();
+    message_loop_->Run();
+  });
+}
+
+TEST_F(TaskQueueManagerPerfTest, RunTenThousandDelayedTasks_FourQueues) {
+  Initialize(4u);
+
+  Benchmark("post 10000 delayed tasks", [this]() {
+    sequence_number_ = 0;
+    TestTask();
+    message_loop_->Run();
+  });
+}
+
+TEST_F(TaskQueueManagerPerfTest, RunTenThousandDelayedTasks_EightQueues) {
+  Initialize(8u);
+
+  Benchmark("post 10000 delayed tasks", [this]() {
+    sequence_number_ = 0;
+    TestTask();
+    message_loop_->Run();
+  });
+}
+
+}  // namespace content