7f0edaad07
This reverts commit bdf634f851.
The tsan race were fixed by
- removing unmodified wrapper reclamation with --cppgc-young-generation
- moving Oilpan's final pause after young trace handle marking
Original change's description:
> unified-young-gen: Trace cross-heap references
>
> The CL enables the marking visitor in CppGC to trace
> v8::TracedReferences (by just reusing the unified heap visitor from the
> full GC). In addition, it specifies VisitJSApiObject for
> NewSpaceVisitors to be able to trace wrappers from Minor MC in case
> --cppgc-young-generation is enabled.
>
> Bug: v8:13475
> Change-Id: I04ba1f2a22e05caebf53dc8d64f2488c42ab8579
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/4026896
> Commit-Queue: Anton Bikineev <bikineev@chromium.org>
> Reviewed-by: Omer Katz <omerkatz@chromium.org>
> Cr-Commit-Position: refs/heads/main@{#84313}
Change-Id: I64d5bfabfa1b83337b1f11666495ccbd7e7e46c7
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/4030318
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Commit-Queue: Anton Bikineev <bikineev@chromium.org>
Cr-Commit-Position: refs/heads/main@{#84324}
135 lines
4.2 KiB
C++
135 lines
4.2 KiB
C++
// Copyright 2022 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.
|
|
|
|
#if defined(CPPGC_YOUNG_GENERATION)
|
|
|
|
#include <memory>
|
|
|
|
#include "include/cppgc/allocation.h"
|
|
#include "include/cppgc/garbage-collected.h"
|
|
#include "include/cppgc/testing.h"
|
|
#include "include/v8-context.h"
|
|
#include "include/v8-cppgc.h"
|
|
#include "include/v8-local-handle.h"
|
|
#include "include/v8-object.h"
|
|
#include "include/v8-traced-handle.h"
|
|
#include "src/api/api-inl.h"
|
|
#include "src/common/globals.h"
|
|
#include "src/heap/cppgc-js/cpp-heap.h"
|
|
#include "src/heap/cppgc/heap-object-header.h"
|
|
#include "src/objects/objects-inl.h"
|
|
#include "test/common/flag-utils.h"
|
|
#include "test/unittests/heap/cppgc-js/unified-heap-utils.h"
|
|
#include "test/unittests/heap/heap-utils.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
namespace {
|
|
|
|
class Wrappable final : public cppgc::GarbageCollected<Wrappable> {
|
|
public:
|
|
static size_t destructor_callcount;
|
|
|
|
~Wrappable() { destructor_callcount++; }
|
|
|
|
void Trace(cppgc::Visitor* visitor) const { visitor->Trace(wrapper_); }
|
|
|
|
void SetWrapper(v8::Isolate* isolate, v8::Local<v8::Object> wrapper) {
|
|
wrapper_.Reset(isolate, wrapper);
|
|
}
|
|
|
|
TracedReference<v8::Object>& wrapper() { return wrapper_; }
|
|
|
|
private:
|
|
TracedReference<v8::Object> wrapper_;
|
|
};
|
|
|
|
size_t Wrappable::destructor_callcount = 0;
|
|
|
|
class MinorMCEnabler {
|
|
public:
|
|
MinorMCEnabler()
|
|
: minor_mc_(&v8_flags.minor_mc, true),
|
|
cppgc_young_generation_(&v8_flags.cppgc_young_generation, true) {}
|
|
|
|
private:
|
|
FlagScope<bool> minor_mc_;
|
|
FlagScope<bool> cppgc_young_generation_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
class YoungUnifiedHeapTest : public MinorMCEnabler, public UnifiedHeapTest {
|
|
public:
|
|
YoungUnifiedHeapTest() {
|
|
// Enable young generation flag and run GC. After the first run the heap
|
|
// will enable minor GC.
|
|
CollectGarbageWithoutEmbedderStack();
|
|
}
|
|
};
|
|
|
|
TEST_F(YoungUnifiedHeapTest, OnlyGC) { CollectYoungGarbageWithEmbedderStack(); }
|
|
|
|
TEST_F(YoungUnifiedHeapTest, CollectUnreachableCppGCObject) {
|
|
v8::HandleScope scope(v8_isolate());
|
|
v8::Local<v8::Context> context = v8::Context::New(v8_isolate());
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
cppgc::MakeGarbageCollected<Wrappable>(allocation_handle());
|
|
v8::Local<v8::Object> api_object =
|
|
WrapperHelper::CreateWrapper(context, nullptr, nullptr);
|
|
EXPECT_FALSE(api_object.IsEmpty());
|
|
|
|
Wrappable::destructor_callcount = 0;
|
|
CollectYoungGarbageWithoutEmbedderStack(cppgc::Heap::SweepingType::kAtomic);
|
|
EXPECT_EQ(1u, Wrappable::destructor_callcount);
|
|
}
|
|
|
|
TEST_F(YoungUnifiedHeapTest, FindingV8ToCppGCReference) {
|
|
v8::HandleScope scope(v8_isolate());
|
|
v8::Local<v8::Context> context = v8::Context::New(v8_isolate());
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
uint16_t wrappable_type = WrapperHelper::kTracedEmbedderId;
|
|
auto* wrappable_object =
|
|
cppgc::MakeGarbageCollected<Wrappable>(allocation_handle());
|
|
v8::Local<v8::Object> api_object =
|
|
WrapperHelper::CreateWrapper(context, &wrappable_type, wrappable_object);
|
|
EXPECT_FALSE(api_object.IsEmpty());
|
|
|
|
Wrappable::destructor_callcount = 0;
|
|
CollectYoungGarbageWithoutEmbedderStack(cppgc::Heap::SweepingType::kAtomic);
|
|
EXPECT_EQ(0u, Wrappable::destructor_callcount);
|
|
|
|
WrapperHelper::ResetWrappableConnection(api_object);
|
|
CollectGarbageWithoutEmbedderStack(cppgc::Heap::SweepingType::kAtomic);
|
|
EXPECT_EQ(1u, Wrappable::destructor_callcount);
|
|
}
|
|
|
|
TEST_F(YoungUnifiedHeapTest, FindingCppGCToV8Reference) {
|
|
v8::HandleScope handle_scope(v8_isolate());
|
|
v8::Local<v8::Context> context = v8::Context::New(v8_isolate());
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
auto* wrappable_object =
|
|
cppgc::MakeGarbageCollected<Wrappable>(allocation_handle());
|
|
|
|
{
|
|
v8::HandleScope inner_handle_scope(v8_isolate());
|
|
auto local = v8::Object::New(v8_isolate());
|
|
EXPECT_TRUE(local->IsObject());
|
|
wrappable_object->SetWrapper(v8_isolate(), local);
|
|
}
|
|
|
|
CollectYoungGarbageWithEmbedderStack(cppgc::Heap::SweepingType::kAtomic);
|
|
auto local = wrappable_object->wrapper().Get(v8_isolate());
|
|
EXPECT_TRUE(local->IsObject());
|
|
}
|
|
|
|
} // namespace internal
|
|
} // namespace v8
|
|
|
|
#endif // defined(CPPGC_YOUNG_GENERATION)
|