v8-cppgc.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_V8_CPPGC_H_
#define INCLUDE_V8_CPPGC_H_
 
#include <cstdint>
#include <memory>
#include <vector>
 
#include "cppgc/common.h"
#include "cppgc/custom-space.h"
#include "cppgc/heap-statistics.h"
#include "cppgc/visitor.h"
#include "v8-internal.h"       // NOLINT(build/include_directory)
#include "v8-platform.h"       // NOLINT(build/include_directory)
#include "v8-traced-handle.h"  // NOLINT(build/include_directory)
 
namespace cppgc {
class AllocationHandle;
class HeapHandle;
}  // namespace cppgc
 
namespace v8 {
 
class Object;
 
namespace internal {
class CppHeap;
}  // namespace internal
 
class CustomSpaceStatisticsReceiver;
 
struct WrapperDescriptor final {
  using InternalFieldIndex = int;
 
  static constexpr uint16_t kUnknownEmbedderId = UINT16_MAX;
 
  constexpr WrapperDescriptor(InternalFieldIndex wrappable_type_index,
                              InternalFieldIndex wrappable_instance_index,
                              uint16_t embedder_id_for_garbage_collected)
      : wrappable_type_index(wrappable_type_index),
        wrappable_instance_index(wrappable_instance_index),
        embedder_id_for_garbage_collected(embedder_id_for_garbage_collected) {}
 
  InternalFieldIndex wrappable_type_index;
 
  InternalFieldIndex wrappable_instance_index;
 
  uint16_t embedder_id_for_garbage_collected;
};
 
struct V8_EXPORT CppHeapCreateParams {
  std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
  WrapperDescriptor wrapper_descriptor;
};
 
class V8_EXPORT CppHeap {
 public:
  static std::unique_ptr<CppHeap> Create(v8::Platform* platform,
                                         const CppHeapCreateParams& params);
 
  virtual ~CppHeap() = default;
 
  cppgc::AllocationHandle& GetAllocationHandle();
 
  cppgc::HeapHandle& GetHeapHandle();
 
  void Terminate();
 
  cppgc::HeapStatistics CollectStatistics(
      cppgc::HeapStatistics::DetailLevel detail_level);
 
  void CollectCustomSpaceStatisticsAtLastGC(
      std::vector<cppgc::CustomSpaceIndex> custom_spaces,
      std::unique_ptr<CustomSpaceStatisticsReceiver> receiver);
 
  void EnableDetachedGarbageCollectionsForTesting();
 
  void CollectGarbageForTesting(cppgc::EmbedderStackState stack_state);
 
  void CollectGarbageInYoungGenerationForTesting(
      cppgc::EmbedderStackState stack_state);
 
 private:
  CppHeap() = default;
 
  friend class internal::CppHeap;
};
 
class JSVisitor : public cppgc::Visitor {
 public:
  explicit JSVisitor(cppgc::Visitor::Key key) : cppgc::Visitor(key) {}
  ~JSVisitor() override = default;
 
  void Trace(const TracedReferenceBase& ref) {
    if (ref.IsEmptyThreadSafe()) return;
    Visit(ref);
  }
 
 protected:
  using cppgc::Visitor::Visit;
 
  virtual void Visit(const TracedReferenceBase& ref) {}
};
 
class CustomSpaceStatisticsReceiver {
 public:
  virtual ~CustomSpaceStatisticsReceiver() = default;
  virtual void AllocatedBytes(cppgc::CustomSpaceIndex space_index,
                              size_t bytes) = 0;
};
 
}  // namespace v8
 
namespace cppgc {
 
template <typename T>
struct TraceTrait<v8::TracedReference<T>> {
  static cppgc::TraceDescriptor GetTraceDescriptor(const void* self) {
    return {nullptr, Trace};
  }
 
  static void Trace(Visitor* visitor, const void* self) {
    static_cast<v8::JSVisitor*>(visitor)->Trace(
        *static_cast<const v8::TracedReference<T>*>(self));
  }
};
 
}  // namespace cppgc
 
#endif  // INCLUDE_V8_CPPGC_H_