Platform Class Reference

#include <v8-platform.h>

Public Types
typedef void(*	StackTracePrinter) ()

Public Member Functions
virtual	~Platform ()=default
virtual PageAllocator *	GetPageAllocator ()=0
virtual ZoneBackingAllocator *	GetZoneBackingAllocator ()
virtual void	OnCriticalMemoryPressure ()
virtual int	NumberOfWorkerThreads ()=0
virtual std::shared_ptr< v8::TaskRunner >	GetForegroundTaskRunner (Isolate *isolate)=0
virtual void	CallOnWorkerThread (std::unique_ptr< Task > task)=0
virtual void	CallBlockingTaskOnWorkerThread (std::unique_ptr< Task > task)
virtual void	CallLowPriorityTaskOnWorkerThread (std::unique_ptr< Task > task)
virtual void	CallDelayedOnWorkerThread (std::unique_ptr< Task > task, double delay_in_seconds)=0
virtual bool	IdleTasksEnabled (Isolate *isolate)
virtual std::unique_ptr< JobHandle >	PostJob (TaskPriority priority, std::unique_ptr< JobTask > job_task)
virtual std::unique_ptr< JobHandle >	CreateJob (TaskPriority priority, std::unique_ptr< JobTask > job_task)=0
virtual std::unique_ptr< ScopedBlockingCall >	CreateBlockingScope (BlockingType blocking_type)
virtual double	MonotonicallyIncreasingTime ()=0
virtual int64_t	CurrentClockTimeMilliseconds ()
virtual double	CurrentClockTimeMillis ()=0
virtual double	CurrentClockTimeMillisecondsHighResolution ()
virtual StackTracePrinter	GetStackTracePrinter ()
virtual TracingController *	GetTracingController ()=0
virtual void	DumpWithoutCrashing ()
virtual HighAllocationThroughputObserver *	GetHighAllocationThroughputObserver ()

Static Protected Member Functions
static V8_EXPORT double	SystemClockTimeMillis ()

Detailed Description

V8 Platform abstraction layer.

The embedder has to provide an implementation of this interface before initializing the rest of V8.

Definition at line 962 of file v8-platform.h.

Member Typedef Documentation

StackTracePrinter

typedef void(* StackTracePrinter) ()

Definition at line 1150 of file v8-platform.h.

Constructor & Destructor Documentation

~Platform()

virtual ~Platform ( )

virtualdefault

Member Function Documentation

CallBlockingTaskOnWorkerThread()

virtual void CallBlockingTaskOnWorkerThread ( std::unique_ptr< Task >  task )

inlinevirtual

Schedules a task that blocks the main thread to be invoked with high-priority on a worker thread.

Definition at line 1016 of file v8-platform.h.

References Platform::CallOnWorkerThread().

CallDelayedOnWorkerThread()

virtual void CallDelayedOnWorkerThread ( std::unique_ptr< Task >  task, double  delay_in_seconds  )

pure virtual

Schedules a task to be invoked on a worker thread after |delay_in_seconds| expires.

CallLowPriorityTaskOnWorkerThread()

virtual void CallLowPriorityTaskOnWorkerThread ( std::unique_ptr< Task >  task )

inlinevirtual

Schedules a task to be invoked with low-priority on a worker thread.

Definition at line 1025 of file v8-platform.h.

References Platform::CallOnWorkerThread().

CallOnWorkerThread()

virtual void CallOnWorkerThread ( std::unique_ptr< Task >  task )

pure virtual

Schedules a task to be invoked on a worker thread.

Referenced by Platform::CallBlockingTaskOnWorkerThread(), and Platform::CallLowPriorityTaskOnWorkerThread().

CreateBlockingScope()

virtual std::unique_ptr< ScopedBlockingCall > CreateBlockingScope ( BlockingType  blocking_type )

inlinevirtual

Instantiates a ScopedBlockingCall to annotate a scope that may/will block.

Definition at line 1113 of file v8-platform.h.

CreateJob()

