Upload folder using huggingface_hub

9297562 verified 5 months ago

7.64 kB

// 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;

/**
 * Describes how V8 wrapper objects maintain references to garbage-collected C++
 * objects.
 */
struct WrapperDescriptor final {
  /**
   * The index used on `v8::Ojbect::SetAlignedPointerFromInternalField()` and
   * related APIs to add additional data to an object which is used to identify
   * JS->C++ references.
   */
  using InternalFieldIndex = int;

  /**
   * Unknown embedder id. The value is reserved for internal usages and must not
   * be used with `CppHeap`.
   */
  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) {}

  /**
   * Index of the wrappable type.
   */
  InternalFieldIndex wrappable_type_index;

  /**
   * Index of the wrappable instance.
   */
  InternalFieldIndex wrappable_instance_index;

  /**
   * Embedder id identifying instances of garbage-collected objects. It is
   * expected that the first field of the wrappable type is a uint16_t holding
   * the id. Only references to instances of wrappables types with an id of
   * `embedder_id_for_garbage_collected` will be considered by CppHeap.
   */
  uint16_t embedder_id_for_garbage_collected;
};

struct V8_EXPORT CppHeapCreateParams {
  CppHeapCreateParams(
      std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces,
      WrapperDescriptor wrapper_descriptor)
      : custom_spaces(std::move(custom_spaces)),
        wrapper_descriptor(wrapper_descriptor) {}

  CppHeapCreateParams(const CppHeapCreateParams&) = delete;
  CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;

  std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
  WrapperDescriptor wrapper_descriptor;
  /**
   * Specifies which kind of marking are supported by the heap. The type may be
   * further reduced via runtime flags when attaching the heap to an Isolate.
   */
  cppgc::Heap::MarkingType marking_support =
      cppgc::Heap::MarkingType::kIncrementalAndConcurrent;
  /**
   * Specifies which kind of sweeping is supported by the heap. The type may be
   * further reduced via runtime flags when attaching the heap to an Isolate.
   */
  cppgc::Heap::SweepingType sweeping_support =
      cppgc::Heap::SweepingType::kIncrementalAndConcurrent;
};

/**
 * A heap for allocating managed C++ objects.
 *
 * Similar to v8::Isolate, the heap may only be accessed from one thread at a
 * time. The heap may be used from different threads using the
 * v8::Locker/v8::Unlocker APIs which is different from generic Oilpan.
 */
class V8_EXPORT CppHeap {
 public:
  static std::unique_ptr<CppHeap> Create(v8::Platform* platform,
                                         const CppHeapCreateParams& params);

  virtual ~CppHeap() = default;

  /**
   * \returns the opaque handle for allocating objects using
   * `MakeGarbageCollected()`.
   */
  cppgc::AllocationHandle& GetAllocationHandle();

  /**
   * \returns the opaque heap handle which may be used to refer to this heap in
   *   other APIs. Valid as long as the underlying `CppHeap` is alive.
   */
  cppgc::HeapHandle& GetHeapHandle();

  /**
   * Terminate clears all roots and performs multiple garbage collections to
   * reclaim potentially newly created objects in destructors.
   *
   * After this call, object allocation is prohibited.
   */
  void Terminate();

  /**
   * \param detail_level specifies whether should return detailed
   *   statistics or only brief summary statistics.
   * \returns current CppHeap statistics regarding memory consumption
   *   and utilization.
   */
  cppgc::HeapStatistics CollectStatistics(
      cppgc::HeapStatistics::DetailLevel detail_level);

  /**
   * Collects statistics for the given spaces and reports them to the receiver.
   *
   * \param custom_spaces a collection of custom space indicies.
   * \param receiver an object that gets the results.
   */
  void CollectCustomSpaceStatisticsAtLastGC(
      std::vector<cppgc::CustomSpaceIndex> custom_spaces,
      std::unique_ptr<CustomSpaceStatisticsReceiver> receiver);

  /**
   * Enables a detached mode that allows testing garbage collection using
   * `cppgc::testing` APIs. Once used, the heap cannot be attached to an
   * `Isolate` anymore.
   */
  void EnableDetachedGarbageCollectionsForTesting();

  /**
   * Performs a stop-the-world garbage collection for testing purposes.
   *
   * \param stack_state The stack state to assume for the garbage collection.
   */
  void CollectGarbageForTesting(cppgc::EmbedderStackState stack_state);

  /**
   * Performs a stop-the-world minor garbage collection for testing purposes.
   *
   * \param stack_state The stack state to assume for the garbage collection.
   */
  void CollectGarbageInYoungGenerationForTesting(
      cppgc::EmbedderStackState stack_state);

  /**
   * \returns the wrapper descriptor of this CppHeap.
   */
  v8::WrapperDescriptor wrapper_descriptor() const;

 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) {}
};

/**
 * Provided as input to `CppHeap::CollectCustomSpaceStatisticsAtLastGC()`.
 *
 * Its method is invoked with the results of the statistic collection.
 */
class CustomSpaceStatisticsReceiver {
 public:
  virtual ~CustomSpaceStatisticsReceiver() = default;
  /**
   * Reports the size of a space at the last GC. It is called for each space
   * that was requested in `CollectCustomSpaceStatisticsAtLastGC()`.
   *
   * \param space_index The index of the space.
   * \param bytes The total size of live objects in the space at the last GC.
   *    It is zero if there was no GC yet.
   */
  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_

	// 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;

