| // 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 "base/task/sequence_manager/sequence_manager.h" | |
| #include <memory> | |
| #include "base/bind.h" | |
| #include "base/message_loop/message_loop.h" | |
| #include "base/message_loop/message_pump_default.h" | |
| #include "base/run_loop.h" | |
| #include "base/single_thread_task_runner.h" | |
| #include "base/strings/stringprintf.h" | |
| #include "base/task/sequence_manager/task_queue_impl.h" | |
| #include "base/task/sequence_manager/test/mock_time_domain.h" | |
| #include "base/task/sequence_manager/test/sequence_manager_for_test.h" | |
| #include "base/task/sequence_manager/test/test_task_queue.h" | |
| #include "base/task/sequence_manager/test/test_task_time_observer.h" | |
| #include "base/task/sequence_manager/thread_controller_with_message_pump_impl.h" | |
| #include "base/threading/thread.h" | |
| #include "base/threading/thread_task_runner_handle.h" | |
| #include "base/time/default_tick_clock.h" | |
| #include "starboard/types.h" | |
| #include "testing/gtest/include/gtest/gtest.h" | |
| #include "testing/perf/perf_test.h" | |
| namespace base { | |
| namespace sequence_manager { | |
| // To reduce noise related to the OS timer, we use a mock time domain to | |
| // fast forward the timers. | |
| class PerfTestTimeDomain : public MockTimeDomain { | |
| public: | |
| PerfTestTimeDomain() : MockTimeDomain(TimeTicks::Now()) {} | |
| ~PerfTestTimeDomain() override = default; | |
| Optional<TimeDelta> DelayTillNextTask(LazyNow* lazy_now) override { | |
| Optional<TimeTicks> run_time = NextScheduledRunTime(); | |
| if (!run_time) | |
| return nullopt; | |
| SetNowTicks(*run_time); | |
| // Makes SequenceManager to continue immediately. | |
| return TimeDelta(); | |
| } | |
| void SetNextDelayedDoWork(LazyNow* lazy_now, TimeTicks run_time) override { | |
| // De-dupe DoWorks. | |
| if (NumberOfScheduledWakeUps() == 1u) | |
| RequestDoWork(); | |
| } | |
| private: | |
| DISALLOW_COPY_AND_ASSIGN(PerfTestTimeDomain); | |
| }; | |
| enum class PerfTestType : int { | |
| kUseMessageLoop = 0, | |
| kUseMessagePump = 1, | |
| }; | |
| class SequenceManagerPerfTest : public testing::TestWithParam<PerfTestType> { | |
| public: | |
| SequenceManagerPerfTest() | |
| : num_queues_(0), | |
| max_tasks_in_flight_(0), | |
| num_tasks_in_flight_(0), | |
| num_tasks_to_post_(0), | |
| num_tasks_to_run_(0) {} | |
| void SetUp() override { | |
| if (ThreadTicks::IsSupported()) | |
| ThreadTicks::WaitUntilInitialized(); | |
| delayed_task_closure_ = BindRepeating( | |
| &SequenceManagerPerfTest::TestDelayedTask, Unretained(this)); | |
| immediate_task_closure_ = BindRepeating( | |
| &SequenceManagerPerfTest::TestImmediateTask, Unretained(this)); | |
| switch (GetParam()) { | |
| case PerfTestType::kUseMessageLoop: | |
| CreateSequenceManagerWithMessageLoop(); | |
| break; | |
| case PerfTestType::kUseMessagePump: | |
| CreateSequenceManagerWithMessagePump(); | |
| break; | |
| } | |
| time_domain_ = std::make_unique<PerfTestTimeDomain>(); | |
| manager_->RegisterTimeDomain(time_domain_.get()); | |
| manager_->AddTaskTimeObserver(&test_task_time_observer_); | |
| } | |
| void CreateSequenceManagerWithMessageLoop() { | |
| message_loop_ = std::make_unique<MessageLoop>(); | |
| manager_ = SequenceManagerForTest::Create(message_loop_.get(), | |
| message_loop_->task_runner(), | |
| DefaultTickClock::GetInstance()); | |
| } | |
| void CreateSequenceManagerWithMessagePump() { | |
| manager_ = SequenceManagerForTest::Create( | |
| std::make_unique<internal::ThreadControllerWithMessagePumpImpl>( | |
| std::make_unique<MessagePumpDefault>(), | |
| DefaultTickClock::GetInstance())); | |
| // ThreadControllerWithMessagePumpImpl doesn't provide a default tas runner. | |
| scoped_refptr<TaskQueue> default_task_queue = | |
| manager_->CreateTaskQueue<TestTaskQueue>(TaskQueue::Spec("default")); | |
| manager_->SetDefaultTaskRunner(default_task_queue->task_runner()); | |
| } | |
| void TearDown() override { | |
| queues_.clear(); | |
| manager_->UnregisterTimeDomain(time_domain_.get()); | |
| manager_.reset(); | |
| } | |
| void Initialize(size_t num_queues) { | |
| num_queues_ = num_queues; | |
| for (size_t i = 0; i < num_queues; i++) { | |
| queues_.push_back(manager_->CreateTaskQueue<TestTaskQueue>( | |
| TaskQueue::Spec("test").SetTimeDomain(time_domain_.get()))); | |
| } | |
| } | |
| void TestDelayedTask() { | |
| if (--num_tasks_to_run_ == 0) { | |
| run_loop_->QuitWhenIdle(); | |
| return; | |
| } | |
| num_tasks_in_flight_--; | |
| // NOTE there are only up to max_tasks_in_flight_ pending delayed tasks at | |
| // any one time. Thanks to the lower_num_tasks_to_post going to zero if | |
| // there are a lot of tasks in flight, the total number of task in flight at | |
| // any one time is very variable. | |
| unsigned int lower_num_tasks_to_post = | |
| num_tasks_in_flight_ < (max_tasks_in_flight_ / 2) ? 1 : 0; | |
| unsigned int max_tasks_to_post = | |
| num_tasks_to_post_ % 2 ? lower_num_tasks_to_post : 10; | |
| for (unsigned int i = 0; | |
| i < max_tasks_to_post && num_tasks_in_flight_ < max_tasks_in_flight_ && | |
| num_tasks_to_post_ > 0; | |
| i++) { | |
| // Choose a queue weighted towards queue 0. | |
| unsigned int queue = num_tasks_to_post_ % (num_queues_ + 1); | |
| if (queue == num_queues_) { | |
| queue = 0; | |
| } | |
| // Simulate a mix of short and longer delays. | |
| unsigned int delay = | |
| num_tasks_to_post_ % 2 ? 1 : (10 + num_tasks_to_post_ % 10); | |
| queues_[queue]->PostDelayedTask(FROM_HERE, delayed_task_closure_, | |
| TimeDelta::FromMilliseconds(delay)); | |
| num_tasks_in_flight_++; | |
| num_tasks_to_post_--; | |
| } | |
| } | |
| void TestImmediateTask() { | |
| if (--num_tasks_to_run_ == 0) { | |
| run_loop_->QuitWhenIdle(); | |
| return; | |
| } | |
| num_tasks_in_flight_--; | |
| // NOTE there are only up to max_tasks_in_flight_ pending delayed tasks at | |
| // any one time. Thanks to the lower_num_tasks_to_post going to zero if | |
| // there are a lot of tasks in flight, the total number of task in flight at | |
| // any one time is very variable. | |
| unsigned int lower_num_tasks_to_post = | |
| num_tasks_in_flight_ < (max_tasks_in_flight_ / 2) ? 1 : 0; | |
| unsigned int max_tasks_to_post = | |
| num_tasks_to_post_ % 2 ? lower_num_tasks_to_post : 10; | |
| for (unsigned int i = 0; | |
| i < max_tasks_to_post && num_tasks_in_flight_ < max_tasks_in_flight_ && | |
| num_tasks_to_post_ > 0; | |
| i++) { | |
| // Choose a queue weighted towards queue 0. | |
| unsigned int queue = num_tasks_to_post_ % (num_queues_ + 1); | |
| if (queue == num_queues_) { | |
| queue = 0; | |
| } | |
| queues_[queue]->PostTask(FROM_HERE, immediate_task_closure_); | |
| num_tasks_in_flight_++; | |
| num_tasks_to_post_--; | |
| } | |
| } | |
| void ResetAndCallTestDelayedTask(unsigned int num_tasks_to_run) { | |
| num_tasks_in_flight_ = 1; | |
| num_tasks_to_post_ = num_tasks_to_run; | |
| num_tasks_to_run_ = num_tasks_to_run; | |
| TestDelayedTask(); | |
| } | |
| void ResetAndCallTestImmediateTask(unsigned int num_tasks_to_run) { | |
| num_tasks_in_flight_ = 1; | |
| num_tasks_to_post_ = num_tasks_to_run; | |
| num_tasks_to_run_ = num_tasks_to_run; | |
| TestImmediateTask(); | |
| } | |
| void Benchmark(const std::string& trace, const RepeatingClosure& test_task) { | |
| ThreadTicks start = ThreadTicks::Now(); | |
| ThreadTicks now; | |
| unsigned long long num_iterations = 0; | |
| do { | |
| test_task.Run(); | |
| run_loop_.reset(new RunLoop()); | |
| run_loop_->Run(); | |
| now = ThreadTicks::Now(); | |
| num_iterations++; | |
| } while (now - start < TimeDelta::FromSeconds(5)); | |
| std::string trace_suffix; | |
| switch (GetParam()) { | |
| case PerfTestType::kUseMessageLoop: | |
| trace_suffix = " with message loop"; | |
| break; | |
| case PerfTestType::kUseMessagePump: | |
| trace_suffix = " with message pump"; | |
| break; | |
| } | |
| perf_test::PrintResult( | |
| "task", "", trace + trace_suffix, | |
| (now - start).InMicroseconds() / static_cast<double>(num_iterations), | |
| "us/run", true); | |
| } | |
| size_t num_queues_; | |
| unsigned int max_tasks_in_flight_; | |
| unsigned int num_tasks_in_flight_; | |
| unsigned int num_tasks_to_post_; | |
| unsigned int num_tasks_to_run_; | |
| std::unique_ptr<MessageLoop> message_loop_; | |
| std::unique_ptr<SequenceManager> manager_; | |
| std::unique_ptr<RunLoop> run_loop_; | |
| std::unique_ptr<TimeDomain> time_domain_; | |
| std::vector<scoped_refptr<TestTaskQueue>> queues_; | |
| RepeatingClosure delayed_task_closure_; | |
| RepeatingClosure immediate_task_closure_; | |
| // TODO(alexclarke): parameterize so we can measure with and without a | |
| // TaskTimeObserver. | |
| TestTaskTimeObserver test_task_time_observer_; | |
| }; | |
| INSTANTIATE_TEST_CASE_P(, | |
| SequenceManagerPerfTest, | |
| testing::Values(PerfTestType::kUseMessageLoop, | |
| PerfTestType::kUseMessagePump)); | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandDelayedTasks_OneQueue) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(1u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark("run 10000 delayed tasks with one queue", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestDelayedTask, | |
| Unretained(this), 10000)); | |
| } | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandDelayedTasks_FourQueues) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(4u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark("run 10000 delayed tasks with four queues", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestDelayedTask, | |
| Unretained(this), 10000)); | |
| } | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandDelayedTasks_EightQueues) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(8u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark("run 10000 delayed tasks with eight queues", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestDelayedTask, | |
| Unretained(this), 10000)); | |
| } | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandDelayedTasks_ThirtyTwoQueues) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(32u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark("run 10000 delayed tasks with thirty two queues", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestDelayedTask, | |
| Unretained(this), 10000)); | |
| } | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandImmediateTasks_OneQueue) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(1u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark( | |
| "run 10000 immediate tasks with one queue", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestImmediateTask, | |
| Unretained(this), 10000)); | |
| } | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandImmediateTasks_FourQueues) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(4u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark( | |
| "run 10000 immediate tasks with four queues", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestImmediateTask, | |
| Unretained(this), 10000)); | |
| } | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandImmediateTasks_EightQueues) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(8u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark( | |
| "run 10000 immediate tasks with eight queues", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestImmediateTask, | |
| Unretained(this), 10000)); | |
| } | |
| TEST_P(SequenceManagerPerfTest, RunTenThousandImmediateTasks_ThirtyTwoQueues) { | |
| if (!ThreadTicks::IsSupported()) | |
| return; | |
| Initialize(32u); | |
| max_tasks_in_flight_ = 200; | |
| Benchmark( | |
| "run 10000 immediate tasks with thirty two queues", | |
| BindRepeating(&SequenceManagerPerfTest::ResetAndCallTestImmediateTask, | |
| Unretained(this), 10000)); | |
| } | |
| // TODO(alexclarke): Add additional tests with different mixes of non-delayed vs | |
| // delayed tasks. | |
| } // namespace sequence_manager | |
| } // namespace base |