virtual std::unique_ptr< JobHandle > CreateJob ( TaskPriority  priority, std::unique_ptr< JobTask >  job_task  )

pure virtual

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()); }

Referenced by Platform::PostJob().

CurrentClockTimeMillis()

virtual double CurrentClockTimeMillis ( )

pure virtual

This function is deprecated and will be deleted. Use either CurrentClockTimeMilliseconds() or CurrentClockTimeMillisecondsHighResolution().

Referenced by Platform::CurrentClockTimeMilliseconds(), and Platform::CurrentClockTimeMillisecondsHighResolution().

CurrentClockTimeMilliseconds()

virtual int64_t CurrentClockTimeMilliseconds ( )

inlinevirtual

Current wall-clock time in milliseconds since epoch. Use CurrentClockTimeMillisHighResolution() when higher precision is required.

Definition at line 1132 of file v8-platform.h.

References Platform::CurrentClockTimeMillis().

CurrentClockTimeMillisecondsHighResolution()

virtual double CurrentClockTimeMillisecondsHighResolution ( )

inlinevirtual

Same as CurrentClockTimeMilliseconds(), but with more precision.

Definition at line 1146 of file v8-platform.h.

References Platform::CurrentClockTimeMillis().

DumpWithoutCrashing()

virtual void DumpWithoutCrashing ( )

inlinevirtual

Tells the embedder to generate and upload a crashdump during an unexpected but non-critical scenario.

Definition at line 1167 of file v8-platform.h.

GetForegroundTaskRunner()

virtual std::shared_ptr< v8::TaskRunner > GetForegroundTaskRunner ( Isolate *  isolate )

pure virtual

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.

GetHighAllocationThroughputObserver()

virtual HighAllocationThroughputObserver * GetHighAllocationThroughputObserver ( )

inlinevirtual

Allows the embedder to observe sections with high throughput allocation operations.

Definition at line 1174 of file v8-platform.h.

GetPageAllocator()

virtual PageAllocator * GetPageAllocator ( )

pure virtual

Allows the embedder to manage memory page allocations. Returning nullptr will cause V8 to use the default page allocator.

GetStackTracePrinter()

virtual StackTracePrinter GetStackTracePrinter ( )

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 1156 of file v8-platform.h.

GetTracingController()

virtual TracingController * GetTracingController ( )

pure virtual

Returns an instance of a v8::TracingController. This must be non-nullptr.

GetZoneBackingAllocator()

virtual ZoneBackingAllocator * GetZoneBackingAllocator ( )

inlinevirtual

Allows the embedder to specify a custom allocator used for zones.

Definition at line 975 of file v8-platform.h.

IdleTasksEnabled()

virtual bool IdleTasksEnabled ( Isolate *  isolate )

inlinevirtual

Returns true if idle tasks are enabled for the given |isolate|.

Definition at line 1041 of file v8-platform.h.

MonotonicallyIncreasingTime()

virtual double MonotonicallyIncreasingTime ( )

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.

NumberOfWorkerThreads()

virtual int NumberOfWorkerThreads ( )

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|.

OnCriticalMemoryPressure()

virtual void OnCriticalMemoryPressure ( )

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 987 of file v8-platform.h.

PostJob()

virtual std::unique_ptr< JobHandle > PostJob ( TaskPriority  priority, std::unique_ptr< JobTask >  job_task  )

inlinevirtual

Posts |job_task| to run in parallel. Returns a JobHandle associated with the Job, which can be joined or canceled. This avoids degenerate cases:

• Calling CallOnWorkerThread() for each work item, causing significant overhead.

• 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).

Definition at line 1087 of file v8-platform.h.

References Platform::CreateJob().

SystemClockTimeMillis()

static V8_EXPORT double SystemClockTimeMillis ( )

staticprotected

Default implementation of current wall-clock time in milliseconds since epoch. Useful for implementing |CurrentClockTimeMillis| if nothing special needed.

---

The documentation for this class was generated from the following file:

• include/v8-platform.h