v8-platform.h

Go to the documentation of this file.

// Copyright 2013 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef V8_V8_PLATFORM_H_
#define V8_V8_PLATFORM_H_
 
#include <math.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>  // For abort.
 
#include <memory>
#include <string>
 
#include "v8-source-location.h"  // NOLINT(build/include_directory)
#include "v8config.h"            // NOLINT(build/include_directory)
 
namespace v8 {
 
class Isolate;
 
// Valid priorities supported by the task scheduling infrastructure.
enum class TaskPriority : uint8_t {
  kBestEffort,
  kUserVisible,
  kUserBlocking,
  kMaxPriority = kUserBlocking
};
 
class Task {
 public:
  virtual ~Task() = default;
 
  virtual void Run() = 0;
};
 
class IdleTask {
 public:
  virtual ~IdleTask() = default;
  virtual void Run(double deadline_in_seconds) = 0;
};
 
class TaskRunner {
 public:
  void PostTask(std::unique_ptr<Task> task,
                const SourceLocation& location = SourceLocation::Current()) {
    PostTaskImpl(std::move(task), location);
  }
 
  void PostNonNestableTask(
      std::unique_ptr<Task> task,
      const SourceLocation& location = SourceLocation::Current()) {
    PostNonNestableTaskImpl(std::move(task), location);
  }
 
  void PostDelayedTask(
      std::unique_ptr<Task> task, double delay_in_seconds,
      const SourceLocation& location = SourceLocation::Current()) {
    PostDelayedTaskImpl(std::move(task), delay_in_seconds, location);
  }
 
  void PostNonNestableDelayedTask(
      std::unique_ptr<Task> task, double delay_in_seconds,
      const SourceLocation& location = SourceLocation::Current()) {
    PostNonNestableDelayedTaskImpl(std::move(task), delay_in_seconds, location);
  }
 
  void PostIdleTask(
      std::unique_ptr<IdleTask> task,
      const SourceLocation& location = SourceLocation::Current()) {
    PostIdleTaskImpl(std::move(task), location);
  }
 
  virtual bool IdleTasksEnabled() = 0;
 
  virtual bool NonNestableTasksEnabled() const { return false; }
 
  virtual bool NonNestableDelayedTasksEnabled() const { return false; }
 
  TaskRunner() = default;
  virtual ~TaskRunner() = default;
 
  TaskRunner(const TaskRunner&) = delete;
  TaskRunner& operator=(const TaskRunner&) = delete;
 
 protected:
  virtual void PostTaskImpl(std::unique_ptr<Task> task,
                            const SourceLocation& location) {}
  virtual void PostNonNestableTaskImpl(std::unique_ptr<Task> task,
                                       const SourceLocation& location) {}
  virtual void PostDelayedTaskImpl(std::unique_ptr<Task> task,
                                   double delay_in_seconds,
                                   const SourceLocation& location) {}
  virtual void PostNonNestableDelayedTaskImpl(std::unique_ptr<Task> task,
                                              double delay_in_seconds,
                                              const SourceLocation& location) {}
  virtual void PostIdleTaskImpl(std::unique_ptr<IdleTask> task,
                                const SourceLocation& location) {}
};
 
class JobDelegate {
 public:
  virtual bool ShouldYield() = 0;
 
  virtual void NotifyConcurrencyIncrease() = 0;
 
  virtual uint8_t GetTaskId() = 0;
 
  virtual bool IsJoiningThread() const = 0;
};
 
class JobHandle {
 public:
  virtual ~JobHandle() = default;
 
  virtual void NotifyConcurrencyIncrease() = 0;
 
  virtual void Join() = 0;
 
  virtual void Cancel() = 0;
 
  /*
   * Forces all existing workers to yield ASAP but doesn’t wait for them.
   * Warning, this is dangerous if the Job's callback is bound to or has access
   * to state which may be deleted after this call.
   */
  virtual void CancelAndDetach() = 0;
 
  virtual bool IsActive() = 0;
 
  virtual bool IsValid() = 0;
 
  virtual bool UpdatePriorityEnabled() const { return false; }
 
  virtual void UpdatePriority(TaskPriority new_priority) {}
};
 
class JobTask {
 public:
  virtual ~JobTask() = default;
 
