blob: 6db8cdb76fe670753f5ec85c951c9012457e478a [file] [log] [blame]
// Copyright 2016 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_scheduler/task_scheduler_impl.h"
#include <utility>
#include "base/metrics/field_trial_params.h"
#include "base/task_scheduler/delayed_task_manager.h"
#include "base/task_scheduler/environment_config.h"
#include "base/task_scheduler/scheduler_worker_pool_params.h"
#include "base/task_scheduler/sequence.h"
#include "base/task_scheduler/sequence_sort_key.h"
#include "base/task_scheduler/task.h"
#include "base/task_scheduler/task_tracker.h"
namespace base {
namespace internal {
TaskSchedulerImpl::TaskSchedulerImpl(
StringPiece name,
std::unique_ptr<TaskTrackerImpl> task_tracker)
: name_(name),
service_thread_("TaskSchedulerServiceThread"),
task_tracker_(std::move(task_tracker)),
single_thread_task_runner_manager_(task_tracker_.get(),
&delayed_task_manager_) {
static_assert(arraysize(worker_pools_) == ENVIRONMENT_COUNT,
"The size of |worker_pools_| must match ENVIRONMENT_COUNT.");
static_assert(
arraysize(kEnvironmentParams) == ENVIRONMENT_COUNT,
"The size of |kEnvironmentParams| must match ENVIRONMENT_COUNT.");
for (int environment_type = 0; environment_type < ENVIRONMENT_COUNT;
++environment_type) {
worker_pools_[environment_type] = std::make_unique<SchedulerWorkerPoolImpl>(
name_ + kEnvironmentParams[environment_type].name_suffix,
kEnvironmentParams[environment_type].priority_hint, task_tracker_.get(),
&delayed_task_manager_);
}
}
TaskSchedulerImpl::~TaskSchedulerImpl() {
#if DCHECK_IS_ON()
DCHECK(join_for_testing_returned_.IsSet());
#endif
}
void TaskSchedulerImpl::Start(const TaskScheduler::InitParams& init_params) {
// This is set in Start() and not in the constructor because variation params
// are usually not ready when TaskSchedulerImpl is instantiated in a process.
if (base::GetFieldTrialParamValue("BrowserScheduler",
"AllTasksUserBlocking") == "true") {
all_tasks_user_blocking_.Set();
}
// Start the service thread. On platforms that support it (POSIX except NaCL
// SFI), the service thread runs a MessageLoopForIO which is used to support
// FileDescriptorWatcher in the scope in which tasks run.
Thread::Options service_thread_options;
service_thread_options.message_loop_type =
#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
MessageLoop::TYPE_IO;
#else
MessageLoop::TYPE_DEFAULT;
#endif
service_thread_options.timer_slack = TIMER_SLACK_MAXIMUM;
CHECK(service_thread_.StartWithOptions(service_thread_options));
#if defined(OS_POSIX) && !defined(OS_NACL_SFI)
// Needs to happen after starting the service thread to get its
// message_loop().
task_tracker_->set_watch_file_descriptor_message_loop(
static_cast<MessageLoopForIO*>(service_thread_.message_loop()));
#if DCHECK_IS_ON()
task_tracker_->set_service_thread_handle(service_thread_.GetThreadHandle());
#endif // DCHECK_IS_ON()
#endif // defined(OS_POSIX) && !defined(OS_NACL_SFI)
// Needs to happen after starting the service thread to get its task_runner().
delayed_task_manager_.Start(service_thread_.task_runner());
single_thread_task_runner_manager_.Start();
worker_pools_[BACKGROUND]->Start(init_params.background_worker_pool_params);
worker_pools_[BACKGROUND_BLOCKING]->Start(
init_params.background_blocking_worker_pool_params);
worker_pools_[FOREGROUND]->Start(init_params.foreground_worker_pool_params);
worker_pools_[FOREGROUND_BLOCKING]->Start(
init_params.foreground_blocking_worker_pool_params);
}
void TaskSchedulerImpl::PostDelayedTaskWithTraits(
const tracked_objects::Location& from_here,
const TaskTraits& traits,
OnceClosure task,
TimeDelta delay) {
// Post |task| as part of a one-off single-task Sequence.
const TaskTraits new_traits = SetUserBlockingPriorityIfNeeded(traits);
GetWorkerPoolForTraits(new_traits)
->PostTaskWithSequence(
std::make_unique<Task>(from_here, std::move(task), new_traits, delay),
MakeRefCounted<Sequence>());
}
scoped_refptr<TaskRunner> TaskSchedulerImpl::CreateTaskRunnerWithTraits(
const TaskTraits& traits) {
const TaskTraits new_traits = SetUserBlockingPriorityIfNeeded(traits);
return GetWorkerPoolForTraits(new_traits)
->CreateTaskRunnerWithTraits(new_traits);
}
scoped_refptr<SequencedTaskRunner>
TaskSchedulerImpl::CreateSequencedTaskRunnerWithTraits(
const TaskTraits& traits) {
const TaskTraits new_traits = SetUserBlockingPriorityIfNeeded(traits);
return GetWorkerPoolForTraits(new_traits)
->CreateSequencedTaskRunnerWithTraits(new_traits);
}
scoped_refptr<SingleThreadTaskRunner>
TaskSchedulerImpl::CreateSingleThreadTaskRunnerWithTraits(
const TaskTraits& traits,
SingleThreadTaskRunnerThreadMode thread_mode) {
return single_thread_task_runner_manager_
.CreateSingleThreadTaskRunnerWithTraits(
name_, SetUserBlockingPriorityIfNeeded(traits), thread_mode);
}
#if defined(OS_WIN)
scoped_refptr<SingleThreadTaskRunner>
TaskSchedulerImpl::CreateCOMSTATaskRunnerWithTraits(
const TaskTraits& traits,
SingleThreadTaskRunnerThreadMode thread_mode) {
return single_thread_task_runner_manager_.CreateCOMSTATaskRunnerWithTraits(
name_, SetUserBlockingPriorityIfNeeded(traits), thread_mode);
}
#endif // defined(OS_WIN)
std::vector<const HistogramBase*> TaskSchedulerImpl::GetHistograms() const {
std::vector<const HistogramBase*> histograms;
for (const auto& worker_pool : worker_pools_)
worker_pool->GetHistograms(&histograms);
return histograms;
}
int TaskSchedulerImpl::GetMaxConcurrentNonBlockedTasksWithTraitsDeprecated(
const TaskTraits& traits) const {
return GetWorkerPoolForTraits(traits)
->GetMaxConcurrentNonBlockedTasksDeprecated();
}
void TaskSchedulerImpl::Shutdown() {
// TODO(fdoray): Increase the priority of BACKGROUND tasks blocking shutdown.
task_tracker_->Shutdown();
}
void TaskSchedulerImpl::FlushForTesting() {
task_tracker_->Flush();
}
void TaskSchedulerImpl::JoinForTesting() {
#if DCHECK_IS_ON()
DCHECK(!join_for_testing_returned_.IsSet());
#endif
single_thread_task_runner_manager_.JoinForTesting();
for (const auto& worker_pool : worker_pools_)
worker_pool->DisallowWorkerCleanupForTesting();
for (const auto& worker_pool : worker_pools_)
worker_pool->JoinForTesting();
service_thread_.Stop();
#if DCHECK_IS_ON()
join_for_testing_returned_.Set();
#endif
}
SchedulerWorkerPoolImpl* TaskSchedulerImpl::GetWorkerPoolForTraits(
const TaskTraits& traits) const {
return worker_pools_[GetEnvironmentIndexForTraits(traits)].get();
}
TaskTraits TaskSchedulerImpl::SetUserBlockingPriorityIfNeeded(
const TaskTraits& traits) const {
return all_tasks_user_blocking_.IsSet()
? TaskTraits::Override(traits, {TaskPriority::USER_BLOCKING})
: traits;
}
} // namespace internal
} // namespace base