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
namespace internal {…}
 
class CustomSpaceStatisticsReceiver;
 
struct V8_EXPORT CppHeapCreateParams {
  explicit CppHeapCreateParams(
      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces)
      : custom_spaces(std::move(custom_spaces)) {}
  explicit CppHeapCreateParams( {…}
 
  CppHeapCreateParams(const CppHeapCreateParams&) = delete;
  CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;
 
  std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
  cppgc::Heap::MarkingType marking_support =
      cppgc::Heap::MarkingType::kIncrementalAndConcurrent;
  cppgc::Heap::SweepingType sweeping_support =
      cppgc::Heap::SweepingType::kIncrementalAndConcurrent;
};
struct V8_EXPORT CppHeapCreateParams {…};

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();

  V8_DEPRECATED("Terminate gets automatically called in the CppHeap destructor")
  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 V8_EXPORT 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);
  }
  void Trace(const TracedReferenceBase& ref) {…}
 
 protected:
  using cppgc::Visitor::Visit;
 
  virtual void Visit(const TracedReferenceBase& ref) {}
};
class JSVisitor : public cppgc::Visitor {…};

class CustomSpaceStatisticsReceiver {
 public:
  virtual ~CustomSpaceStatisticsReceiver() = default;
  virtual void AllocatedBytes(cppgc::CustomSpaceIndex space_index,
                              size_t bytes) = 0;
};
class CustomSpaceStatisticsReceiver {…};
 
}  // namespace v8
 
namespace cppgc {
 
template <typename T>
struct TraceTrait<v8::TracedReference<T>> {
  static cppgc::TraceDescriptor GetTraceDescriptor(const void* self) {
    return {nullptr, Trace};
  }
  static cppgc::TraceDescriptor GetTraceDescriptor(const void* self) {…}
 
  static void Trace(Visitor* visitor, const void* self) {
    static_cast<v8::JSVisitor*>(visitor)->Trace(
        *static_cast<const v8::TracedReference<T>*>(self));
  }
  static void Trace(Visitor* visitor, const void* self) {…}
};
struct TraceTrait<v8::TracedReference<T>> {…};
 
}  // namespace cppgc
 
#endif  // INCLUDE_V8_CPPGC_H_