Loading...
Searching...
No Matches
v8-platform.h
Go to the documentation of this file.
1// Copyright 2013 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef V8_V8_PLATFORM_H_
6#define V8_V8_PLATFORM_H_
7
8#include <math.h>
9#include <stddef.h>
10#include <stdint.h>
11#include <stdlib.h> // For abort.
12
13#include <memory>
14#include <optional>
15#include <string>
16
17#include "v8-source-location.h" // NOLINT(build/include_directory)
18#include "v8config.h" // NOLINT(build/include_directory)
19
20namespace v8 {
21
22class Isolate;
23
24// Valid priorities supported by the task scheduling infrastructure.
25enum class TaskPriority : uint8_t {
45};
46
50class Task {
51 public:
52 virtual ~Task() = default;
53
54 virtual void Run() = 0;
55};
56
63class IdleTask {
64 public:
65 virtual ~IdleTask() = default;
66 virtual void Run(double deadline_in_seconds) = 0;
67};
68
76 public:
83 void PostTask(std::unique_ptr<Task> task,
84 const SourceLocation& location = SourceLocation::Current()) {
85 PostTaskImpl(std::move(task), location);
86 }
87
106 std::unique_ptr<Task> task,
107 const SourceLocation& location = SourceLocation::Current()) {
108 PostNonNestableTaskImpl(std::move(task), location);
109 }
110
119 std::unique_ptr<Task> task, double delay_in_seconds,
120 const SourceLocation& location = SourceLocation::Current()) {
121 PostDelayedTaskImpl(std::move(task), delay_in_seconds, location);
122 }
123
143 std::unique_ptr<Task> task, double delay_in_seconds,
144 const SourceLocation& location = SourceLocation::Current()) {
145 PostNonNestableDelayedTaskImpl(std::move(task), delay_in_seconds, location);
146 }
147
159 std::unique_ptr<IdleTask> task,
160 const SourceLocation& location = SourceLocation::Current()) {
161 PostIdleTaskImpl(std::move(task), location);
162 }
163
167 virtual bool IdleTasksEnabled() = 0;
168
172 virtual bool NonNestableTasksEnabled() const { return false; }
173
177 virtual bool NonNestableDelayedTasksEnabled() const { return false; }
178
179 TaskRunner() = default;
180 virtual ~TaskRunner() = default;
181
182 TaskRunner(const TaskRunner&) = delete;
183 TaskRunner& operator=(const TaskRunner&) = delete;
184
185 protected:
189 virtual void PostTaskImpl(std::unique_ptr<Task> task,
190 const SourceLocation& location) {}
191 virtual void PostNonNestableTaskImpl(std::unique_ptr<Task> task,
192 const SourceLocation& location) {}
193 virtual void PostDelayedTaskImpl(std::unique_ptr<Task> task,
194 double delay_in_seconds,
195 const SourceLocation& location) {}
196 virtual void PostNonNestableDelayedTaskImpl(std::unique_ptr<Task> task,
197 double delay_in_seconds,
198 const SourceLocation& location) {}
199 virtual void PostIdleTaskImpl(std::unique_ptr<IdleTask> task,
200 const SourceLocation& location) {}
201};
202
208 public:
215 virtual bool ShouldYield() = 0;
216
222 virtual void NotifyConcurrencyIncrease() = 0;
223
229 virtual uint8_t GetTaskId() = 0;
230
235 virtual bool IsJoiningThread() const = 0;
236};
237
243 public:
244 virtual ~JobHandle() = default;
245
251 virtual void NotifyConcurrencyIncrease() = 0;
252
260 virtual void Join() = 0;
261
266 virtual void Cancel() = 0;
267
268 /*
269 * Forces all existing workers to yield ASAP but doesn’t wait for them.
270 * Warning, this is dangerous if the Job's callback is bound to or has access
271 * to state which may be deleted after this call.
272 */
273 virtual void CancelAndDetach() = 0;
274
278 virtual bool IsActive() = 0;
279
285 virtual bool IsValid() = 0;
286
290 virtual bool UpdatePriorityEnabled() const { return false; }
291
295 virtual void UpdatePriority(TaskPriority new_priority) {}
296};
297
301class JobTask {
302 public:
303 virtual ~JobTask() = default;
304
305 virtual void Run(JobDelegate* delegate) = 0;
306
318 virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
319};
320
333enum class BlockingType {
334 // The call might block (e.g. file I/O that might hit in memory cache).
335 kMayBlock,
336 // The call will definitely block (e.g. cache already checked and now pinging
337 // server synchronously).
339};
340
349 public:
350 virtual ~ScopedBlockingCall() = default;
351};
352
357 public:
358 virtual ~ConvertableToTraceFormat() = default;
359
366 virtual void AppendAsTraceFormat(std::string* out) const = 0;
367};
368
377 public:
378 virtual ~TracingController() = default;
379
380 // In Perfetto mode, trace events are written using Perfetto's Track Event
381 // API directly without going through the embedder. However, it is still
382 // possible to observe tracing being enabled and disabled.
383#if !defined(V8_USE_PERFETTO)
391 virtual const uint8_t* GetCategoryGroupEnabled(const char* name) {
392 static uint8_t no = 0;
393 return &no;
394 }
395
404 virtual uint64_t AddTraceEvent(
405 char phase, const uint8_t* category_enabled_flag, const char* name,
406 const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
407 const char** arg_names, const uint8_t* arg_types,
408 const uint64_t* arg_values,
409 std::unique_ptr<ConvertableToTraceFormat>* arg_convertables,
410 unsigned int flags) {
411 return 0;
412 }
414 char phase, const uint8_t* category_enabled_flag, const char* name,
415 const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
416 const char** arg_names, const uint8_t* arg_types,
417 const uint64_t* arg_values,
418 std::unique_ptr<ConvertableToTraceFormat>* arg_convertables,
419 unsigned int flags, int64_t timestamp) {
420 return 0;
421 }
422
427 virtual void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
428 const char* name, uint64_t handle) {}
429#endif // !defined(V8_USE_PERFETTO)
430
432 public:
433 virtual ~TraceStateObserver() = default;
434 virtual void OnTraceEnabled() = 0;
435 virtual void OnTraceDisabled() = 0;
436 };
437
443
449};
450
457 public:
458 virtual ~PageAllocator() = default;
459
464 virtual size_t AllocatePageSize() = 0;
465
470 virtual size_t CommitPageSize() = 0;
471
476 virtual void SetRandomMmapSeed(int64_t seed) = 0;
477
482 virtual void* GetRandomMmapAddr() = 0;
483
493 // Set this when reserving memory that will later require kReadWriteExecute
494 // permissions. The resulting behavior is platform-specific, currently
495 // this is used to set the MAP_JIT flag on Apple Silicon.
496 // TODO(jkummerow): Remove this when Wasm has a platform-independent
497 // w^x implementation.
498 // TODO(saelo): Remove this once all JIT pages are allocated through the
499 // VirtualAddressSpace API.
501 };
502
506 class AllocationHint final {
507 public:
508 AllocationHint() = default;
509
511 void* address) const {
512 return AllocationHint(address, may_grow_);
513 }
514
516 return AllocationHint(address_, true);
517 }
518
519 bool MayGrow() const { return may_grow_; }
520 void* Address() const { return address_; }
521
522 private:
523 constexpr AllocationHint(void* address, bool may_grow)
524 : address_(address), may_grow_(may_grow) {}
525
526 void* address_ = nullptr;
527 bool may_grow_ = false;
528 };
529
533 virtual void* AllocatePages(void* address, size_t length, size_t alignment,
534 Permission permissions) = 0;
535
541 virtual void* AllocatePages(size_t length, size_t alignment,
542 Permission permissions, AllocationHint hint) {
543 return AllocatePages(hint.Address(), length, alignment, permissions);
544 }
545
551 virtual bool ResizeAllocationAt(void* address, size_t old_length,
552 size_t new_length, Permission permissions) {
553 return false;
554 }
555
559 virtual bool FreePages(void* address, size_t length) = 0;
560
564 virtual bool ReleasePages(void* address, size_t length,
565 size_t new_length) = 0;
566
570 virtual bool SetPermissions(void* address, size_t length,
571 Permission permissions) = 0;
572
578 virtual bool RecommitPages(void* address, size_t length,
579 Permission permissions) {
580 // TODO(v8:12797): make it pure once it's implemented on Chromium side.
581 return false;
582 }
583
591 virtual bool DiscardSystemPages(void* address, size_t size) { return true; }
592
601 virtual bool DecommitPages(void* address, size_t size) = 0;
602
611 virtual bool SealPages(void* address, size_t length) {
612 // TODO(360048056): make it pure once it's implemented on Chromium side.
613 return false;
614 }
615
621 public:
622 // Implementations are expected to free the shared memory mapping in the
623 // destructor.
624 virtual ~SharedMemoryMapping() = default;
625 virtual void* GetMemory() const = 0;
626 };
627
633 public:
634 // Implementations are expected to free the shared memory in the destructor.
635 virtual ~SharedMemory() = default;
636 virtual std::unique_ptr<SharedMemoryMapping> RemapTo(
637 void* new_address) const = 0;
638 virtual void* GetMemory() const = 0;
639 virtual size_t GetSize() const = 0;
640 };
641
651 virtual bool ReserveForSharedMemoryMapping(void* address, size_t size) {
652 return false;
653 }
654
664 virtual std::unique_ptr<SharedMemory> AllocateSharedPages(
665 size_t length, const void* original_address) {
666 return {};
667 }
668
677 virtual bool CanAllocateSharedPages() { return false; }
678};
679
689 public:
690 virtual ~ThreadIsolatedAllocator() = default;
691
692 virtual void* Allocate(size_t size) = 0;
693
694 virtual void Free(void* object) = 0;
695
696 enum class Type {
697 kPkey,
698 };
699
700 virtual Type Type() const = 0;
701
705 virtual int Pkey() const { return -1; }
706};
707
708// Opaque type representing a handle to a shared memory region.
710static constexpr PlatformSharedMemoryHandle kInvalidSharedMemoryHandle = -1;
711
712// Conversion routines from the platform-dependent shared memory identifiers
713// into the opaque PlatformSharedMemoryHandle type. These use the underlying
714// types (e.g. unsigned int) instead of the typedef'd ones (e.g. mach_port_t)
715// to avoid pulling in large OS header files into this header file. Instead,
716// the users of these routines are expected to include the respecitve OS
717// headers in addition to this one.
718#if V8_OS_DARWIN
719// Convert between a shared memory handle and a mach_port_t referencing a memory
720// entry object.
721inline PlatformSharedMemoryHandle SharedMemoryHandleFromMachMemoryEntry(
722 unsigned int port) {
723 return static_cast<PlatformSharedMemoryHandle>(port);
724}
725inline unsigned int MachMemoryEntryFromSharedMemoryHandle(
727 return static_cast<unsigned int>(handle);
728}
729#elif V8_OS_FUCHSIA
730// Convert between a shared memory handle and a zx_handle_t to a VMO.
731inline PlatformSharedMemoryHandle SharedMemoryHandleFromVMO(uint32_t handle) {
732 return static_cast<PlatformSharedMemoryHandle>(handle);
733}
734inline uint32_t VMOFromSharedMemoryHandle(PlatformSharedMemoryHandle handle) {
735 return static_cast<uint32_t>(handle);
736}
737#elif V8_OS_WIN
738// Convert between a shared memory handle and a Windows HANDLE to a file mapping
739// object.
740inline PlatformSharedMemoryHandle SharedMemoryHandleFromFileMapping(
741 void* handle) {
742 return reinterpret_cast<PlatformSharedMemoryHandle>(handle);
743}
744inline void* FileMappingFromSharedMemoryHandle(
746 return reinterpret_cast<void*>(handle);
747}
748#else
749// Convert between a shared memory handle and a file descriptor.
751 return static_cast<PlatformSharedMemoryHandle>(fd);
752}
755 return static_cast<int>(handle);
756}
757#endif
758
762enum class PagePermissions {
763 kNoAccess,
764 kRead,
768};
769
781 public:
782 using Address = uintptr_t;
783
785 Address base, size_t size,
787 : page_size_(page_size),
788 allocation_granularity_(allocation_granularity),
789 base_(base),
790 size_(size),
791 max_page_permissions_(max_page_permissions) {}
792
793 virtual ~VirtualAddressSpace() = default;
794
802 size_t page_size() const { return page_size_; }
803
812 size_t allocation_granularity() const { return allocation_granularity_; }
813
819 Address base() const { return base_; }
820
826 size_t size() const { return size_; }
827
834 PagePermissions max_page_permissions() const { return max_page_permissions_; }
835
841 bool Contains(Address address) const {
842 return (address >= base()) && (address < base() + size());
843 }
844
851 virtual void SetRandomSeed(int64_t seed) = 0;
852
860
881 static constexpr Address kNoHint = 0;
883 AllocatePages(Address hint, size_t size, size_t alignment,
884 PagePermissions permissions) = 0;
885
898 virtual void FreePages(Address address, size_t size) = 0;
899
918 Address address, size_t size, PagePermissions permissions) = 0;
919
937 size_t size) = 0;
938
952 virtual void FreeGuardRegion(Address address, size_t size) = 0;
953
975 PlatformSharedMemoryHandle handle, uint64_t offset) = 0;
976
989 virtual void FreeSharedPages(Address address, size_t size) = 0;
990
1003
1012 virtual std::optional<MemoryProtectionKeyId> ActiveMemoryProtectionKey() = 0;
1013
1019 virtual bool CanAllocateSubspaces() = 0;
1020
1021 /*
1022 * Allocate a subspace.
1023 *
1024 * The address space of a subspace stays reserved in the parent space for the
1025 * lifetime of the subspace. As such, it is guaranteed that page allocations
1026 * on the parent space cannot end up inside a subspace.
1027 *
1028 * \param hint Hints where the subspace should be allocated. See
1029 * AllocatePages() for more details.
1030 *
1031 * \param size The size in bytes of the subspace. Must be a multiple of the
1032 * allocation_granularity().
1033 *
1034 * \param alignment The alignment of the subspace in bytes. Must be a multiple
1035 * of the allocation_granularity() and should be a power of two.
1036 *
1037 * \param max_page_permissions The maximum permissions that pages allocated in
1038 * the subspace can obtain.
1039 *
1040 * \param key Optional memory protection key for the subspace. If used, the
1041 * returned subspace will use this key for all its memory pages.
1042 *
1043 * \returns a new subspace or nullptr on failure.
1044 */
1045 virtual std::unique_ptr<VirtualAddressSpace> AllocateSubspace(
1046 Address hint, size_t size, size_t alignment,
1048 std::optional<MemoryProtectionKeyId> key = std::nullopt) = 0;
1049
1050 //
1051 // TODO(v8) maybe refactor the methods below before stabilizing the API. For
1052 // example by combining them into some form of page operation method that
1053 // takes a command enum as parameter.
1054 //
1055
1072 Address address, size_t size, PagePermissions permissions) = 0;
1073
1085 size_t size) {
1086 return true;
1087 }
1099 size_t size) = 0;
1100
1101 private:
1102 const size_t page_size_;
1103 const size_t allocation_granularity_;
1104 const Address base_;
1105 const size_t size_;
1106 const PagePermissions max_page_permissions_;
1107};
1108
1114 public:
1115 virtual void EnterSection() {}
1116 virtual void LeaveSection() {}
1117};
1118
1126 public:
1127 virtual ~Platform() = default;
1128
1133 virtual PageAllocator* GetPageAllocator() { return nullptr; }
1134
1142 return nullptr;
1143 }
1144
1153
1162 virtual int NumberOfWorkerThreads() = 0;
1163
1169 std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(Isolate* isolate) {
1171 }
1172
1178 virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
1179 Isolate* isolate, TaskPriority priority) = 0;
1180
1186 V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
1188 std::unique_ptr<Task> task,
1189 const SourceLocation& location = SourceLocation::Current()) {
1191 location);
1192 }
1193
1200 V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
1202 std::unique_ptr<Task> task,
1203 const SourceLocation& location = SourceLocation::Current()) {
1204 // Embedders may optionally override this to process these tasks in a high
1205 // priority pool.
1207 location);
1208 }
1209
1215 V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
1217 std::unique_ptr<Task> task,
1218 const SourceLocation& location = SourceLocation::Current()) {
1219 // Embedders may optionally override this to process these tasks in a low
1220 // priority pool.
1222 location);
1223 }
1224
1231 V8_DEPRECATE_SOON("Use PostDelayedTaskOnWorkerThread instead.")
1233 std::unique_ptr<Task> task, double delay_in_seconds,
1234 const SourceLocation& location = SourceLocation::Current()) {
1236 std::move(task), delay_in_seconds,
1237 location);
1238 }
1239
1246 TaskPriority priority, std::unique_ptr<Task> task,
1247 const SourceLocation& location = SourceLocation::Current()) {
1248 PostTaskOnWorkerThreadImpl(priority, std::move(task), location);
1249 }
1250
1258 TaskPriority priority, std::unique_ptr<Task> task,
1259 double delay_in_seconds,
1260 const SourceLocation& location = SourceLocation::Current()) {
1261 PostDelayedTaskOnWorkerThreadImpl(priority, std::move(task),
1262 delay_in_seconds, location);
1263 }
1264
1268 virtual bool IdleTasksEnabled(Isolate* isolate) { return false; }
1269
1315 std::unique_ptr<JobHandle> PostJob(
1316 TaskPriority priority, std::unique_ptr<JobTask> job_task,
1317 const SourceLocation& location = SourceLocation::Current()) {
1318 auto handle = CreateJob(priority, std::move(job_task), location);
1319 handle->NotifyConcurrencyIncrease();
1320 return handle;
1321 }
1322
1338 std::unique_ptr<JobHandle> CreateJob(
1339 TaskPriority priority, std::unique_ptr<JobTask> job_task,
1340 const SourceLocation& location = SourceLocation::Current()) {
1341 return CreateJobImpl(priority, std::move(job_task), location);
1342 }
1343
1347 virtual std::unique_ptr<ScopedBlockingCall> CreateBlockingScope(
1348 BlockingType blocking_type) {
1349 return nullptr;
1350 }
1351
1359 virtual double MonotonicallyIncreasingTime() = 0;
1360
1367 return static_cast<int64_t>(floor(CurrentClockTimeMillis()));
1368 }
1369
1375 virtual double CurrentClockTimeMillis() = 0;
1376
1381 return CurrentClockTimeMillis();
1382 }
1383
1384 typedef void (*StackTracePrinter)();
1385
1390 virtual StackTracePrinter GetStackTracePrinter() { return nullptr; }
1391
1396
1401 virtual void DumpWithoutCrashing() {}
1402
1409 static HighAllocationThroughputObserver default_observer;
1410 return &default_observer;
1411 }
1412
1413 protected:
1420
1424 virtual std::unique_ptr<JobHandle> CreateJobImpl(
1425 TaskPriority priority, std::unique_ptr<JobTask> job_task,
1426 const SourceLocation& location) = 0;
1427
1432 std::unique_ptr<Task> task,
1433 const SourceLocation& location) = 0;
1434
1440 TaskPriority priority, std::unique_ptr<Task> task,
1441 double delay_in_seconds, const SourceLocation& location) = 0;
1442};
1443
1444} // namespace v8
1445
1446#endif // V8_V8_PLATFORM_H_
Definition: v8-platform.h:356
virtual ~ConvertableToTraceFormat()=default
virtual void AppendAsTraceFormat(std::string *out) const =0
Definition: v8-platform.h:1113
virtual void EnterSection()
Definition: v8-platform.h:1115
virtual void LeaveSection()
Definition: v8-platform.h:1116
Definition: v8-platform.h:63
virtual void Run(double deadline_in_seconds)=0
virtual ~IdleTask()=default
Definition: v8-isolate.h:290
Definition: v8-platform.h:207
virtual void NotifyConcurrencyIncrease()=0
virtual bool ShouldYield()=0
virtual bool IsJoiningThread() const =0
virtual uint8_t GetTaskId()=0
Definition: v8-platform.h:242
virtual void NotifyConcurrencyIncrease()=0
virtual void CancelAndDetach()=0
virtual bool IsActive()=0
virtual bool UpdatePriorityEnabled() const
Definition: v8-platform.h:290
virtual bool IsValid()=0
virtual void UpdatePriority(TaskPriority new_priority)
Definition: v8-platform.h:295
virtual void Cancel()=0
virtual ~JobHandle()=default
virtual void Join()=0
Definition: v8-platform.h:301
virtual void Run(JobDelegate *delegate)=0
virtual size_t GetMaxConcurrency(size_t worker_count) const =0
virtual ~JobTask()=default
Definition: v8-platform.h:506
bool MayGrow() const
Definition: v8-platform.h:519
void * Address() const
Definition: v8-platform.h:520
constexpr AllocationHint WithAddress(void *address) const
Definition: v8-platform.h:510
constexpr AllocationHint WithMayGrow() const
Definition: v8-platform.h:515
Definition: v8-platform.h:620
virtual void * GetMemory() const =0
Definition: v8-platform.h:632
virtual std::unique_ptr< SharedMemoryMapping > RemapTo(void *new_address) const =0
virtual void * GetMemory() const =0
virtual size_t GetSize() const =0
virtual ~SharedMemory()=default
Definition: v8-platform.h:456
virtual void * GetRandomMmapAddr()=0
virtual bool ResizeAllocationAt(void *address, size_t old_length, size_t new_length, Permission permissions)
Definition: v8-platform.h:551
virtual ~PageAllocator()=default
virtual void * AllocatePages(size_t length, size_t alignment, Permission permissions, AllocationHint hint)
Definition: v8-platform.h:541
virtual bool ReleasePages(void *address, size_t length, size_t new_length)=0
Permission
Definition: v8-platform.h:487
@ kReadExecute
Definition: v8-platform.h:492
@ kRead
Definition: v8-platform.h:489
@ kNoAccess
Definition: v8-platform.h:488
@ kNoAccessWillJitLater
Definition: v8-platform.h:500
@ kReadWrite
Definition: v8-platform.h:490
@ kReadWriteExecute
Definition: v8-platform.h:491
virtual bool DecommitPages(void *address, size_t size)=0
virtual size_t AllocatePageSize()=0
virtual void SetRandomMmapSeed(int64_t seed)=0
virtual void * AllocatePages(void *address, size_t length, size_t alignment, Permission permissions)=0
virtual bool CanAllocateSharedPages()
Definition: v8-platform.h:677
virtual bool RecommitPages(void *address, size_t length, Permission permissions)
Definition: v8-platform.h:578
virtual bool SetPermissions(void *address, size_t length, Permission permissions)=0
virtual bool SealPages(void *address, size_t length)
Definition: v8-platform.h:611
virtual bool FreePages(void *address, size_t length)=0
virtual std::unique_ptr< SharedMemory > AllocateSharedPages(size_t length, const void *original_address)
Definition: v8-platform.h:664
virtual bool DiscardSystemPages(void *address, size_t size)
Definition: v8-platform.h:591
virtual size_t CommitPageSize()=0
virtual bool ReserveForSharedMemoryMapping(void *address, size_t size)
Definition: v8-platform.h:651
Definition: v8-platform.h:1125
virtual std::unique_ptr< ScopedBlockingCall > CreateBlockingScope(BlockingType blocking_type)
Definition: v8-platform.h:1347
void PostTaskOnWorkerThread(TaskPriority priority, std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1245
static double SystemClockTimeMillis()
virtual void PostDelayedTaskOnWorkerThreadImpl(TaskPriority priority, std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)=0
void PostDelayedTaskOnWorkerThread(TaskPriority priority, std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1257
std::unique_ptr< JobHandle > PostJob(TaskPriority priority, std::unique_ptr< JobTask > job_task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1315
virtual std::shared_ptr< v8::TaskRunner > GetForegroundTaskRunner(Isolate *isolate, TaskPriority priority)=0
virtual TracingController * GetTracingController()=0
virtual PageAllocator * GetPageAllocator()
Definition: v8-platform.h:1133
virtual int NumberOfWorkerThreads()=0
void CallLowPriorityTaskOnWorkerThread(std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1216
virtual double MonotonicallyIncreasingTime()=0
void CallDelayedOnWorkerThread(std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1232
virtual HighAllocationThroughputObserver * GetHighAllocationThroughputObserver()
Definition: v8-platform.h:1408
virtual void OnCriticalMemoryPressure()
Definition: v8-platform.h:1152
virtual int64_t CurrentClockTimeMilliseconds()
Definition: v8-platform.h:1366
virtual double CurrentClockTimeMillis()=0
void CallBlockingTaskOnWorkerThread(std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1201
void CallOnWorkerThread(std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1187
virtual StackTracePrinter GetStackTracePrinter()
Definition: v8-platform.h:1390
void(* StackTracePrinter)()
Definition: v8-platform.h:1384
virtual ~Platform()=default
std::unique_ptr< JobHandle > CreateJob(TaskPriority priority, std::unique_ptr< JobTask > job_task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:1338
virtual double CurrentClockTimeMillisecondsHighResolution()
Definition: v8-platform.h:1380
virtual void DumpWithoutCrashing()
Definition: v8-platform.h:1401
virtual void PostTaskOnWorkerThreadImpl(TaskPriority priority, std::unique_ptr< Task > task, const SourceLocation &location)=0
virtual bool IdleTasksEnabled(Isolate *isolate)
Definition: v8-platform.h:1268
std::shared_ptr< v8::TaskRunner > GetForegroundTaskRunner(Isolate *isolate)
Definition: v8-platform.h:1169
virtual std::unique_ptr< JobHandle > CreateJobImpl(TaskPriority priority, std::unique_ptr< JobTask > job_task, const SourceLocation &location)=0
virtual ThreadIsolatedAllocator * GetThreadIsolatedAllocator()
Definition: v8-platform.h:1141
Definition: v8-platform.h:348
virtual ~ScopedBlockingCall()=default
Definition: v8-source-location.h:31
static constexpr SourceLocation Current()
Definition: v8-source-location.h:44
Definition: v8-platform.h:75
TaskRunner & operator=(const TaskRunner &)=delete
virtual void PostIdleTaskImpl(std::unique_ptr< IdleTask > task, const SourceLocation &location)
Definition: v8-platform.h:199
TaskRunner(const TaskRunner &)=delete
virtual void PostNonNestableTaskImpl(std::unique_ptr< Task > task, const SourceLocation &location)
Definition: v8-platform.h:191
virtual void PostTaskImpl(std::unique_ptr< Task > task, const SourceLocation &location)
Definition: v8-platform.h:189
virtual void PostDelayedTaskImpl(std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)
Definition: v8-platform.h:193
virtual bool NonNestableDelayedTasksEnabled() const
Definition: v8-platform.h:177
TaskRunner()=default
void PostDelayedTask(std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:118
void PostIdleTask(std::unique_ptr< IdleTask > task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:158
void PostTask(std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:83
virtual bool NonNestableTasksEnabled() const
Definition: v8-platform.h:172
virtual ~TaskRunner()=default
virtual void PostNonNestableDelayedTaskImpl(std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)
Definition: v8-platform.h:196
virtual bool IdleTasksEnabled()=0
void PostNonNestableTask(std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:105
void PostNonNestableDelayedTask(std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location=SourceLocation::Current())
Definition: v8-platform.h:142
Definition: v8-platform.h:50
virtual void Run()=0
virtual ~Task()=default
Definition: v8-platform.h:688
virtual int Pkey() const
Definition: v8-platform.h:705
virtual void * Allocate(size_t size)=0
virtual void Free(void *object)=0
virtual ~ThreadIsolatedAllocator()=default
virtual Type Type() const =0
Type
Definition: v8-platform.h:696
Definition: v8-platform.h:431
Definition: v8-platform.h:376
virtual uint64_t AddTraceEventWithTimestamp(char phase, const uint8_t *category_enabled_flag, const char *name, const char *scope, uint64_t id, uint64_t bind_id, int32_t num_args, const char **arg_names, const uint8_t *arg_types, const uint64_t *arg_values, std::unique_ptr< ConvertableToTraceFormat > *arg_convertables, unsigned int flags, int64_t timestamp)
Definition: v8-platform.h:413
virtual const uint8_t * GetCategoryGroupEnabled(const char *name)
Definition: v8-platform.h:391
virtual ~TracingController()=default
virtual void AddTraceStateObserver(TraceStateObserver *)
Definition: v8-platform.h:442
virtual void RemoveTraceStateObserver(TraceStateObserver *)
Definition: v8-platform.h:448
virtual void UpdateTraceEventDuration(const uint8_t *category_enabled_flag, const char *name, uint64_t handle)
Definition: v8-platform.h:427
virtual uint64_t AddTraceEvent(char phase, const uint8_t *category_enabled_flag, const char *name, const char *scope, uint64_t id, uint64_t bind_id, int32_t num_args, const char **arg_names, const uint8_t *arg_types, const uint64_t *arg_values, std::unique_ptr< ConvertableToTraceFormat > *arg_convertables, unsigned int flags)
Definition: v8-platform.h:404
Definition: v8-platform.h:780
virtual bool CanAllocateSubspaces()=0
Address base() const
Definition: v8-platform.h:819
virtual void FreePages(Address address, size_t size)=0
virtual void SetRandomSeed(int64_t seed)=0
static constexpr Address kNoHint
Definition: v8-platform.h:881
bool Contains(Address address) const
Definition: v8-platform.h:841
uintptr_t Address
Definition: v8-platform.h:782
virtual std::unique_ptr< VirtualAddressSpace > AllocateSubspace(Address hint, size_t size, size_t alignment, PagePermissions max_page_permissions, std::optional< MemoryProtectionKeyId > key=std::nullopt)=0
virtual bool DiscardSystemPages(Address address, size_t size)
Definition: v8-platform.h:1084
virtual void FreeSharedPages(Address address, size_t size)=0
virtual void FreeGuardRegion(Address address, size_t size)=0
virtual Address AllocateSharedPages(Address hint, size_t size, PagePermissions permissions, PlatformSharedMemoryHandle handle, uint64_t offset)=0
virtual bool SetPagePermissions(Address address, size_t size, PagePermissions permissions)=0
VirtualAddressSpace(size_t page_size, size_t allocation_granularity, Address base, size_t size, PagePermissions max_page_permissions)
Definition: v8-platform.h:784
int MemoryProtectionKeyId
Definition: v8-platform.h:1002
size_t size() const
Definition: v8-platform.h:826
virtual bool AllocateGuardRegion(Address address, size_t size)=0
PagePermissions max_page_permissions() const
Definition: v8-platform.h:834
virtual std::optional< MemoryProtectionKeyId > ActiveMemoryProtectionKey()=0
size_t allocation_granularity() const
Definition: v8-platform.h:812
virtual Address RandomPageAddress()=0
virtual bool RecommitPages(Address address, size_t size, PagePermissions permissions)=0
virtual ~VirtualAddressSpace()=default
virtual bool DecommitPages(Address address, size_t size)=0
virtual Address AllocatePages(Address hint, size_t size, size_t alignment, PagePermissions permissions)=0
size_t page_size() const
Definition: v8-platform.h:802
Definition: libplatform.h:15
TaskPriority
Definition: v8-platform.h:25
int FileDescriptorFromSharedMemoryHandle(PlatformSharedMemoryHandle handle)
Definition: v8-platform.h:753
PlatformSharedMemoryHandle SharedMemoryHandleFromFileDescriptor(int fd)
Definition: v8-platform.h:750
BlockingType
Definition: v8-platform.h:333
intptr_t PlatformSharedMemoryHandle
Definition: v8-platform.h:709
PagePermissions
Definition: v8-platform.h:762
#define V8_EXPORT
Definition: v8config.h:812
#define V8_DEPRECATE_SOON(message)
Definition: v8config.h:625
#define V8_WARN_UNUSED_RESULT
Definition: v8config.h:682