From a8a1805e126d45ea635f332df26f786c67787419 Mon Sep 17 00:00:00 2001 From: Michael Lippautz Date: Mon, 2 Jan 2023 15:12:15 +0100 Subject: [PATCH] [api, heap, handles] Remove deprecated EmbedderHeapTracer MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This removes EmbedderHeapTracer from V8's API. Going forward v8::TracedReference is only supported with using CppHeap (Oilpan). Bug: v8:13207 Change-Id: I4e0efa94890ed147293b5df69fd7e0edad45abb5 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/4111546 Reviewed-by: Dominik Inführ Commit-Queue: Michael Lippautz Cr-Commit-Position: refs/heads/main@{#85061} --- include/v8-embedder-heap.h | 169 ----- include/v8-isolate.h | 23 +- include/v8-traced-handle.h | 15 +- src/DEPS | 1 + src/api/api.cc | 81 --- src/handles/traced-handles.cc | 36 +- src/handles/traced-handles.h | 8 - src/heap/cppgc-js/cpp-heap.cc | 3 +- src/heap/embedder-tracing.cc | 156 +---- src/heap/embedder-tracing.h | 96 +-- src/heap/gc-tracer.h | 4 +- src/heap/heap.cc | 40 -- src/heap/heap.h | 10 - src/heap/incremental-marking.cc | 22 +- src/heap/mark-compact-inl.h | 10 - src/heap/mark-compact.cc | 27 +- src/heap/mark-compact.h | 3 - test/unittests/BUILD.gn | 1 - .../heap/embedder-tracing-unittest.cc | 607 ------------------ test/unittests/heap/heap-utils.h | 20 - 20 files changed, 68 insertions(+), 1264 deletions(-) delete mode 100644 test/unittests/heap/embedder-tracing-unittest.cc diff --git a/include/v8-embedder-heap.h b/include/v8-embedder-heap.h index f994cdfdf3..9e2e3ef58c 100644 --- a/include/v8-embedder-heap.h +++ b/include/v8-embedder-heap.h @@ -5,27 +5,14 @@ #ifndef INCLUDE_V8_EMBEDDER_HEAP_H_ #define INCLUDE_V8_EMBEDDER_HEAP_H_ -#include -#include - -#include -#include - -#include "cppgc/common.h" -#include "v8-local-handle.h" // NOLINT(build/include_directory) #include "v8-traced-handle.h" // NOLINT(build/include_directory) #include "v8config.h" // NOLINT(build/include_directory) namespace v8 { -class Data; class Isolate; class Value; -namespace internal { -class LocalEmbedderHeapTracer; -} // namespace internal - /** * Handler for embedder roots on non-unified heap garbage collections. */ @@ -62,162 +49,6 @@ class V8_EXPORT EmbedderRootsHandler { virtual void ResetRoot(const v8::TracedReference& handle) = 0; }; -/** - * Interface for tracing through the embedder heap. During a V8 garbage - * collection, V8 collects hidden fields of all potential wrappers, and at the - * end of its marking phase iterates the collection and asks the embedder to - * trace through its heap and use reporter to report each JavaScript object - * reachable from any of the given wrappers. - */ -class V8_EXPORT -// GCC doesn't like combining __attribute__(()) with [[deprecated]]. -#ifdef __clang__ -V8_DEPRECATED("Use CppHeap when working with v8::TracedReference.") -#endif // __clang__ - EmbedderHeapTracer { - public: - using EmbedderStackState = cppgc::EmbedderStackState; - - enum TraceFlags : uint64_t { - kNoFlags = 0, - kReduceMemory = 1 << 0, - kForced = 1 << 2, - }; - - /** - * Interface for iterating through |TracedReference| handles. - */ - class V8_EXPORT TracedGlobalHandleVisitor { - public: - virtual ~TracedGlobalHandleVisitor() = default; - virtual void VisitTracedReference(const TracedReference& handle) {} - }; - - /** - * Summary of a garbage collection cycle. See |TraceEpilogue| on how the - * summary is reported. - */ - struct TraceSummary { - /** - * Time spent managing the retained memory in milliseconds. This can e.g. - * include the time tracing through objects in the embedder. - */ - double time = 0.0; - - /** - * Memory retained by the embedder through the |EmbedderHeapTracer| - * mechanism in bytes. - */ - size_t allocated_size = 0; - }; - - virtual ~EmbedderHeapTracer() = default; - - /** - * Iterates all |TracedReference| handles created for the |v8::Isolate| the - * tracer is attached to. - */ - void IterateTracedGlobalHandles(TracedGlobalHandleVisitor* visitor); - - /** - * Called by the embedder to set the start of the stack which is e.g. used by - * V8 to determine whether handles are used from stack or heap. - */ - void SetStackStart(void* stack_start); - - /** - * Called by v8 to register internal fields of found wrappers. - * - * The embedder is expected to store them somewhere and trace reachable - * wrappers from them when called through |AdvanceTracing|. - */ - virtual void RegisterV8References( - const std::vector>& embedder_fields) = 0; - - void RegisterEmbedderReference(const BasicTracedReference& ref); - - /** - * Called at the beginning of a GC cycle. - */ - virtual void TracePrologue(TraceFlags flags) {} - - /** - * Called to advance tracing in the embedder. - * - * The embedder is expected to trace its heap starting from wrappers reported - * by RegisterV8References method, and report back all reachable wrappers. - * Furthermore, the embedder is expected to stop tracing by the given - * deadline. A deadline of infinity means that tracing should be finished. - * - * Returns |true| if tracing is done, and false otherwise. - */ - virtual bool AdvanceTracing(double deadline_in_ms) = 0; - - /* - * Returns true if there no more tracing work to be done (see AdvanceTracing) - * and false otherwise. - */ - virtual bool IsTracingDone() = 0; - - /** - * Called at the end of a GC cycle. - * - * Note that allocation is *not* allowed within |TraceEpilogue|. Can be - * overriden to fill a |TraceSummary| that is used by V8 to schedule future - * garbage collections. - */ - virtual void TraceEpilogue(TraceSummary* trace_summary) {} - - /** - * Called upon entering the final marking pause. No more incremental marking - * steps will follow this call. - */ - virtual void EnterFinalPause(EmbedderStackState stack_state) = 0; - - /* - * Called by the embedder to request immediate finalization of the currently - * running tracing phase that has been started with TracePrologue and not - * yet finished with TraceEpilogue. - * - * Will be a noop when currently not in tracing. - * - * This is an experimental feature. - */ - void FinalizeTracing(); - - /** - * See documentation on EmbedderRootsHandler. - */ - virtual bool IsRootForNonTracingGC( - const v8::TracedReference& handle); - - /** - * See documentation on EmbedderRootsHandler. - */ - virtual void ResetHandleInNonTracingGC( - const v8::TracedReference& handle); - - /* - * Called by the embedder to signal newly allocated or freed memory. Not bound - * to tracing phases. Embedders should trade off when increments are reported - * as V8 may consult global heuristics on whether to trigger garbage - * collection on this change. - */ - void IncreaseAllocatedSize(size_t bytes); - void DecreaseAllocatedSize(size_t bytes); - - /* - * Returns the v8::Isolate this tracer is attached too and |nullptr| if it - * is not attached to any v8::Isolate. - */ - v8::Isolate* isolate() const { return v8_isolate_; } - - protected: - v8::Isolate* v8_isolate_ = nullptr; - - friend class internal::LocalEmbedderHeapTracer; -}; - } // namespace v8 #endif // INCLUDE_V8_EMBEDDER_HEAP_H_ diff --git a/include/v8-isolate.h b/include/v8-isolate.h index 9659300751..bae459630b 100644 --- a/include/v8-isolate.h +++ b/include/v8-isolate.h @@ -924,27 +924,10 @@ class V8_EXPORT Isolate { void RemoveGCPrologueCallback(GCCallbackWithData, void* data = nullptr); void RemoveGCPrologueCallback(GCCallback callback); - START_ALLOW_USE_DEPRECATED() - /** - * Sets the embedder heap tracer for the isolate. - * SetEmbedderHeapTracer cannot be used simultaneously with AttachCppHeap. - */ - void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer); - - /* - * Gets the currently active heap tracer for the isolate that was set with - * SetEmbedderHeapTracer. - */ - EmbedderHeapTracer* GetEmbedderHeapTracer(); - END_ALLOW_USE_DEPRECATED() - /** * Sets an embedder roots handle that V8 should consider when performing - * non-unified heap garbage collections. - * - * Using only EmbedderHeapTracer automatically sets up a default handler. - * The intended use case is for setting a custom handler after invoking - * `AttachCppHeap()`. + * non-unified heap garbage collections. The intended use case is for setting + * a custom handler after invoking `AttachCppHeap()`. * * V8 does not take ownership of the handler. */ @@ -955,8 +938,6 @@ class V8_EXPORT Isolate { * embedder maintains ownership of the CppHeap. At most one C++ heap can be * attached to V8. * - * AttachCppHeap cannot be used simultaneously with SetEmbedderHeapTracer. - * * Multi-threaded use requires the use of v8::Locker/v8::Unlocker, see * CppHeap. */ diff --git a/include/v8-traced-handle.h b/include/v8-traced-handle.h index e0fd57c49d..784016b37c 100644 --- a/include/v8-traced-handle.h +++ b/include/v8-traced-handle.h @@ -117,11 +117,11 @@ class TracedReferenceBase { /** * A traced handle with copy and move semantics. The handle is to be used - * together with |v8::EmbedderHeapTracer| or as part of GarbageCollected objects - * (see v8-cppgc.h) and specifies edges from C++ objects to JavaScript. + * together as part of GarbageCollected objects (see v8-cppgc.h) or from stack + * and specifies edges from C++ objects to JavaScript. * * The exact semantics are: - * - Tracing garbage collections use |v8::EmbedderHeapTracer| or cppgc. + * - Tracing garbage collections using CppHeap. * - Non-tracing garbage collections refer to * |v8::EmbedderRootsHandler::IsRoot()| whether the handle should * be treated as root or not. @@ -166,7 +166,6 @@ class BasicTracedReference : public TracedReferenceBase { Isolate* isolate, T* that, void* slot, internal::GlobalHandleStoreMode store_mode); - friend class EmbedderHeapTracer; template friend class Local; friend class Object; @@ -181,13 +180,7 @@ class BasicTracedReference : public TracedReferenceBase { /** * A traced handle without destructor that clears the handle. The embedder needs * to ensure that the handle is not accessed once the V8 object has been - * reclaimed. This can happen when the handle is not passed through the - * EmbedderHeapTracer. For more details see BasicTracedReference. - * - * The reference assumes the embedder has precise knowledge about references at - * all times. In case V8 needs to separately handle on-stack references, the - * embedder is required to set the stack start through - * |EmbedderHeapTracer::SetStackStart|. + * reclaimed. For more details see BasicTracedReference. */ template class TracedReference : public BasicTracedReference { diff --git a/src/DEPS b/src/DEPS index 8912d7fb25..aeb32f23a1 100644 --- a/src/DEPS +++ b/src/DEPS @@ -76,6 +76,7 @@ include_rules = [ "+starboard", # Using cppgc inside v8 is not (yet) allowed. "-include/cppgc", + "+include/cppgc/common.h", "+include/cppgc/platform.h", "+include/cppgc/source-location.h", ] diff --git a/src/api/api.cc b/src/api/api.cc index bfba6d66c7..de12398f39 100644 --- a/src/api/api.cc +++ b/src/api/api.cc @@ -8874,21 +8874,6 @@ void Isolate::RemoveGCEpilogueCallback(GCCallback callback) { RemoveGCEpilogueCallback(CallGCCallbackWithoutData, data); } -START_ALLOW_USE_DEPRECATED() - -void Isolate::SetEmbedderHeapTracer(EmbedderHeapTracer* tracer) { - i::Isolate* i_isolate = reinterpret_cast(this); - CHECK_NULL(i_isolate->heap()->cpp_heap()); - i_isolate->heap()->SetEmbedderHeapTracer(tracer); -} - -EmbedderHeapTracer* Isolate::GetEmbedderHeapTracer() { - i::Isolate* i_isolate = reinterpret_cast(this); - return i_isolate->heap()->GetEmbedderHeapTracer(); -} - -END_ALLOW_USE_DEPRECATED() - void Isolate::SetEmbedderRootsHandler(EmbedderRootsHandler* handler) { i::Isolate* i_isolate = reinterpret_cast(this); i_isolate->heap()->SetEmbedderRootsHandler(handler); @@ -8896,7 +8881,6 @@ void Isolate::SetEmbedderRootsHandler(EmbedderRootsHandler* handler) { void Isolate::AttachCppHeap(CppHeap* cpp_heap) { i::Isolate* i_isolate = reinterpret_cast(this); - CHECK_NULL(GetEmbedderHeapTracer()); i_isolate->heap()->AttachCppHeap(cpp_heap); } @@ -10705,71 +10689,6 @@ void HeapProfiler::SetGetDetachednessCallback(GetDetachednessCallback callback, data); } -void EmbedderHeapTracer::SetStackStart(void* stack_start) { - CHECK(v8_isolate_); - reinterpret_cast(v8_isolate_) - ->heap() - ->SetStackStart(stack_start); -} - -void EmbedderHeapTracer::FinalizeTracing() { - if (v8_isolate_) { - i::Isolate* i_isolate = reinterpret_cast(v8_isolate_); - if (i_isolate->heap()->incremental_marking()->IsMarking()) { - i_isolate->heap()->FinalizeIncrementalMarkingAtomically( - i::GarbageCollectionReason::kExternalFinalize); - } - } -} - -void EmbedderHeapTracer::IncreaseAllocatedSize(size_t bytes) { - if (v8_isolate_) { - i::LocalEmbedderHeapTracer* const tracer = - reinterpret_cast(v8_isolate_) - ->heap() - ->local_embedder_heap_tracer(); - DCHECK_NOT_NULL(tracer); - tracer->IncreaseAllocatedSize(bytes); - } -} - -void EmbedderHeapTracer::DecreaseAllocatedSize(size_t bytes) { - if (v8_isolate_) { - i::LocalEmbedderHeapTracer* const tracer = - reinterpret_cast(v8_isolate_) - ->heap() - ->local_embedder_heap_tracer(); - DCHECK_NOT_NULL(tracer); - tracer->DecreaseAllocatedSize(bytes); - } -} - -void EmbedderHeapTracer::RegisterEmbedderReference( - const BasicTracedReference& ref) { - if (ref.IsEmpty()) return; - - i::Heap* const heap = reinterpret_cast(v8_isolate_)->heap(); - heap->RegisterExternallyReferencedObject( - reinterpret_cast(ref.val_)); -} - -void EmbedderHeapTracer::IterateTracedGlobalHandles( - TracedGlobalHandleVisitor* visitor) { - i::Isolate* i_isolate = reinterpret_cast(v8_isolate_); - i::DisallowGarbageCollection no_gc; - i_isolate->traced_handles()->Iterate(visitor); -} - -bool EmbedderHeapTracer::IsRootForNonTracingGC( - const v8::TracedReference& handle) { - return true; -} - -void EmbedderHeapTracer::ResetHandleInNonTracingGC( - const v8::TracedReference& handle) { - UNREACHABLE(); -} - EmbedderStateScope::EmbedderStateScope(Isolate* v8_isolate, Local context, EmbedderStateTag tag) diff --git a/src/handles/traced-handles.cc b/src/handles/traced-handles.cc index 4c2961d600..82e5a3eb6c 100644 --- a/src/handles/traced-handles.cc +++ b/src/handles/traced-handles.cc @@ -539,12 +539,6 @@ class TracedHandlesImpl final { size_t used_size_bytes() const { return sizeof(TracedNode) * used_nodes_; } size_t total_size_bytes() const { return block_size_bytes_; } - START_ALLOW_USE_DEPRECATED() - - void Iterate(v8::EmbedderHeapTracer::TracedGlobalHandleVisitor* visitor); - - END_ALLOW_USE_DEPRECATED() - private: TracedNode* AllocateNode(); void FreeNode(TracedNode*); @@ -894,6 +888,8 @@ void TracedHandlesImpl::ComputeWeaknessForYoungObjects( if (is_marking_) return; auto* const handler = isolate_->heap()->GetEmbedderRootsHandler(); + if (!handler) return; + for (TracedNode* node : young_nodes_) { if (node->is_in_use()) { DCHECK(node->is_root()); @@ -912,6 +908,8 @@ void TracedHandlesImpl::ProcessYoungObjects( if (!v8_flags.reclaim_unmodified_wrappers) return; auto* const handler = isolate_->heap()->GetEmbedderRootsHandler(); + if (!handler) return; + for (TracedNode* node : young_nodes_) { if (!node->is_in_use()) continue; @@ -996,23 +994,6 @@ void TracedHandlesImpl::IterateYoungRootsWithOldHostsForTesting( } } -START_ALLOW_USE_DEPRECATED() - -void TracedHandlesImpl::Iterate( - v8::EmbedderHeapTracer::TracedGlobalHandleVisitor* visitor) { - for (auto* block : blocks_) { - for (auto* node : *block) { - if (node->is_in_use()) { - v8::Value* value = ToApi(node->handle()); - visitor->VisitTracedReference( - *reinterpret_cast*>(&value)); - } - } - } -} - -END_ALLOW_USE_DEPRECATED() - TracedHandles::TracedHandles(Isolate* isolate) : impl_(std::make_unique(isolate)) {} @@ -1092,15 +1073,6 @@ size_t TracedHandles::used_size_bytes() const { return impl_->used_size_bytes(); } -START_ALLOW_USE_DEPRECATED() - -void TracedHandles::Iterate( - v8::EmbedderHeapTracer::TracedGlobalHandleVisitor* visitor) { - impl_->Iterate(visitor); -} - -END_ALLOW_USE_DEPRECATED() - // static void TracedHandles::Destroy(Address* location) { if (!location) return; diff --git a/src/handles/traced-handles.h b/src/handles/traced-handles.h index 9d62298a9b..c30230da74 100644 --- a/src/handles/traced-handles.h +++ b/src/handles/traced-handles.h @@ -76,14 +76,6 @@ class V8_EXPORT_PRIVATE TracedHandles final { void IterateAndMarkYoungRootsWithOldHosts(RootVisitor*); void IterateYoungRootsWithOldHostsForTesting(RootVisitor*); - START_ALLOW_USE_DEPRECATED() - - // Iterates over all traces handles represented by - // `v8::TracedReferenceBase`. - void Iterate(v8::EmbedderHeapTracer::TracedGlobalHandleVisitor* visitor); - - END_ALLOW_USE_DEPRECATED() - size_t used_node_count() const; size_t total_size_bytes() const; size_t used_size_bytes() const; diff --git a/src/heap/cppgc-js/cpp-heap.cc b/src/heap/cppgc-js/cpp-heap.cc index e63084381e..67a33bd83c 100644 --- a/src/heap/cppgc-js/cpp-heap.cc +++ b/src/heap/cppgc-js/cpp-heap.cc @@ -548,8 +548,7 @@ void CppHeap::DetachIsolate() { // CHECK across all relevant embedders and setups. if (!isolate_) return; - // Delegate to existing EmbedderHeapTracer API to finish any ongoing garbage - // collection. + // Finish any ongoing garbage collection. if (isolate_->heap()->incremental_marking()->IsMarking()) { isolate_->heap()->FinalizeIncrementalMarkingAtomically( i::GarbageCollectionReason::kExternalFinalize); diff --git a/src/heap/embedder-tracing.cc b/src/heap/embedder-tracing.cc index 1ac9d44a31..9f4ddf5ec2 100644 --- a/src/heap/embedder-tracing.cc +++ b/src/heap/embedder-tracing.cc @@ -4,6 +4,7 @@ #include "src/heap/embedder-tracing.h" +#include "include/cppgc/common.h" #include "include/v8-cppgc.h" #include "src/base/logging.h" #include "src/handles/global-handles.h" @@ -15,51 +16,34 @@ namespace v8::internal { START_ALLOW_USE_DEPRECATED() -void LocalEmbedderHeapTracer::SetRemoteTracer(EmbedderHeapTracer* tracer) { - CHECK_NULL(cpp_heap_); - if (remote_tracer_) remote_tracer_->v8_isolate_ = nullptr; - - remote_tracer_ = tracer; - default_embedder_roots_handler_.SetTracer(tracer); - if (remote_tracer_) - remote_tracer_->v8_isolate_ = reinterpret_cast(isolate_); -} - void LocalEmbedderHeapTracer::SetCppHeap(CppHeap* cpp_heap) { - CHECK_NULL(remote_tracer_); cpp_heap_ = cpp_heap; } -namespace { -CppHeap::GarbageCollectionFlags ConvertTraceFlags( - EmbedderHeapTracer::TraceFlags flags) { - CppHeap::GarbageCollectionFlags result; - if (flags & EmbedderHeapTracer::TraceFlags::kForced) - result |= CppHeap::GarbageCollectionFlagValues::kForced; - if (flags & EmbedderHeapTracer::TraceFlags::kReduceMemory) - result |= CppHeap::GarbageCollectionFlagValues::kReduceMemory; - return result; -} -} // namespace +void LocalEmbedderHeapTracer::PrepareForTrace(CollectionType type) { + if (!InUse()) return; -void LocalEmbedderHeapTracer::PrepareForTrace( - EmbedderHeapTracer::TraceFlags flags, CollectionType type) { - if (cpp_heap_) - cpp_heap()->InitializeTracing(type == CollectionType::kMajor - ? cppgc::internal::CollectionType::kMajor - : cppgc::internal::CollectionType::kMinor, - ConvertTraceFlags(flags)); + CppHeap::GarbageCollectionFlags flags = + CppHeap::GarbageCollectionFlagValues::kNoFlags; + auto* heap = isolate_->heap(); + if (heap->is_current_gc_forced()) { + flags |= CppHeap::GarbageCollectionFlagValues::kForced; + } + if (heap->ShouldReduceMemory()) { + flags |= CppHeap::GarbageCollectionFlagValues::kReduceMemory; + } + cpp_heap()->InitializeTracing(type == CollectionType::kMajor + ? cppgc::internal::CollectionType::kMajor + : cppgc::internal::CollectionType::kMinor, + flags); } -void LocalEmbedderHeapTracer::TracePrologue( - EmbedderHeapTracer::TraceFlags flags) { +void LocalEmbedderHeapTracer::TracePrologue() { if (!InUse()) return; embedder_worklist_empty_ = false; - if (cpp_heap_) - cpp_heap()->StartTracing(); - else - remote_tracer_->TracePrologue(flags); + + cpp_heap()->StartTracing(); } void LocalEmbedderHeapTracer::TraceEpilogue() { @@ -67,16 +51,9 @@ void LocalEmbedderHeapTracer::TraceEpilogue() { // Resetting to state unknown as there may be follow up garbage collections // triggered from callbacks that have a different stack state. - embedder_stack_state_ = - EmbedderHeapTracer::EmbedderStackState::kMayContainHeapPointers; + embedder_stack_state_ = cppgc::EmbedderStackState::kMayContainHeapPointers; - if (cpp_heap_) { - cpp_heap()->TraceEpilogue(); - } else { - EmbedderHeapTracer::TraceSummary summary; - remote_tracer_->TraceEpilogue(&summary); - UpdateRemoteStats(summary.allocated_size, summary.time); - } + cpp_heap()->TraceEpilogue(); } void LocalEmbedderHeapTracer::UpdateRemoteStats(size_t allocated_size, @@ -94,41 +71,21 @@ void LocalEmbedderHeapTracer::UpdateRemoteStats(size_t allocated_size, void LocalEmbedderHeapTracer::EnterFinalPause() { if (!InUse()) return; - if (cpp_heap_) - cpp_heap()->EnterFinalPause(embedder_stack_state_); - else - remote_tracer_->EnterFinalPause(embedder_stack_state_); + cpp_heap()->EnterFinalPause(embedder_stack_state_); } bool LocalEmbedderHeapTracer::Trace(double max_duration) { - if (!InUse()) return true; - - return cpp_heap_ ? cpp_heap_->AdvanceTracing(max_duration) - : remote_tracer_->AdvanceTracing(max_duration); + return !InUse() || cpp_heap()->AdvanceTracing(max_duration); } bool LocalEmbedderHeapTracer::IsRemoteTracingDone() { - return !InUse() || (cpp_heap_ ? cpp_heap()->IsTracingDone() - : remote_tracer_->IsTracingDone()); -} - -LocalEmbedderHeapTracer::ProcessingScope::ProcessingScope( - LocalEmbedderHeapTracer* tracer) - : tracer_(tracer), wrapper_descriptor_(tracer->wrapper_descriptor_) { - DCHECK(!tracer_->cpp_heap_); - wrapper_cache_.reserve(kWrapperCacheSize); -} - -LocalEmbedderHeapTracer::ProcessingScope::~ProcessingScope() { - DCHECK(!tracer_->cpp_heap_); - if (!wrapper_cache_.empty()) { - tracer_->remote_tracer_->RegisterV8References(std::move(wrapper_cache_)); - } + return !InUse() || cpp_heap()->IsTracingDone(); } LocalEmbedderHeapTracer::WrapperInfo LocalEmbedderHeapTracer::ExtractWrapperInfo(Isolate* isolate, JSObject js_object) { + DCHECK(InUse()); WrapperInfo info; if (ExtractWrappableInfo(isolate, js_object, wrapper_descriptor(), &info)) { return info; @@ -136,32 +93,6 @@ LocalEmbedderHeapTracer::ExtractWrapperInfo(Isolate* isolate, return {nullptr, nullptr}; } -void LocalEmbedderHeapTracer::ProcessingScope::TracePossibleWrapper( - JSObject js_object) { - DCHECK(js_object.MayHaveEmbedderFields()); - WrapperInfo info; - if (ExtractWrappableInfo(tracer_->isolate_, js_object, wrapper_descriptor_, - &info)) { - wrapper_cache_.push_back(std::move(info)); - FlushWrapperCacheIfFull(); - } -} - -void LocalEmbedderHeapTracer::ProcessingScope::FlushWrapperCacheIfFull() { - DCHECK(!tracer_->cpp_heap_); - if (wrapper_cache_.size() == wrapper_cache_.capacity()) { - tracer_->remote_tracer_->RegisterV8References(std::move(wrapper_cache_)); - wrapper_cache_.clear(); - wrapper_cache_.reserve(kWrapperCacheSize); - } -} - -void LocalEmbedderHeapTracer::ProcessingScope::AddWrapperInfoForTesting( - WrapperInfo info) { - wrapper_cache_.push_back(info); - FlushWrapperCacheIfFull(); -} - void LocalEmbedderHeapTracer::StartIncrementalMarkingIfNeeded() { if (!v8_flags.global_gc_scheduling || !v8_flags.incremental_marking) return; @@ -179,33 +110,16 @@ void LocalEmbedderHeapTracer::EmbedderWriteBarrier(Heap* heap, JSObject js_object) { DCHECK(InUse()); DCHECK(js_object.MayHaveEmbedderFields()); - if (cpp_heap_) { - DCHECK_NOT_NULL(heap->mark_compact_collector()); - const EmbedderDataSlot type_slot(js_object, - wrapper_descriptor_.wrappable_type_index); - const EmbedderDataSlot instance_slot( - js_object, wrapper_descriptor_.wrappable_instance_index); - heap->mark_compact_collector() - ->local_marking_worklists() - ->cpp_marking_state() - ->MarkAndPush(type_slot, instance_slot); - return; - } - LocalEmbedderHeapTracer::ProcessingScope scope(this); - scope.TracePossibleWrapper(js_object); -} - -bool DefaultEmbedderRootsHandler::IsRoot( - const v8::TracedReference& handle) { - return !tracer_ || tracer_->IsRootForNonTracingGC(handle); -} - -void DefaultEmbedderRootsHandler::ResetRoot( - const v8::TracedReference& handle) { - // Resetting is only called when IsRoot() returns false which - // can only happen the EmbedderHeapTracer is set on API level. - DCHECK(tracer_); - tracer_->ResetHandleInNonTracingGC(handle); + DCHECK_NOT_NULL(heap->mark_compact_collector()); + auto descriptor = wrapper_descriptor(); + const EmbedderDataSlot type_slot(js_object, descriptor.wrappable_type_index); + const EmbedderDataSlot instance_slot(js_object, + descriptor.wrappable_instance_index); + heap->mark_compact_collector() + ->local_marking_worklists() + ->cpp_marking_state() + ->MarkAndPush(type_slot, instance_slot); + return; } END_ALLOW_USE_DEPRECATED() diff --git a/src/heap/embedder-tracing.h b/src/heap/embedder-tracing.h index 9843076258..6166eb0cee 100644 --- a/src/heap/embedder-tracing.h +++ b/src/heap/embedder-tracing.h @@ -8,8 +8,6 @@ #include #include "include/v8-cppgc.h" -#include "include/v8-embedder-heap.h" -#include "include/v8-traced-handle.h" #include "src/common/globals.h" #include "src/execution/isolate.h" #include "src/flags/flags.h" @@ -21,21 +19,6 @@ namespace internal { class Heap; class JSObject; -START_ALLOW_USE_DEPRECATED() - -class V8_EXPORT_PRIVATE DefaultEmbedderRootsHandler final - : public EmbedderRootsHandler { - public: - bool IsRoot(const v8::TracedReference& handle) final; - - void ResetRoot(const v8::TracedReference& handle) final; - - void SetTracer(EmbedderHeapTracer* tracer) { tracer_ = tracer; } - - private: - EmbedderHeapTracer* tracer_ = nullptr; -}; - class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { public: enum class CollectionType : uint8_t { @@ -43,7 +26,6 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { kMajor, }; using WrapperInfo = std::pair; - using WrapperCache = std::vector; // WrapperInfo is passed over the API. Use VerboseWrapperInfo to access pair // internals in a named way. See ProcessingScope::TracePossibleJSWrapper() @@ -63,25 +45,6 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { const WrapperInfo& raw_info; }; - class V8_EXPORT_PRIVATE V8_NODISCARD ProcessingScope { - public: - explicit ProcessingScope(LocalEmbedderHeapTracer* tracer); - ~ProcessingScope(); - - void TracePossibleWrapper(JSObject js_object); - - void AddWrapperInfoForTesting(WrapperInfo info); - - private: - static constexpr size_t kWrapperCacheSize = 1000; - - void FlushWrapperCacheIfFull(); - - LocalEmbedderHeapTracer* const tracer_; - const WrapperDescriptor wrapper_descriptor_; - WrapperCache wrapper_cache_; - }; - static V8_INLINE bool ExtractWrappableInfo(Isolate*, JSObject, const WrapperDescriptor&, WrapperInfo*); @@ -92,23 +55,15 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { explicit LocalEmbedderHeapTracer(Isolate* isolate) : isolate_(isolate) {} ~LocalEmbedderHeapTracer() { - if (remote_tracer_) remote_tracer_->v8_isolate_ = nullptr; // CppHeap is not detached from Isolate here. Detaching is done explicitly // on Isolate/Heap/CppHeap destruction. } - bool InUse() const { return cpp_heap_ || (remote_tracer_ != nullptr); } - // This method doesn't take CppHeap into account. - EmbedderHeapTracer* remote_tracer() const { - DCHECK_NULL(cpp_heap_); - return remote_tracer_; - } + bool InUse() const { return cpp_heap_; } - void SetRemoteTracer(EmbedderHeapTracer* tracer); void SetCppHeap(CppHeap* cpp_heap); - void PrepareForTrace(EmbedderHeapTracer::TraceFlags flags, - CollectionType type); - void TracePrologue(EmbedderHeapTracer::TraceFlags flags); + void PrepareForTrace(CollectionType type); + void TracePrologue(); void TraceEpilogue(); void EnterFinalPause(); bool Trace(double deadline); @@ -125,8 +80,7 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { bool SupportsIncrementalEmbedderSteps() const { if (!InUse()) return false; - return cpp_heap_ ? v8_flags.cppheap_incremental_marking - : v8_flags.incremental_marking_wrappers; + return v8_flags.cppheap_incremental_marking; } void SetEmbedderWorklistEmpty(bool is_empty) { @@ -158,18 +112,9 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { WrapperInfo ExtractWrapperInfo(Isolate* isolate, JSObject js_object); - void SetWrapperDescriptor(const WrapperDescriptor& wrapper_descriptor) { - DCHECK_NULL(cpp_heap_); - wrapper_descriptor_ = wrapper_descriptor; - } - void UpdateRemoteStats(size_t, double); - DefaultEmbedderRootsHandler& default_embedder_roots_handler() { - return default_embedder_roots_handler_; - } - - EmbedderHeapTracer::EmbedderStackState embedder_stack_state() const { + cppgc::EmbedderStackState embedder_stack_state() const { return embedder_stack_state_; } @@ -178,39 +123,21 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { private: static constexpr size_t kEmbedderAllocatedThreshold = 128 * KB; - static constexpr WrapperDescriptor::InternalFieldIndex - kDefaultWrapperTypeEmbedderIndex = 0; - static constexpr WrapperDescriptor::InternalFieldIndex - kDefaultWrapperInstanceEmbedderIndex = 1; - - static constexpr WrapperDescriptor GetDefaultWrapperDescriptor() { - // The default descriptor assumes the indices that known embedders use. - return WrapperDescriptor(kDefaultWrapperTypeEmbedderIndex, - kDefaultWrapperInstanceEmbedderIndex, - WrapperDescriptor::kUnknownEmbedderId); - } - CppHeap* cpp_heap() { DCHECK_NOT_NULL(cpp_heap_); - DCHECK_NULL(remote_tracer_); DCHECK_IMPLIES(isolate_, cpp_heap_ == isolate_->heap()->cpp_heap()); return cpp_heap_; } WrapperDescriptor wrapper_descriptor() { - if (cpp_heap_) - return cpp_heap()->wrapper_descriptor(); - else - return wrapper_descriptor_; + return cpp_heap()->wrapper_descriptor(); } Isolate* const isolate_; - EmbedderHeapTracer* remote_tracer_ = nullptr; CppHeap* cpp_heap_ = nullptr; - DefaultEmbedderRootsHandler default_embedder_roots_handler_; - EmbedderHeapTracer::EmbedderStackState embedder_stack_state_ = - EmbedderHeapTracer::EmbedderStackState::kMayContainHeapPointers; + cppgc::EmbedderStackState embedder_stack_state_ = + cppgc::EmbedderStackState::kMayContainHeapPointers; // Indicates whether the embedder worklist was observed empty on the main // thread. This is opportunistic as concurrent marking tasks may hold local // segments of potential embedder fields to move to the main thread. @@ -229,16 +156,9 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final { size_t allocated_size_limit_for_check = 0; } remote_stats_; - // Default descriptor only used when the embedder is using EmbedderHeapTracer. - // The value is overriden by CppHeap with values that the embedder provided - // upon initialization. - WrapperDescriptor wrapper_descriptor_ = GetDefaultWrapperDescriptor(); - friend class EmbedderStackStateScope; }; -END_ALLOW_USE_DEPRECATED() - } // namespace internal } // namespace v8 diff --git a/src/heap/gc-tracer.h b/src/heap/gc-tracer.h index 3bc12b6bab..e6d34cb367 100644 --- a/src/heap/gc-tracer.h +++ b/src/heap/gc-tracer.h @@ -347,7 +347,7 @@ class V8_EXPORT_PRIVATE GCTracer { double time_ms = 0) const; // Allocation throughput in the embedder in bytes/millisecond in the - // last time_ms milliseconds. Reported through v8::EmbedderHeapTracer. + // last time_ms milliseconds. // Returns 0 if no allocation events have been recorded. double EmbedderAllocationThroughputInBytesPerMillisecond( double time_ms = 0) const; @@ -368,7 +368,7 @@ class V8_EXPORT_PRIVATE GCTracer { double CurrentOldGenerationAllocationThroughputInBytesPerMillisecond() const; // Allocation throughput in the embedder in bytes/milliseconds in the last - // kThroughputTimeFrameMs seconds. Reported through v8::EmbedderHeapTracer. + // kThroughputTimeFrameMs seconds. // Returns 0 if no allocation events have been recorded. double CurrentEmbedderAllocationThroughputInBytesPerMillisecond() const; diff --git a/src/heap/heap.cc b/src/heap/heap.cc index f0ffe5f236..c971669f05 100644 --- a/src/heap/heap.cc +++ b/src/heap/heap.cc @@ -5612,8 +5612,6 @@ void Heap::SetUpSpaces(LinearAllocationArea& new_allocation_info, dead_object_stats_.reset(new ObjectStats(this)); } local_embedder_heap_tracer_.reset(new LocalEmbedderHeapTracer(isolate())); - embedder_roots_handler_ = - &local_embedder_heap_tracer()->default_embedder_roots_handler(); if (Heap::AllocationTrackerForDebugging::IsNeeded()) { allocation_tracker_for_debugging_ = std::make_unique(this); @@ -5789,30 +5787,6 @@ void Heap::NotifyOldGenerationExpansion(AllocationSpace space, } } -START_ALLOW_USE_DEPRECATED() - -void Heap::SetEmbedderHeapTracer(EmbedderHeapTracer* tracer) { - DCHECK_EQ(gc_state(), HeapState::NOT_IN_GC); - // Setting a tracer is only supported when CppHeap is not used. - DCHECK_IMPLIES(tracer, !cpp_heap_); - local_embedder_heap_tracer()->SetRemoteTracer(tracer); -} - -EmbedderHeapTracer* Heap::GetEmbedderHeapTracer() const { - return local_embedder_heap_tracer()->remote_tracer(); -} - -EmbedderHeapTracer::TraceFlags Heap::flags_for_embedder_tracer() const { - if (is_current_gc_forced()) { - return EmbedderHeapTracer::TraceFlags::kForced; - } else if (ShouldReduceMemory()) { - return EmbedderHeapTracer::TraceFlags::kReduceMemory; - } - return EmbedderHeapTracer::TraceFlags::kNoFlags; -} - -END_ALLOW_USE_DEPRECATED() - void Heap::SetEmbedderRootsHandler(EmbedderRootsHandler* handler) { embedder_roots_handler_ = handler; } @@ -5847,20 +5821,6 @@ void Heap::SetStackStart(void* stack_start) { return isolate_->thread_local_top()->stack_; } -void Heap::RegisterExternallyReferencedObject(Address* location) { - Object object = TracedHandles::Mark(location, TracedHandles::MarkMode::kAll); - if (!object.IsHeapObject()) { - // The embedder is not aware of whether numbers are materialized as heap - // objects are just passed around as Smis. - return; - } - HeapObject heap_object = HeapObject::cast(object); - DCHECK(IsValidHeapObject(this, heap_object)); - DCHECK(incremental_marking()->IsMarking() || - mark_compact_collector()->in_use()); - mark_compact_collector()->MarkExternallyReferencedObject(heap_object); -} - void Heap::StartTearDown() { // Finish any ongoing sweeping to avoid stray background tasks still accessing // the heap during teardown. diff --git a/src/heap/heap.h b/src/heap/heap.h index 39e6efb080..0df9e0ad15 100644 --- a/src/heap/heap.h +++ b/src/heap/heap.h @@ -1163,16 +1163,6 @@ class Heap { return local_embedder_heap_tracer_.get(); } - START_ALLOW_USE_DEPRECATED() - - V8_EXPORT_PRIVATE void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer); - EmbedderHeapTracer* GetEmbedderHeapTracer() const; - EmbedderHeapTracer::TraceFlags flags_for_embedder_tracer() const; - - END_ALLOW_USE_DEPRECATED() - - void RegisterExternallyReferencedObject(Address* location); - // =========================================================================== // Unified heap (C++) support. =============================================== // =========================================================================== diff --git a/src/heap/incremental-marking.cc b/src/heap/incremental-marking.cc index 2e1cf40605..8a796e2bf4 100644 --- a/src/heap/incremental-marking.cc +++ b/src/heap/incremental-marking.cc @@ -315,14 +315,13 @@ void IncrementalMarking::StartMarkingMajor() { isolate()->external_pointer_table().StartCompactingIfNeeded(); #endif // V8_COMPRESS_POINTERS - auto embedder_flags = heap_->flags_for_embedder_tracer(); { TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_INCREMENTAL_EMBEDDER_PROLOGUE); // PrepareForTrace should be called before visitor initialization in // StartMarking. It is only used with CppHeap. heap_->local_embedder_heap_tracer()->PrepareForTrace( - embedder_flags, LocalEmbedderHeapTracer::CollectionType::kMajor); + LocalEmbedderHeapTracer::CollectionType::kMajor); } major_collector_->StartMarking(); @@ -358,7 +357,7 @@ void IncrementalMarking::StartMarkingMajor() { // marking (including write barriers) is fully set up. TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_INCREMENTAL_EMBEDDER_PROLOGUE); - heap_->local_embedder_heap_tracer()->TracePrologue(embedder_flags); + heap_->local_embedder_heap_tracer()->TracePrologue(); } heap_->InvokeIncrementalMarkingEpilogueCallbacks(); @@ -555,8 +554,6 @@ void IncrementalMarking::EmbedderStep(double expected_duration_ms, return; } - constexpr size_t kObjectsToProcessBeforeDeadlineCheck = 500; - TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_INCREMENTAL_EMBEDDER_TRACING); LocalEmbedderHeapTracer* local_tracer = heap_->local_embedder_heap_tracer(); const double start = heap_->MonotonicallyIncreasingTimeInMs(); @@ -564,21 +561,6 @@ void IncrementalMarking::EmbedderStep(double expected_duration_ms, bool empty_worklist = true; if (local_marking_worklists()->PublishWrapper()) { DCHECK(local_marking_worklists()->IsWrapperEmpty()); - } else { - // Cannot directly publish wrapper objects. - LocalEmbedderHeapTracer::ProcessingScope scope(local_tracer); - HeapObject object; - size_t cnt = 0; - while (local_marking_worklists()->PopWrapper(&object)) { - scope.TracePossibleWrapper(JSObject::cast(object)); - if (++cnt == kObjectsToProcessBeforeDeadlineCheck) { - if (deadline <= heap_->MonotonicallyIncreasingTimeInMs()) { - empty_worklist = false; - break; - } - cnt = 0; - } - } } // |deadline - heap_->MonotonicallyIncreasingTimeInMs()| could be negative, // which means |local_tracer| won't do any actual tracing, so there is no diff --git a/src/heap/mark-compact-inl.h b/src/heap/mark-compact-inl.h index 6cef400d0e..271df8c1b9 100644 --- a/src/heap/mark-compact-inl.h +++ b/src/heap/mark-compact-inl.h @@ -51,16 +51,6 @@ void MinorMarkCompactCollector::MarkRootObject(HeapObject obj) { } } -void MarkCompactCollector::MarkExternallyReferencedObject(HeapObject obj) { - DCHECK(ReadOnlyHeap::Contains(obj) || heap()->Contains(obj)); - if (marking_state()->WhiteToGrey(obj)) { - local_marking_worklists()->Push(obj); - if (V8_UNLIKELY(v8_flags.track_retaining_path)) { - heap_->AddRetainingRoot(Root::kWrapperTracing, obj); - } - } -} - // static void MarkCompactCollector::RecordSlot(HeapObject object, ObjectSlot slot, HeapObject target) { diff --git a/src/heap/mark-compact.cc b/src/heap/mark-compact.cc index 49cbaea44f..4f0493830c 100644 --- a/src/heap/mark-compact.cc +++ b/src/heap/mark-compact.cc @@ -910,13 +910,12 @@ void MarkCompactCollector::Prepare() { DCHECK(!heap_->memory_allocator()->unmapper()->IsRunning()); if (!heap()->incremental_marking()->IsMarking()) { - const auto embedder_flags = heap_->flags_for_embedder_tracer(); { TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_MARK_EMBEDDER_PROLOGUE); // PrepareForTrace should be called before visitor initialization in // StartMarking. heap_->local_embedder_heap_tracer()->PrepareForTrace( - embedder_flags, LocalEmbedderHeapTracer::CollectionType::kMajor); + LocalEmbedderHeapTracer::CollectionType::kMajor); } StartCompaction(StartCompactionMode::kAtomic); StartMarking(); @@ -924,7 +923,7 @@ void MarkCompactCollector::Prepare() { TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_MARK_EMBEDDER_PROLOGUE); // TracePrologue immediately starts marking which requires V8 worklists to // be set up. - heap_->local_embedder_heap_tracer()->TracePrologue(embedder_flags); + heap_->local_embedder_heap_tracer()->TracePrologue(); } #ifdef V8_COMPRESS_POINTERS heap_->isolate()->external_pointer_table().StartCompactingIfNeeded(); @@ -2112,8 +2111,9 @@ void MarkCompactCollector::MarkRoots(RootVisitor* root_visitor) { if (!heap_->cpp_heap() && heap_->local_embedder_heap_tracer()->InUse()) { // Conservative global handle scanning is necessary for keeping - // v8::TracedReference alive from the stack. This is only needed when using - // `EmbedderHeapTracer` and not using `CppHeap`. + // v8::TracedReference alive from the stack. + // + // TODO(v8:v8:13207): Remove as this is not required when using `CppHeap`. auto& stack = heap()->stack(); if (heap_->local_embedder_heap_tracer()->embedder_stack_state() == cppgc::EmbedderStackState::kMayContainHeapPointers) { @@ -2551,14 +2551,6 @@ void MarkCompactCollector::PerformWrapperTracing() { TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_MARK_EMBEDDER_TRACING); if (local_marking_worklists()->PublishWrapper()) { DCHECK(local_marking_worklists()->IsWrapperEmpty()); - } else { - // Cannot directly publish wrapper objects. - LocalEmbedderHeapTracer::ProcessingScope scope( - heap_->local_embedder_heap_tracer()); - HeapObject object; - while (local_marking_worklists()->PopWrapper(&object)) { - scope.TracePossibleWrapper(JSObject::cast(object)); - } } heap_->local_embedder_heap_tracer()->Trace( std::numeric_limits::infinity()); @@ -5790,8 +5782,8 @@ void MinorMarkCompactCollector::SweepArrayBufferExtensions() { void MinorMarkCompactCollector::PerformWrapperTracing() { if (!heap_->local_embedder_heap_tracer()->InUse()) return; - // TODO(v8:13475): DCHECK instead of bailing out once EmbedderHeapTracer is - // removed. + // TODO(v8:v8:13207): DCHECK instead of bailing out as only CppHeap is + // supported. if (!local_marking_worklists()->PublishWrapper()) return; DCHECK_NOT_NULL(CppHeap::From(heap_->cpp_heap())); DCHECK(CppHeap::From(heap_->cpp_heap())->generational_gc_supported()); @@ -5986,21 +5978,20 @@ void MinorMarkCompactCollector::Prepare() { // Probably requires more. if (!heap()->incremental_marking()->IsMarking()) { - const auto embedder_flags = heap_->flags_for_embedder_tracer(); { TRACE_GC(heap()->tracer(), GCTracer::Scope::MINOR_MC_MARK_EMBEDDER_PROLOGUE); // PrepareForTrace should be called before visitor initialization in // StartMarking. heap_->local_embedder_heap_tracer()->PrepareForTrace( - embedder_flags, LocalEmbedderHeapTracer::CollectionType::kMinor); + LocalEmbedderHeapTracer::CollectionType::kMinor); } StartMarking(); { TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_MARK_EMBEDDER_PROLOGUE); // TracePrologue immediately starts marking which requires V8 worklists to // be set up. - heap_->local_embedder_heap_tracer()->TracePrologue(embedder_flags); + heap_->local_embedder_heap_tracer()->TracePrologue(); } } diff --git a/src/heap/mark-compact.h b/src/heap/mark-compact.h index 254a351758..166f134a04 100644 --- a/src/heap/mark-compact.h +++ b/src/heap/mark-compact.h @@ -452,9 +452,6 @@ class MarkCompactCollector final : public CollectorBase { explicit MarkCompactCollector(Heap* heap); ~MarkCompactCollector() final; - // Used by wrapper tracing. - V8_INLINE void MarkExternallyReferencedObject(HeapObject obj); - std::unique_ptr CreateRememberedSetUpdatingItem( MemoryChunk* chunk); diff --git a/test/unittests/BUILD.gn b/test/unittests/BUILD.gn index fe6fe5bc50..cd1e19f570 100644 --- a/test/unittests/BUILD.gn +++ b/test/unittests/BUILD.gn @@ -412,7 +412,6 @@ v8_source_set("unittests_sources") { "heap/cppgc-js/unified-heap-utils.cc", "heap/cppgc-js/unified-heap-utils.h", "heap/cppgc-js/young-unified-heap-unittest.cc", - "heap/embedder-tracing-unittest.cc", "heap/gc-idle-time-handler-unittest.cc", "heap/gc-tracer-unittest.cc", "heap/global-handles-unittest.cc", diff --git a/test/unittests/heap/embedder-tracing-unittest.cc b/test/unittests/heap/embedder-tracing-unittest.cc deleted file mode 100644 index d2a54aecc2..0000000000 --- a/test/unittests/heap/embedder-tracing-unittest.cc +++ /dev/null @@ -1,607 +0,0 @@ -// Copyright 2016 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. - -#include "src/heap/embedder-tracing.h" - -#include "include/v8-embedder-heap.h" -#include "include/v8-function.h" -#include "include/v8-template.h" -#include "src/handles/global-handles.h" -#include "src/heap/gc-tracer.h" -#include "src/heap/heap.h" -#include "test/unittests/heap/heap-utils.h" -#include "test/unittests/test-utils.h" -#include "testing/gmock/include/gmock/gmock.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace v8 { -namespace internal { - -using LocalEmbedderHeapTracerWithIsolate = TestWithHeapInternals; - -namespace heap { - -using testing::StrictMock; -using testing::_; -using testing::Return; -using v8::EmbedderHeapTracer; -using v8::internal::LocalEmbedderHeapTracer; - -namespace { - -LocalEmbedderHeapTracer::WrapperInfo CreateWrapperInfo() { - return LocalEmbedderHeapTracer::WrapperInfo(nullptr, nullptr); -} - -} // namespace - -START_ALLOW_USE_DEPRECATED() -class MockEmbedderHeapTracer : public EmbedderHeapTracer { - public: - MOCK_METHOD(void, TracePrologue, (EmbedderHeapTracer::TraceFlags), - (override)); - MOCK_METHOD(void, TraceEpilogue, (EmbedderHeapTracer::TraceSummary*), - (override)); - MOCK_METHOD(void, EnterFinalPause, (EmbedderHeapTracer::EmbedderStackState), - (override)); - MOCK_METHOD(bool, IsTracingDone, (), (override)); - MOCK_METHOD(void, RegisterV8References, - ((const std::vector >&)), (override)); - MOCK_METHOD(bool, AdvanceTracing, (double deadline_in_ms), (override)); -}; - -END_ALLOW_USE_DEPRECATED() - -TEST(LocalEmbedderHeapTracer, InUse) { - MockEmbedderHeapTracer mock_remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&mock_remote_tracer); - EXPECT_TRUE(local_tracer.InUse()); -} - -TEST(LocalEmbedderHeapTracer, NoRemoteTracer) { - LocalEmbedderHeapTracer local_tracer(nullptr); - // We should be able to call all functions without a remote tracer being - // attached. - EXPECT_FALSE(local_tracer.InUse()); - local_tracer.TracePrologue(EmbedderHeapTracer::TraceFlags::kNoFlags); - local_tracer.EnterFinalPause(); - bool done = local_tracer.Trace(std::numeric_limits::infinity()); - EXPECT_TRUE(done); - local_tracer.TraceEpilogue(); -} - -TEST(LocalEmbedderHeapTracer, TracePrologueForwards) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_CALL(remote_tracer, TracePrologue(_)); - local_tracer.TracePrologue(EmbedderHeapTracer::TraceFlags::kNoFlags); -} - -TEST(LocalEmbedderHeapTracer, TracePrologueForwardsMemoryReducingFlag) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_CALL(remote_tracer, - TracePrologue(EmbedderHeapTracer::TraceFlags::kReduceMemory)); - local_tracer.TracePrologue(EmbedderHeapTracer::TraceFlags::kReduceMemory); -} - -TEST(LocalEmbedderHeapTracer, TraceEpilogueForwards) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_CALL(remote_tracer, TraceEpilogue(_)); - local_tracer.TraceEpilogue(); -} - -TEST(LocalEmbedderHeapTracer, EnterFinalPauseForwards) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_CALL(remote_tracer, EnterFinalPause(_)); - local_tracer.EnterFinalPause(); -} - -TEST(LocalEmbedderHeapTracer, IsRemoteTracingDoneForwards) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_CALL(remote_tracer, IsTracingDone()); - local_tracer.IsRemoteTracingDone(); -} - -TEST(LocalEmbedderHeapTracer, EnterFinalPauseDefaultStackStateUnkown) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - // The default stack state is expected to be unkown. - EXPECT_CALL( - remote_tracer, - EnterFinalPause( - EmbedderHeapTracer::EmbedderStackState::kMayContainHeapPointers)); - local_tracer.EnterFinalPause(); -} - -TEST_F(LocalEmbedderHeapTracerWithIsolate, - EnterFinalPauseStackStateIsForwarded) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(isolate()); - local_tracer.SetRemoteTracer(&remote_tracer); - EmbedderStackStateScope scope = - EmbedderStackStateScope::ExplicitScopeForTesting( - &local_tracer, - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers); - EXPECT_CALL( - remote_tracer, - EnterFinalPause(EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers)); - local_tracer.EnterFinalPause(); -} - -TEST_F(LocalEmbedderHeapTracerWithIsolate, TemporaryEmbedderStackState) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(isolate()); - local_tracer.SetRemoteTracer(&remote_tracer); - // Default is unknown, see above. - { - EmbedderStackStateScope scope = - EmbedderStackStateScope::ExplicitScopeForTesting( - &local_tracer, - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers); - EXPECT_CALL(remote_tracer, - EnterFinalPause( - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers)); - local_tracer.EnterFinalPause(); - } -} - -TEST_F(LocalEmbedderHeapTracerWithIsolate, - TemporaryEmbedderStackStateRestores) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(isolate()); - local_tracer.SetRemoteTracer(&remote_tracer); - // Default is unknown, see above. - { - EmbedderStackStateScope scope = - EmbedderStackStateScope::ExplicitScopeForTesting( - &local_tracer, - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers); - { - EmbedderStackStateScope nested_scope = - EmbedderStackStateScope::ExplicitScopeForTesting( - &local_tracer, - EmbedderHeapTracer::EmbedderStackState::kMayContainHeapPointers); - EXPECT_CALL( - remote_tracer, - EnterFinalPause( - EmbedderHeapTracer::EmbedderStackState::kMayContainHeapPointers)); - local_tracer.EnterFinalPause(); - } - EXPECT_CALL(remote_tracer, - EnterFinalPause( - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers)); - local_tracer.EnterFinalPause(); - } -} - -TEST_F(LocalEmbedderHeapTracerWithIsolate, TraceEpilogueStackStateResets) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(isolate()); - local_tracer.SetRemoteTracer(&remote_tracer); - EmbedderStackStateScope scope = - EmbedderStackStateScope::ExplicitScopeForTesting( - &local_tracer, - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers); - EXPECT_CALL( - remote_tracer, - EnterFinalPause(EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers)); - local_tracer.EnterFinalPause(); - EXPECT_CALL(remote_tracer, TraceEpilogue(_)); - local_tracer.TraceEpilogue(); - EXPECT_CALL( - remote_tracer, - EnterFinalPause( - EmbedderHeapTracer::EmbedderStackState::kMayContainHeapPointers)); - local_tracer.EnterFinalPause(); -} - -TEST(LocalEmbedderHeapTracer, IsRemoteTracingDoneIncludesRemote) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_CALL(remote_tracer, IsTracingDone()); - local_tracer.IsRemoteTracingDone(); -} - -TEST(LocalEmbedderHeapTracer, RegisterV8ReferencesWithRemoteTracer) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(nullptr); - local_tracer.SetRemoteTracer(&remote_tracer); - { - LocalEmbedderHeapTracer::ProcessingScope scope(&local_tracer); - scope.AddWrapperInfoForTesting(CreateWrapperInfo()); - EXPECT_CALL(remote_tracer, RegisterV8References(_)); - } - EXPECT_CALL(remote_tracer, IsTracingDone()).WillOnce(Return(false)); - EXPECT_FALSE(local_tracer.IsRemoteTracingDone()); -} - -TEST_F(LocalEmbedderHeapTracerWithIsolate, SetRemoteTracerSetsIsolate) { - StrictMock remote_tracer; - LocalEmbedderHeapTracer local_tracer(isolate()); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_EQ(isolate(), reinterpret_cast(remote_tracer.isolate())); -} - -TEST_F(LocalEmbedderHeapTracerWithIsolate, DestructorClearsIsolate) { - StrictMock remote_tracer; - { - LocalEmbedderHeapTracer local_tracer(isolate()); - local_tracer.SetRemoteTracer(&remote_tracer); - EXPECT_EQ(isolate(), reinterpret_cast(remote_tracer.isolate())); - } - EXPECT_EQ(nullptr, remote_tracer.isolate()); -} - -namespace { - -v8::Local ConstructTraceableJSApiObject( - v8::Local context, void* first_field, void* second_field) { - v8::EscapableHandleScope scope(context->GetIsolate()); - v8::Local function_t = - v8::FunctionTemplate::New(context->GetIsolate()); - v8::Local instance_t = function_t->InstanceTemplate(); - instance_t->SetInternalFieldCount(2); - v8::Local function = - function_t->GetFunction(context).ToLocalChecked(); - v8::Local instance = - function->NewInstance(context).ToLocalChecked(); - instance->SetAlignedPointerInInternalField(0, first_field); - instance->SetAlignedPointerInInternalField(1, second_field); - EXPECT_FALSE(instance.IsEmpty()); - i::Handle js_obj = v8::Utils::OpenHandle(*instance); - EXPECT_EQ(i::JS_API_OBJECT_TYPE, js_obj->map().instance_type()); - return scope.Escape(instance); -} - -enum class TracePrologueBehavior { kNoop, kCallV8WriteBarrier }; - -START_ALLOW_USE_DEPRECATED() - -class TestEmbedderHeapTracer final : public v8::EmbedderHeapTracer { - public: - TestEmbedderHeapTracer() = default; - TestEmbedderHeapTracer(TracePrologueBehavior prologue_behavior, - v8::Global array) - : prologue_behavior_(prologue_behavior), array_(std::move(array)) {} - - void RegisterV8References( - const std::vector>& embedder_fields) final { - registered_from_v8_.insert(registered_from_v8_.end(), - embedder_fields.begin(), embedder_fields.end()); - } - - void AddReferenceForTracing(v8::TracedReference* ref) { - to_register_with_v8_references_.push_back(ref); - } - - bool AdvanceTracing(double deadline_in_ms) final { - for (auto ref : to_register_with_v8_references_) { - RegisterEmbedderReference(ref->As()); - } - to_register_with_v8_references_.clear(); - return true; - } - - bool IsTracingDone() final { return to_register_with_v8_references_.empty(); } - - void TracePrologue(EmbedderHeapTracer::TraceFlags) final { - if (prologue_behavior_ == TracePrologueBehavior::kCallV8WriteBarrier) { - auto local = array_.Get(isolate()); - local - ->Set(local->GetCreationContext().ToLocalChecked(), 0, - v8::Object::New(isolate())) - .Check(); - } - } - - void TraceEpilogue(TraceSummary*) final {} - void EnterFinalPause(EmbedderStackState) final {} - - bool IsRegisteredFromV8(void* first_field) const { - for (auto pair : registered_from_v8_) { - if (pair.first == first_field) return true; - } - return false; - } - - void DoNotConsiderAsRootForScavenge(v8::TracedReference* handle) { - handle->SetWrapperClassId(17); - non_root_handles_.push_back(handle); - } - - bool IsRootForNonTracingGC( - const v8::TracedReference& handle) final { - return handle.WrapperClassId() != 17; - } - - void ResetHandleInNonTracingGC( - const v8::TracedReference& handle) final { - for (auto* non_root_handle : non_root_handles_) { - if (*non_root_handle == handle) { - non_root_handle->Reset(); - } - } - } - - private: - std::vector> registered_from_v8_; - std::vector*> to_register_with_v8_references_; - TracePrologueBehavior prologue_behavior_ = TracePrologueBehavior::kNoop; - v8::Global array_; - std::vector*> non_root_handles_; -}; - -class V8_NODISCARD TemporaryEmbedderHeapTracerScope final { - public: - TemporaryEmbedderHeapTracerScope(v8::Isolate* isolate, - v8::EmbedderHeapTracer* tracer) - : isolate_(isolate) { - isolate_->SetEmbedderHeapTracer(tracer); - } - - ~TemporaryEmbedderHeapTracerScope() { - isolate_->SetEmbedderHeapTracer(nullptr); - } - - private: - v8::Isolate* const isolate_; -}; - -END_ALLOW_USE_DEPRECATED() - -} // namespace - -using EmbedderTracingTest = TestWithHeapInternalsAndContext; - -TEST_F(EmbedderTracingTest, V8RegisterEmbedderReference) { - // Tests that wrappers are properly registered with the embedder heap - // tracer. - ManualGCScope manual_gc(i_isolate()); - TestEmbedderHeapTracer tracer; - heap::TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - v8::HandleScope scope(v8_isolate()); - v8::Local context = v8::Context::New(v8_isolate()); - v8::Context::Scope context_scope(context); - - void* first_and_second_field = reinterpret_cast(0x2); - v8::Local api_object = ConstructTraceableJSApiObject( - context, first_and_second_field, first_and_second_field); - ASSERT_FALSE(api_object.IsEmpty()); - CollectGarbage(i::OLD_SPACE); - EXPECT_TRUE(tracer.IsRegisteredFromV8(first_and_second_field)); -} - -TEST_F(EmbedderTracingTest, EmbedderRegisteringV8Reference) { - // Tests that references that are registered by the embedder heap tracer are - // considered live by V8. - ManualGCScope manual_gc(i_isolate()); - TestEmbedderHeapTracer tracer; - heap::TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - v8::HandleScope scope(v8_isolate()); - v8::Local context = v8::Context::New(v8_isolate()); - v8::Context::Scope context_scope(context); - - auto handle = std::make_unique>(); - { - v8::HandleScope inner_scope(v8_isolate()); - v8::Local o = - v8::Local::New(v8_isolate(), v8::Object::New(v8_isolate())); - handle->Reset(v8_isolate(), o); - } - tracer.AddReferenceForTracing(handle.get()); - CollectGarbage(i::OLD_SPACE); - EXPECT_FALSE(handle->IsEmpty()); -} - -TEST_F(EmbedderTracingTest, FinalizeTracingIsNoopWhenNotMarking) { - ManualGCScope manual_gc(i_isolate()); - TestEmbedderHeapTracer tracer; - heap::TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - - // Finalize a potentially running garbage collection. - CollectGarbage(OLD_SPACE); - EXPECT_TRUE(i_isolate()->heap()->incremental_marking()->IsStopped()); - - int gc_counter = i_isolate()->heap()->gc_count(); - tracer.FinalizeTracing(); - EXPECT_TRUE(i_isolate()->heap()->incremental_marking()->IsStopped()); - EXPECT_EQ(gc_counter, i_isolate()->heap()->gc_count()); -} - -TEST_F(EmbedderTracingTest, FinalizeTracingWhenMarking) { - if (!v8_flags.incremental_marking) return; - ManualGCScope manual_gc(i_isolate()); - Heap* heap = i_isolate()->heap(); - TestEmbedderHeapTracer tracer; - heap::TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - - // Finalize a potentially running garbage collection. - CollectGarbage(OLD_SPACE); - if (heap->sweeping_in_progress()) { - heap->EnsureSweepingCompleted( - Heap::SweepingForcedFinalizationMode::kV8Only); - } - heap->tracer()->StopFullCycleIfNeeded(); - EXPECT_TRUE(heap->incremental_marking()->IsStopped()); - - i::IncrementalMarking* marking = heap->incremental_marking(); - { - IsolateSafepointScope scope(heap); - heap->tracer()->StartCycle( - GarbageCollector::MARK_COMPACTOR, GarbageCollectionReason::kTesting, - "collector cctest", GCTracer::MarkingType::kIncremental); - marking->Start(GarbageCollector::MARK_COMPACTOR, - GarbageCollectionReason::kTesting); - } - - // Sweeping is not runing so we should immediately start marking. - EXPECT_TRUE(marking->IsMarking()); - tracer.FinalizeTracing(); - EXPECT_TRUE(marking->IsStopped()); -} - -namespace { - -void ConstructJSObject(v8::Isolate* isolate, v8::Local context, - v8::TracedReference* handle) { - v8::HandleScope scope(isolate); - v8::Local object(v8::Object::New(isolate)); - EXPECT_FALSE(object.IsEmpty()); - *handle = v8::TracedReference(isolate, object); - EXPECT_FALSE(handle->IsEmpty()); -} - -} // namespace - -TEST_F(EmbedderTracingTest, TracedReferenceHandlesMarking) { - ManualGCScope manual_gc(i_isolate()); - v8::HandleScope scope(v8_isolate()); - auto live = std::make_unique>(); - auto dead = std::make_unique>(); - live->Reset(v8_isolate(), v8::Undefined(v8_isolate())); - dead->Reset(v8_isolate(), v8::Undefined(v8_isolate())); - auto* traced_handles = i_isolate()->traced_handles(); - { - TestEmbedderHeapTracer tracer; - heap::TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - tracer.AddReferenceForTracing(live.get()); - const size_t initial_count = traced_handles->used_node_count(); - { - // Conservative scanning may find stale pointers to on-stack handles. - // Disable scanning, assuming the slots are overwritten. - DisableConservativeStackScanningScopeForTesting no_stack_scanning( - i_isolate()->heap()); - EmbedderStackStateScope scope = - EmbedderStackStateScope::ExplicitScopeForTesting( - reinterpret_cast(v8_isolate()) - ->heap() - ->local_embedder_heap_tracer(), - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers); - FullGC(); - } - const size_t final_count = traced_handles->used_node_count(); - // Handles are not black allocated, so `dead` is immediately reclaimed. - EXPECT_EQ(initial_count, final_count + 1); - } -} - -namespace { - -START_ALLOW_USE_DEPRECATED() - -class TracedReferenceVisitor final - : public v8::EmbedderHeapTracer::TracedGlobalHandleVisitor { - public: - ~TracedReferenceVisitor() override = default; - - void VisitTracedReference(const TracedReference& value) final { - if (value.WrapperClassId() == 57) { - count_++; - } - } - - size_t count() const { return count_; } - - private: - size_t count_ = 0; -}; - -END_ALLOW_USE_DEPRECATED() - -} // namespace - -TEST_F(EmbedderTracingTest, TracedReferenceIteration) { - ManualGCScope manual_gc(i_isolate()); - v8::HandleScope scope(v8_isolate()); - TestEmbedderHeapTracer tracer; - heap::TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - - auto handle = std::make_unique>(); - ConstructJSObject(v8_isolate(), v8_isolate()->GetCurrentContext(), - handle.get()); - EXPECT_FALSE(handle->IsEmpty()); - handle->SetWrapperClassId(57); - TracedReferenceVisitor visitor; - { - v8::HandleScope new_scope(v8_isolate()); - tracer.IterateTracedGlobalHandles(&visitor); - } - EXPECT_EQ(1u, visitor.count()); -} - -TEST_F(EmbedderTracingTest, TracePrologueCallingIntoV8WriteBarrier) { - // Regression test: https://crbug.com/940003 - if (!v8_flags.incremental_marking) return; - ManualGCScope manual_gc(isolate()); - v8::HandleScope scope(v8_isolate()); - v8::Global global; - { - v8::HandleScope new_scope(v8_isolate()); - auto local = v8::Array::New(v8_isolate(), 10); - global.Reset(v8_isolate(), local); - } - TestEmbedderHeapTracer tracer(TracePrologueBehavior::kCallV8WriteBarrier, - std::move(global)); - TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - SimulateIncrementalMarking(); - // Finish GC to avoid removing the tracer while GC is running which may end up - // in an infinite loop because of unprocessed objects. - FullGC(); -} - -TEST_F(EmbedderTracingTest, BasicTracedReference) { - ManualGCScope manual_gc(i_isolate()); - v8::HandleScope scope(v8_isolate()); - TestEmbedderHeapTracer tracer; - heap::TemporaryEmbedderHeapTracerScope tracer_scope(v8_isolate(), &tracer); - tracer.SetStackStart( - static_cast(base::Stack::GetCurrentFrameAddress())); - auto* traced_handles = i_isolate()->traced_handles(); - - const size_t initial_count = traced_handles->used_node_count(); - char* memory = new char[sizeof(v8::TracedReference)]; - auto* traced = new (memory) v8::TracedReference(); - { - v8::HandleScope new_scope(v8_isolate()); - v8::Local object(ConstructTraceableJSApiObject( - v8_isolate()->GetCurrentContext(), nullptr, nullptr)); - EXPECT_TRUE(traced->IsEmpty()); - *traced = v8::TracedReference(v8_isolate(), object); - EXPECT_FALSE(traced->IsEmpty()); - EXPECT_EQ(initial_count + 1, traced_handles->used_node_count()); - } - traced->~TracedReference(); - EXPECT_EQ(initial_count + 1, traced_handles->used_node_count()); - { - // Conservative scanning may find stale pointers to on-stack handles. - // Disable scanning, assuming the slots are overwritten. - DisableConservativeStackScanningScopeForTesting no_stack_scanning( - i_isolate()->heap()); - EmbedderStackStateScope scope = - EmbedderStackStateScope::ExplicitScopeForTesting( - reinterpret_cast(v8_isolate()) - ->heap() - ->local_embedder_heap_tracer(), - EmbedderHeapTracer::EmbedderStackState::kNoHeapPointers); - FullGC(); - } - EXPECT_EQ(initial_count, traced_handles->used_node_count()); - delete[] memory; -} - -} // namespace heap -} // namespace internal -} // namespace v8 diff --git a/test/unittests/heap/heap-utils.h b/test/unittests/heap/heap-utils.h index 15fbb9ca91..633652617d 100644 --- a/test/unittests/heap/heap-utils.h +++ b/test/unittests/heap/heap-utils.h @@ -97,26 +97,6 @@ class WithHeapInternals : public TMixin, HeapInternalsBase { } }; -START_ALLOW_USE_DEPRECATED() - -class V8_NODISCARD TemporaryEmbedderHeapTracerScope { - public: - TemporaryEmbedderHeapTracerScope(v8::Isolate* isolate, - v8::EmbedderHeapTracer* tracer) - : isolate_(isolate) { - isolate_->SetEmbedderHeapTracer(tracer); - } - - ~TemporaryEmbedderHeapTracerScope() { - isolate_->SetEmbedderHeapTracer(nullptr); - } - - private: - v8::Isolate* const isolate_; -}; - -END_ALLOW_USE_DEPRECATED() - using TestWithHeapInternals = // WithHeapInternals< // WithInternalIsolateMixin< //