  virtual void Run(JobDelegate* delegate) = 0;
 
  virtual size_t GetMaxConcurrency(size_t worker_count) const = 0;
};
 
enum class BlockingType {
  // The call might block (e.g. file I/O that might hit in memory cache).
  kMayBlock,
  // The call will definitely block (e.g. cache already checked and now pinging
  // server synchronously).
  kWillBlock
};
 
class ScopedBlockingCall {
 public:
  virtual ~ScopedBlockingCall() = default;
};
 
class ConvertableToTraceFormat {
 public:
  virtual ~ConvertableToTraceFormat() = default;
 
  virtual void AppendAsTraceFormat(std::string* out) const = 0;
};
 
class TracingController {
 public:
  virtual ~TracingController() = default;
 
  // In Perfetto mode, trace events are written using Perfetto's Track Event
  // API directly without going through the embedder. However, it is still
  // possible to observe tracing being enabled and disabled.
#if !defined(V8_USE_PERFETTO)
  virtual const uint8_t* GetCategoryGroupEnabled(const char* name) {
    static uint8_t no = 0;
    return &no;
  }
 
  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) {
    return 0;
  }
  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) {
    return 0;
  }
 
  virtual void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
                                        const char* name, uint64_t handle) {}
#endif  // !defined(V8_USE_PERFETTO)
 
  class TraceStateObserver {
   public:
    virtual ~TraceStateObserver() = default;
    virtual void OnTraceEnabled() = 0;
    virtual void OnTraceDisabled() = 0;
  };
 
  virtual void AddTraceStateObserver(TraceStateObserver*) {}
 
  virtual void RemoveTraceStateObserver(TraceStateObserver*) {}
};
 
class PageAllocator {
 public:
  virtual ~PageAllocator() = default;
 
  virtual size_t AllocatePageSize() = 0;
 
  virtual size_t CommitPageSize() = 0;
 
  virtual void SetRandomMmapSeed(int64_t seed) = 0;
 
  virtual void* GetRandomMmapAddr() = 0;
 
  enum Permission {
    kNoAccess,
    kRead,
    kReadWrite,
    kReadWriteExecute,
    kReadExecute,
    // Set this when reserving memory that will later require kReadWriteExecute
    // permissions. The resulting behavior is platform-specific, currently
    // this is used to set the MAP_JIT flag on Apple Silicon.
    // TODO(jkummerow): Remove this when Wasm has a platform-independent
    // w^x implementation.
    // TODO(saelo): Remove this once all JIT pages are allocated through the
    // VirtualAddressSpace API.
    kNoAccessWillJitLater
  };
 
  class AllocationHint final {
   public:
    AllocationHint() = default;
 
    V8_WARN_UNUSED_RESULT constexpr AllocationHint WithAddress(
        void* address) const {
      return AllocationHint(address, may_grow_);
    }
 
    V8_WARN_UNUSED_RESULT constexpr AllocationHint WithMayGrow() const {
      return AllocationHint(address_, true);
    }
 
    bool MayGrow() const { return may_grow_; }
    void* Address() const { return address_; }
 
   private:
    constexpr AllocationHint(void* address, bool may_grow)
        : address_(address), may_grow_(may_grow) {}
 
    void* address_ = nullptr;
    bool may_grow_ = false;
  };
 
  virtual void* AllocatePages(void* address, size_t length, size_t alignment,
                              Permission permissions) = 0;
 
  virtual void* AllocatePages(size_t length, size_t alignment,
                              Permission permissions, AllocationHint hint) {
    return AllocatePages(hint.Address(), length, alignment, permissions);
  }
 
  virtual bool ResizeAllocationAt(void* address, size_t old_length,
                                  size_t new_length, Permission permissions) {
    return false;
  }
 
  virtual bool FreePages(void* address, size_t length) = 0;
 
  virtual bool ReleasePages(void* address, size_t length,
                            size_t new_length) = 0;
 
  virtual bool SetPermissions(void* address, size_t length,
                              Permission permissions) = 0;
 
  virtual bool RecommitPages(void* address, size_t length,
                             Permission permissions) {
    // TODO(v8:12797): make it pure once it's implemented on Chromium side.
    return false;
  }
 
