platform.h

Go to the documentation of this file.

// Copyright 2020 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 INCLUDE_CPPGC_PLATFORM_H_
#define INCLUDE_CPPGC_PLATFORM_H_
 
#include <memory>
 
#include "cppgc/source-location.h"
#include "v8-platform.h"  // NOLINT(build/include_directory)
#include "v8config.h"     // NOLINT(build/include_directory)
 
namespace cppgc {
 
// TODO(v8:10346): Create separate includes for concepts that are not
// V8-specific.
using IdleTask = v8::IdleTask;
using JobHandle = v8::JobHandle;
using JobDelegate = v8::JobDelegate;
using JobTask = v8::JobTask;
using PageAllocator = v8::PageAllocator;
using Task = v8::Task;
using TaskPriority = v8::TaskPriority;
using TaskRunner = v8::TaskRunner;
using TracingController = v8::TracingController;
 
class V8_EXPORT AllocationSampler {
 public:
  virtual ~AllocationSampler() = default;
 
  virtual size_t GetSampleInterval() const { return 0; }
 
  virtual bool OnAllocated(void* address, size_t size) = 0;
 
  virtual void OnFreed(void* address) = 0;
 
  virtual bool OnMove(void* from, void* to, size_t size) = 0;
};
 
class V8_EXPORT Platform {
 public:
  virtual ~Platform() = default;
 
  virtual PageAllocator* GetPageAllocator() = 0;
 
  virtual double MonotonicallyIncreasingTime() = 0;
 
  virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner() {
    return GetForegroundTaskRunner(TaskPriority::kUserBlocking);
  }
 
  virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner(
      TaskPriority priority) {
    return nullptr;
  }
 
  virtual std::unique_ptr<JobHandle> PostJob(
      TaskPriority priority, std::unique_ptr<JobTask> job_task) {
    return nullptr;
  }
 
  virtual TracingController* GetTracingController();
};
 
V8_EXPORT bool IsInitialized();
 
V8_EXPORT void InitializeProcess(PageAllocator* page_allocator = nullptr,
                                 size_t desired_heap_size = 0);
 
V8_EXPORT void ShutdownProcess();
 
namespace internal {
 
V8_EXPORT void Fatal(const std::string& reason = std::string(),
                     SourceLocation = SourceLocation::Current());
 
}  // namespace internal
 
}  // namespace cppgc
 
#endif  // INCLUDE_CPPGC_PLATFORM_H_