128 lines
4.5 KiB
C++
128 lines
4.5 KiB
C++
// Copyright 2016 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.
|
|
|
|
#ifndef BASE_TASK_THREAD_POOL_SEQUENCE_H_
|
|
#define BASE_TASK_THREAD_POOL_SEQUENCE_H_
|
|
|
|
#include <stddef.h>
|
|
|
|
#include "base/base_export.h"
|
|
#include "base/compiler_specific.h"
|
|
#include "base/containers/queue.h"
|
|
#include "base/macros.h"
|
|
#include "base/optional.h"
|
|
#include "base/sequence_token.h"
|
|
#include "base/task/task_traits.h"
|
|
#include "base/task/thread_pool/pooled_parallel_task_runner.h"
|
|
#include "base/task/thread_pool/sequence_sort_key.h"
|
|
#include "base/task/thread_pool/task.h"
|
|
#include "base/task/thread_pool/task_source.h"
|
|
#include "base/threading/sequence_local_storage_map.h"
|
|
|
|
namespace base {
|
|
namespace internal {
|
|
|
|
// A Sequence holds slots each containing up to a single Task that must be
|
|
// executed in posting order.
|
|
//
|
|
// In comments below, an "empty Sequence" is a Sequence with no slot.
|
|
//
|
|
// Note: there is a known refcounted-ownership cycle in the Scheduler
|
|
// architecture: Sequence -> Task -> TaskRunner -> Sequence -> ...
|
|
// This is okay so long as the other owners of Sequence (PriorityQueue and
|
|
// WorkerThread in alternation and
|
|
// ThreadGroupImpl::WorkerThreadDelegateImpl::GetWork()
|
|
// temporarily) keep running it (and taking Tasks from it as a result). A
|
|
// dangling reference cycle would only occur should they release their reference
|
|
// to it while it's not empty. In other words, it is only correct for them to
|
|
// release it after PopTask() returns false to indicate it was made empty by
|
|
// that call (in which case the next PushTask() will return true to indicate to
|
|
// the caller that the Sequence should be re-enqueued for execution).
|
|
//
|
|
// This class is thread-safe.
|
|
class BASE_EXPORT Sequence : public TaskSource {
|
|
public:
|
|
// A Transaction can perform multiple operations atomically on a
|
|
// Sequence. While a Transaction is alive, it is guaranteed that nothing
|
|
// else will access the Sequence; the Sequence's lock is held for the
|
|
// lifetime of the Transaction.
|
|
class BASE_EXPORT Transaction : public TaskSource::Transaction {
|
|
public:
|
|
Transaction(Transaction&& other);
|
|
~Transaction();
|
|
|
|
// Returns true if the sequence would need to be queued after receiving a
|
|
// new Task.
|
|
bool WillPushTask() const WARN_UNUSED_RESULT;
|
|
|
|
// Adds |task| in a new slot at the end of the Sequence. This must only be
|
|
// called after invoking WillPushTask().
|
|
void PushTask(Task task);
|
|
|
|
Sequence* sequence() const { return static_cast<Sequence*>(task_source()); }
|
|
|
|
private:
|
|
friend class Sequence;
|
|
|
|
explicit Transaction(Sequence* sequence);
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(Transaction);
|
|
};
|
|
|
|
// |traits| is metadata that applies to all Tasks in the Sequence.
|
|
// |task_runner| is a reference to the TaskRunner feeding this TaskSource.
|
|
// |task_runner| can be nullptr only for tasks with no TaskRunner, in which
|
|
// case |execution_mode| must be kParallel. Otherwise, |execution_mode| is the
|
|
// execution mode of |task_runner|.
|
|
Sequence(const TaskTraits& traits,
|
|
TaskRunner* task_runner,
|
|
TaskSourceExecutionMode execution_mode);
|
|
|
|
// Begins a Transaction. This method cannot be called on a thread which has an
|
|
// active Sequence::Transaction.
|
|
Transaction BeginTransaction() WARN_UNUSED_RESULT;
|
|
|
|
// TaskSource:
|
|
ExecutionEnvironment GetExecutionEnvironment() override;
|
|
size_t GetRemainingConcurrency() const override;
|
|
|
|
// Returns a token that uniquely identifies this Sequence.
|
|
const SequenceToken& token() const { return token_; }
|
|
|
|
SequenceLocalStorageMap* sequence_local_storage() {
|
|
return &sequence_local_storage_;
|
|
}
|
|
|
|
private:
|
|
~Sequence() override;
|
|
|
|
// TaskSource:
|
|
RunStatus WillRunTask() override;
|
|
Task TakeTask(TaskSource::Transaction* transaction) override;
|
|
Task Clear(TaskSource::Transaction* transaction) override;
|
|
bool DidProcessTask(TaskSource::Transaction* transaction) override;
|
|
SequenceSortKey GetSortKey() const override;
|
|
|
|
// Releases reference to TaskRunner.
|
|
void ReleaseTaskRunner();
|
|
|
|
const SequenceToken token_ = SequenceToken::Create();
|
|
|
|
// Queue of tasks to execute.
|
|
base::queue<Task> queue_;
|
|
|
|
// True if a worker is currently associated with a Task from this Sequence.
|
|
bool has_worker_ = false;
|
|
|
|
// Holds data stored through the SequenceLocalStorageSlot API.
|
|
SequenceLocalStorageMap sequence_local_storage_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(Sequence);
|
|
};
|
|
|
|
} // namespace internal
|
|
} // namespace base
|
|
|
|
#endif // BASE_TASK_THREAD_POOL_SEQUENCE_H_
|