1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
// 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.
#include "src/heap/cppgc-js/unified-heap-marking-visitor.h"
#include "src/heap/cppgc-js/unified-heap-marking-state-inl.h"
#include "src/heap/cppgc/heap.h"
#include "src/heap/cppgc/marking-state.h"
#include "src/heap/cppgc/visitor.h"
#include "src/heap/heap.h"
#include "src/heap/mark-compact.h"
namespace v8 {
namespace internal {
namespace {
std::unique_ptr<MarkingWorklists::Local> GetV8MarkingWorklists(
Heap* heap, cppgc::internal::CollectionType collection_type) {
if (!heap) return {};
auto* worklist =
(collection_type == cppgc::internal::CollectionType::kMajor)
? heap->mark_compact_collector()->marking_worklists()
: heap->minor_mark_compact_collector()->marking_worklists();
return std::make_unique<MarkingWorklists::Local>(worklist);
}
} // namespace
UnifiedHeapMarkingVisitorBase::UnifiedHeapMarkingVisitorBase(
HeapBase& heap, cppgc::internal::BasicMarkingState& marking_state,
UnifiedHeapMarkingState& unified_heap_marking_state)
: JSVisitor(cppgc::internal::VisitorFactory::CreateKey()),
marking_state_(marking_state),
unified_heap_marking_state_(unified_heap_marking_state) {}
void UnifiedHeapMarkingVisitorBase::Visit(const void* object,
TraceDescriptor desc) {
marking_state_.MarkAndPush(object, desc);
}
void UnifiedHeapMarkingVisitorBase::VisitWeak(const void* object,
TraceDescriptor desc,
WeakCallback weak_callback,
const void* weak_member) {
marking_state_.RegisterWeakReferenceIfNeeded(object, desc, weak_callback,
weak_member);
}
void UnifiedHeapMarkingVisitorBase::VisitEphemeron(const void* key,
const void* value,
TraceDescriptor value_desc) {
marking_state_.ProcessEphemeron(key, value, value_desc, *this);
}
void UnifiedHeapMarkingVisitorBase::VisitWeakContainer(
const void* self, TraceDescriptor strong_desc, TraceDescriptor weak_desc,
WeakCallback callback, const void* data) {
marking_state_.ProcessWeakContainer(self, weak_desc, callback, data);
}
void UnifiedHeapMarkingVisitorBase::RegisterWeakCallback(WeakCallback callback,
const void* object) {
marking_state_.RegisterWeakCustomCallback(callback, object);
}
void UnifiedHeapMarkingVisitorBase::HandleMovableReference(const void** slot) {
marking_state_.RegisterMovableReference(slot);
}
void UnifiedHeapMarkingVisitorBase::Visit(const TracedReferenceBase& ref) {
unified_heap_marking_state_.MarkAndPush(ref);
}
MutatorUnifiedHeapMarkingVisitor::MutatorUnifiedHeapMarkingVisitor(
HeapBase& heap, MutatorMarkingState& marking_state,
UnifiedHeapMarkingState& unified_heap_marking_state)
: UnifiedHeapMarkingVisitorBase(heap, marking_state,
unified_heap_marking_state) {}
ConcurrentUnifiedHeapMarkingVisitor::ConcurrentUnifiedHeapMarkingVisitor(
HeapBase& heap, Heap* v8_heap,
cppgc::internal::ConcurrentMarkingState& marking_state,
CppHeap::CollectionType collection_type)
: UnifiedHeapMarkingVisitorBase(heap, marking_state,
concurrent_unified_heap_marking_state_),
local_marking_worklist_(GetV8MarkingWorklists(v8_heap, collection_type)),
concurrent_unified_heap_marking_state_(
v8_heap, local_marking_worklist_.get(), collection_type) {}
ConcurrentUnifiedHeapMarkingVisitor::~ConcurrentUnifiedHeapMarkingVisitor() {
if (local_marking_worklist_) {
local_marking_worklist_->Publish();
}
}
bool ConcurrentUnifiedHeapMarkingVisitor::DeferTraceToMutatorThreadIfConcurrent(
const void* parameter, cppgc::TraceCallback callback,
size_t deferred_size) {
marking_state_.concurrent_marking_bailout_worklist().Push(
{parameter, callback, deferred_size});
static_cast<cppgc::internal::ConcurrentMarkingState&>(marking_state_)
.AccountDeferredMarkedBytes(deferred_size);
return true;
}
} // namespace internal
} // namespace v8
|