	/**
	* Describes how V8 wrapper objects maintain references to garbage-collected C++
	* objects.
	*/
	struct WrapperDescriptor final {
	/**
	* The index used on `v8::Ojbect::SetAlignedPointerFromInternalField()` and
	* related APIs to add additional data to an object which is used to identify
	* JS->C++ references.
	*/
	using InternalFieldIndex = int;

	/**
	* Unknown embedder id. The value is reserved for internal usages and must not
	* be used with `CppHeap`.
	*/
	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) {}

	/**
	* Index of the wrappable type.
	*/
	InternalFieldIndex wrappable_type_index;

	/**
	* Index of the wrappable instance.
	*/
	InternalFieldIndex wrappable_instance_index;

	/**
	* Embedder id identifying instances of garbage-collected objects. It is
	* expected that the first field of the wrappable type is a uint16_t holding
	* the id. Only references to instances of wrappables types with an id of
	* `embedder_id_for_garbage_collected` will be considered by CppHeap.
	*/
	uint16_t embedder_id_for_garbage_collected;
	};

	struct V8_EXPORT CppHeapCreateParams {
	CppHeapCreateParams(
	std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces,
	WrapperDescriptor wrapper_descriptor)
	: custom_spaces(std::move(custom_spaces)),
	wrapper_descriptor(wrapper_descriptor) {}

	CppHeapCreateParams(const CppHeapCreateParams&) = delete;
	CppHeapCreateParams& operator=(const CppHeapCreateParams&) = delete;

	std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
	WrapperDescriptor wrapper_descriptor;
	/**
	* Specifies which kind of marking are supported by the heap. The type may be
	* further reduced via runtime flags when attaching the heap to an Isolate.
	*/
	cppgc::Heap::MarkingType marking_support =
	cppgc::Heap::MarkingType::kIncrementalAndConcurrent;
	/**
	* Specifies which kind of sweeping is supported by the heap. The type may be
	* further reduced via runtime flags when attaching the heap to an Isolate.
	*/
	cppgc::Heap::SweepingType sweeping_support =
	cppgc::Heap::SweepingType::kIncrementalAndConcurrent;
	};

	/**
	* A heap for allocating managed C++ objects.
	*
	* Similar to v8::Isolate, the heap may only be accessed from one thread at a
	* time. The heap may be used from different threads using the
	* v8::Locker/v8::Unlocker APIs which is different from generic Oilpan.
	*/
	class V8_EXPORT CppHeap {
	public:
	static std::unique_ptr<CppHeap> Create(v8::Platform* platform,
	const CppHeapCreateParams& params);

	virtual ~CppHeap() = default;

	/**
	* \returns the opaque handle for allocating objects using
	* `MakeGarbageCollected()`.
	*/
	cppgc::AllocationHandle& GetAllocationHandle();

	/**
	* \returns the opaque heap handle which may be used to refer to this heap in
	* other APIs. Valid as long as the underlying `CppHeap` is alive.
	*/
	cppgc::HeapHandle& GetHeapHandle();

	/**
	* Terminate clears all roots and performs multiple garbage collections to
	* reclaim potentially newly created objects in destructors.
	*
	* After this call, object allocation is prohibited.
	*/
	void Terminate();

	/**
	* \param detail_level specifies whether should return detailed
	* statistics or only brief summary statistics.
	* \returns current CppHeap statistics regarding memory consumption
	* and utilization.
	*/
	cppgc::HeapStatistics CollectStatistics(
	cppgc::HeapStatistics::DetailLevel detail_level);

	/**
	* Collects statistics for the given spaces and reports them to the receiver.
	*
	* \param custom_spaces a collection of custom space indicies.
	* \param receiver an object that gets the results.
	*/
	void CollectCustomSpaceStatisticsAtLastGC(
	std::vector<cppgc::CustomSpaceIndex> custom_spaces,
	std::unique_ptr<CustomSpaceStatisticsReceiver> receiver);

	/**
	* Enables a detached mode that allows testing garbage collection using
	* `cppgc::testing` APIs. Once used, the heap cannot be attached to an
	* `Isolate` anymore.
	*/
	void EnableDetachedGarbageCollectionsForTesting();

	/**
	* Performs a stop-the-world garbage collection for testing purposes.
	*
	* \param stack_state The stack state to assume for the garbage collection.
	*/
	void CollectGarbageForTesting(cppgc::EmbedderStackState stack_state);

	/**
	* Performs a stop-the-world minor garbage collection for testing purposes.
	*
	* \param stack_state The stack state to assume for the garbage collection.
	*/
	void CollectGarbageInYoungGenerationForTesting(
	cppgc::EmbedderStackState stack_state);

	/**
	* \returns the wrapper descriptor of this CppHeap.
	*/
	v8::WrapperDescriptor wrapper_descriptor() const;

	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) {}
	};

	/**
	* Provided as input to `CppHeap::CollectCustomSpaceStatisticsAtLastGC()`.
	*
	* Its method is invoked with the results of the statistic collection.
	*/
	class CustomSpaceStatisticsReceiver {
	public:
	virtual ~CustomSpaceStatisticsReceiver() = default;
	/**
	* Reports the size of a space at the last GC. It is called for each space
	* that was requested in `CollectCustomSpaceStatisticsAtLastGC()`.
	*
	* \param space_index The index of the space.
	* \param bytes The total size of live objects in the space at the last GC.
	* It is zero if there was no GC yet.
	*/
	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_