  virtual bool DiscardSystemPages(void* address, size_t size) { return true; }
 
  virtual bool DecommitPages(void* address, size_t size) = 0;
 
  virtual bool SealPages(void* address, size_t length) {
    // TODO(360048056): make it pure once it's implemented on Chromium side.
    return false;
  }
 
  class SharedMemoryMapping {
   public:
    // Implementations are expected to free the shared memory mapping in the
    // destructor.
    virtual ~SharedMemoryMapping() = default;
    virtual void* GetMemory() const = 0;
  };
 
  class SharedMemory {
   public:
    // Implementations are expected to free the shared memory in the destructor.
    virtual ~SharedMemory() = default;
    virtual std::unique_ptr<SharedMemoryMapping> RemapTo(
        void* new_address) const = 0;
    virtual void* GetMemory() const = 0;
    virtual size_t GetSize() const = 0;
  };
 
  virtual bool ReserveForSharedMemoryMapping(void* address, size_t size) {
    return false;
  }
 
  virtual std::unique_ptr<SharedMemory> AllocateSharedPages(
      size_t length, const void* original_address) {
    return {};
  }
 
  virtual bool CanAllocateSharedPages() { return false; }
};
 
class ThreadIsolatedAllocator {
 public:
  virtual ~ThreadIsolatedAllocator() = default;
 
  virtual void* Allocate(size_t size) = 0;
 
  virtual void Free(void* object) = 0;
 
  enum class Type {
    kPkey,
  };
 
  virtual Type Type() const = 0;
 
  virtual int Pkey() const { return -1; }
};
 
// Opaque type representing a handle to a shared memory region.
using PlatformSharedMemoryHandle = intptr_t;
static constexpr PlatformSharedMemoryHandle kInvalidSharedMemoryHandle = -1;
 
// Conversion routines from the platform-dependent shared memory identifiers
// into the opaque PlatformSharedMemoryHandle type. These use the underlying
// types (e.g. unsigned int) instead of the typedef'd ones (e.g. mach_port_t)
// to avoid pulling in large OS header files into this header file. Instead,
// the users of these routines are expected to include the respecitve OS
// headers in addition to this one.
#if V8_OS_DARWIN
// Convert between a shared memory handle and a mach_port_t referencing a memory
// entry object.
inline PlatformSharedMemoryHandle SharedMemoryHandleFromMachMemoryEntry(
    unsigned int port) {
  return static_cast<PlatformSharedMemoryHandle>(port);
}
inline unsigned int MachMemoryEntryFromSharedMemoryHandle(
    PlatformSharedMemoryHandle handle) {
  return static_cast<unsigned int>(handle);
}
#elif V8_OS_FUCHSIA
// Convert between a shared memory handle and a zx_handle_t to a VMO.
inline PlatformSharedMemoryHandle SharedMemoryHandleFromVMO(uint32_t handle) {
  return static_cast<PlatformSharedMemoryHandle>(handle);
}
inline uint32_t VMOFromSharedMemoryHandle(PlatformSharedMemoryHandle handle) {
  return static_cast<uint32_t>(handle);
}
#elif V8_OS_WIN
// Convert between a shared memory handle and a Windows HANDLE to a file mapping
// object.
inline PlatformSharedMemoryHandle SharedMemoryHandleFromFileMapping(
    void* handle) {
  return reinterpret_cast<PlatformSharedMemoryHandle>(handle);
}
inline void* FileMappingFromSharedMemoryHandle(
    PlatformSharedMemoryHandle handle) {
  return reinterpret_cast<void*>(handle);
}
#else
// Convert between a shared memory handle and a file descriptor.
inline PlatformSharedMemoryHandle SharedMemoryHandleFromFileDescriptor(int fd) {
  return static_cast<PlatformSharedMemoryHandle>(fd);
}
inline int FileDescriptorFromSharedMemoryHandle(
    PlatformSharedMemoryHandle handle) {
  return static_cast<int>(handle);
}
#endif
 
enum class PagePermissions {
  kNoAccess,
  kRead,
  kReadWrite,
  kReadWriteExecute,
  kReadExecute,
};
 
