54 _oops_do(cl);
55 }
56 }
57
58 ShenandoahSerialRoots::ShenandoahSerialRoots() :
59 _universe_root(&Universe::oops_do, ShenandoahPhaseTimings::UniverseRoots),
60 _object_synchronizer_root(&ObjectSynchronizer::oops_do, ShenandoahPhaseTimings::ObjectSynchronizerRoots),
61 _management_root(&Management::oops_do, ShenandoahPhaseTimings::ManagementRoots),
62 _system_dictionary_root(&SystemDictionary::oops_do, ShenandoahPhaseTimings::SystemDictionaryRoots),
63 _jvmti_root(&JvmtiExport::oops_do, ShenandoahPhaseTimings::JVMTIRoots) {
64 }
65
66 void ShenandoahSerialRoots::oops_do(OopClosure* cl, uint worker_id) {
67 _universe_root.oops_do(cl, worker_id);
68 _object_synchronizer_root.oops_do(cl, worker_id);
69 _management_root.oops_do(cl, worker_id);
70 _system_dictionary_root.oops_do(cl, worker_id);
71 _jvmti_root.oops_do(cl, worker_id);
72 }
73
74 ShenandoahJNIHandleRoots::ShenandoahJNIHandleRoots() :
75 ShenandoahSerialRoot(&JNIHandles::oops_do, ShenandoahPhaseTimings::JNIRoots) {
76 }
77
78 ShenandoahThreadRoots::ShenandoahThreadRoots(bool is_par) : _is_par(is_par) {
79 Threads::change_thread_claim_token();
80 }
81
82 void ShenandoahThreadRoots::oops_do(OopClosure* oops_cl, CodeBlobClosure* code_cl, uint worker_id) {
83 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
84 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::ThreadRoots, worker_id);
85 ResourceMark rm;
86 Threads::possibly_parallel_oops_do(_is_par, oops_cl, code_cl);
87 }
88
89 void ShenandoahThreadRoots::threads_do(ThreadClosure* tc, uint worker_id) {
90 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
91 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::ThreadRoots, worker_id);
92 ResourceMark rm;
93 Threads::possibly_parallel_threads_do(_is_par, tc);
94 }
95
96 ShenandoahThreadRoots::~ShenandoahThreadRoots() {
97 Threads::assert_all_threads_claimed();
109 }
110
111 ShenandoahStringDedupRoots::ShenandoahStringDedupRoots() {
112 if (ShenandoahStringDedup::is_enabled()) {
113 StringDedup::gc_prologue(false);
114 }
115 }
116
117 ShenandoahStringDedupRoots::~ShenandoahStringDedupRoots() {
118 if (ShenandoahStringDedup::is_enabled()) {
119 StringDedup::gc_epilogue();
120 }
121 }
122
123 void ShenandoahStringDedupRoots::oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
124 if (ShenandoahStringDedup::is_enabled()) {
125 ShenandoahStringDedup::parallel_oops_do(is_alive, keep_alive, worker_id);
126 }
127 }
128
129 ShenandoahClassLoaderDataRoots::ShenandoahClassLoaderDataRoots() {
130 ClassLoaderDataGraph::clear_claimed_marks();
131 }
132
133 void ShenandoahClassLoaderDataRoots::always_strong_cld_do(CLDClosure* clds, uint worker_id) {
134 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
135 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
136 ClassLoaderDataGraph::always_strong_cld_do(clds);
137 }
138
139 void ShenandoahClassLoaderDataRoots::cld_do(CLDClosure* clds, uint worker_id) {
140 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
141 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
142 ClassLoaderDataGraph::cld_do(clds);
143 }
144
145 ShenandoahRootProcessor::ShenandoahRootProcessor(ShenandoahPhaseTimings::Phase phase) :
146 _heap(ShenandoahHeap::heap()),
147 _phase(phase) {
148 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
149 _heap->phase_timings()->record_workers_start(_phase);
150 }
151
152 ShenandoahRootProcessor::~ShenandoahRootProcessor() {
153 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
154 _heap->phase_timings()->record_workers_end(_phase);
155 }
156
157 ShenandoahRootEvacuator::ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
158 ShenandoahRootProcessor(phase),
159 _thread_roots(n_workers > 1),
160 _weak_roots(n_workers) {
161 }
162
163 void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
164 MarkingCodeBlobClosure blobsCl(oops, CodeBlobToOopClosure::FixRelocations);
165 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
166 CLDToOopClosure* weak_clds = ShenandoahHeap::heap()->unload_classes() ? NULL : &clds;
167
168 AlwaysTrueClosure always_true;
169
170 _serial_roots.oops_do(oops, worker_id);
171 _jni_roots.oops_do(oops, worker_id);
172
173 _thread_roots.oops_do(oops, NULL, worker_id);
174 _cld_roots.cld_do(&clds, worker_id);
175 _code_roots.code_blobs_do(&blobsCl, worker_id);
176
177 _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
178 _dedup_roots.oops_do(&always_true, oops, worker_id);
179 }
180
181 ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool update_code_cache) :
182 ShenandoahRootProcessor(phase),
183 _thread_roots(n_workers > 1),
184 _weak_roots(n_workers),
185 _update_code_cache(update_code_cache) {
186 }
187
188 ShenandoahRootAdjuster::ShenandoahRootAdjuster(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
189 ShenandoahRootProcessor(phase),
190 _thread_roots(n_workers > 1),
191 _weak_roots(n_workers) {
192 assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
193 }
194
|
54 _oops_do(cl);
55 }
56 }
57
58 ShenandoahSerialRoots::ShenandoahSerialRoots() :
59 _universe_root(&Universe::oops_do, ShenandoahPhaseTimings::UniverseRoots),
60 _object_synchronizer_root(&ObjectSynchronizer::oops_do, ShenandoahPhaseTimings::ObjectSynchronizerRoots),
61 _management_root(&Management::oops_do, ShenandoahPhaseTimings::ManagementRoots),
62 _system_dictionary_root(&SystemDictionary::oops_do, ShenandoahPhaseTimings::SystemDictionaryRoots),
63 _jvmti_root(&JvmtiExport::oops_do, ShenandoahPhaseTimings::JVMTIRoots) {
64 }
65
66 void ShenandoahSerialRoots::oops_do(OopClosure* cl, uint worker_id) {
67 _universe_root.oops_do(cl, worker_id);
68 _object_synchronizer_root.oops_do(cl, worker_id);
69 _management_root.oops_do(cl, worker_id);
70 _system_dictionary_root.oops_do(cl, worker_id);
71 _jvmti_root.oops_do(cl, worker_id);
72 }
73
74 ShenandoahThreadRoots::ShenandoahThreadRoots(bool is_par) : _is_par(is_par) {
75 Threads::change_thread_claim_token();
76 }
77
78 void ShenandoahThreadRoots::oops_do(OopClosure* oops_cl, CodeBlobClosure* code_cl, uint worker_id) {
79 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
80 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::ThreadRoots, worker_id);
81 ResourceMark rm;
82 Threads::possibly_parallel_oops_do(_is_par, oops_cl, code_cl);
83 }
84
85 void ShenandoahThreadRoots::threads_do(ThreadClosure* tc, uint worker_id) {
86 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
87 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::ThreadRoots, worker_id);
88 ResourceMark rm;
89 Threads::possibly_parallel_threads_do(_is_par, tc);
90 }
91
92 ShenandoahThreadRoots::~ShenandoahThreadRoots() {
93 Threads::assert_all_threads_claimed();
105 }
106
107 ShenandoahStringDedupRoots::ShenandoahStringDedupRoots() {
108 if (ShenandoahStringDedup::is_enabled()) {
109 StringDedup::gc_prologue(false);
110 }
111 }
112
113 ShenandoahStringDedupRoots::~ShenandoahStringDedupRoots() {
114 if (ShenandoahStringDedup::is_enabled()) {
115 StringDedup::gc_epilogue();
116 }
117 }
118
119 void ShenandoahStringDedupRoots::oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
120 if (ShenandoahStringDedup::is_enabled()) {
121 ShenandoahStringDedup::parallel_oops_do(is_alive, keep_alive, worker_id);
122 }
123 }
124
125 ShenandoahRootProcessor::ShenandoahRootProcessor(ShenandoahPhaseTimings::Phase phase) :
126 _heap(ShenandoahHeap::heap()),
127 _phase(phase) {
128 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
129 _heap->phase_timings()->record_workers_start(_phase);
130 }
131
132 ShenandoahRootProcessor::~ShenandoahRootProcessor() {
133 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
134 _heap->phase_timings()->record_workers_end(_phase);
135 }
136
137 ShenandoahRootEvacuator::ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool include_concurrent_roots) :
138 ShenandoahRootProcessor(phase),
139 _thread_roots(n_workers > 1),
140 _weak_roots(n_workers),
141 _include_concurrent_roots(include_concurrent_roots) {
142 }
143
144 void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
145 MarkingCodeBlobClosure blobsCl(oops, CodeBlobToOopClosure::FixRelocations);
146 AlwaysTrueClosure always_true;
147
148 _serial_roots.oops_do(oops, worker_id);
149 if (_include_concurrent_roots) {
150 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
151 _jni_roots.oops_do<OopClosure>(oops, worker_id);
152 _cld_roots.cld_do(&clds, worker_id);
153 }
154
155 _thread_roots.oops_do(oops, NULL, worker_id);
156 _code_roots.code_blobs_do(&blobsCl, worker_id);
157
158 _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
159 _dedup_roots.oops_do(&always_true, oops, worker_id);
160 }
161
162 ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool update_code_cache) :
163 ShenandoahRootProcessor(phase),
164 _thread_roots(n_workers > 1),
165 _weak_roots(n_workers),
166 _update_code_cache(update_code_cache) {
167 }
168
169 ShenandoahRootAdjuster::ShenandoahRootAdjuster(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
170 ShenandoahRootProcessor(phase),
171 _thread_roots(n_workers > 1),
172 _weak_roots(n_workers) {
173 assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
174 }
175
|