OLD | NEW |
(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 |
OLD | NEW |