| // Copyright 2015 the V8 project 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 "src/cancelable-task.h" |
| |
| #include "src/base/platform/platform.h" |
| #include "src/isolate.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| |
| Cancelable::Cancelable(CancelableTaskManager* parent) |
| : parent_(parent), status_(kWaiting), id_(0), cancel_counter_(0) { |
| id_ = parent->Register(this); |
| CHECK(id_ != 0); |
| } |
| |
| |
| Cancelable::~Cancelable() { |
| // The following check is needed to avoid calling an already terminated |
| // manager object. This happens when the manager cancels all pending tasks |
| // in {CancelAndWait} only before destroying the manager object. |
| if (TryRun() || IsRunning()) { |
| parent_->RemoveFinishedTask(id_); |
| } |
| } |
| |
| |
| static bool ComparePointers(void* ptr1, void* ptr2) { return ptr1 == ptr2; } |
| |
| |
| CancelableTaskManager::CancelableTaskManager() |
| : task_id_counter_(0), cancelable_tasks_(ComparePointers) {} |
| |
| |
| uint32_t CancelableTaskManager::Register(Cancelable* task) { |
| base::LockGuard<base::Mutex> guard(&mutex_); |
| uint32_t id = ++task_id_counter_; |
| // The loop below is just used when task_id_counter_ overflows. |
| while ((id == 0) || (cancelable_tasks_.Lookup(reinterpret_cast<void*>(id), |
| id) != nullptr)) { |
| ++id; |
| } |
| HashMap::Entry* entry = |
| cancelable_tasks_.LookupOrInsert(reinterpret_cast<void*>(id), id); |
| entry->value = task; |
| return id; |
| } |
| |
| |
| void CancelableTaskManager::RemoveFinishedTask(uint32_t id) { |
| base::LockGuard<base::Mutex> guard(&mutex_); |
| void* removed = cancelable_tasks_.Remove(reinterpret_cast<void*>(id), id); |
| USE(removed); |
| DCHECK(removed != nullptr); |
| cancelable_tasks_barrier_.NotifyOne(); |
| } |
| |
| |
| bool CancelableTaskManager::TryAbort(uint32_t id) { |
| base::LockGuard<base::Mutex> guard(&mutex_); |
| HashMap::Entry* entry = |
| cancelable_tasks_.Lookup(reinterpret_cast<void*>(id), id); |
| if (entry != nullptr) { |
| Cancelable* value = reinterpret_cast<Cancelable*>(entry->value); |
| if (value->Cancel()) { |
| // Cannot call RemoveFinishedTask here because of recursive locking. |
| void* removed = cancelable_tasks_.Remove(reinterpret_cast<void*>(id), id); |
| USE(removed); |
| DCHECK(removed != nullptr); |
| cancelable_tasks_barrier_.NotifyOne(); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| void CancelableTaskManager::CancelAndWait() { |
| // Clean up all cancelable fore- and background tasks. Tasks are canceled on |
| // the way if possible, i.e., if they have not started yet. After each round |
| // of canceling we wait for the background tasks that have already been |
| // started. |
| base::LockGuard<base::Mutex> guard(&mutex_); |
| |
| // HashMap does not support removing while iterating, hence keep a set of |
| // entries that are to be removed. |
| std::set<uint32_t> to_remove; |
| |
| // Cancelable tasks could potentially register new tasks, requiring a loop |
| // here. |
| while (cancelable_tasks_.occupancy() > 0) { |
| for (HashMap::Entry* p = cancelable_tasks_.Start(); p != nullptr; |
| p = cancelable_tasks_.Next(p)) { |
| if (reinterpret_cast<Cancelable*>(p->value)->Cancel()) { |
| to_remove.insert(reinterpret_cast<Cancelable*>(p->value)->id()); |
| } |
| } |
| // Remove tasks that were successfully canceled. |
| for (auto id : to_remove) { |
| cancelable_tasks_.Remove(reinterpret_cast<void*>(id), id); |
| } |
| to_remove.clear(); |
| |
| // Finally, wait for already running background tasks. |
| if (cancelable_tasks_.occupancy() > 0) { |
| cancelable_tasks_barrier_.Wait(&mutex_); |
| } |
| } |
| } |
| |
| |
| CancelableTask::CancelableTask(Isolate* isolate) |
| : Cancelable(isolate->cancelable_task_manager()), isolate_(isolate) {} |
| |
| |
| CancelableIdleTask::CancelableIdleTask(Isolate* isolate) |
| : Cancelable(isolate->cancelable_task_manager()), isolate_(isolate) {} |
| |
| } // namespace internal |
| } // namespace v8 |