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
|
// 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/gc-invoker.h"
#include <memory>
#include "include/cppgc/platform.h"
#include "src/heap/cppgc/heap.h"
#include "src/heap/cppgc/task-handle.h"
namespace cppgc {
namespace internal {
class GCInvoker::GCInvokerImpl final : public GarbageCollector {
public:
GCInvokerImpl(GarbageCollector*, cppgc::Platform*, cppgc::Heap::StackSupport);
~GCInvokerImpl();
GCInvokerImpl(const GCInvokerImpl&) = delete;
GCInvokerImpl& operator=(const GCInvokerImpl&) = delete;
void CollectGarbage(GarbageCollector::Config) final;
size_t epoch() const final { return collector_->epoch(); }
private:
class GCTask final : public cppgc::Task {
public:
using Handle = SingleThreadedHandle;
static Handle Post(GarbageCollector* collector, cppgc::TaskRunner* runner) {
auto task = std::make_unique<GCInvoker::GCInvokerImpl::GCTask>(collector);
auto handle = task->GetHandle();
runner->PostNonNestableTask(std::move(task));
return handle;
}
explicit GCTask(GarbageCollector* collector)
: collector_(collector), saved_epoch_(collector->epoch()) {}
private:
void Run() final {
if (handle_.IsCanceled() || (collector_->epoch() != saved_epoch_)) return;
collector_->CollectGarbage(
GarbageCollector::Config::PreciseAtomicConfig());
handle_.Cancel();
}
Handle GetHandle() { return handle_; }
GarbageCollector* collector_;
Handle handle_;
size_t saved_epoch_;
};
GarbageCollector* collector_;
cppgc::Platform* platform_;
cppgc::Heap::StackSupport stack_support_;
GCTask::Handle gc_task_handle_;
};
GCInvoker::GCInvokerImpl::GCInvokerImpl(GarbageCollector* collector,
cppgc::Platform* platform,
cppgc::Heap::StackSupport stack_support)
: collector_(collector),
platform_(platform),
stack_support_(stack_support) {}
GCInvoker::GCInvokerImpl::~GCInvokerImpl() {
if (gc_task_handle_) {
gc_task_handle_.Cancel();
}
}
void GCInvoker::GCInvokerImpl::CollectGarbage(GarbageCollector::Config config) {
if ((config.stack_state ==
GarbageCollector::Config::StackState::kNoHeapPointers) ||
(stack_support_ ==
cppgc::Heap::StackSupport::kSupportsConservativeStackScan)) {
collector_->CollectGarbage(config);
} else if (platform_->GetForegroundTaskRunner()->NonNestableTasksEnabled()) {
if (!gc_task_handle_) {
gc_task_handle_ =
GCTask::Post(collector_, platform_->GetForegroundTaskRunner().get());
}
}
}
GCInvoker::GCInvoker(GarbageCollector* collector, cppgc::Platform* platform,
cppgc::Heap::StackSupport stack_support)
: impl_(std::make_unique<GCInvoker::GCInvokerImpl>(collector, platform,
stack_support)) {}
GCInvoker::~GCInvoker() = default;
void GCInvoker::CollectGarbage(GarbageCollector::Config config) {
impl_->CollectGarbage(config);
}
size_t GCInvoker::epoch() const { return impl_->epoch(); }
} // namespace internal
} // namespace cppgc
|
