1 /*
2 * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #include "precompiled.hpp"
25 #include "classfile/classLoaderData.hpp"
26 #include "classfile/stringTable.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "code/codeCache.hpp"
30 #include "compiler/oopMap.hpp"
31 #include "gc/shared/oopStorageParState.inline.hpp"
32 #include "gc/z/zGlobals.hpp"
33 #include "gc/z/zNMethodTable.hpp"
34 #include "gc/z/zOopClosures.inline.hpp"
35 #include "gc/z/zRootsIterator.hpp"
36 #include "gc/z/zStat.hpp"
37 #include "gc/z/zThreadLocalData.hpp"
38 #include "memory/resourceArea.hpp"
39 #include "memory/universe.hpp"
40 #include "prims/jvmtiExport.hpp"
41 #include "runtime/atomic.hpp"
42 #include "runtime/jniHandles.hpp"
43 #include "runtime/thread.hpp"
44 #include "runtime/safepoint.hpp"
45 #include "runtime/synchronizer.hpp"
46 #include "services/management.hpp"
47 #include "utilities/debug.hpp"
48 #if INCLUDE_JFR
49 #include "jfr/jfr.hpp"
50 #endif
51
52 static const ZStatSubPhase ZSubPhasePauseRootsSetup("Pause Roots Setup");
53 static const ZStatSubPhase ZSubPhasePauseRoots("Pause Roots");
54 static const ZStatSubPhase ZSubPhasePauseRootsTeardown("Pause Roots Teardown");
55 static const ZStatSubPhase ZSubPhasePauseRootsUniverse("Pause Roots Universe");
56 static const ZStatSubPhase ZSubPhasePauseRootsVMWeakHandles("Pause Roots VMWeakHandles");
57 static const ZStatSubPhase ZSubPhasePauseRootsJNIHandles("Pause Roots JNIHandles");
58 static const ZStatSubPhase ZSubPhasePauseRootsJNIWeakHandles("Pause Roots JNIWeakHandles");
59 static const ZStatSubPhase ZSubPhasePauseRootsObjectSynchronizer("Pause Roots ObjectSynchronizer");
60 static const ZStatSubPhase ZSubPhasePauseRootsManagement("Pause Roots Management");
61 static const ZStatSubPhase ZSubPhasePauseRootsJVMTIExport("Pause Roots JVMTIExport");
62 static const ZStatSubPhase ZSubPhasePauseRootsJVMTIWeakExport("Pause Roots JVMTIWeakExport");
63 static const ZStatSubPhase ZSubPhasePauseRootsJFRWeak("Pause Roots JRFWeak");
64 static const ZStatSubPhase ZSubPhasePauseRootsSystemDictionary("Pause Roots SystemDictionary");
65 static const ZStatSubPhase ZSubPhasePauseRootsClassLoaderDataGraph("Pause Roots ClassLoaderDataGraph");
66 static const ZStatSubPhase ZSubPhasePauseRootsThreads("Pause Roots Threads");
67 static const ZStatSubPhase ZSubPhasePauseRootsCodeCache("Pause Roots CodeCache");
68 static const ZStatSubPhase ZSubPhasePauseRootsStringTable("Pause Roots StringTable");
69
70 static const ZStatSubPhase ZSubPhasePauseWeakRootsSetup("Pause Weak Roots Setup");
71 static const ZStatSubPhase ZSubPhasePauseWeakRoots("Pause Weak Roots");
72 static const ZStatSubPhase ZSubPhasePauseWeakRootsTeardown("Pause Weak Roots Teardown");
73 static const ZStatSubPhase ZSubPhasePauseWeakRootsVMWeakHandles("Pause Weak Roots VMWeakHandles");
74 static const ZStatSubPhase ZSubPhasePauseWeakRootsJNIWeakHandles("Pause Weak Roots JNIWeakHandles");
75 static const ZStatSubPhase ZSubPhasePauseWeakRootsJVMTIWeakExport("Pause Weak Roots JVMTIWeakExport");
76 static const ZStatSubPhase ZSubPhasePauseWeakRootsJFRWeak("Pause Weak Roots JFRWeak");
77 static const ZStatSubPhase ZSubPhasePauseWeakRootsSymbolTable("Pause Weak Roots SymbolTable");
78 static const ZStatSubPhase ZSubPhasePauseWeakRootsStringTable("Pause Weak Roots StringTable");
79
80 static const ZStatSubPhase ZSubPhaseConcurrentWeakRoots("Concurrent Weak Roots");
81 static const ZStatSubPhase ZSubPhaseConcurrentWeakRootsVMWeakHandles("Concurrent Weak Roots VMWeakHandles");
82 static const ZStatSubPhase ZSubPhaseConcurrentWeakRootsJNIWeakHandles("Concurrent Weak Roots JNIWeakHandles");
83 static const ZStatSubPhase ZSubPhaseConcurrentWeakRootsStringTable("Concurrent Weak Roots StringTable");
84
85 template <typename T, void (T::*F)(OopClosure*)>
86 ZSerialOopsDo<T, F>::ZSerialOopsDo(T* iter) :
87 _iter(iter),
88 _claimed(false) {}
89
90 template <typename T, void (T::*F)(OopClosure*)>
91 void ZSerialOopsDo<T, F>::oops_do(OopClosure* cl) {
92 if (!_claimed && Atomic::cmpxchg(true, &_claimed, false) == false) {
93 (_iter->*F)(cl);
94 }
95 }
96
97 template <typename T, void (T::*F)(OopClosure*)>
98 ZParallelOopsDo<T, F>::ZParallelOopsDo(T* iter) :
99 _iter(iter),
100 _completed(false) {}
101
102 template <typename T, void (T::*F)(OopClosure*)>
103 void ZParallelOopsDo<T, F>::oops_do(OopClosure* cl) {
104 if (!_completed) {
105 (_iter->*F)(cl);
106 if (!_completed) {
107 _completed = true;
108 }
109 }
110 }
111
112 template <typename T, void (T::*F)(BoolObjectClosure*, OopClosure*)>
113 ZSerialWeakOopsDo<T, F>::ZSerialWeakOopsDo(T* iter) :
114 _iter(iter),
115 _claimed(false) {}
116
117 template <typename T, void (T::*F)(BoolObjectClosure*, OopClosure*)>
118 void ZSerialWeakOopsDo<T, F>::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* cl) {
119 if (!_claimed && Atomic::cmpxchg(true, &_claimed, false) == false) {
120 (_iter->*F)(is_alive, cl);
121 }
122 }
123
124 template <typename T, void (T::*F)(BoolObjectClosure*, OopClosure*)>
125 ZParallelWeakOopsDo<T, F>::ZParallelWeakOopsDo(T* iter) :
126 _iter(iter),
127 _completed(false) {}
128
129 template <typename T, void (T::*F)(BoolObjectClosure*, OopClosure*)>
130 void ZParallelWeakOopsDo<T, F>::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* cl) {
131 if (!_completed) {
132 (_iter->*F)(is_alive, cl);
133 if (!_completed) {
134 _completed = true;
135 }
136 }
137 }
138
139 ZRootsIterator::ZRootsIterator() :
140 _vm_weak_handles_iter(SystemDictionary::vm_weak_oop_storage()),
141 _jni_handles_iter(JNIHandles::global_handles()),
142 _jni_weak_handles_iter(JNIHandles::weak_global_handles()),
143 _string_table_iter(StringTable::weak_storage()),
144 _universe(this),
145 _object_synchronizer(this),
146 _management(this),
147 _jvmti_export(this),
148 _jvmti_weak_export(this),
149 _jfr_weak(this),
150 _system_dictionary(this),
151 _vm_weak_handles(this),
152 _jni_handles(this),
153 _jni_weak_handles(this),
154 _class_loader_data_graph(this),
155 _threads(this),
156 _code_cache(this),
157 _string_table(this) {
158 assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
159 ZStatTimer timer(ZSubPhasePauseRootsSetup);
160 Threads::change_thread_claim_parity();
161 ClassLoaderDataGraph::clear_claimed_marks();
162 COMPILER2_PRESENT(DerivedPointerTable::clear());
163 CodeCache::gc_prologue();
164 ZNMethodTable::gc_prologue();
165 }
166
167 ZRootsIterator::~ZRootsIterator() {
168 ZStatTimer timer(ZSubPhasePauseRootsTeardown);
169 ResourceMark rm;
170 ZNMethodTable::gc_epilogue();
171 CodeCache::gc_epilogue();
172 JvmtiExport::gc_epilogue();
173 COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
174 Threads::assert_all_threads_claimed();
175 }
176
177 void ZRootsIterator::do_universe(OopClosure* cl) {
178 ZStatTimer timer(ZSubPhasePauseRootsUniverse);
179 Universe::oops_do(cl);
180 }
181
182 void ZRootsIterator::do_vm_weak_handles(OopClosure* cl) {
183 ZStatTimer timer(ZSubPhasePauseRootsVMWeakHandles);
184 _vm_weak_handles_iter.oops_do(cl);
185 }
186
187 void ZRootsIterator::do_jni_handles(OopClosure* cl) {
188 ZStatTimer timer(ZSubPhasePauseRootsJNIHandles);
189 _jni_handles_iter.oops_do(cl);
190 }
191
192 void ZRootsIterator::do_jni_weak_handles(OopClosure* cl) {
193 ZStatTimer timer(ZSubPhasePauseRootsJNIWeakHandles);
194 _jni_weak_handles_iter.oops_do(cl);
195 }
196
197 void ZRootsIterator::do_object_synchronizer(OopClosure* cl) {
198 ZStatTimer timer(ZSubPhasePauseRootsObjectSynchronizer);
199 ObjectSynchronizer::oops_do(cl);
200 }
201
202 void ZRootsIterator::do_management(OopClosure* cl) {
203 ZStatTimer timer(ZSubPhasePauseRootsManagement);
204 Management::oops_do(cl);
205 }
206
207 void ZRootsIterator::do_jvmti_export(OopClosure* cl) {
208 ZStatTimer timer(ZSubPhasePauseRootsJVMTIExport);
209 JvmtiExport::oops_do(cl);
210 }
211
212 void ZRootsIterator::do_jvmti_weak_export(OopClosure* cl) {
213 ZStatTimer timer(ZSubPhasePauseRootsJVMTIWeakExport);
214 AlwaysTrueClosure always_alive;
215 JvmtiExport::weak_oops_do(&always_alive, cl);
216 }
217
218 void ZRootsIterator::do_jfr_weak(OopClosure* cl) {
219 #if INCLUDE_JFR
220 ZStatTimer timer(ZSubPhasePauseRootsJFRWeak);
221 AlwaysTrueClosure always_alive;
222 Jfr::weak_oops_do(&always_alive, cl);
223 #endif
224 }
225
226 void ZRootsIterator::do_system_dictionary(OopClosure* cl) {
227 ZStatTimer timer(ZSubPhasePauseRootsSystemDictionary);
228 SystemDictionary::oops_do(cl);
229 }
230
231 void ZRootsIterator::do_class_loader_data_graph(OopClosure* cl) {
232 ZStatTimer timer(ZSubPhasePauseRootsClassLoaderDataGraph);
233 CLDToOopClosure cld_cl(cl);
234 ClassLoaderDataGraph::cld_do(&cld_cl);
235 }
236
237 class ZRootsIteratorThreadClosure : public ThreadClosure {
238 private:
239 OopClosure* const _cl;
240
241 public:
242 ZRootsIteratorThreadClosure(OopClosure* cl) :
243 _cl(cl) {}
244
245 virtual void do_thread(Thread* thread) {
246 if (thread->is_Java_thread()) {
247 // Update thread local address bad mask
248 ZThreadLocalData::set_address_bad_mask(thread, ZAddressBadMask);
249 }
250
251 // Process thread oops
252 thread->oops_do(_cl, NULL);
253 }
254 };
255
256 void ZRootsIterator::do_threads(OopClosure* cl) {
257 ZStatTimer timer(ZSubPhasePauseRootsThreads);
258 ResourceMark rm;
259 ZRootsIteratorThreadClosure thread_cl(cl);
260 Threads::possibly_parallel_threads_do(true, &thread_cl);
261 }
262
263 void ZRootsIterator::do_code_cache(OopClosure* cl) {
264 ZStatTimer timer(ZSubPhasePauseRootsCodeCache);
265 ZNMethodTable::oops_do(cl);
266 }
267
268 void ZRootsIterator::do_string_table(OopClosure* cl) {
269 ZStatTimer timer(ZSubPhasePauseRootsStringTable);
270 _string_table_iter.oops_do(cl);
271 }
272
273 void ZRootsIterator::oops_do(OopClosure* cl, bool visit_jvmti_weak_export) {
274 ZStatTimer timer(ZSubPhasePauseRoots);
275 _universe.oops_do(cl);
276 _object_synchronizer.oops_do(cl);
277 _management.oops_do(cl);
278 _jvmti_export.oops_do(cl);
279 _system_dictionary.oops_do(cl);
280 _jni_handles.oops_do(cl);
281 _class_loader_data_graph.oops_do(cl);
282 _threads.oops_do(cl);
283 _code_cache.oops_do(cl);
284 if (!ZWeakRoots) {
285 _jvmti_weak_export.oops_do(cl);
286 _jfr_weak.oops_do(cl);
287 _vm_weak_handles.oops_do(cl);
288 _jni_weak_handles.oops_do(cl);
289 _string_table.oops_do(cl);
290 } else {
291 if (visit_jvmti_weak_export) {
292 _jvmti_weak_export.oops_do(cl);
293 }
294 }
295 }
296
297 ZWeakRootsIterator::ZWeakRootsIterator() :
298 _vm_weak_handles_iter(SystemDictionary::vm_weak_oop_storage()),
299 _jni_weak_handles_iter(JNIHandles::weak_global_handles()),
300 _string_table_iter(StringTable::weak_storage()),
301 _jvmti_weak_export(this),
302 _jfr_weak(this),
303 _vm_weak_handles(this),
304 _jni_weak_handles(this),
305 _symbol_table(this),
306 _string_table(this) {
307 assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
308 ZStatTimer timer(ZSubPhasePauseWeakRootsSetup);
309 SymbolTable::clear_parallel_claimed_index();
310 StringTable::reset_dead_counter();
311 }
312
313 ZWeakRootsIterator::~ZWeakRootsIterator() {
314 ZStatTimer timer(ZSubPhasePauseWeakRootsTeardown);
315 StringTable::finish_dead_counter();
316 }
317
318 void ZWeakRootsIterator::do_vm_weak_handles(BoolObjectClosure* is_alive, OopClosure* cl) {
319 ZStatTimer timer(ZSubPhasePauseWeakRootsVMWeakHandles);
320 _vm_weak_handles_iter.weak_oops_do(is_alive, cl);
321 }
322
323 void ZWeakRootsIterator::do_jni_weak_handles(BoolObjectClosure* is_alive, OopClosure* cl) {
324 ZStatTimer timer(ZSubPhasePauseWeakRootsJNIWeakHandles);
325 _jni_weak_handles_iter.weak_oops_do(is_alive, cl);
326 }
327
328 void ZWeakRootsIterator::do_jvmti_weak_export(BoolObjectClosure* is_alive, OopClosure* cl) {
329 ZStatTimer timer(ZSubPhasePauseWeakRootsJVMTIWeakExport);
330 JvmtiExport::weak_oops_do(is_alive, cl);
331 }
332
333 void ZWeakRootsIterator::do_jfr_weak(BoolObjectClosure* is_alive, OopClosure* cl) {
334 #if INCLUDE_JFR
335 ZStatTimer timer(ZSubPhasePauseWeakRootsJFRWeak);
336 Jfr::weak_oops_do(is_alive, cl);
337 #endif
338 }
339
340 void ZWeakRootsIterator::do_symbol_table(BoolObjectClosure* is_alive, OopClosure* cl) {
341 ZStatTimer timer(ZSubPhasePauseWeakRootsSymbolTable);
342 int dummy;
343 SymbolTable::possibly_parallel_unlink(&dummy, &dummy);
344 }
345
346 class ZStringTableDeadCounterBoolObjectClosure : public BoolObjectClosure {
347 private:
348 BoolObjectClosure* const _cl;
349 size_t _ndead;
350
351 public:
352 ZStringTableDeadCounterBoolObjectClosure(BoolObjectClosure* cl) :
353 _cl(cl),
354 _ndead(0) {}
355
356 ~ZStringTableDeadCounterBoolObjectClosure() {
357 StringTable::inc_dead_counter(_ndead);
358 }
359
360 virtual bool do_object_b(oop obj) {
361 if (_cl->do_object_b(obj)) {
362 return true;
363 }
364
365 _ndead++;
366 return false;
367 }
368 };
369
370 void ZWeakRootsIterator::do_string_table(BoolObjectClosure* is_alive, OopClosure* cl) {
371 ZStatTimer timer(ZSubPhasePauseWeakRootsStringTable);
372 ZStringTableDeadCounterBoolObjectClosure counter_is_alive(is_alive);
373 _string_table_iter.weak_oops_do(&counter_is_alive, cl);
374 }
375
376 void ZWeakRootsIterator::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* cl) {
377 ZStatTimer timer(ZSubPhasePauseWeakRoots);
378 if (ZSymbolTableUnloading) {
379 _symbol_table.weak_oops_do(is_alive, cl);
380 }
381 if (ZWeakRoots) {
382 _jvmti_weak_export.weak_oops_do(is_alive, cl);
383 _jfr_weak.weak_oops_do(is_alive, cl);
384 if (!ZConcurrentVMWeakHandles) {
385 _vm_weak_handles.weak_oops_do(is_alive, cl);
386 }
387 if (!ZConcurrentJNIWeakGlobalHandles) {
388 _jni_weak_handles.weak_oops_do(is_alive, cl);
389 }
390 if (!ZConcurrentStringTable) {
391 _string_table.weak_oops_do(is_alive, cl);
392 }
393 }
394 }
395
396 void ZWeakRootsIterator::oops_do(OopClosure* cl) {
397 AlwaysTrueClosure always_alive;
398 weak_oops_do(&always_alive, cl);
399 }
400
401 ZConcurrentWeakRootsIterator::ZConcurrentWeakRootsIterator() :
402 _vm_weak_handles_iter(SystemDictionary::vm_weak_oop_storage()),
403 _jni_weak_handles_iter(JNIHandles::weak_global_handles()),
404 _string_table_iter(StringTable::weak_storage()),
405 _vm_weak_handles(this),
406 _jni_weak_handles(this),
407 _string_table(this) {
408 StringTable::reset_dead_counter();
409 }
410
411 ZConcurrentWeakRootsIterator::~ZConcurrentWeakRootsIterator() {
412 StringTable::finish_dead_counter();
413 }
414
415 void ZConcurrentWeakRootsIterator::do_vm_weak_handles(OopClosure* cl) {
416 ZStatTimer timer(ZSubPhaseConcurrentWeakRootsVMWeakHandles);
417 _vm_weak_handles_iter.oops_do(cl);
418 }
419
420 void ZConcurrentWeakRootsIterator::do_jni_weak_handles(OopClosure* cl) {
421 ZStatTimer timer(ZSubPhaseConcurrentWeakRootsJNIWeakHandles);
422 _jni_weak_handles_iter.oops_do(cl);
423 }
424
425 class ZStringTableDeadCounterOopClosure : public OopClosure {
426 private:
427 OopClosure* const _cl;
428 size_t _ndead;
429
430 public:
431 ZStringTableDeadCounterOopClosure(OopClosure* cl) :
432 _cl(cl),
433 _ndead(0) {}
434
435 ~ZStringTableDeadCounterOopClosure() {
436 StringTable::inc_dead_counter(_ndead);
437 }
438
439 virtual void do_oop(oop* p) {
440 _cl->do_oop(p);
441 if (*p == NULL) {
442 _ndead++;
443 }
444 }
445
446 virtual void do_oop(narrowOop* p) {
447 ShouldNotReachHere();
448 }
449 };
450
451 void ZConcurrentWeakRootsIterator::do_string_table(OopClosure* cl) {
452 ZStatTimer timer(ZSubPhaseConcurrentWeakRootsStringTable);
453 ZStringTableDeadCounterOopClosure counter_cl(cl);
454 _string_table_iter.oops_do(&counter_cl);
455 }
456
457 void ZConcurrentWeakRootsIterator::oops_do(OopClosure* cl) {
458 ZStatTimer timer(ZSubPhaseConcurrentWeakRoots);
459 if (ZWeakRoots) {
460 if (ZConcurrentVMWeakHandles) {
461 _vm_weak_handles.oops_do(cl);
462 }
463 if (ZConcurrentJNIWeakGlobalHandles) {
464 _jni_weak_handles.oops_do(cl);
465 }
466 if (ZConcurrentStringTable) {
467 _string_table.oops_do(cl);
468 }
469 }
470 }
471
472 ZThreadRootsIterator::ZThreadRootsIterator() :
473 _threads(this) {
474 assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
475 ZStatTimer timer(ZSubPhasePauseRootsSetup);
476 Threads::change_thread_claim_parity();
477 }
478
479 ZThreadRootsIterator::~ZThreadRootsIterator() {
480 ZStatTimer timer(ZSubPhasePauseRootsTeardown);
481 Threads::assert_all_threads_claimed();
482 }
483
484 void ZThreadRootsIterator::do_threads(OopClosure* cl) {
485 ZStatTimer timer(ZSubPhasePauseRootsThreads);
486 ResourceMark rm;
487 Threads::possibly_parallel_oops_do(true, cl, NULL);
488 }
489
490 void ZThreadRootsIterator::oops_do(OopClosure* cl) {
491 ZStatTimer timer(ZSubPhasePauseRoots);
492 _threads.oops_do(cl);
493 }