blob: 27ea9ea6eb7385b9f38e3421df53167163859a2f [file] [log] [blame]
// 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