#include <v8-platform.h>
Public Types | |
| typedef void(* | StackTracePrinter) () |
Protected Member Functions | |
| virtual std::unique_ptr< JobHandle > | CreateJobImpl (TaskPriority priority, std::unique_ptr< JobTask > job_task, const SourceLocation &location)=0 |
| virtual void | PostTaskOnWorkerThreadImpl (TaskPriority priority, std::unique_ptr< Task > task, const SourceLocation &location)=0 |
| virtual void | PostDelayedTaskOnWorkerThreadImpl (TaskPriority priority, std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)=0 |
Static Protected Member Functions | |
| static double | SystemClockTimeMillis () |
V8 Platform abstraction layer.
The embedder has to provide an implementation of this interface before initializing the rest of V8.
| typedef void(* v8::Platform::StackTracePrinter) () |
|
virtualdefault |
|
inline |
Schedules a task that blocks the main thread to be invoked with high-priority on a worker thread. Embedders should override PostTaskOnWorkerThreadImpl() instead of CallBlockingTaskOnWorkerThread().
|
inline |
Schedules a task to be invoked on a worker thread after |delay_in_seconds| expires. Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of CallDelayedOnWorkerThread().
|
inline |
Schedules a task to be invoked with low-priority on a worker thread. Embedders should override PostTaskOnWorkerThreadImpl() instead of CallLowPriorityTaskOnWorkerThread().
|
inline |
Schedules a task to be invoked on a worker thread. Embedders should override PostTaskOnWorkerThreadImpl() instead of CallOnWorkerThread().
|
inlinevirtual |
Instantiates a ScopedBlockingCall to annotate a scope that may/will block.
|
inline |
Creates and returns a JobHandle associated with a Job. Unlike PostJob(), this doesn't immediately schedules |worker_task| to run; the Job is then scheduled by calling either NotifyConcurrencyIncrease() or Join().
A sufficient CreateJob() implementation that uses the default Job provided in libplatform looks like: std::unique_ptr<JobHandle> CreateJob( TaskPriority priority, std::unique_ptr<JobTask> job_task) override { return v8::platform::NewDefaultJobHandle( this, priority, std::move(job_task), NumberOfWorkerThreads()); }
Embedders should override CreateJobImpl() instead of CreateJob().
|
protectedpure virtual |
|
pure virtual |
This function is deprecated and will be deleted. Use either CurrentClockTimeMilliseconds() or CurrentClockTimeMillisecondsHighResolution().
|
inlinevirtual |
Current wall-clock time in milliseconds since epoch. Use CurrentClockTimeMillisHighResolution() when higher precision is required.
|
inlinevirtual |
Same as CurrentClockTimeMilliseconds(), but with more precision.
|
inlinevirtual |
Tells the embedder to generate and upload a crashdump during an unexpected but non-critical scenario.
|
inline |
Returns a TaskRunner which can be used to post a task on the foreground. The TaskRunner's NonNestableTasksEnabled() must be true. This function should only be called from a foreground thread.
|
pure virtual |
Returns a TaskRunner with a specific |priority| which can be used to post a task on the foreground thread. The TaskRunner's NonNestableTasksEnabled() must be true. This function should only be called from a foreground thread.
|
inlinevirtual |
Allows the embedder to observe sections with high throughput allocation operations.
|
pure virtual |
Allows the embedder to manage memory page allocations. Returning nullptr will cause V8 to use the default page allocator.
|
inlinevirtual |
Returns a function pointer that print a stack trace of the current stack on invocation. Disables printing of the stack trace if nullptr.
|
inlinevirtual |
Allows the embedder to provide an allocator that uses per-thread memory permissions to protect allocations. Returning nullptr will cause V8 to disable protections that rely on this feature.
|
pure virtual |
Returns an instance of a v8::TracingController. This must be non-nullptr.
|
inlinevirtual |
Returns true if idle tasks are enabled for the given |isolate|.
|
pure virtual |
Monotonically increasing time in seconds from an arbitrary fixed point in the past. This function is expected to return at least millisecond-precision values. For this reason, it is recommended that the fixed point be no further in the past than the epoch.
|
pure virtual |
Gets the max number of worker threads that may be used to execute concurrent work scheduled for any single TaskPriority by Call(BlockingTask)OnWorkerThread() or PostJob(). This can be used to estimate the number of tasks a work package should be split into. A return value of 0 means that there are no worker threads available. Note that a value of 0 won't prohibit V8 from posting tasks using |CallOnWorkerThread|.
|
inlinevirtual |
|
inline |
Schedules a task to be invoked on a worker thread after |delay_in_seconds| expires. Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of PostDelayedTaskOnWorkerThread().
|
protectedpure virtual |
Schedules a task with |priority| to be invoked on a worker thread after |delay_in_seconds| expires.
|
inline |
Posts |job_task| to run in parallel. Returns a JobHandle associated with the Job, which can be joined or canceled. This avoids degenerate cases:
Fixed number of CallOnWorkerThread() calls that split the work and might run for a long time. This is problematic when many components post "num cores" tasks and all expect to use all the cores. In these cases, the scheduler lacks context to be fair to multiple same-priority requests and/or ability to request lower priority work to yield when high priority work comes in. A canonical implementation of |job_task| looks like: class MyJobTask : public JobTask { public: MyJobTask(...) : worker_queue_(...) {} // JobTask: void Run(JobDelegate* delegate) override { while (!delegate->ShouldYield()) { // Smallest unit of work. auto work_item = worker_queue_.TakeWorkItem(); // Thread safe. if (!work_item) return; ProcessWork(work_item); } }
size_t GetMaxConcurrency() const override { return worker_queue_.GetSize(); // Thread safe. } }; auto handle = PostJob(TaskPriority::kUserVisible, std::make_unique<MyJobTask>(...)); handle->Join();
PostJob() and methods of the returned JobHandle/JobDelegate, must never be called while holding a lock that could be acquired by JobTask::Run or JobTask::GetMaxConcurrency – that could result in a deadlock. This is because [1] JobTask::GetMaxConcurrency may be invoked while holding internal lock (A), hence JobTask::GetMaxConcurrency can only use a lock (B) if that lock is never held while calling back into JobHandle from any thread (A=>B/B=>A deadlock) and [2] JobTask::Run or JobTask::GetMaxConcurrency may be invoked synchronously from JobHandle (B=>JobHandle::foo=>B deadlock). Embedders should override CreateJobImpl() instead of PostJob().
|
inline |
Schedules a task to be invoked on a worker thread. Embedders should override PostTaskOnWorkerThreadImpl() instead of PostTaskOnWorkerThread().
|
protectedpure virtual |
Schedules a task with |priority| to be invoked on a worker thread.
|
staticprotected |
Default implementation of current wall-clock time in milliseconds since epoch. Useful for implementing |CurrentClockTimeMillis| if nothing special needed.