1 /*
2  * Copyright (c) 2015, 2019, 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/classLoaderDataGraph.hpp"
26 #include "classfile/stringTable.hpp"
27 #include "classfile/systemDictionary.hpp"
28 #include "code/codeCache.hpp"
29 #include "compiler/oopMap.hpp"
30 #include "gc/shared/barrierSet.hpp"
31 #include "gc/shared/barrierSetNMethod.hpp"
32 #include "gc/shared/oopStorageParState.inline.hpp"
33 #include "gc/shared/oopStorageSet.hpp"
34 #include "gc/shared/suspendibleThreadSet.hpp"
35 #include "gc/z/zBarrierSetNMethod.hpp"
36 #include "gc/z/zGlobals.hpp"
37 #include "gc/z/zNMethod.hpp"
38 #include "gc/z/zOopClosures.inline.hpp"
39 #include "gc/z/zRootsIterator.hpp"
40 #include "gc/z/zStat.hpp"
41 #include "gc/z/zThreadLocalData.hpp"
42 #include "memory/iterator.hpp"
43 #include "memory/resourceArea.hpp"
44 #include "memory/universe.hpp"
45 #include "prims/jvmtiExport.hpp"
46 #include "prims/resolvedMethodTable.hpp"
47 #include "runtime/atomic.hpp"
48 #include "runtime/thread.hpp"
49 #include "runtime/safepoint.hpp"
50 #include "runtime/synchronizer.hpp"
51 #include "services/management.hpp"
52 #include "utilities/debug.hpp"
53 #if INCLUDE_JFR
54 #include "jfr/jfr.hpp"
55 #endif
56 
57 static const ZStatSubPhase ZSubPhasePauseRootsSetup("Pause Roots Setup");
58 static const ZStatSubPhase ZSubPhasePauseRoots("Pause Roots");
59 static const ZStatSubPhase ZSubPhasePauseRootsTeardown("Pause Roots Teardown");
60 static const ZStatSubPhase ZSubPhasePauseRootsUniverse("Pause Roots Universe");
61 static const ZStatSubPhase ZSubPhasePauseRootsObjectSynchronizer("Pause Roots ObjectSynchronizer");
62 static const ZStatSubPhase ZSubPhasePauseRootsManagement("Pause Roots Management");
63 static const ZStatSubPhase ZSubPhasePauseRootsJVMTIExport("Pause Roots JVMTIExport");
64 static const ZStatSubPhase ZSubPhasePauseRootsJVMTIWeakExport("Pause Roots JVMTIWeakExport");
65 static const ZStatSubPhase ZSubPhasePauseRootsSystemDictionary("Pause Roots SystemDictionary");
66 static const ZStatSubPhase ZSubPhasePauseRootsThreads("Pause Roots Threads");
67 static const ZStatSubPhase ZSubPhasePauseRootsCodeCache("Pause Roots CodeCache");
68 
69 static const ZStatSubPhase ZSubPhaseConcurrentRootsSetup("Concurrent Roots Setup");
70 static const ZStatSubPhase ZSubPhaseConcurrentRoots("Concurrent Roots");
71 static const ZStatSubPhase ZSubPhaseConcurrentRootsTeardown("Concurrent Roots Teardown");
72 static const ZStatSubPhase ZSubPhaseConcurrentRootsJNIHandles("Concurrent Roots JNIHandles");
73 static const ZStatSubPhase ZSubPhaseConcurrentRootsVMHandles("Concurrent Roots VMHandles");
74 static const ZStatSubPhase ZSubPhaseConcurrentRootsClassLoaderDataGraph("Concurrent Roots ClassLoaderDataGraph");
75 
76 static const ZStatSubPhase ZSubPhasePauseWeakRootsSetup("Pause Weak Roots Setup");
77 static const ZStatSubPhase ZSubPhasePauseWeakRoots("Pause Weak Roots");
78 static const ZStatSubPhase ZSubPhasePauseWeakRootsTeardown("Pause Weak Roots Teardown");
79 static const ZStatSubPhase ZSubPhasePauseWeakRootsJVMTIWeakExport("Pause Weak Roots JVMTIWeakExport");
80 static const ZStatSubPhase ZSubPhasePauseWeakRootsJFRWeak("Pause Weak Roots JFRWeak");
81 
82 static const ZStatSubPhase ZSubPhaseConcurrentWeakRoots("Concurrent Weak Roots");
83 static const ZStatSubPhase ZSubPhaseConcurrentWeakRootsVMWeakHandles("Concurrent Weak Roots VMWeakHandles");
84 static const ZStatSubPhase ZSubPhaseConcurrentWeakRootsJNIWeakHandles("Concurrent Weak Roots JNIWeakHandles");
85 static const ZStatSubPhase ZSubPhaseConcurrentWeakRootsStringTable("Concurrent Weak Roots StringTable");
86 static const ZStatSubPhase ZSubPhaseConcurrentWeakRootsResolvedMethodTable("Concurrent Weak Roots ResolvedMethodTable");
87 
88 template <typename T, void (T::*F)(ZRootsIteratorClosure*)>
ZSerialOopsDo(T * iter)89 ZSerialOopsDo<T, F>::ZSerialOopsDo(T* iter) :
90     _iter(iter),
91     _claimed(false) {}
92 
93 template <typename T, void (T::*F)(ZRootsIteratorClosure*)>
oops_do(ZRootsIteratorClosure * cl)94 void ZSerialOopsDo<T, F>::oops_do(ZRootsIteratorClosure* cl) {
95   if (!_claimed && Atomic::cmpxchg(&_claimed, false, true) == false) {
96     (_iter->*F)(cl);
97   }
98 }
99 
100 template <typename T, void (T::*F)(ZRootsIteratorClosure*)>
ZParallelOopsDo(T * iter)101 ZParallelOopsDo<T, F>::ZParallelOopsDo(T* iter) :
102     _iter(iter),
103     _completed(false) {}
104 
105 template <typename T, void (T::*F)(ZRootsIteratorClosure*)>
oops_do(ZRootsIteratorClosure * cl)106 void ZParallelOopsDo<T, F>::oops_do(ZRootsIteratorClosure* cl) {
107   if (!_completed) {
108     (_iter->*F)(cl);
109     if (!_completed) {
110       _completed = true;
111     }
112   }
113 }
114 
115 template <typename T, void (T::*F)(BoolObjectClosure*, ZRootsIteratorClosure*)>
ZSerialWeakOopsDo(T * iter)116 ZSerialWeakOopsDo<T, F>::ZSerialWeakOopsDo(T* iter) :
117     _iter(iter),
118     _claimed(false) {}
119 
120 template <typename T, void (T::*F)(BoolObjectClosure*, ZRootsIteratorClosure*)>
weak_oops_do(BoolObjectClosure * is_alive,ZRootsIteratorClosure * cl)121 void ZSerialWeakOopsDo<T, F>::weak_oops_do(BoolObjectClosure* is_alive, ZRootsIteratorClosure* cl) {
122   if (!_claimed && Atomic::cmpxchg(&_claimed, false, true) == false) {
123     (_iter->*F)(is_alive, cl);
124   }
125 }
126 
127 template <typename T, void (T::*F)(BoolObjectClosure*, ZRootsIteratorClosure*)>
ZParallelWeakOopsDo(T * iter)128 ZParallelWeakOopsDo<T, F>::ZParallelWeakOopsDo(T* iter) :
129     _iter(iter),
130     _completed(false) {}
131 
132 template <typename T, void (T::*F)(BoolObjectClosure*, ZRootsIteratorClosure*)>
weak_oops_do(BoolObjectClosure * is_alive,ZRootsIteratorClosure * cl)133 void ZParallelWeakOopsDo<T, F>::weak_oops_do(BoolObjectClosure* is_alive, ZRootsIteratorClosure* cl) {
134   if (!_completed) {
135     (_iter->*F)(is_alive, cl);
136     if (!_completed) {
137       _completed = true;
138     }
139   }
140 }
141 
142 class ZRootsIteratorCodeBlobClosure : public CodeBlobClosure {
143 private:
144   ZRootsIteratorClosure* const _cl;
145   const bool                   _should_disarm_nmethods;
146 
147 public:
ZRootsIteratorCodeBlobClosure(ZRootsIteratorClosure * cl)148   ZRootsIteratorCodeBlobClosure(ZRootsIteratorClosure* cl) :
149       _cl(cl),
150       _should_disarm_nmethods(cl->should_disarm_nmethods()) {}
151 
do_code_blob(CodeBlob * cb)152   virtual void do_code_blob(CodeBlob* cb) {
153     nmethod* const nm = cb->as_nmethod_or_null();
154     if (nm != NULL && nm->oops_do_try_claim()) {
155       ZNMethod::nmethod_oops_do(nm, _cl);
156       assert(!ZNMethod::supports_entry_barrier(nm) ||
157              ZNMethod::is_armed(nm) == _should_disarm_nmethods, "Invalid state");
158       if (_should_disarm_nmethods) {
159         ZNMethod::disarm(nm);
160       }
161     }
162   }
163 };
164 
165 class ZRootsIteratorThreadClosure : public ThreadClosure {
166 private:
167   ZRootsIteratorClosure* const _cl;
168 
169 public:
ZRootsIteratorThreadClosure(ZRootsIteratorClosure * cl)170   ZRootsIteratorThreadClosure(ZRootsIteratorClosure* cl) :
171       _cl(cl) {}
172 
do_thread(Thread * thread)173   virtual void do_thread(Thread* thread) {
174     ZRootsIteratorCodeBlobClosure code_cl(_cl);
175     thread->oops_do(_cl, ClassUnloading ? &code_cl : NULL);
176     _cl->do_thread(thread);
177   }
178 };
179 
ZRootsIterator(bool visit_jvmti_weak_export)180 ZRootsIterator::ZRootsIterator(bool visit_jvmti_weak_export) :
181     _visit_jvmti_weak_export(visit_jvmti_weak_export),
182     _universe(this),
183     _object_synchronizer(this),
184     _management(this),
185     _jvmti_export(this),
186     _jvmti_weak_export(this),
187     _system_dictionary(this),
188     _threads(this),
189     _code_cache(this) {
190   assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
191   ZStatTimer timer(ZSubPhasePauseRootsSetup);
192   Threads::change_thread_claim_token();
193   COMPILER2_OR_JVMCI_PRESENT(DerivedPointerTable::clear());
194   if (ClassUnloading) {
195     nmethod::oops_do_marking_prologue();
196   } else {
197     ZNMethod::oops_do_begin();
198   }
199 }
200 
~ZRootsIterator()201 ZRootsIterator::~ZRootsIterator() {
202   ZStatTimer timer(ZSubPhasePauseRootsTeardown);
203   ResourceMark rm;
204   if (ClassUnloading) {
205     nmethod::oops_do_marking_epilogue();
206   } else {
207     ZNMethod::oops_do_end();
208   }
209 
210   COMPILER2_OR_JVMCI_PRESENT(DerivedPointerTable::update_pointers());
211   Threads::assert_all_threads_claimed();
212 }
213 
do_universe(ZRootsIteratorClosure * cl)214 void ZRootsIterator::do_universe(ZRootsIteratorClosure* cl) {
215   ZStatTimer timer(ZSubPhasePauseRootsUniverse);
216   Universe::oops_do(cl);
217 }
218 
do_object_synchronizer(ZRootsIteratorClosure * cl)219 void ZRootsIterator::do_object_synchronizer(ZRootsIteratorClosure* cl) {
220   ZStatTimer timer(ZSubPhasePauseRootsObjectSynchronizer);
221   ObjectSynchronizer::oops_do(cl);
222 }
223 
do_management(ZRootsIteratorClosure * cl)224 void ZRootsIterator::do_management(ZRootsIteratorClosure* cl) {
225   ZStatTimer timer(ZSubPhasePauseRootsManagement);
226   Management::oops_do(cl);
227 }
228 
do_jvmti_export(ZRootsIteratorClosure * cl)229 void ZRootsIterator::do_jvmti_export(ZRootsIteratorClosure* cl) {
230   ZStatTimer timer(ZSubPhasePauseRootsJVMTIExport);
231   JvmtiExport::oops_do(cl);
232 }
233 
do_jvmti_weak_export(ZRootsIteratorClosure * cl)234 void ZRootsIterator::do_jvmti_weak_export(ZRootsIteratorClosure* cl) {
235   ZStatTimer timer(ZSubPhasePauseRootsJVMTIWeakExport);
236   AlwaysTrueClosure always_alive;
237   JvmtiExport::weak_oops_do(&always_alive, cl);
238 }
239 
do_system_dictionary(ZRootsIteratorClosure * cl)240 void ZRootsIterator::do_system_dictionary(ZRootsIteratorClosure* cl) {
241   ZStatTimer timer(ZSubPhasePauseRootsSystemDictionary);
242   // Handles are processed via _vm_handles.
243   SystemDictionary::oops_do(cl, false /* include_handles */);
244 }
245 
do_threads(ZRootsIteratorClosure * cl)246 void ZRootsIterator::do_threads(ZRootsIteratorClosure* cl) {
247   ZStatTimer timer(ZSubPhasePauseRootsThreads);
248   ResourceMark rm;
249   ZRootsIteratorThreadClosure thread_cl(cl);
250   Threads::possibly_parallel_threads_do(true, &thread_cl);
251 }
252 
do_code_cache(ZRootsIteratorClosure * cl)253 void ZRootsIterator::do_code_cache(ZRootsIteratorClosure* cl) {
254   ZStatTimer timer(ZSubPhasePauseRootsCodeCache);
255   ZNMethod::oops_do(cl);
256 }
257 
oops_do(ZRootsIteratorClosure * cl)258 void ZRootsIterator::oops_do(ZRootsIteratorClosure* cl) {
259   ZStatTimer timer(ZSubPhasePauseRoots);
260   _universe.oops_do(cl);
261   _object_synchronizer.oops_do(cl);
262   _management.oops_do(cl);
263   _jvmti_export.oops_do(cl);
264   _system_dictionary.oops_do(cl);
265   _threads.oops_do(cl);
266   if (!ClassUnloading) {
267     _code_cache.oops_do(cl);
268   }
269   if (_visit_jvmti_weak_export) {
270     _jvmti_weak_export.oops_do(cl);
271   }
272 }
273 
ZConcurrentRootsIterator(int cld_claim)274 ZConcurrentRootsIterator::ZConcurrentRootsIterator(int cld_claim) :
275     _jni_handles_iter(OopStorageSet::jni_global()),
276     _vm_handles_iter(OopStorageSet::vm_global()),
277     _cld_claim(cld_claim),
278     _jni_handles(this),
279     _vm_handles(this),
280     _class_loader_data_graph(this) {
281   ZStatTimer timer(ZSubPhaseConcurrentRootsSetup);
282   ClassLoaderDataGraph::clear_claimed_marks(cld_claim);
283 }
284 
~ZConcurrentRootsIterator()285 ZConcurrentRootsIterator::~ZConcurrentRootsIterator() {
286   ZStatTimer timer(ZSubPhaseConcurrentRootsTeardown);
287 }
288 
do_jni_handles(ZRootsIteratorClosure * cl)289 void ZConcurrentRootsIterator::do_jni_handles(ZRootsIteratorClosure* cl) {
290   ZStatTimer timer(ZSubPhaseConcurrentRootsJNIHandles);
291   _jni_handles_iter.oops_do(cl);
292 }
293 
do_vm_handles(ZRootsIteratorClosure * cl)294 void ZConcurrentRootsIterator::do_vm_handles(ZRootsIteratorClosure* cl) {
295   ZStatTimer timer(ZSubPhaseConcurrentRootsVMHandles);
296   _vm_handles_iter.oops_do(cl);
297 }
298 
do_class_loader_data_graph(ZRootsIteratorClosure * cl)299 void ZConcurrentRootsIterator::do_class_loader_data_graph(ZRootsIteratorClosure* cl) {
300   ZStatTimer timer(ZSubPhaseConcurrentRootsClassLoaderDataGraph);
301   CLDToOopClosure cld_cl(cl, _cld_claim);
302   ClassLoaderDataGraph::always_strong_cld_do(&cld_cl);
303 }
304 
oops_do(ZRootsIteratorClosure * cl)305 void ZConcurrentRootsIterator::oops_do(ZRootsIteratorClosure* cl) {
306   ZStatTimer timer(ZSubPhaseConcurrentRoots);
307   _jni_handles.oops_do(cl);
308   _vm_handles.oops_do(cl),
309   _class_loader_data_graph.oops_do(cl);
310 }
311 
ZWeakRootsIterator()312 ZWeakRootsIterator::ZWeakRootsIterator() :
313     _jvmti_weak_export(this),
314     _jfr_weak(this) {
315   assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
316   ZStatTimer timer(ZSubPhasePauseWeakRootsSetup);
317 }
318 
~ZWeakRootsIterator()319 ZWeakRootsIterator::~ZWeakRootsIterator() {
320   ZStatTimer timer(ZSubPhasePauseWeakRootsTeardown);
321 }
322 
do_jvmti_weak_export(BoolObjectClosure * is_alive,ZRootsIteratorClosure * cl)323 void ZWeakRootsIterator::do_jvmti_weak_export(BoolObjectClosure* is_alive, ZRootsIteratorClosure* cl) {
324   ZStatTimer timer(ZSubPhasePauseWeakRootsJVMTIWeakExport);
325   JvmtiExport::weak_oops_do(is_alive, cl);
326 }
327 
do_jfr_weak(BoolObjectClosure * is_alive,ZRootsIteratorClosure * cl)328 void ZWeakRootsIterator::do_jfr_weak(BoolObjectClosure* is_alive, ZRootsIteratorClosure* cl) {
329 #if INCLUDE_JFR
330   ZStatTimer timer(ZSubPhasePauseWeakRootsJFRWeak);
331   Jfr::weak_oops_do(is_alive, cl);
332 #endif
333 }
334 
weak_oops_do(BoolObjectClosure * is_alive,ZRootsIteratorClosure * cl)335 void ZWeakRootsIterator::weak_oops_do(BoolObjectClosure* is_alive, ZRootsIteratorClosure* cl) {
336   ZStatTimer timer(ZSubPhasePauseWeakRoots);
337   _jvmti_weak_export.weak_oops_do(is_alive, cl);
338   _jfr_weak.weak_oops_do(is_alive, cl);
339 }
340 
oops_do(ZRootsIteratorClosure * cl)341 void ZWeakRootsIterator::oops_do(ZRootsIteratorClosure* cl) {
342   AlwaysTrueClosure always_alive;
343   weak_oops_do(&always_alive, cl);
344 }
345 
ZConcurrentWeakRootsIterator()346 ZConcurrentWeakRootsIterator::ZConcurrentWeakRootsIterator() :
347     _vm_weak_handles_iter(OopStorageSet::vm_weak()),
348     _jni_weak_handles_iter(OopStorageSet::jni_weak()),
349     _string_table_iter(OopStorageSet::string_table_weak()),
350     _resolved_method_table_iter(OopStorageSet::resolved_method_table_weak()),
351     _vm_weak_handles(this),
352     _jni_weak_handles(this),
353     _string_table(this),
354     _resolved_method_table(this) {
355   StringTable::reset_dead_counter();
356   ResolvedMethodTable::reset_dead_counter();
357 }
358 
~ZConcurrentWeakRootsIterator()359 ZConcurrentWeakRootsIterator::~ZConcurrentWeakRootsIterator() {
360   StringTable::finish_dead_counter();
361   ResolvedMethodTable::finish_dead_counter();
362 }
363 
do_vm_weak_handles(ZRootsIteratorClosure * cl)364 void ZConcurrentWeakRootsIterator::do_vm_weak_handles(ZRootsIteratorClosure* cl) {
365   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsVMWeakHandles);
366   _vm_weak_handles_iter.oops_do(cl);
367 }
368 
do_jni_weak_handles(ZRootsIteratorClosure * cl)369 void ZConcurrentWeakRootsIterator::do_jni_weak_handles(ZRootsIteratorClosure* cl) {
370   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsJNIWeakHandles);
371   _jni_weak_handles_iter.oops_do(cl);
372 }
373 
374 template <class Container>
375 class ZDeadCounterClosure : public ZRootsIteratorClosure  {
376 private:
377   ZRootsIteratorClosure* const _cl;
378   size_t                       _ndead;
379 
380 public:
ZDeadCounterClosure(ZRootsIteratorClosure * cl)381   ZDeadCounterClosure(ZRootsIteratorClosure* cl) :
382       _cl(cl),
383       _ndead(0) {}
384 
~ZDeadCounterClosure()385   ~ZDeadCounterClosure() {
386     Container::inc_dead_counter(_ndead);
387   }
388 
do_oop(oop * p)389   virtual void do_oop(oop* p) {
390     _cl->do_oop(p);
391     if (*p == NULL) {
392       _ndead++;
393     }
394   }
395 
do_oop(narrowOop * p)396   virtual void do_oop(narrowOop* p) {
397     ShouldNotReachHere();
398   }
399 };
400 
do_string_table(ZRootsIteratorClosure * cl)401 void ZConcurrentWeakRootsIterator::do_string_table(ZRootsIteratorClosure* cl) {
402   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsStringTable);
403   ZDeadCounterClosure<StringTable> counter_cl(cl);
404   _string_table_iter.oops_do(&counter_cl);
405 }
406 
do_resolved_method_table(ZRootsIteratorClosure * cl)407 void ZConcurrentWeakRootsIterator::do_resolved_method_table(ZRootsIteratorClosure* cl) {
408   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsResolvedMethodTable);
409   ZDeadCounterClosure<ResolvedMethodTable> counter_cl(cl);
410   _resolved_method_table_iter.oops_do(&counter_cl);
411 }
412 
oops_do(ZRootsIteratorClosure * cl)413 void ZConcurrentWeakRootsIterator::oops_do(ZRootsIteratorClosure* cl) {
414   ZStatTimer timer(ZSubPhaseConcurrentWeakRoots);
415   _vm_weak_handles.oops_do(cl);
416   _jni_weak_handles.oops_do(cl);
417   _string_table.oops_do(cl);
418   _resolved_method_table.oops_do(cl);
419 }
420