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,
85 PostTaskImpl(std::move(task), location);
86 }
87
106 std::unique_ptr<Task> task,
108 PostNonNestableTaskImpl(std::move(task), location);
109 }
110
118 void PostDelayedTask(std::unique_ptr<Task> task, double delay_in_seconds,
120 PostDelayedTaskImpl(std::move(task), delay_in_seconds, location);
121 }
122
142 std::unique_ptr<Task> task, double delay_in_seconds,
144 PostNonNestableDelayedTaskImpl(std::move(task), delay_in_seconds, location);
145 }
146
157 void PostIdleTask(std::unique_ptr<IdleTask> task,
159 PostIdleTaskImpl(std::move(task), location);
160 }
161
165 virtual bool IdleTasksEnabled() = 0;
166
170 virtual bool NonNestableTasksEnabled() const { return false; }
171
175 virtual bool NonNestableDelayedTasksEnabled() const { return false; }
176
177 TaskRunner() = default;
178 virtual ~TaskRunner() = default;
179
180 TaskRunner(const TaskRunner&) = delete;
181 TaskRunner& operator=(const TaskRunner&) = delete;
182
183 protected:
187 virtual void PostTaskImpl(std::unique_ptr<Task> task,
188 const SourceLocation& location) {}
189 virtual void PostNonNestableTaskImpl(std::unique_ptr<Task> task,
190 const SourceLocation& location) {}
191 virtual void PostDelayedTaskImpl(std::unique_ptr<Task> task,
192 double delay_in_seconds,
193 const SourceLocation& location) {}
194 virtual void PostNonNestableDelayedTaskImpl(std::unique_ptr<Task> task,
195 double delay_in_seconds,
196 const SourceLocation& location) {}
197 virtual void PostIdleTaskImpl(std::unique_ptr<IdleTask> task,
198 const SourceLocation& location) {}
199};
200
206 public:
213 virtual bool ShouldYield() = 0;
214
220 virtual void NotifyConcurrencyIncrease() = 0;
221
227 virtual uint8_t GetTaskId() = 0;
228
233 virtual bool IsJoiningThread() const = 0;
234};
235
241 public:
242 virtual ~JobHandle() = default;
243
249 virtual void NotifyConcurrencyIncrease() = 0;
250
258 virtual void Join() = 0;
259
264 virtual void Cancel() = 0;
265
266 /*
267 * Forces all existing workers to yield ASAP but doesn’t wait for them.
268 * Warning, this is dangerous if the Job's callback is bound to or has access
269 * to state which may be deleted after this call.
270 */
271 virtual void CancelAndDetach() = 0;
272
276 virtual bool IsActive() = 0;
277
283 virtual bool IsValid() = 0;
284
288 virtual bool UpdatePriorityEnabled() const { return false; }
289
293 virtual void UpdatePriority(TaskPriority new_priority) {}
294};
295
299class JobTask {
300 public:
301 virtual ~JobTask() = default;
302
303 virtual void Run(JobDelegate* delegate) = 0;
304
316 virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
317};
318
331enum class BlockingType {
332 // The call might block (e.g. file I/O that might hit in memory cache).
333 kMayBlock,
334 // The call will definitely block (e.g. cache already checked and now pinging
335 // server synchronously).
337};
338
347 public:
348 virtual ~ScopedBlockingCall() = default;
349};
350
355 public:
356 virtual ~ConvertableToTraceFormat() = default;
357
364 virtual void AppendAsTraceFormat(std::string* out) const = 0;
365};
366
375 public:
376 virtual ~TracingController() = default;
377
378 // In Perfetto mode, trace events are written using Perfetto's Track Event
379 // API directly without going through the embedder. However, it is still
380 // possible to observe tracing being enabled and disabled.
381#if !defined(V8_USE_PERFETTO)
389 virtual const uint8_t* GetCategoryGroupEnabled(const char* name) {
390 static uint8_t no = 0;
391 return &no;
392 }
393
402 virtual uint64_t AddTraceEvent(
403 char phase, const uint8_t* category_enabled_flag, const char* name,
404 const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
405 const char** arg_names, const uint8_t* arg_types,
406 const uint64_t* arg_values,
407 std::unique_ptr<ConvertableToTraceFormat>* arg_convertables,
408 unsigned int flags) {
409 return 0;
410 }
412 char phase, const uint8_t* category_enabled_flag, const char* name,
413 const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
414 const char** arg_names, const uint8_t* arg_types,
415 const uint64_t* arg_values,
416 std::unique_ptr<ConvertableToTraceFormat>* arg_convertables,
417 unsigned int flags, int64_t timestamp) {
418 return 0;
419 }
420
425 virtual void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
426 const char* name, uint64_t handle) {}
427#endif // !defined(V8_USE_PERFETTO)
428
430 public:
431 virtual ~TraceStateObserver() = default;
432 virtual void OnTraceEnabled() = 0;
433 virtual void OnTraceDisabled() = 0;
434 };
435
441
447};
448
455 public:
456 virtual ~PageAllocator() = default;
457
462 virtual size_t AllocatePageSize() = 0;
463
468 virtual size_t CommitPageSize() = 0;
469
474 virtual void SetRandomMmapSeed(int64_t seed) = 0;
475
480 virtual void* GetRandomMmapAddr() = 0;
481
491 // Set this when reserving memory that will later require kReadWriteExecute
492 // permissions. The resulting behavior is platform-specific, currently
493 // this is used to set the MAP_JIT flag on Apple Silicon.
494 // TODO(jkummerow): Remove this when Wasm has a platform-independent
495 // w^x implementation.
496 // TODO(saelo): Remove this once all JIT pages are allocated through the
497 // VirtualAddressSpace API.
499 };
500
504 class AllocationHint final {
505 public:
506 AllocationHint() = default;
507
509 void* address) const {
510 return AllocationHint(address, may_grow_);
511 }
512
514 return AllocationHint(address_, true);
515 }
516
517 bool MayGrow() const { return may_grow_; }
518 void* Address() const { return address_; }
519
520 private:
521 constexpr AllocationHint(void* address, bool may_grow)
522 : address_(address), may_grow_(may_grow) {}
523
524 void* address_ = nullptr;
525 bool may_grow_ = false;
526 };
527
531 virtual void* AllocatePages(void* address, size_t length, size_t alignment,
532 Permission permissions) = 0;
533
539 virtual void* AllocatePages(size_t length, size_t alignment,
540 Permission permissions, AllocationHint hint) {
541 return AllocatePages(hint.Address(), length, alignment, permissions);
542 }
543
549 virtual bool ResizeAllocationAt(void* address, size_t old_length,
550 size_t new_length, Permission permissions) {
551 return false;
552 }
553
557 virtual bool FreePages(void* address, size_t length) = 0;
558
562 virtual bool ReleasePages(void* address, size_t length,
563 size_t new_length) = 0;
564
568 virtual bool SetPermissions(void* address, size_t length,
569 Permission permissions) = 0;
570
576 virtual bool RecommitPages(void* address, size_t length,
577 Permission permissions) {
578 // TODO(v8:12797): make it pure once it's implemented on Chromium side.
579 return false;
580 }
581
589 virtual bool DiscardSystemPages(void* address, size_t size) { return true; }
590
599 virtual bool DecommitPages(void* address, size_t size) = 0;
600
609 virtual bool SealPages(void* address, size_t length) {
610 // TODO(360048056): make it pure once it's implemented on Chromium side.
611 return false;
612 }
613
619 public:
620 // Implementations are expected to free the shared memory mapping in the
621 // destructor.
622 virtual ~SharedMemoryMapping() = default;
623 virtual void* GetMemory() const = 0;
624 };
625
631 public:
632 // Implementations are expected to free the shared memory in the destructor.
633 virtual ~SharedMemory() = default;
634 virtual std::unique_ptr<SharedMemoryMapping> RemapTo(
635 void* new_address) const = 0;
636 virtual void* GetMemory() const = 0;
637 virtual size_t GetSize() const = 0;
638 };
639
649 virtual bool ReserveForSharedMemoryMapping(void* address, size_t size) {
650 return false;
651 }
652
662 virtual std::unique_ptr<SharedMemory> AllocateSharedPages(
663 size_t length, const void* original_address) {
664 return {};
665 }
666
675 virtual bool CanAllocateSharedPages() { return false; }
676};
677
687 public:
688 virtual ~ThreadIsolatedAllocator() = default;
689
690 virtual void* Allocate(size_t size) = 0;
691
692 virtual void Free(void* object) = 0;
693
694 enum class Type {
695 kPkey,
696 };
697
698 virtual Type Type() const = 0;
699
703 virtual int Pkey() const { return -1; }
704};
705
706// Opaque type representing a handle to a shared memory region.
708static constexpr PlatformSharedMemoryHandle kInvalidSharedMemoryHandle = -1;
709
710// Conversion routines from the platform-dependent shared memory identifiers
711// into the opaque PlatformSharedMemoryHandle type. These use the underlying
712// types (e.g. unsigned int) instead of the typedef'd ones (e.g. mach_port_t)
713// to avoid pulling in large OS header files into this header file. Instead,
714// the users of these routines are expected to include the respecitve OS
715// headers in addition to this one.
716#if V8_OS_DARWIN
717// Convert between a shared memory handle and a mach_port_t referencing a memory
718// entry object.
719inline PlatformSharedMemoryHandle SharedMemoryHandleFromMachMemoryEntry(
720 unsigned int port) {
721 return static_cast<PlatformSharedMemoryHandle>(port);
722}
723inline unsigned int MachMemoryEntryFromSharedMemoryHandle(
725 return static_cast<unsigned int>(handle);
726}
727#elif V8_OS_FUCHSIA
728// Convert between a shared memory handle and a zx_handle_t to a VMO.
729inline PlatformSharedMemoryHandle SharedMemoryHandleFromVMO(uint32_t handle) {
730 return static_cast<PlatformSharedMemoryHandle>(handle);
731}
732inline uint32_t VMOFromSharedMemoryHandle(PlatformSharedMemoryHandle handle) {
733 return static_cast<uint32_t>(handle);
734}
735#elif V8_OS_WIN
736// Convert between a shared memory handle and a Windows HANDLE to a file mapping
737// object.
738inline PlatformSharedMemoryHandle SharedMemoryHandleFromFileMapping(
739 void* handle) {
740 return reinterpret_cast<PlatformSharedMemoryHandle>(handle);
741}
742inline void* FileMappingFromSharedMemoryHandle(
744 return reinterpret_cast<void*>(handle);
745}
746#else
747// Convert between a shared memory handle and a file descriptor.
749 return static_cast<PlatformSharedMemoryHandle>(fd);
750}
753 return static_cast<int>(handle);
754}
755#endif
756
760enum class PagePermissions {
761 kNoAccess,
762 kRead,
766};
767
779 public:
780 using Address = uintptr_t;
781
783 Address base, size_t size,
785 : page_size_(page_size),
786 allocation_granularity_(allocation_granularity),
787 base_(base),
788 size_(size),
789 max_page_permissions_(max_page_permissions) {}
790
791 virtual ~VirtualAddressSpace() = default;
792
800 size_t page_size() const { return page_size_; }
801
810 size_t allocation_granularity() const { return allocation_granularity_; }
811
817 Address base() const { return base_; }
818
824 size_t size() const { return size_; }
825
832 PagePermissions max_page_permissions() const { return max_page_permissions_; }
833
839 bool Contains(Address address) const {
840 return (address >= base()) && (address < base() + size());
841 }
842
849 virtual void SetRandomSeed(int64_t seed) = 0;
850
858
879 static constexpr Address kNoHint = 0;
881 AllocatePages(Address hint, size_t size, size_t alignment,
882 PagePermissions permissions) = 0;
883
896 virtual void FreePages(Address address, size_t size) = 0;
897
916 Address address, size_t size, PagePermissions permissions) = 0;
917
935 size_t size) = 0;
936
950 virtual void FreeGuardRegion(Address address, size_t size) = 0;
951
973 PlatformSharedMemoryHandle handle, uint64_t offset) = 0;
974
987 virtual void FreeSharedPages(Address address, size_t size) = 0;
988
1001
1010 virtual std::optional<MemoryProtectionKeyId> ActiveMemoryProtectionKey() = 0;
1011
1017 virtual bool CanAllocateSubspaces() = 0;
1018
1019 /*
1020 * Allocate a subspace.
1021 *
1022 * The address space of a subspace stays reserved in the parent space for the
1023 * lifetime of the subspace. As such, it is guaranteed that page allocations
1024 * on the parent space cannot end up inside a subspace.
1025 *
1026 * \param hint Hints where the subspace should be allocated. See
1027 * AllocatePages() for more details.
1028 *
1029 * \param size The size in bytes of the subspace. Must be a multiple of the
1030 * allocation_granularity().
1031 *
1032 * \param alignment The alignment of the subspace in bytes. Must be a multiple
1033 * of the allocation_granularity() and should be a power of two.
1034 *
1035 * \param max_page_permissions The maximum permissions that pages allocated in
1036 * the subspace can obtain.
1037 *
1038 * \param key Optional memory protection key for the subspace. If used, the
1039 * returned subspace will use this key for all its memory pages.
1040 *
1041 * \returns a new subspace or nullptr on failure.
1042 */
1043 virtual std::unique_ptr<VirtualAddressSpace> AllocateSubspace(
1044 Address hint, size_t size, size_t alignment,
1046 std::optional<MemoryProtectionKeyId> key = std::nullopt) = 0;
1047
1048 //
1049 // TODO(v8) maybe refactor the methods below before stabilizing the API. For
1050 // example by combining them into some form of page operation method that
1051 // takes a command enum as parameter.
1052 //
1053
1070 Address address, size_t size, PagePermissions permissions) = 0;
1071
1083 size_t size) {
1084 return true;
1085 }
1097 size_t size) = 0;
1098
1099 private:
1100 const size_t page_size_;
1101 const size_t allocation_granularity_;
1102 const Address base_;
1103 const size_t size_;
1104 const PagePermissions max_page_permissions_;
1105};
1106
1112 public:
1113 virtual void EnterSection() {}
1114 virtual void LeaveSection() {}
1115};
1116
1124 public:
1125 virtual ~Platform() = default;
1126
1131 virtual PageAllocator* GetPageAllocator() { return nullptr; }
1132
1140 return nullptr;
1141 }
1142
1151
1160 virtual int NumberOfWorkerThreads() = 0;
1161
1167 std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(Isolate* isolate) {
1169 }
1170
1176 virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
1177 Isolate* isolate, TaskPriority priority) = 0;
1178
1184 V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
1185 void CallOnWorkerThread(std::unique_ptr<Task> task,
1186 SourceLocation location = SourceLocation::Current()) {
1188 location);
1189 }
1190
1197 V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
1199 std::unique_ptr<Task> task,
1200 SourceLocation location = SourceLocation::Current()) {
1201 // Embedders may optionally override this to process these tasks in a high
1202 // priority pool.
1204 location);
1205 }
1206
1212 V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
1214 std::unique_ptr<Task> task,
1215 SourceLocation location = SourceLocation::Current()) {
1216 // Embedders may optionally override this to process these tasks in a low
1217 // priority pool.
1219 location);
1220 }
1221
1228 V8_DEPRECATE_SOON("Use PostDelayedTaskOnWorkerThread instead.")
1230 std::unique_ptr<Task> task, double delay_in_seconds,
1231 SourceLocation location = SourceLocation::Current()) {
1233 std::move(task), delay_in_seconds,
1234 location);
1235 }
1236
1243 TaskPriority priority, std::unique_ptr<Task> task,
1245 PostTaskOnWorkerThreadImpl(priority, std::move(task), location);
1246 }
1247
1255 TaskPriority priority, std::unique_ptr<Task> task,
1256 double delay_in_seconds,
1258 PostDelayedTaskOnWorkerThreadImpl(priority, std::move(task),
1259 delay_in_seconds, location);
1260 }
1261
1265 virtual bool IdleTasksEnabled(Isolate* isolate) { return false; }
1266
1312 std::unique_ptr<JobHandle> PostJob(
1313 TaskPriority priority, std::unique_ptr<JobTask> job_task,
1315 auto handle = CreateJob(priority, std::move(job_task), location);
1316 handle->NotifyConcurrencyIncrease();
1317 return handle;
1318 }
1319
1335 std::unique_ptr<JobHandle> CreateJob(
1336 TaskPriority priority, std::unique_ptr<JobTask> job_task,
1338 return CreateJobImpl(priority, std::move(job_task), location);
1339 }
1340
1344 virtual std::unique_ptr<ScopedBlockingCall> CreateBlockingScope(
1345 BlockingType blocking_type) {
1346 return nullptr;
1347 }
1348
1356 virtual double MonotonicallyIncreasingTime() = 0;
1357
1364 return static_cast<int64_t>(floor(CurrentClockTimeMillis()));
1365 }
1366
1372 virtual double CurrentClockTimeMillis() = 0;
1373
1378 return CurrentClockTimeMillis();
1379 }
1380
1381 typedef void (*StackTracePrinter)();
1382
1387 virtual StackTracePrinter GetStackTracePrinter() { return nullptr; }
1388
1393
1398 virtual void DumpWithoutCrashing() {}
1399
1406 static HighAllocationThroughputObserver default_observer;
1407 return &default_observer;
1408 }
1409
1410 protected:
1417
1421 virtual std::unique_ptr<JobHandle> CreateJobImpl(
1422 TaskPriority priority, std::unique_ptr<JobTask> job_task,
1423 const SourceLocation& location) = 0;
1424
1429 std::unique_ptr<Task> task,
1430 const SourceLocation& location) = 0;
1431
1437 TaskPriority priority, std::unique_ptr<Task> task,
1438 double delay_in_seconds, const SourceLocation& location) = 0;
1439};
1440
1441} // namespace v8
1442
1443#endif // V8_V8_PLATFORM_H_
Definition: v8-platform.h:354
virtual ~ConvertableToTraceFormat()=default
virtual void AppendAsTraceFormat(std::string *out) const =0
Definition: v8-platform.h:1111
virtual void EnterSection()
Definition: v8-platform.h:1113
virtual void LeaveSection()
Definition: v8-platform.h:1114
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:205
virtual void NotifyConcurrencyIncrease()=0
virtual bool ShouldYield()=0
virtual bool IsJoiningThread() const =0
virtual uint8_t GetTaskId()=0
Definition: v8-platform.h:240
virtual void NotifyConcurrencyIncrease()=0
virtual void CancelAndDetach()=0
virtual bool IsActive()=0
virtual bool UpdatePriorityEnabled() const
Definition: v8-platform.h:288
virtual bool IsValid()=0
virtual void UpdatePriority(TaskPriority new_priority)
Definition: v8-platform.h:293
virtual void Cancel()=0
virtual ~JobHandle()=default
virtual void Join()=0
Definition: v8-platform.h:299
virtual void Run(JobDelegate *delegate)=0
virtual size_t GetMaxConcurrency(size_t worker_count) const =0
virtual ~JobTask()=default
Definition: v8-platform.h:504
bool MayGrow() const
Definition: v8-platform.h:517
void * Address() const
Definition: v8-platform.h:518
constexpr AllocationHint WithAddress(void *address) const
Definition: v8-platform.h:508
constexpr AllocationHint WithMayGrow() const
Definition: v8-platform.h:513
Definition: v8-platform.h:618
virtual void * GetMemory() const =0
Definition: v8-platform.h:630
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:454
virtual void * GetRandomMmapAddr()=0
virtual bool ResizeAllocationAt(void *address, size_t old_length, size_t new_length, Permission permissions)
Definition: v8-platform.h:549
virtual ~PageAllocator()=default
virtual void * AllocatePages(size_t length, size_t alignment, Permission permissions, AllocationHint hint)
Definition: v8-platform.h:539
virtual bool ReleasePages(void *address, size_t length, size_t new_length)=0
Permission
Definition: v8-platform.h:485
@ kReadExecute
Definition: v8-platform.h:490
@ kRead
Definition: v8-platform.h:487
@ kNoAccess
Definition: v8-platform.h:486
@ kNoAccessWillJitLater
Definition: v8-platform.h:498
@ kReadWrite
Definition: v8-platform.h:488
@ kReadWriteExecute
Definition: v8-platform.h:489
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:675
virtual bool RecommitPages(void *address, size_t length, Permission permissions)
Definition: v8-platform.h:576
virtual bool SetPermissions(void *address, size_t length, Permission permissions)=0
virtual bool SealPages(void *address, size_t length)
Definition: v8-platform.h:609
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:662
virtual bool DiscardSystemPages(void *address, size_t size)
Definition: v8-platform.h:589
virtual size_t CommitPageSize()=0
virtual bool ReserveForSharedMemoryMapping(void *address, size_t size)
Definition: v8-platform.h:649
Definition: v8-platform.h:1123
virtual std::unique_ptr< ScopedBlockingCall > CreateBlockingScope(BlockingType blocking_type)
Definition: v8-platform.h:1344
void PostTaskOnWorkerThread(TaskPriority priority, std::unique_ptr< Task > task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1242
void CallLowPriorityTaskOnWorkerThread(std::unique_ptr< Task > task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1213
std::unique_ptr< JobHandle > CreateJob(TaskPriority priority, std::unique_ptr< JobTask > job_task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1335
static double SystemClockTimeMillis()
void PostDelayedTaskOnWorkerThread(TaskPriority priority, std::unique_ptr< Task > task, double delay_in_seconds, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1254
virtual void PostDelayedTaskOnWorkerThreadImpl(TaskPriority priority, std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)=0
virtual std::shared_ptr< v8::TaskRunner > GetForegroundTaskRunner(Isolate *isolate, TaskPriority priority)=0
void CallDelayedOnWorkerThread(std::unique_ptr< Task > task, double delay_in_seconds, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1229
virtual TracingController * GetTracingController()=0
virtual PageAllocator * GetPageAllocator()
Definition: v8-platform.h:1131
virtual int NumberOfWorkerThreads()=0
virtual double MonotonicallyIncreasingTime()=0
virtual HighAllocationThroughputObserver * GetHighAllocationThroughputObserver()
Definition: v8-platform.h:1405
virtual void OnCriticalMemoryPressure()
Definition: v8-platform.h:1150
void CallBlockingTaskOnWorkerThread(std::unique_ptr< Task > task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1198
virtual int64_t CurrentClockTimeMilliseconds()
Definition: v8-platform.h:1363
virtual double CurrentClockTimeMillis()=0
virtual StackTracePrinter GetStackTracePrinter()
Definition: v8-platform.h:1387
void(* StackTracePrinter)()
Definition: v8-platform.h:1381
virtual ~Platform()=default
virtual double CurrentClockTimeMillisecondsHighResolution()
Definition: v8-platform.h:1377
virtual void DumpWithoutCrashing()
Definition: v8-platform.h:1398
virtual void PostTaskOnWorkerThreadImpl(TaskPriority priority, std::unique_ptr< Task > task, const SourceLocation &location)=0
void CallOnWorkerThread(std::unique_ptr< Task > task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1185
virtual bool IdleTasksEnabled(Isolate *isolate)
Definition: v8-platform.h:1265
std::shared_ptr< v8::TaskRunner > GetForegroundTaskRunner(Isolate *isolate)
Definition: v8-platform.h:1167
virtual std::unique_ptr< JobHandle > CreateJobImpl(TaskPriority priority, std::unique_ptr< JobTask > job_task, const SourceLocation &location)=0
std::unique_ptr< JobHandle > PostJob(TaskPriority priority, std::unique_ptr< JobTask > job_task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:1312
virtual ThreadIsolatedAllocator * GetThreadIsolatedAllocator()
Definition: v8-platform.h:1139
Definition: v8-platform.h:346
virtual ~ScopedBlockingCall()=default
Definition: v8-source-location.h:22
static constexpr SourceLocation Current(const std::source_location &loc=std::source_location::current())
Definition: v8-source-location.h:28
Definition: v8-platform.h:75
void PostNonNestableDelayedTask(std::unique_ptr< Task > task, double delay_in_seconds, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:141
TaskRunner & operator=(const TaskRunner &)=delete
virtual void PostIdleTaskImpl(std::unique_ptr< IdleTask > task, const SourceLocation &location)
Definition: v8-platform.h:197
TaskRunner(const TaskRunner &)=delete
virtual void PostNonNestableTaskImpl(std::unique_ptr< Task > task, const SourceLocation &location)
Definition: v8-platform.h:189
virtual void PostTaskImpl(std::unique_ptr< Task > task, const SourceLocation &location)
Definition: v8-platform.h:187
virtual void PostDelayedTaskImpl(std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)
Definition: v8-platform.h:191
virtual bool NonNestableDelayedTasksEnabled() const
Definition: v8-platform.h:175
TaskRunner()=default
void PostIdleTask(std::unique_ptr< IdleTask > task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:157
virtual bool NonNestableTasksEnabled() const
Definition: v8-platform.h:170
void PostTask(std::unique_ptr< Task > task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:83
virtual ~TaskRunner()=default
virtual void PostNonNestableDelayedTaskImpl(std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)
Definition: v8-platform.h:194
virtual bool IdleTasksEnabled()=0
void PostNonNestableTask(std::unique_ptr< Task > task, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:105
void PostDelayedTask(std::unique_ptr< Task > task, double delay_in_seconds, SourceLocation location=SourceLocation::Current())
Definition: v8-platform.h:118
Definition: v8-platform.h:50
virtual void Run()=0
virtual ~Task()=default
Definition: v8-platform.h:686
virtual int Pkey() const
Definition: v8-platform.h:703
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:694
Definition: v8-platform.h:429
Definition: v8-platform.h:374
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:411
virtual const uint8_t * GetCategoryGroupEnabled(const char *name)
Definition: v8-platform.h:389
virtual ~TracingController()=default
virtual void AddTraceStateObserver(TraceStateObserver *)
Definition: v8-platform.h:440
virtual void RemoveTraceStateObserver(TraceStateObserver *)
Definition: v8-platform.h:446
virtual void UpdateTraceEventDuration(const uint8_t *category_enabled_flag, const char *name, uint64_t handle)
Definition: v8-platform.h:425
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:402
Definition: v8-platform.h:778
virtual bool CanAllocateSubspaces()=0
Address base() const
Definition: v8-platform.h:817
virtual void FreePages(Address address, size_t size)=0
virtual void SetRandomSeed(int64_t seed)=0
static constexpr Address kNoHint
Definition: v8-platform.h:879
bool Contains(Address address) const
Definition: v8-platform.h:839
uintptr_t Address
Definition: v8-platform.h:780
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:1082
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:782
int MemoryProtectionKeyId
Definition: v8-platform.h:1000
size_t size() const
Definition: v8-platform.h:824
virtual bool AllocateGuardRegion(Address address, size_t size)=0
PagePermissions max_page_permissions() const
Definition: v8-platform.h:832
virtual std::optional< MemoryProtectionKeyId > ActiveMemoryProtectionKey()=0
size_t allocation_granularity() const
Definition: v8-platform.h:810
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:800
Definition: libplatform.h:15
TaskPriority
Definition: v8-platform.h:25
int FileDescriptorFromSharedMemoryHandle(PlatformSharedMemoryHandle handle)
Definition: v8-platform.h:751
PlatformSharedMemoryHandle SharedMemoryHandleFromFileDescriptor(int fd)
Definition: v8-platform.h:748
BlockingType
Definition: v8-platform.h:331
intptr_t PlatformSharedMemoryHandle
Definition: v8-platform.h:707
PagePermissions
Definition: v8-platform.h:760
#define V8_EXPORT
Definition: v8config.h:860
#define V8_DEPRECATE_SOON(message)
Definition: v8config.h:627
#define V8_WARN_UNUSED_RESULT
Definition: v8config.h:684