Repo created
This commit is contained in:
parent
81b91f4139
commit
f8c34fa5ee
22732 changed files with 4815320 additions and 2 deletions
|
|
@ -0,0 +1,275 @@
|
|||
// Copyright 2014 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/cancelable_task_tracker.h"
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include <utility>
|
||||
|
||||
#include "base/bind.h"
|
||||
#include "base/bind_helpers.h"
|
||||
#include "base/callback_helpers.h"
|
||||
#include "base/feature_list.h"
|
||||
#include "base/location.h"
|
||||
#include "base/memory/ref_counted.h"
|
||||
#include "base/metrics/histogram_macros.h"
|
||||
#include "base/sequenced_task_runner.h"
|
||||
#include "base/task/scoped_set_task_priority_for_current_thread.h"
|
||||
#include "base/task_runner.h"
|
||||
#include "base/threading/sequenced_task_runner_handle.h"
|
||||
|
||||
namespace base {
|
||||
|
||||
namespace {
|
||||
|
||||
void RunOrPostToTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner,
|
||||
OnceClosure closure) {
|
||||
if (task_runner->RunsTasksInCurrentSequence())
|
||||
std::move(closure).Run();
|
||||
else
|
||||
task_runner->PostTask(FROM_HERE, std::move(closure));
|
||||
}
|
||||
|
||||
// TODO(https://crbug.com/1009795): Remove these once we have established
|
||||
// whether off-sequence cancelation is worthwhile.
|
||||
|
||||
// These values are persisted to logs. Entries should not be renumbered and
|
||||
// numeric values should never be reused.
|
||||
enum class TaskStatus {
|
||||
kSameSequenceLive = 0,
|
||||
kOffSequenceLive = 1,
|
||||
kSameSequenceCanceled = 2,
|
||||
kOffSequenceCanceled = 3,
|
||||
kMaxValue = kOffSequenceCanceled,
|
||||
};
|
||||
|
||||
void UmaRecordTaskDuration(bool same_sequence,
|
||||
bool background,
|
||||
bool canceled,
|
||||
TimeDelta duration) {
|
||||
#define DECLARE_HISTOGRAM(suffix) \
|
||||
Histogram::FactoryTimeGet( \
|
||||
"Scheduler.CancelableTaskTracker.TaskDuration2_" suffix, \
|
||||
TimeDelta::FromMilliseconds(1), TimeDelta::FromSeconds(10), 50, \
|
||||
Histogram::kUmaTargetedHistogramFlag)
|
||||
|
||||
static HistogramBase* histograms[] = {
|
||||
DECLARE_HISTOGRAM("LiveForegroundOffSequence"),
|
||||
DECLARE_HISTOGRAM("LiveForegroundSameSequence"),
|
||||
DECLARE_HISTOGRAM("LiveBackgroundOffSequence"),
|
||||
DECLARE_HISTOGRAM("LiveBackgroundSameSequence"),
|
||||
DECLARE_HISTOGRAM("CanceledForegroundOffSequence"),
|
||||
DECLARE_HISTOGRAM("CanceledForegroundSameSequence"),
|
||||
DECLARE_HISTOGRAM("CanceledBackgroundOffSequence"),
|
||||
DECLARE_HISTOGRAM("CanceledBackgroundSameSequence")};
|
||||
|
||||
int i = (same_sequence ? 1 : 0) + (background ? 2 : 0) + (canceled ? 4 : 0);
|
||||
histograms[i]->AddTimeMillisecondsGranularity(duration);
|
||||
}
|
||||
|
||||
const base::Feature kAllowOffSequenceTaskCancelation{
|
||||
"AllowOffSequenceTaskCancelation", base::FEATURE_ENABLED_BY_DEFAULT};
|
||||
|
||||
bool AllowOffSequenceTaskCancelation() {
|
||||
if (!base::FeatureList::GetInstance())
|
||||
return true;
|
||||
return base::FeatureList::IsEnabled(kAllowOffSequenceTaskCancelation);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// static
|
||||
const CancelableTaskTracker::TaskId CancelableTaskTracker::kBadTaskId = 0;
|
||||
|
||||
CancelableTaskTracker::CancelableTaskTracker() {
|
||||
weak_this_ = weak_factory_.GetWeakPtr();
|
||||
}
|
||||
|
||||
CancelableTaskTracker::~CancelableTaskTracker() {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
|
||||
TryCancelAll();
|
||||
}
|
||||
|
||||
CancelableTaskTracker::TaskId CancelableTaskTracker::PostTask(
|
||||
TaskRunner* task_runner,
|
||||
const Location& from_here,
|
||||
OnceClosure task) {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
CHECK(weak_this_);
|
||||
|
||||
return PostTaskAndReply(task_runner, from_here, std::move(task), DoNothing());
|
||||
}
|
||||
|
||||
CancelableTaskTracker::TaskId CancelableTaskTracker::PostTaskAndReply(
|
||||
TaskRunner* task_runner,
|
||||
const Location& from_here,
|
||||
OnceClosure task,
|
||||
OnceClosure reply) {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
CHECK(weak_this_);
|
||||
|
||||
// We need a SequencedTaskRunnerHandle to run |reply|.
|
||||
DCHECK(SequencedTaskRunnerHandle::IsSet());
|
||||
|
||||
auto flag = MakeRefCounted<TaskCancellationFlag>();
|
||||
|
||||
TaskId id = next_id_;
|
||||
next_id_++; // int64_t is big enough that we ignore the potential overflow.
|
||||
|
||||
// Unretained(this) is safe because |flag| will have been set to the
|
||||
// "canceled" state after |this| is deleted.
|
||||
OnceClosure untrack_closure =
|
||||
BindOnce(&CancelableTaskTracker::Untrack, Unretained(this), id);
|
||||
bool success = task_runner->PostTaskAndReply(
|
||||
from_here,
|
||||
BindOnce(&RunIfNotCanceled, SequencedTaskRunnerHandle::Get(), flag,
|
||||
std::move(task)),
|
||||
BindOnce(&RunThenUntrackIfNotCanceled, SequencedTaskRunnerHandle::Get(),
|
||||
flag, std::move(reply), std::move(untrack_closure)));
|
||||
|
||||
if (!success)
|
||||
return kBadTaskId;
|
||||
|
||||
Track(id, std::move(flag));
|
||||
return id;
|
||||
}
|
||||
|
||||
CancelableTaskTracker::TaskId CancelableTaskTracker::NewTrackedTaskId(
|
||||
IsCanceledCallback* is_canceled_cb) {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
DCHECK(SequencedTaskRunnerHandle::IsSet());
|
||||
|
||||
TaskId id = next_id_;
|
||||
next_id_++; // int64_t is big enough that we ignore the potential overflow.
|
||||
|
||||
auto flag = MakeRefCounted<TaskCancellationFlag>();
|
||||
|
||||
// Unretained(this) is safe because |flag| will have been set to the
|
||||
// "canceled" state after |this| is deleted.
|
||||
OnceClosure untrack_closure =
|
||||
BindOnce(&CancelableTaskTracker::Untrack, Unretained(this), id);
|
||||
|
||||
// Will always run |untrack_closure| on current sequence.
|
||||
ScopedClosureRunner untrack_runner(
|
||||
BindOnce(&RunOrPostToTaskRunner, SequencedTaskRunnerHandle::Get(),
|
||||
BindOnce(&RunIfNotCanceled, SequencedTaskRunnerHandle::Get(),
|
||||
flag, std::move(untrack_closure))));
|
||||
|
||||
*is_canceled_cb = BindRepeating(&IsCanceled, SequencedTaskRunnerHandle::Get(),
|
||||
flag, std::move(untrack_runner));
|
||||
|
||||
Track(id, std::move(flag));
|
||||
return id;
|
||||
}
|
||||
|
||||
void CancelableTaskTracker::TryCancel(TaskId id) {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
|
||||
const auto it = task_flags_.find(id);
|
||||
if (it == task_flags_.end()) {
|
||||
// Two possibilities:
|
||||
//
|
||||
// 1. The task has already been untracked.
|
||||
// 2. The TaskId is bad or unknown.
|
||||
//
|
||||
// Since this function is best-effort, it's OK to ignore these.
|
||||
return;
|
||||
}
|
||||
it->second->data.Set();
|
||||
|
||||
// Remove |id| from |task_flags_| immediately, since we have no further
|
||||
// use for tracking it. This allows the reply closures (see
|
||||
// PostTaskAndReply()) for cancelled tasks to be skipped, since they have
|
||||
// no clean-up to perform.
|
||||
task_flags_.erase(it);
|
||||
}
|
||||
|
||||
void CancelableTaskTracker::TryCancelAll() {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
for (const auto& it : task_flags_)
|
||||
it.second->data.Set();
|
||||
task_flags_.clear();
|
||||
}
|
||||
|
||||
bool CancelableTaskTracker::HasTrackedTasks() const {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
return !task_flags_.empty();
|
||||
}
|
||||
|
||||
// static
|
||||
void CancelableTaskTracker::RunIfNotCanceled(
|
||||
const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
|
||||
const scoped_refptr<TaskCancellationFlag>& flag,
|
||||
OnceClosure task) {
|
||||
// TODO(https://crbug.com/1009795): Record durations for executed tasks,
|
||||
// correlated with whether the task runs on a background or foreground
|
||||
// sequence, and whether it is the same sequence as the CancelableTaskTracker.
|
||||
// Also correlate with whether the task was run despite being canceled, to
|
||||
// allow an experiment to assess the value of off-sequence cancelation.
|
||||
|
||||
// Record canceled & off-sequence status for all tasks.
|
||||
const bool was_canceled = flag->data.IsSet();
|
||||
const bool same_sequence = origin_task_runner->RunsTasksInCurrentSequence();
|
||||
const TaskStatus task_status =
|
||||
was_canceled ? (same_sequence ? TaskStatus::kSameSequenceCanceled
|
||||
: TaskStatus::kOffSequenceCanceled)
|
||||
: (same_sequence ? TaskStatus::kSameSequenceLive
|
||||
: TaskStatus::kOffSequenceLive);
|
||||
UMA_HISTOGRAM_ENUMERATION("Scheduler.CancelableTaskTracker.TaskStatus",
|
||||
task_status);
|
||||
|
||||
// Skip tasks if they are canceled, taking into account the off-sequence
|
||||
// cancelation experiment.
|
||||
const bool skip_task =
|
||||
was_canceled && (AllowOffSequenceTaskCancelation() || same_sequence);
|
||||
if (skip_task)
|
||||
return;
|
||||
|
||||
// Run the task and record its duration.
|
||||
const TimeTicks before_task_ticks = TimeTicks::Now();
|
||||
std::move(task).Run();
|
||||
const TimeDelta duration = TimeTicks::Now() - before_task_ticks;
|
||||
const bool is_background =
|
||||
internal::GetTaskPriorityForCurrentThread() < TaskPriority::USER_VISIBLE;
|
||||
UmaRecordTaskDuration(same_sequence, is_background, was_canceled, duration);
|
||||
}
|
||||
|
||||
// static
|
||||
void CancelableTaskTracker::RunThenUntrackIfNotCanceled(
|
||||
const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
|
||||
const scoped_refptr<TaskCancellationFlag>& flag,
|
||||
OnceClosure task,
|
||||
OnceClosure untrack) {
|
||||
RunIfNotCanceled(origin_task_runner, flag, std::move(task));
|
||||
RunIfNotCanceled(origin_task_runner, flag, std::move(untrack));
|
||||
}
|
||||
|
||||
// static
|
||||
bool CancelableTaskTracker::IsCanceled(
|
||||
const scoped_refptr<SequencedTaskRunner>& origin_task_runner,
|
||||
const scoped_refptr<TaskCancellationFlag>& flag,
|
||||
const ScopedClosureRunner& cleanup_runner) {
|
||||
return flag->data.IsSet() &&
|
||||
(AllowOffSequenceTaskCancelation() ||
|
||||
origin_task_runner->RunsTasksInCurrentSequence());
|
||||
}
|
||||
|
||||
void CancelableTaskTracker::Track(TaskId id,
|
||||
scoped_refptr<TaskCancellationFlag> flag) {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
CHECK(weak_this_);
|
||||
bool success = task_flags_.insert(std::make_pair(id, std::move(flag))).second;
|
||||
DCHECK(success);
|
||||
}
|
||||
|
||||
void CancelableTaskTracker::Untrack(TaskId id) {
|
||||
DCHECK(sequence_checker_.CalledOnValidSequence());
|
||||
CHECK(weak_this_);
|
||||
size_t num = task_flags_.erase(id);
|
||||
DCHECK_EQ(1u, num);
|
||||
}
|
||||
|
||||
} // namespace base
|
||||
Loading…
Add table
Add a link
Reference in a new issue