935d915186
Unified heap support in V8 requires having another (at least internal) heap that implements a unfied garbage collection strategy. This will not re-use the already existing cppgc::Heap because there should be no way in creating such a heap externally or scheduling stand-alone garbage collections. In order to have a common token, this CL introduces AllocationHandle which can be passed to MakeGarbageCollected to allocate C++ objects. V8 (soon) and the stand-alone heap both have methods to retrieve such a handle. This works around a problem with creating diamond class hierarchies when a base class would be exposed on the public API level. Fast paths for Blink are still possible because allocation handles can be cached the same way (e.g. global, or TLS) as a heap can be cached. Tbr: yangguo@chromium.org Bug: chromium:1056170 Change-Id: I8e9472a2c24ef82d1178953e8429b1fd8a2344bc Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2238027 Commit-Queue: Michael Lippautz <mlippautz@chromium.org> Reviewed-by: Omer Katz <omerkatz@chromium.org> Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Cr-Commit-Position: refs/heads/master@{#68310}
135 lines
3.8 KiB
C++
135 lines
3.8 KiB
C++
// 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_HEAP_H_
|
|
#define INCLUDE_CPPGC_HEAP_H_
|
|
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "cppgc/common.h"
|
|
#include "cppgc/custom-space.h"
|
|
#include "cppgc/platform.h"
|
|
#include "v8config.h" // NOLINT(build/include_directory)
|
|
|
|
/**
|
|
* cppgc - A C++ garbage collection library.
|
|
*/
|
|
namespace cppgc {
|
|
|
|
class AllocationHandle;
|
|
|
|
namespace internal {
|
|
class Heap;
|
|
} // namespace internal
|
|
|
|
class V8_EXPORT Heap {
|
|
public:
|
|
/**
|
|
* Specifies the stack state the embedder is in.
|
|
*/
|
|
using StackState = EmbedderStackState;
|
|
|
|
/**
|
|
* Specifies whether conservative stack scanning is supported.
|
|
*/
|
|
enum class StackSupport : uint8_t {
|
|
/**
|
|
* Conservative stack scan is supported.
|
|
*/
|
|
kSupportsConservativeStackScan,
|
|
/**
|
|
* Conservative stack scan is not supported. Embedders may use this option
|
|
* when using custom infrastructure that is unsupported by the library.
|
|
*/
|
|
kNoConservativeStackScan,
|
|
};
|
|
|
|
/**
|
|
* Constraints for a Heap setup.
|
|
*/
|
|
struct ResourceConstraints {
|
|
/**
|
|
* Allows the heap to grow to some initial size in bytes before triggering
|
|
* garbage collections. This is useful when it is known that applications
|
|
* need a certain minimum heap to run to avoid repeatedly invoking the
|
|
* garbage collector when growing the heap.
|
|
*/
|
|
size_t initial_heap_size_bytes = 0;
|
|
};
|
|
|
|
/**
|
|
* Options specifying Heap properties (e.g. custom spaces) when initializing a
|
|
* heap through Heap::Create().
|
|
*/
|
|
struct HeapOptions {
|
|
/**
|
|
* Creates reasonable defaults for instantiating a Heap.
|
|
*
|
|
* \returns the HeapOptions that can be passed to Heap::Create().
|
|
*/
|
|
static HeapOptions Default() { return {}; }
|
|
|
|
/**
|
|
* Custom spaces added to heap are required to have indices forming a
|
|
* numbered sequence starting at 0, i.e., their kSpaceIndex must correspond
|
|
* to the index they reside in the vector.
|
|
*/
|
|
std::vector<std::unique_ptr<CustomSpaceBase>> custom_spaces;
|
|
|
|
/**
|
|
* Specifies whether conserative stack scan is supported. When conservative
|
|
* stack scan is not supported, the collector may try to invoke
|
|
* garbage collections using non-nestable task, which are guaranteed to have
|
|
* no interesting stack, through the provided Platform. If such tasks are
|
|
* not supported by the Platform, the embedder must take care of invoking
|
|
* the GC through ForceGarbageCollectionSlow().
|
|
*/
|
|
StackSupport stack_support = StackSupport::kSupportsConservativeStackScan;
|
|
|
|
/**
|
|
* Resource constraints specifying various properties that the internal
|
|
* GC scheduler follows.
|
|
*/
|
|
ResourceConstraints resource_constraints;
|
|
};
|
|
|
|
/**
|
|
* Creates a new heap that can be used for object allocation.
|
|
*
|
|
* \param platform implemented and provided by the embedder.
|
|
* \param options HeapOptions specifying various properties for the Heap.
|
|
* \returns a new Heap instance.
|
|
*/
|
|
static std::unique_ptr<Heap> Create(
|
|
std::shared_ptr<Platform> platform,
|
|
HeapOptions options = HeapOptions::Default());
|
|
|
|
virtual ~Heap() = default;
|
|
|
|
/**
|
|
* Forces garbage collection.
|
|
*
|
|
* \param source String specifying the source (or caller) triggering a
|
|
* forced garbage collection.
|
|
* \param reason String specifying the reason for the forced garbage
|
|
* collection.
|
|
* \param stack_state The embedder stack state, see StackState.
|
|
*/
|
|
void ForceGarbageCollectionSlow(
|
|
const char* source, const char* reason,
|
|
StackState stack_state = StackState::kMayContainHeapPointers);
|
|
|
|
AllocationHandle& GetAllocationHandle();
|
|
|
|
private:
|
|
Heap() = default;
|
|
|
|
friend class internal::Heap;
|
|
};
|
|
|
|
} // namespace cppgc
|
|
|
|
#endif // INCLUDE_CPPGC_HEAP_H_
|