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

Unified 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 side-by-side diff with in-line comments
Download patch
Index: base/test/sequenced_task_runner_test_template.cc
===================================================================
--- base/test/sequenced_task_runner_test_template.cc (revision 0)
+++ base/test/sequenced_task_runner_test_template.cc (revision 0)
@@ -0,0 +1,204 @@
+// Copyright (c) 2012 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/test/sequenced_task_runner_test_template.h"
+
+namespace base {
+
+SeqTaskTracker::TaskStatus::TaskStatus()
+ : lock_(),
+ claimed_(false),
+ completed_(false),
+ completed_set_(false),
+ prev_completed_(false),
+ prev_completed_set_(false) {
+}
+
+SeqTaskTracker::TaskStatus::TaskStatus(const TaskStatus& ts)
+ : lock_(),
+ claimed_(ts.claimed_),
+ completed_(ts.completed_),
+ completed_set_(ts.completed_set_),
+ prev_completed_(ts.prev_completed_),
+ prev_completed_set_(ts.prev_completed_set_) {
+}
+
+SeqTaskTracker::TaskStatus& SeqTaskTracker::TaskStatus::operator=(
+ const TaskStatus& ts) {
+ if (&ts == this)
+ return *this;
+ claimed_ = ts.claimed_;
+ completed_ = ts.completed_;
+ prev_completed_ = ts.prev_completed_;
+ completed_set_ = ts.completed_set_;
+ prev_completed_set_ = ts.prev_completed_set_;
+ return *this;
+}
+
+bool SeqTaskTracker::TaskStatus::Claim() {
+ AutoLock lock(lock_);
+ if (claimed_)
+ return false;
+ claimed_ = true;
+ return true;
+}
+
+bool SeqTaskTracker::TaskStatus::Completed() const {
+ AutoLock lock(lock_);
+ return completed_;
+}
+
+// Only called after the run has completed, so locking is not required.
+bool SeqTaskTracker::TaskStatus::PrevCompletedBefore() const {
+ return prev_completed_;
+}
+
+void SeqTaskTracker::TaskStatus::SetCompleted() {
+ AutoLock lock(lock_);
+ CHECK(!completed_set_);
+ completed_ = true;
+ completed_set_ = true;
+}
+
+void SeqTaskTracker::TaskStatus::SetPrevCompletedBefore(const bool b) {
+ AutoLock lock(lock_);
+ CHECK(!prev_completed_set_);
+ prev_completed_ = b;
+ prev_completed_set_ = true;
+}
+
+bool SeqTaskTracker::TaskStatus::operator==(const TaskStatus& ts) const {
+ return (Completed() == ts.Completed() &&
+ PrevCompletedBefore() == ts.PrevCompletedBefore());
+}
+
+std::ostream& operator<<(std::ostream& os,
+ const SeqTaskTracker::TaskStatus& ts) {
+ return os << "completed=" << std::boolalpha << ts.Completed()
+ << "; prev_completed_before=" << ts.PrevCompletedBefore();
+}
+
+SeqTaskTracker::SeqTaskTracker() {
+}
+
+SeqTaskTracker::~SeqTaskTracker() {
+}
+
+void SeqTaskTracker::SetNonNestableTaskCount(
+ const std::size_t task_count) {
+ non_nestable_statuses_.resize(task_count);
+}
+
+void SeqTaskTracker::SetNestableTaskCount(
+ const std::size_t task_count) {
+ nestable_statuses_.resize(task_count);
+}
+
+void SeqTaskTracker::FastNonNestableTask(int base_status_i) {
+ const int i = ClaimNonNestableTaskStatus(base_status_i);
+ DLOG(INFO) << "XXX FastNonNestableTask " << i << " STARTING";
+ non_nestable_statuses_[i].SetPrevCompletedBefore(
+ i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+ non_nestable_statuses_[i].SetCompleted();
+ DLOG(INFO) << "XXX FastNonNestableTask " << i << " DONE";
+}
+
+void SeqTaskTracker::FastNestableTask(int base_status_i) {
+ const int i = ClaimNestableTaskStatus(base_status_i);
+ DLOG(INFO) << "XXX FastNestableTask " << i << " STARTING";
+ nestable_statuses_[i].SetPrevCompletedBefore(true);
+ nestable_statuses_[i].SetCompleted();
+ DLOG(INFO) << "XXX FastNestableTask " << i << " DONE";
+}
+
+void SeqTaskTracker::SlowNonNestableTask(int base_status_i) {
+ const int i = ClaimNonNestableTaskStatus(base_status_i);
+ DLOG(INFO) << "XXX SlowNonNestableTask " << i << " STARTING";
+ non_nestable_statuses_[i].SetPrevCompletedBefore(
+ i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+ base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+ non_nestable_statuses_[i].SetCompleted();
+ DLOG(INFO) << "XXX SlowNonNestableTask " << i << " DONE";
+}
+
+void SeqTaskTracker::PostFastNonNestableFromSlowNonNestable(
+ scoped_refptr<SequencedTaskRunner> tr,
+ const int base_status_i,
+ const int child_count) {
+
+ const int i = ClaimNonNestableTaskStatus(base_status_i);
+
+ DLOG(INFO) << "XXX PostFastNonNestableFromSlowNonNestable "
+ << i << " STARTING";
+
+ non_nestable_statuses_[i].SetPrevCompletedBefore(
+ i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+
+ for (int j = 0; j < child_count; ++j) {
+ Closure task = Bind(&SeqTaskTracker::FastNonNestableTask, this, i);
+ tr->PostNonNestableTask(FROM_HERE, task);
+ DLOG(INFO) << "XXX PostFastNonNestableFromSlowNonNestable "
+ << i << " POSTED CHILD TASK " << (i + j);
+ }
+ non_nestable_statuses_[i].SetCompleted();
+
+ DLOG(INFO) << "XXX PostFastNonNestableFromSlowNonNestable " << i << " DONE";
+}
+
+void SeqTaskTracker::PostFastNestableFromSlowNonNestable(
+ scoped_refptr<SequencedTaskRunner> tr,
+ const int base_status_i,
+ const int child_count) {
+
+ const int i = ClaimNonNestableTaskStatus(base_status_i);
+
+ DLOG(INFO) << "XXX PostNestableFromSlowNonNestable " << i << " STARTING";
+
+ non_nestable_statuses_[i].SetPrevCompletedBefore(
+ i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+
+ for (int j = 0; j < child_count; ++j) {
+ const int child_i = i * child_count + j;
+ Closure task = Bind(&SeqTaskTracker::FastNestableTask,
+ this,
+ child_i);
+ DLOG(INFO) << "XXX PostNestableFromSlowNonNestable " << i
+ << " POSTED CHILD " << child_i ;
+ tr->PostTask(FROM_HERE, task);
+ }
+ non_nestable_statuses_[i].SetCompleted();
+ DLOG(INFO) << "XXX PostNestableFromSlowNonNestable " << i << " DONE";
+}
+
+int SeqTaskTracker::ClaimNonNestableTaskStatus(const int search_from) {
+ const int end = static_cast<int>(non_nestable_statuses_.size());
+ for (int i = search_from; i < end; ++i) {
+ if (non_nestable_statuses_[i].Claim())
+ return i;
+ }
+ CHECK(false) << "Unable to find an unclaimed non-nestable task status slot";
+ return -1;
+}
+
+int SeqTaskTracker::ClaimNestableTaskStatus(const int search_from) {
+ const int end = static_cast<int>(nestable_statuses_.size());
+ for (int i = search_from; i < end; ++i) {
+ if (nestable_statuses_[i].Claim())
+ return i;
+ }
+ CHECK(false) << "Unable to find an unclaimed nestable task status slot";
+ return -1;
+}
+
+const SeqTaskTracker::TaskStatuses& SeqTaskTracker::GetNonNestableTaskStatuses(
+) const {
+ return non_nestable_statuses_;
+}
+
+const SeqTaskTracker::TaskStatuses& SeqTaskTracker::GetNestableTaskStatuses(
+) const {
+ return nestable_statuses_;
+}
+
+} // namespace base
Property changes on: base/test/sequenced_task_runner_test_template.cc
___________________________________________________________________
Added: svn:eol-style
+ LF

Powered by Google App Engine
This is Rietveld 408576698