1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_CANCELABLE_TASK_H_
#define V8_CANCELABLE_TASK_H_
#include <unordered_map>
#include "include/v8-platform.h"
#include "src/base/atomic-utils.h"
#include "src/base/macros.h"
#include "src/base/platform/condition-variable.h"
#include "src/globals.h"
namespace v8 {
namespace internal {
class Cancelable;
class Isolate;
// Keeps track of cancelable tasks. It is possible to register and remove tasks
// from any fore- and background task/thread.
class V8_EXPORT_PRIVATE CancelableTaskManager {
public:
using Id = uint64_t;
CancelableTaskManager();
// Registers a new cancelable {task}. Returns the unique {id} of the task that
// can be used to try to abort a task by calling {Abort}.
// Must not be called after CancelAndWait.
Id Register(Cancelable* task);
// Try to abort running a task identified by {id}. The possible outcomes are:
// (1) The task is already finished running or was canceled before and
// thus has been removed from the manager.
// (2) The task is currently running and cannot be canceled anymore.
// (3) The task is not yet running (or finished) so it is canceled and
// removed.
//
enum TryAbortResult { kTaskRemoved, kTaskRunning, kTaskAborted };
TryAbortResult TryAbort(Id id);
// Cancels all remaining registered tasks and waits for tasks that are
// already running. This disallows subsequent Register calls.
void CancelAndWait();
// Tries to cancel all remaining registered tasks. The return value indicates
// whether
//
// 1) No tasks were registered (kTaskRemoved), or
//
// 2) There is at least one remaining task that couldn't be cancelled
// (kTaskRunning), or
//
// 3) All registered tasks were cancelled (kTaskAborted).
TryAbortResult TryAbortAll();
private:
// Only called by {Cancelable} destructor. The task is done with executing,
// but needs to be removed.
void RemoveFinishedTask(Id id);
// To mitigate the ABA problem, the api refers to tasks through an id.
Id task_id_counter_;
// A set of cancelable tasks that are currently registered.
std::unordered_map<Id, Cancelable*> cancelable_tasks_;
// Mutex and condition variable enabling concurrent register and removing, as
// well as waiting for background tasks on {CancelAndWait}.
base::ConditionVariable cancelable_tasks_barrier_;
base::Mutex mutex_;
bool canceled_;
friend class Cancelable;
DISALLOW_COPY_AND_ASSIGN(CancelableTaskManager);
};
class V8_EXPORT_PRIVATE Cancelable {
public:
explicit Cancelable(CancelableTaskManager* parent);
virtual ~Cancelable();
// Never invoke after handing over the task to the platform! The reason is
// that {Cancelable} is used in combination with {v8::Task} and handed to
// a platform. This step transfers ownership to the platform, which destroys
// the task after running it. Since the exact time is not known, we cannot
// access the object after handing it to a platform.
CancelableTaskManager::Id id() { return id_; }
protected:
bool TryRun() { return status_.TrySetValue(kWaiting, kRunning); }
bool IsRunning() { return status_.Value() == kRunning; }
intptr_t CancelAttempts() { return cancel_counter_; }
private:
// Identifies the state a cancelable task is in:
// |kWaiting|: The task is scheduled and waiting to be executed. {TryRun} will
// succeed.
// |kCanceled|: The task has been canceled. {TryRun} will fail.
// |kRunning|: The task is currently running and cannot be canceled anymore.
enum Status {
kWaiting,
kCanceled,
kRunning,
};
// Use {CancelableTaskManager} to abort a task that has not yet been
// executed.
bool Cancel() {
if (status_.TrySetValue(kWaiting, kCanceled)) {
return true;
}
cancel_counter_++;
return false;
}
CancelableTaskManager* parent_;
base::AtomicValue<Status> status_;
CancelableTaskManager::Id id_;
// The counter is incremented for failing tries to cancel a task. This can be
// used by the task itself as an indication how often external entities tried
// to abort it.
std::atomic<intptr_t> cancel_counter_;
friend class CancelableTaskManager;
DISALLOW_COPY_AND_ASSIGN(Cancelable);
};
// Multiple inheritance can be used because Task is a pure interface.
class V8_EXPORT_PRIVATE CancelableTask : public Cancelable,
NON_EXPORTED_BASE(public Task) {
public:
explicit CancelableTask(Isolate* isolate);
explicit CancelableTask(CancelableTaskManager* manager);
// Task overrides.
void Run() final {
if (TryRun()) {
RunInternal();
}
}
virtual void RunInternal() = 0;
private:
DISALLOW_COPY_AND_ASSIGN(CancelableTask);
};
// Multiple inheritance can be used because IdleTask is a pure interface.
class CancelableIdleTask : public Cancelable, public IdleTask {
public:
explicit CancelableIdleTask(Isolate* isolate);
explicit CancelableIdleTask(CancelableTaskManager* manager);
// IdleTask overrides.
void Run(double deadline_in_seconds) final {
if (TryRun()) {
RunInternal(deadline_in_seconds);
}
}
virtual void RunInternal(double deadline_in_seconds) = 0;
private:
DISALLOW_COPY_AND_ASSIGN(CancelableIdleTask);
};
} // namespace internal
} // namespace v8
#endif // V8_CANCELABLE_TASK_H_
|
