1 // 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 #include "src/cancelable-task.h" 6 7 #include "src/base/platform/platform.h" 8 #include "src/isolate.h" 9 10 namespace v8 { 11 namespace internal { 12 13 Cancelable(CancelableTaskManager * parent)14Cancelable::Cancelable(CancelableTaskManager* parent) 15 : parent_(parent), status_(kWaiting), id_(0), cancel_counter_(0) { 16 id_ = parent->Register(this); 17 } 18 19 ~Cancelable()20Cancelable::~Cancelable() { 21 // The following check is needed to avoid calling an already terminated 22 // manager object. This happens when the manager cancels all pending tasks 23 // in {CancelAndWait} only before destroying the manager object. 24 if (TryRun() || IsRunning()) { 25 parent_->RemoveFinishedTask(id_); 26 } 27 } 28 CancelableTaskManager()29CancelableTaskManager::CancelableTaskManager() : task_id_counter_(0) {} 30 Register(Cancelable * task)31uint32_t CancelableTaskManager::Register(Cancelable* task) { 32 base::LockGuard<base::Mutex> guard(&mutex_); 33 uint32_t id = ++task_id_counter_; 34 // The loop below is just used when task_id_counter_ overflows. 35 while (cancelable_tasks_.count(id) > 0) ++id; 36 cancelable_tasks_[id] = task; 37 return id; 38 } 39 40 RemoveFinishedTask(uint32_t id)41void CancelableTaskManager::RemoveFinishedTask(uint32_t id) { 42 base::LockGuard<base::Mutex> guard(&mutex_); 43 size_t removed = cancelable_tasks_.erase(id); 44 USE(removed); 45 DCHECK_NE(0, removed); 46 cancelable_tasks_barrier_.NotifyOne(); 47 } 48 49 TryAbort(uint32_t id)50bool CancelableTaskManager::TryAbort(uint32_t id) { 51 base::LockGuard<base::Mutex> guard(&mutex_); 52 auto entry = cancelable_tasks_.find(id); 53 if (entry != cancelable_tasks_.end()) { 54 Cancelable* value = entry->second; 55 if (value->Cancel()) { 56 // Cannot call RemoveFinishedTask here because of recursive locking. 57 cancelable_tasks_.erase(entry); 58 cancelable_tasks_barrier_.NotifyOne(); 59 return true; 60 } 61 } 62 return false; 63 } 64 65 CancelAndWait()66void CancelableTaskManager::CancelAndWait() { 67 // Clean up all cancelable fore- and background tasks. Tasks are canceled on 68 // the way if possible, i.e., if they have not started yet. After each round 69 // of canceling we wait for the background tasks that have already been 70 // started. 71 base::LockGuard<base::Mutex> guard(&mutex_); 72 73 // Cancelable tasks could be running or could potentially register new 74 // tasks, requiring a loop here. 75 while (!cancelable_tasks_.empty()) { 76 for (auto it = cancelable_tasks_.begin(); it != cancelable_tasks_.end();) { 77 auto current = it; 78 // We need to get to the next element before erasing the current. 79 ++it; 80 if (current->second->Cancel()) { 81 cancelable_tasks_.erase(current); 82 } 83 } 84 // Wait for already running background tasks. 85 if (!cancelable_tasks_.empty()) { 86 cancelable_tasks_barrier_.Wait(&mutex_); 87 } 88 } 89 } 90 91 CancelableTask(Isolate * isolate)92CancelableTask::CancelableTask(Isolate* isolate) 93 : Cancelable(isolate->cancelable_task_manager()), isolate_(isolate) {} 94 95 CancelableIdleTask(Isolate * isolate)96CancelableIdleTask::CancelableIdleTask(Isolate* isolate) 97 : Cancelable(isolate->cancelable_task_manager()), isolate_(isolate) {} 98 99 } // namespace internal 100 } // namespace v8 101