diff options
Diffstat (limited to 'deps/v8/src/libplatform/default-job.h')
-rw-r--r-- | deps/v8/src/libplatform/default-job.h | 126 |
1 files changed, 126 insertions, 0 deletions
diff --git a/deps/v8/src/libplatform/default-job.h b/deps/v8/src/libplatform/default-job.h new file mode 100644 index 00000000000..2eb00cbd748 --- /dev/null +++ b/deps/v8/src/libplatform/default-job.h @@ -0,0 +1,126 @@ +// Copyright 2020 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. + +#ifndef V8_LIBPLATFORM_DEFAULT_JOB_H_ +#define V8_LIBPLATFORM_DEFAULT_JOB_H_ + +#include <atomic> +#include <memory> + +#include "include/libplatform/libplatform-export.h" +#include "include/v8-platform.h" +#include "src/base/platform/condition-variable.h" +#include "src/base/platform/mutex.h" + +namespace v8 { +namespace platform { + +class V8_PLATFORM_EXPORT DefaultJobState + : NON_EXPORTED_BASE(public JobDelegate), + public std::enable_shared_from_this<DefaultJobState> { + public: + DefaultJobState(Platform* platform, std::unique_ptr<JobTask> job_task, + TaskPriority priority, size_t num_worker_threads) + : platform_(platform), + job_task_(std::move(job_task)), + priority_(priority), + num_worker_threads_(num_worker_threads) {} + virtual ~DefaultJobState(); + + void NotifyConcurrencyIncrease() override; + bool ShouldYield() override { + // Thread-safe but may return an outdated result. + return is_canceled_.load(std::memory_order_relaxed); + } + + void Join(); + void CancelAndWait(); + + // Must be called before running |job_task_| for the first time. If it returns + // true, then the worker thread must contribute and must call DidRunTask(), or + // false if it should return. + bool CanRunFirstTask(); + // Must be called after running |job_task_|. Returns true if the worker thread + // must contribute again, or false if it should return. + bool DidRunTask(); + + private: + // Called from the joining thread. Waits for the worker count to be below or + // equal to max concurrency (will happen when a worker calls + // DidRunTask()). Returns true if the joining thread should run a task, or + // false if joining was completed and all other workers returned because + // there's no work remaining. + bool WaitForParticipationOpportunityLockRequired(); + + // Returns GetMaxConcurrency() capped by the number of threads used by this + // job. + size_t CappedMaxConcurrency() const; + + void CallOnWorkerThread(std::unique_ptr<Task> task); + + Platform* const platform_; + std::unique_ptr<JobTask> job_task_; + + // All members below are protected by |mutex_|. + base::Mutex mutex_; + TaskPriority priority_; + // Number of workers running this job. + size_t active_workers_ = 0; + // Number of posted tasks that aren't running this job yet. + size_t pending_tasks_ = 0; + // Indicates if the job is canceled. + std::atomic_bool is_canceled_{false}; + // Number of worker threads available to schedule the worker task. + size_t num_worker_threads_; + // Signaled when a worker returns. + base::ConditionVariable worker_released_condition_; +}; + +class V8_PLATFORM_EXPORT DefaultJobHandle : public JobHandle { + public: + explicit DefaultJobHandle(std::shared_ptr<DefaultJobState> state); + ~DefaultJobHandle() override; + + void NotifyConcurrencyIncrease() override { + state_->NotifyConcurrencyIncrease(); + } + + void Join() override; + void Cancel() override; + bool IsRunning() override { return state_ != nullptr; } + + private: + std::shared_ptr<DefaultJobState> state_; + + DISALLOW_COPY_AND_ASSIGN(DefaultJobHandle); +}; + +class DefaultJobWorker : public Task { + public: + DefaultJobWorker(std::weak_ptr<DefaultJobState> state, JobTask* job_task) + : state_(std::move(state)), job_task_(job_task) {} + ~DefaultJobWorker() override = default; + + void Run() override { + auto shared_state = state_.lock(); + if (!shared_state) return; + if (!shared_state->CanRunFirstTask()) return; + do { + job_task_->Run(shared_state.get()); + } while (shared_state->DidRunTask()); + } + + private: + friend class DefaultJob; + + std::weak_ptr<DefaultJobState> state_; + JobTask* job_task_; + + DISALLOW_COPY_AND_ASSIGN(DefaultJobWorker); +}; + +} // namespace platform +} // namespace v8 + +#endif // V8_LIBPLATFORM_DEFAULT_JOB_H_ |