class VirtualAddressSpace {
 public:
  using Address = uintptr_t;
 
  VirtualAddressSpace(size_t page_size, size_t allocation_granularity,
                      Address base, size_t size,
                      PagePermissions max_page_permissions)
      : page_size_(page_size),
        allocation_granularity_(allocation_granularity),
        base_(base),
        size_(size),
        max_page_permissions_(max_page_permissions) {}
 
  virtual ~VirtualAddressSpace() = default;
 
  size_t page_size() const { return page_size_; }
 
  size_t allocation_granularity() const { return allocation_granularity_; }
 
  Address base() const { return base_; }
 
  size_t size() const { return size_; }
 
  PagePermissions max_page_permissions() const { return max_page_permissions_; }
 
  bool Contains(Address address) const {
    return (address >= base()) && (address < base() + size());
  }
 
  virtual void SetRandomSeed(int64_t seed) = 0;
 
  virtual Address RandomPageAddress() = 0;
 
  static constexpr Address kNoHint = 0;
  virtual V8_WARN_UNUSED_RESULT Address
  AllocatePages(Address hint, size_t size, size_t alignment,
                PagePermissions permissions) = 0;
 
  virtual void FreePages(Address address, size_t size) = 0;
 
  virtual V8_WARN_UNUSED_RESULT bool SetPagePermissions(
      Address address, size_t size, PagePermissions permissions) = 0;
 
  virtual V8_WARN_UNUSED_RESULT bool AllocateGuardRegion(Address address,
                                                         size_t size) = 0;
 
  virtual void FreeGuardRegion(Address address, size_t size) = 0;
 
  virtual V8_WARN_UNUSED_RESULT Address
  AllocateSharedPages(Address hint, size_t size, PagePermissions permissions,
                      PlatformSharedMemoryHandle handle, uint64_t offset) = 0;
 
  virtual void FreeSharedPages(Address address, size_t size) = 0;
 
  virtual bool CanAllocateSubspaces() = 0;
 
  /*
   * Allocate a subspace.
   *
   * The address space of a subspace stays reserved in the parent space for the
   * lifetime of the subspace. As such, it is guaranteed that page allocations
   * on the parent space cannot end up inside a subspace.
   *
   * \param hint Hints where the subspace should be allocated. See
   * AllocatePages() for more details.
   *
   * \param size The size in bytes of the subspace. Must be a multiple of the
   * allocation_granularity().
   *
   * \param alignment The alignment of the subspace in bytes. Must be a multiple
   * of the allocation_granularity() and should be a power of two.
   *
   * \param max_page_permissions The maximum permissions that pages allocated in
   * the subspace can obtain.
   *
   * \returns a new subspace or nullptr on failure.
   */
  virtual std::unique_ptr<VirtualAddressSpace> AllocateSubspace(
      Address hint, size_t size, size_t alignment,
      PagePermissions max_page_permissions) = 0;
 
  //
  // TODO(v8) maybe refactor the methods below before stabilizing the API. For
  // example by combining them into some form of page operation method that
  // takes a command enum as parameter.
  //
 
  virtual V8_WARN_UNUSED_RESULT bool RecommitPages(
      Address address, size_t size, PagePermissions permissions) = 0;
 
  virtual V8_WARN_UNUSED_RESULT bool DiscardSystemPages(Address address,
                                                        size_t size) {
    return true;
  }
  virtual V8_WARN_UNUSED_RESULT bool DecommitPages(Address address,
                                                   size_t size) = 0;
 
 private:
  const size_t page_size_;
  const size_t allocation_granularity_;
  const Address base_;
  const size_t size_;
  const PagePermissions max_page_permissions_;
};
 
class HighAllocationThroughputObserver {
 public:
  virtual void EnterSection() {}
  virtual void LeaveSection() {}
};
 
class Platform {
 public:
  virtual ~Platform() = default;
 
  virtual PageAllocator* GetPageAllocator() { return nullptr; }
 
  virtual ThreadIsolatedAllocator* GetThreadIsolatedAllocator() {
    return nullptr;
  }
 
  virtual void OnCriticalMemoryPressure() {}
 
