 |
v8 13.6.233 (node 24.1.0)
V8 is Google's open source JavaScript engine
|
|
v8 13.6.233 (node 24.1.0)
V8 is Google's open source JavaScript engine
|
#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 V8_EXPORT double | SystemClockTimeMillis () |
V8 Platform abstraction layer.
The embedder has to provide an implementation of this interface before initializing the rest of V8.
Definition at line 1058 of file v8-platform.h.
| typedef void(* StackTracePrinter) () |
Definition at line 1317 of file v8-platform.h.
|
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().
Definition at line 1134 of file v8-platform.h.
References CallBlockingTaskOnWorkerThread(), v8::kUserBlocking, and PostTaskOnWorkerThreadImpl().
Referenced by CallBlockingTaskOnWorkerThread().
|
inline |
Schedules a task to be invoked on a worker thread after |delay_in_seconds| expires. Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of CallDelayedOnWorkerThread().
Definition at line 1165 of file v8-platform.h.
References CallDelayedOnWorkerThread(), v8::kUserVisible, and PostDelayedTaskOnWorkerThreadImpl().
Referenced by CallDelayedOnWorkerThread().
|
inline |
Schedules a task to be invoked with low-priority on a worker thread. Embedders should override PostTaskOnWorkerThreadImpl() instead of CallLowPriorityTaskOnWorkerThread().
Definition at line 1149 of file v8-platform.h.
References CallLowPriorityTaskOnWorkerThread(), v8::kBestEffort, and PostTaskOnWorkerThreadImpl().
Referenced by CallLowPriorityTaskOnWorkerThread().
|
inline |
Schedules a task to be invoked on a worker thread. Embedders should override PostTaskOnWorkerThreadImpl() instead of CallOnWorkerThread().
Definition at line 1120 of file v8-platform.h.
References CallOnWorkerThread(), v8::kUserVisible, and PostTaskOnWorkerThreadImpl().
Referenced by CallOnWorkerThread().
|
inlinevirtual |
Instantiates a ScopedBlockingCall to annotate a scope that may/will block.
Definition at line 1280 of file v8-platform.h.
|
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().
Definition at line 1271 of file v8-platform.h.
References CreateJobImpl(), and SourceLocation::Current().
Referenced by PostJob().
|
protectedpure virtual |
Creates and returns a JobHandle associated with a Job.
Referenced by CreateJob().
|
pure virtual |
This function is deprecated and will be deleted. Use either CurrentClockTimeMilliseconds() or CurrentClockTimeMillisecondsHighResolution().
Referenced by CurrentClockTimeMilliseconds(), and CurrentClockTimeMillisecondsHighResolution().
|
inlinevirtual |
Current wall-clock time in milliseconds since epoch. Use CurrentClockTimeMillisHighResolution() when higher precision is required.
Definition at line 1299 of file v8-platform.h.
References CurrentClockTimeMillis().
|
inlinevirtual |
Same as CurrentClockTimeMilliseconds(), but with more precision.
Definition at line 1313 of file v8-platform.h.
References CurrentClockTimeMillis().
|
inlinevirtual |
Tells the embedder to generate and upload a crashdump during an unexpected but non-critical scenario.
Definition at line 1334 of file v8-platform.h.
|
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.
Definition at line 1102 of file v8-platform.h.
References GetForegroundTaskRunner(), and v8::kUserBlocking.
Referenced by GetForegroundTaskRunner().
|
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.
Definition at line 1341 of file v8-platform.h.
|
inlinevirtual |
Allows the embedder to manage memory page allocations. Returning nullptr will cause V8 to use the default page allocator.
Definition at line 1066 of file v8-platform.h.
|
inlinevirtual |
Returns a function pointer that print a stack trace of the current stack on invocation. Disables printing of the stack trace if nullptr.
Definition at line 1323 of file v8-platform.h.
|
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.
Definition at line 1074 of file v8-platform.h.
|
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|.
Definition at line 1201 of file v8-platform.h.
|
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 |
Enables the embedder to respond in cases where V8 can't allocate large blocks of memory. V8 retries the failed allocation once after calling this method. On success, execution continues; otherwise V8 exits with a fatal error. Embedder overrides of this function must NOT call back into V8.
Definition at line 1085 of file v8-platform.h.
|
inline |
Schedules a task to be invoked on a worker thread after |delay_in_seconds| expires. Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of PostDelayedTaskOnWorkerThread().
Definition at line 1190 of file v8-platform.h.
References SourceLocation::Current(), and PostDelayedTaskOnWorkerThreadImpl().
|
protectedpure virtual |
Schedules a task with |priority| to be invoked on a worker thread after |delay_in_seconds| expires.
Referenced by CallDelayedOnWorkerThread(), and PostDelayedTaskOnWorkerThread().
|
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().
Definition at line 1248 of file v8-platform.h.
References CreateJob(), and SourceLocation::Current().
|
inline |
Schedules a task to be invoked on a worker thread. Embedders should override PostTaskOnWorkerThreadImpl() instead of PostTaskOnWorkerThread().
Definition at line 1178 of file v8-platform.h.
References SourceLocation::Current(), and PostTaskOnWorkerThreadImpl().
|
protectedpure virtual |
Schedules a task with |priority| to be invoked on a worker thread.
Referenced by CallBlockingTaskOnWorkerThread(), CallLowPriorityTaskOnWorkerThread(), CallOnWorkerThread(), and PostTaskOnWorkerThread().
|
staticprotected |
Default implementation of current wall-clock time in milliseconds since epoch. Useful for implementing |CurrentClockTimeMillis| if nothing special needed.
References V8_EXPORT.
