Revert 202363 "cc: Cancel and re-prioritize worker pool tasks."

trunk/src/cc/base/worker_pool_perftest.cc

-// Copyright 2013 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 "cc/base/worker_pool.h"
-
-#include "base/time.h"
-#include "cc/base/completion_event.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace cc {
-
-namespace {
-
-static const int kTimeLimitMillis = 2000;
-static const int kWarmupRuns = 5;
-static const int kTimeCheckInterval = 10;
-
-class PerfTaskImpl : public internal::WorkerPoolTask {
- public:
-  explicit PerfTaskImpl(internal::WorkerPoolTask::TaskVector* dependencies)
-      : internal::WorkerPoolTask(dependencies) {}
-
-  // Overridden from internal::WorkerPoolTask:
-  virtual void RunOnThread(unsigned thread_index) OVERRIDE {}
-  virtual void DispatchCompletionCallback() OVERRIDE {}
-
- private:
-  virtual ~PerfTaskImpl() {}
-};
-
-class PerfControlTaskImpl : public internal::WorkerPoolTask {
- public:
-  explicit PerfControlTaskImpl(
-      internal::WorkerPoolTask::TaskVector* dependencies)
-      : internal::WorkerPoolTask(dependencies),
-        did_start_(new CompletionEvent),
-        can_finish_(new CompletionEvent) {}
-
-  // Overridden from internal::WorkerPoolTask:
-  virtual void RunOnThread(unsigned thread_index) OVERRIDE {
-    did_start_->Signal();
-    can_finish_->Wait();
-  }
-  virtual void DispatchCompletionCallback() OVERRIDE {}
-
-  void WaitForTaskToStartRunning() {
-    did_start_->Wait();
-  }
-
-  void AllowTaskToFinish() {
-    can_finish_->Signal();
-  }
-
- private:
-  virtual ~PerfControlTaskImpl() {}
-
-  scoped_ptr<CompletionEvent> did_start_;
-  scoped_ptr<CompletionEvent> can_finish_;
-};
-
-class PerfWorkerPool : public WorkerPool {
- public:
-  PerfWorkerPool() : WorkerPool(1, base::TimeDelta::FromDays(1024), "test") {}
-  virtual ~PerfWorkerPool() {}
-
-  static scoped_ptr<PerfWorkerPool> Create() {
-    return make_scoped_ptr(new PerfWorkerPool);
-  }
-
-  void ScheduleTasks(internal::WorkerPoolTask* root) {
-    WorkerPool::ScheduleTasks(root);
-  }
-};
-
-class WorkerPoolPerfTest : public testing::Test,
-                           public WorkerPoolClient {
- public:
-  WorkerPoolPerfTest() : num_runs_(0) {}
-
-  // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
-    worker_pool_ = PerfWorkerPool::Create();
-    worker_pool_->SetClient(this);
-  }
-  virtual void TearDown() OVERRIDE {
-    worker_pool_->Shutdown();
-  }
-
-  // Overridden from WorkerPoolClient:
-  virtual void DidFinishDispatchingWorkerPoolCompletionCallbacks() OVERRIDE {}
-
-  void EndTest() {
-    elapsed_ = base::TimeTicks::HighResNow() - start_time_;
-  }
-
-  void AfterTest(const std::string test_name) {
-    // Format matches chrome/test/perf/perf_test.h:PrintResult
-    printf("*RESULT %s: %.2f runs/s\n",
-           test_name.c_str(),
-           num_runs_ / elapsed_.InSecondsF());
-  }
-
-  void BuildTaskGraph(internal::WorkerPoolTask::TaskVector* dependencies,
-                      unsigned current_depth,
-                      unsigned max_depth,
-                      unsigned num_children_per_node) {
-    internal::WorkerPoolTask::TaskVector children;
-    if (current_depth < max_depth) {
-      for (unsigned i = 0; i < num_children_per_node; ++i) {
-        BuildTaskGraph(&children,
-                       current_depth + 1,
-                       max_depth,
-                       num_children_per_node);
-      }
-    } else if (leaf_task_) {
-      children.push_back(leaf_task_);
-    }
-    dependencies->push_back(make_scoped_refptr(new PerfTaskImpl(&children)));
-  }
-
-  bool DidRun() {
-    ++num_runs_;
-    if (num_runs_ == kWarmupRuns)
-      start_time_ = base::TimeTicks::HighResNow();
-
-    if (!start_time_.is_null() && (num_runs_ % kTimeCheckInterval) == 0) {
-      base::TimeDelta elapsed = base::TimeTicks::HighResNow() - start_time_;
-      if (elapsed >= base::TimeDelta::FromMilliseconds(kTimeLimitMillis)) {
-        elapsed_ = elapsed;
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  void RunBuildTaskGraphTest(const std::string test_name,
-                             unsigned max_depth,
-                             unsigned num_children_per_node) {
-    start_time_ = base::TimeTicks();
-    num_runs_ = 0;
-    do {
-      internal::WorkerPoolTask::TaskVector children;
-      BuildTaskGraph(&children, 0, max_depth, num_children_per_node);
-    } while (DidRun());
-
-    AfterTest(test_name);
-  }
-
-  void RunScheduleTasksTest(const std::string test_name,
-                            unsigned max_depth,
-                            unsigned num_children_per_node) {
-    start_time_ = base::TimeTicks();
-    num_runs_ = 0;
-    do {
-      internal::WorkerPoolTask::TaskVector empty;
-      leaf_task_ = make_scoped_refptr(new PerfControlTaskImpl(&empty));
-      internal::WorkerPoolTask::TaskVector children;
-      BuildTaskGraph(&children, 0, max_depth, num_children_per_node);
-      scoped_refptr<PerfTaskImpl> root_task(
-          make_scoped_refptr(new PerfTaskImpl(&children)));
-
-      worker_pool_->ScheduleTasks(root_task);
-      leaf_task_->WaitForTaskToStartRunning();
-      worker_pool_->ScheduleTasks(NULL);
-      worker_pool_->CheckForCompletedTasks();
-      leaf_task_->AllowTaskToFinish();
-    } while (DidRun());
-
-    AfterTest(test_name);
-  }
-
-  void RunExecuteTasksTest(const std::string test_name,
-                           unsigned max_depth,
-                           unsigned num_children_per_node) {
-    start_time_ = base::TimeTicks();
-    num_runs_ = 0;
-    do {
-      internal::WorkerPoolTask::TaskVector children;
-      BuildTaskGraph(&children, 0, max_depth, num_children_per_node);
-      scoped_refptr<PerfControlTaskImpl> root_task(
-          make_scoped_refptr(new PerfControlTaskImpl(&children)));
-
-      worker_pool_->ScheduleTasks(root_task);
-      root_task->WaitForTaskToStartRunning();
-      root_task->AllowTaskToFinish();
-      worker_pool_->CheckForCompletedTasks();
-    } while (DidRun());
-
-    AfterTest(test_name);
-  }
-
- protected:
-  scoped_ptr<PerfWorkerPool> worker_pool_;
-  scoped_refptr<PerfControlTaskImpl> leaf_task_;
-  base::TimeTicks start_time_;
-  base::TimeDelta elapsed_;
-  int num_runs_;
-};
-
-TEST_F(WorkerPoolPerfTest, BuildTaskGraph) {
-  RunBuildTaskGraphTest("build_task_graph_1_10", 1, 10);
-  RunBuildTaskGraphTest("build_task_graph_1_1000", 1, 1000);
-  RunBuildTaskGraphTest("build_task_graph_2_10", 2, 10);
-  RunBuildTaskGraphTest("build_task_graph_5_5", 5, 5);
-  RunBuildTaskGraphTest("build_task_graph_10_2", 10, 2);
-  RunBuildTaskGraphTest("build_task_graph_1000_1", 1000, 1);
-  RunBuildTaskGraphTest("build_task_graph_10_1", 10, 1);
-}
-
-TEST_F(WorkerPoolPerfTest, ScheduleTasks) {
-  RunScheduleTasksTest("schedule_tasks_1_10", 1, 10);
-  RunScheduleTasksTest("schedule_tasks_1_1000", 1, 1000);
-  RunScheduleTasksTest("schedule_tasks_2_10", 2, 10);
-  RunScheduleTasksTest("schedule_tasks_5_5", 5, 5);
-  RunScheduleTasksTest("schedule_tasks_10_2", 10, 2);
-  RunScheduleTasksTest("schedule_tasks_1000_1", 1000, 1);
-  RunScheduleTasksTest("schedule_tasks_10_1", 10, 1);
-}
-
-TEST_F(WorkerPoolPerfTest, ExecuteTasks) {
-  RunExecuteTasksTest("execute_tasks_1_10", 1, 10);
-  RunExecuteTasksTest("execute_tasks_1_1000", 1, 1000);
-  RunExecuteTasksTest("execute_tasks_2_10", 2, 10);
-  RunExecuteTasksTest("execute_tasks_5_5", 5, 5);
-  RunExecuteTasksTest("execute_tasks_10_2", 10, 2);
-  RunExecuteTasksTest("execute_tasks_1000_1", 1000, 1);
-  RunExecuteTasksTest("execute_tasks_10_1", 10, 1);
-}
-
-}  // namespace
-
-}  // namespace cc