  virtual int NumberOfWorkerThreads() = 0;
 
  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(Isolate* isolate) {
    return GetForegroundTaskRunner(isolate, TaskPriority::kUserBlocking);
  }
 
  virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
      Isolate* isolate, TaskPriority priority) = 0;
 
  V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
  void CallOnWorkerThread(
      std::unique_ptr<Task> task,
      const SourceLocation& location = SourceLocation::Current()) {
    PostTaskOnWorkerThreadImpl(TaskPriority::kUserVisible, std::move(task),
                               location);
  }
 
  V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
  void CallBlockingTaskOnWorkerThread(
      std::unique_ptr<Task> task,
      const SourceLocation& location = SourceLocation::Current()) {
    // Embedders may optionally override this to process these tasks in a high
    // priority pool.
    PostTaskOnWorkerThreadImpl(TaskPriority::kUserBlocking, std::move(task),
                               location);
  }
 
  V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
  void CallLowPriorityTaskOnWorkerThread(
      std::unique_ptr<Task> task,
      const SourceLocation& location = SourceLocation::Current()) {
    // Embedders may optionally override this to process these tasks in a low
    // priority pool.
    PostTaskOnWorkerThreadImpl(TaskPriority::kBestEffort, std::move(task),
                               location);
  }
 
  V8_DEPRECATE_SOON("Use PostDelayedTaskOnWorkerThread instead.")
  void CallDelayedOnWorkerThread(
      std::unique_ptr<Task> task, double delay_in_seconds,
      const SourceLocation& location = SourceLocation::Current()) {
    PostDelayedTaskOnWorkerThreadImpl(TaskPriority::kUserVisible,
                                      std::move(task), delay_in_seconds,
                                      location);
  }
 
  void PostTaskOnWorkerThread(
      TaskPriority priority, std::unique_ptr<Task> task,
      const SourceLocation& location = SourceLocation::Current()) {
    PostTaskOnWorkerThreadImpl(priority, std::move(task), location);
  }
 
  void PostDelayedTaskOnWorkerThread(
      TaskPriority priority, std::unique_ptr<Task> task,
      double delay_in_seconds,
      const SourceLocation& location = SourceLocation::Current()) {
    PostDelayedTaskOnWorkerThreadImpl(priority, std::move(task),
                                      delay_in_seconds, location);
  }
 
  virtual bool IdleTasksEnabled(Isolate* isolate) { return false; }
 
  std::unique_ptr<JobHandle> PostJob(
      TaskPriority priority, std::unique_ptr<JobTask> job_task,
      const SourceLocation& location = SourceLocation::Current()) {
    auto handle = CreateJob(priority, std::move(job_task), location);
    handle->NotifyConcurrencyIncrease();
    return handle;
  }
 
  std::unique_ptr<JobHandle> CreateJob(
      TaskPriority priority, std::unique_ptr<JobTask> job_task,
      const SourceLocation& location = SourceLocation::Current()) {
    return CreateJobImpl(priority, std::move(job_task), location);
  }
 
  virtual std::unique_ptr<ScopedBlockingCall> CreateBlockingScope(
      BlockingType blocking_type) {
    return nullptr;
  }
 
  virtual double MonotonicallyIncreasingTime() = 0;
 
  virtual int64_t CurrentClockTimeMilliseconds() {
    return static_cast<int64_t>(floor(CurrentClockTimeMillis()));
  }
 
  virtual double CurrentClockTimeMillis() = 0;
 
  virtual double CurrentClockTimeMillisecondsHighResolution() {
    return CurrentClockTimeMillis();
  }
 
  typedef void (*StackTracePrinter)();
 
  virtual StackTracePrinter GetStackTracePrinter() { return nullptr; }
 
  virtual TracingController* GetTracingController() = 0;
 
  virtual void DumpWithoutCrashing() {}
 
  virtual HighAllocationThroughputObserver*
  GetHighAllocationThroughputObserver() {
    static HighAllocationThroughputObserver default_observer;
    return &default_observer;
  }
 
 protected:
  V8_EXPORT static double SystemClockTimeMillis();
 
  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;
};
 
}  // namespace v8
 
#endif  // V8_V8_PLATFORM_H_