Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(188)

Side by Side Diff: base/test/sequenced_task_runner_test_template.cc

Issue 9663075: Implementation of SequencedTaskRunner based on SequencedWorkerPool. (Closed) Base URL: http://src.chromium.org/svn/trunk/src/
Patch Set: Created 8 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
Property Changes:
Added: svn:eol-style
+ LF
OLDNEW
(Empty)
1 // Copyright (c) 2012 The Chromium 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 #include "base/test/sequenced_task_runner_test_template.h"
6
7 namespace base {
8
9 namespace internal {
10
11 SequencedTaskTracker::TaskStatus::TaskStatus()
12 : lock_(),
13 start_event_(true, false),
14 claimed_(false),
15 started_(false),
16 completed_(false),
17 prev_started_(false),
18 prev_completed_(false) {
19 }
20
21 SequencedTaskTracker::TaskStatus::TaskStatus(const TaskStatus& ts)
22 : lock_(),
23 start_event_(true, false),
24 claimed_(ts.claimed_),
25 started_(ts.started_),
26 completed_(ts.completed_),
27 prev_started_(ts.prev_started_),
28 prev_completed_(ts.prev_completed_) {
29 }
30
31 SequencedTaskTracker::TaskStatus& SequencedTaskTracker::TaskStatus::operator=(
32 const TaskStatus& ts) {
33 if (&ts == this)
34 return *this;
35 claimed_ = ts.claimed_;
36 started_ = ts.started_;
37 completed_ = ts.completed_;
38 prev_started_ = ts.prev_started_;
39 prev_completed_ = ts.prev_completed_;
40 return *this;
41 }
42
43 bool SequencedTaskTracker::TaskStatus::Claim() {
44 AutoLock lock(lock_);
45 if (claimed_)
46 return false;
47 claimed_ = true;
48 return true;
49 }
50
51 bool SequencedTaskTracker::TaskStatus::Started() const {
52 start_event_.Wait();
53 AutoLock lock(lock_);
54 return started_;
55 }
56
57 bool SequencedTaskTracker::TaskStatus::Completed() const {
58 AutoLock lock(lock_);
59 return completed_;
60 }
61
62 // Only called after the run has completed, so locking is not required.
63 bool SequencedTaskTracker::TaskStatus::PrevStartedBefore() const {
64 return prev_started_;
65 }
66
67 // Only called after the run has completed, so locking is not required.
68 bool SequencedTaskTracker::TaskStatus::PrevCompletedBefore() const {
69 return prev_completed_;
70 }
71
72 void SequencedTaskTracker::TaskStatus::SetStarted() {
73 AutoLock lock(lock_);
74 started_ = true;
75 start_event_.Signal();
76 }
77
78 void SequencedTaskTracker::TaskStatus::SetCompleted() {
79 AutoLock lock(lock_);
80 completed_ = true;
81 }
82
83 void SequencedTaskTracker::TaskStatus::SetPrevStartedBefore(bool b) {
84 AutoLock lock(lock_);
85 prev_started_ = b;
86 }
87
88 void SequencedTaskTracker::TaskStatus::SetPrevCompletedBefore(bool b) {
89 AutoLock lock(lock_);
90 prev_completed_ = b;
91 }
92
93 bool SequencedTaskTracker::TaskStatus::operator==(const TaskStatus& ts) const {
94 return (Completed() == ts.Completed() &&
95 started_ == ts.started_ &&
96 started_ == ts.started_ &&
97 PrevStartedBefore() == ts.PrevStartedBefore() &&
98 PrevCompletedBefore() == ts.PrevCompletedBefore());
99 }
100
101 std::ostream& operator<<(std::ostream& os,
102 const SequencedTaskTracker::TaskStatus& ts) {
103 return os << "{ started=" << std::boolalpha << ts.started_
104 << "; completed=" << ts.Completed()
105 << "; prev_started_before=" << ts.PrevStartedBefore()
106 << "; prev_completed_before=" << ts.PrevCompletedBefore()
107 << " }";
108 }
109
110 SequencedTaskTracker::SequencedTaskTracker() {
111 }
112
113 SequencedTaskTracker::~SequencedTaskTracker() {
114 }
115
116 void SequencedTaskTracker::SetNonNestableTaskCount(
117 std::size_t task_count) {
118 non_nestable_statuses_.resize(task_count);
119 }
120
121 void SequencedTaskTracker::SetNestableTaskCount(
122 std::size_t task_count) {
123 nestable_statuses_.resize(task_count);
124 }
125
126 void SequencedTaskTracker::FastNonNestableTask(int base_status_i) {
127 const int i = ClaimNonNestableTaskStatus(base_status_i);
128 non_nestable_statuses_[i].SetStarted();
129 // "Started before" is covered by "completed before" for non-nestable tasks.
130 non_nestable_statuses_[i].SetPrevStartedBefore(true);
131 non_nestable_statuses_[i].SetPrevCompletedBefore(
132 i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
133 non_nestable_statuses_[i].SetCompleted();
134 }
135
136 void SequencedTaskTracker::FastNestableTask(int base_status_i) {
137 const int i = ClaimNestableTaskStatus(base_status_i);
138 nestable_statuses_[i].SetStarted();
139 nestable_statuses_[i].SetPrevStartedBefore(
140 i > 0 ? nestable_statuses_[i - 1].Started() : true);
141 // Don't care about "completed before" for nestable tasks.
142 nestable_statuses_[i].SetPrevCompletedBefore(true);
143 nestable_statuses_[i].SetCompleted();
144 }
145
146 void SequencedTaskTracker::SlowNonNestableTask(int base_status_i) {
147 const int i = ClaimNonNestableTaskStatus(base_status_i);
148 non_nestable_statuses_[i].SetStarted();
149 non_nestable_statuses_[i].SetPrevStartedBefore(true);
150 non_nestable_statuses_[i].SetPrevCompletedBefore(
151 i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
152 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
153 non_nestable_statuses_[i].SetCompleted();
154 }
155
156 void SequencedTaskTracker::SlowNestableTask(int base_status_i) {
157 const int i = ClaimNestableTaskStatus(base_status_i);
158 nestable_statuses_[i].SetStarted();
159 nestable_statuses_[i].SetPrevStartedBefore(
160 i > 0 ? nestable_statuses_[i - 1].Started() : true);
161 // Don't care about "completed before" for nestable tasks.
162 nestable_statuses_[i].SetPrevCompletedBefore(true);
163 base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
164 nestable_statuses_[i].SetCompleted();
165 }
166
167 void SequencedTaskTracker::PostFastNonNestableFromSlowNonNestable(
168 scoped_refptr<SequencedTaskRunner> task_runner,
169 const int base_status_i,
170 const int child_count) {
171
172 const int i = ClaimNonNestableTaskStatus(base_status_i);
173 non_nestable_statuses_[i].SetStarted();
174
175 non_nestable_statuses_[i].SetPrevStartedBefore(true);
176 non_nestable_statuses_[i].SetPrevCompletedBefore(
177 i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
178
179 for (int j = 0; j < child_count; ++j) {
180 Closure task = Bind(&SequencedTaskTracker::FastNonNestableTask, this, i);
181 task_runner->PostNonNestableTask(FROM_HERE, task);
182 }
183 non_nestable_statuses_[i].SetCompleted();
184 }
185
186 void SequencedTaskTracker::PostFastNestableFromSlowNonNestable(
187 scoped_refptr<SequencedTaskRunner> task_runner,
188 const int base_status_i,
189 const int child_count) {
190 const int i = ClaimNonNestableTaskStatus(base_status_i);
191 non_nestable_statuses_[i].SetStarted();
192 non_nestable_statuses_[i].SetPrevStartedBefore(true);
193 non_nestable_statuses_[i].SetPrevCompletedBefore(
194 i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
195
196 for (int j = 0; j < child_count; ++j) {
197 const int child_i = i * child_count + j;
198 Closure task = Bind(&SequencedTaskTracker::FastNestableTask,
199 this,
200 child_i);
201 task_runner->PostTask(FROM_HERE, task);
202 }
203 non_nestable_statuses_[i].SetCompleted();
204 }
205
206 int SequencedTaskTracker::ClaimNonNestableTaskStatus(const int search_from) {
207 const int end = static_cast<int>(non_nestable_statuses_.size());
208 for (int i = search_from; i < end; ++i) {
209 if (non_nestable_statuses_[i].Claim())
210 return i;
211 }
212 CHECK(false) << "Unable to find an unclaimed non-nestable task status slot";
213 return -1;
214 }
215
216 int SequencedTaskTracker::ClaimNestableTaskStatus(const int search_from) {
217 const int end = static_cast<int>(nestable_statuses_.size());
218 for (int i = search_from; i < end; ++i) {
219 if (nestable_statuses_[i].Claim())
220 return i;
221 }
222 CHECK(false) << "Unable to find an unclaimed nestable task status slot";
223 return -1;
224 }
225
226 const SequencedTaskTracker::TaskStatuses&
227 SequencedTaskTracker::GetNonNestableTaskStatuses() const {
228 return non_nestable_statuses_;
229 }
230
231 const SequencedTaskTracker::TaskStatuses&
232 SequencedTaskTracker::GetNestableTaskStatuses() const {
233 return nestable_statuses_;
234 }
235
236 } // namespace internal
237
238 } // namespace base
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698