Commit 61d42c94 authored by Clemens Hammacher's avatar Clemens Hammacher Committed by Commit Bot

Use std::atomic in Cancelable

Avoid deprecated base::AtomicValue, use std::atomic instead.
Plus minor drive-by cleanups.

R=mstarzinger@chromium.org

Bug: v8:8238
Change-Id: I47a1f00e26a843b60380c50399eedc49d859830a
Reviewed-on: https://chromium-review.googlesource.com/c/1326463
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: 's avatarMichael Starzinger <mstarzinger@chromium.org>
Reviewed-by: 's avatarUlan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57386}
parent b407d274
......@@ -10,18 +10,12 @@
namespace v8 {
namespace internal {
Cancelable::Cancelable(CancelableTaskManager* parent)
: parent_(parent), status_(kWaiting), id_(0), cancel_counter_(0) {
id_ = parent->Register(this);
}
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()) {
Status previous;
if (TryRun(&previous) || previous == kRunning) {
parent_->RemoveFinishedTask(id_);
}
}
......
......@@ -5,10 +5,10 @@
#ifndef V8_CANCELABLE_TASK_H_
#define V8_CANCELABLE_TASK_H_
#include <atomic>
#include <unordered_map>
#include "include/v8-platform.h"
#include "src/base/atomic-utils.h"
#include "src/base/macros.h"
#include "src/base/platform/condition-variable.h"
#include "src/globals.h"
......@@ -86,7 +86,9 @@ class V8_EXPORT_PRIVATE CancelableTaskManager {
class V8_EXPORT_PRIVATE Cancelable {
public:
explicit Cancelable(CancelableTaskManager* parent);
explicit Cancelable(CancelableTaskManager* parent)
: parent_(parent), id_(parent->Register(this)) {}
virtual ~Cancelable();
// Never invoke after handing over the task to the platform! The reason is
......@@ -97,42 +99,48 @@ class V8_EXPORT_PRIVATE Cancelable {
CancelableTaskManager::Id id() { return id_; }
protected:
bool TryRun() { return status_.TrySetValue(kWaiting, kRunning); }
bool IsRunning() { return status_.Value() == kRunning; }
intptr_t CancelAttempts() { return cancel_counter_; }
private:
// Identifies the state a cancelable task is in:
// |kWaiting|: The task is scheduled and waiting to be executed. {TryRun} will
// succeed.
// |kCanceled|: The task has been canceled. {TryRun} will fail.
// |kRunning|: The task is currently running and cannot be canceled anymore.
enum Status {
kWaiting,
kCanceled,
kRunning,
};
enum Status { kWaiting, kCanceled, kRunning };
bool TryRun(Status* previous = nullptr) {
return CompareExchangeStatus(kWaiting, kRunning, previous);
}
intptr_t CancelAttempts() { return cancel_counter_; }
private:
friend class CancelableTaskManager;
// Use {CancelableTaskManager} to abort a task that has not yet been
// executed.
bool Cancel() {
if (status_.TrySetValue(kWaiting, kCanceled)) {
if (CompareExchangeStatus(kWaiting, kCanceled)) {
return true;
}
cancel_counter_++;
return false;
}
CancelableTaskManager* parent_;
base::AtomicValue<Status> status_;
CancelableTaskManager::Id id_;
bool CompareExchangeStatus(Status expected, Status desired,
Status* previous = nullptr) {
// {compare_exchange_strong} updates {expected}.
bool success = status_.compare_exchange_strong(expected, desired,
std::memory_order_relaxed);
if (previous) *previous = expected;
return success;
}
CancelableTaskManager* const parent_;
std::atomic<Status> status_{kWaiting};
const CancelableTaskManager::Id id_;
// The counter is incremented for failing tries to cancel a task. This can be
// used by the task itself as an indication how often external entities tried
// to abort it.
std::atomic<intptr_t> cancel_counter_;
friend class CancelableTaskManager;
std::atomic<intptr_t> cancel_counter_{0};
DISALLOW_COPY_AND_ASSIGN(Cancelable);
};
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment