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