1 /* 2 * Copyright (c) 2019, Red Hat, Inc. All rights reserved. 3 * 4 * This code is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 only, as 6 * published by the Free Software Foundation. 7 * 8 * This code is distributed in the hope that it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 11 * version 2 for more details (a copy is included in the LICENSE file that 12 * accompanied this code). 13 * 14 * You should have received a copy of the GNU General Public License version 15 * 2 along with this work; if not, write to the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 17 * 18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 19 * or visit www.oracle.com if you need additional information or have any 20 * questions. 21 * 22 */ 23 24 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP 25 #define SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP 26 27 #include "classfile/classLoaderDataGraph.hpp" 28 #include "classfile/stringTable.hpp" 29 #include "classfile/systemDictionary.hpp" 30 #include "gc/shared/oopStorageParState.inline.hpp" 31 #include "gc/shenandoah/shenandoahHeuristics.hpp" 32 #include "gc/shenandoah/shenandoahRootProcessor.hpp" 33 #include "gc/shenandoah/shenandoahTimingTracker.hpp" 34 #include "gc/shenandoah/shenandoahUtils.hpp" 35 #include "prims/resolvedMethodTable.hpp" 36 #include "memory/resourceArea.hpp" 37 38 template <bool CONCURRENT> 39 inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) : 40 _itr(storage), _phase(phase) { 41 } 42 43 template <bool CONCURRENT> 44 template <typename Closure> 45 inline void ShenandoahWeakRoot<CONCURRENT>::oops_do(Closure* cl, uint worker_id) { 46 if (CONCURRENT) { 47 _itr.oops_do(cl); 48 } else { 49 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 50 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::ThreadRoots, worker_id); 51 _itr.oops_do(cl); 52 } 53 } 54 55 inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) : 56 _itr(storage), _phase(phase) { 57 } 58 59 template <typename IsAliveClosure, typename KeepAliveClosure> 60 void ShenandoahWeakRoot<false /* concurrent */>::weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id) { 61 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 62 ShenandoahWorkerTimingsTracker timer(worker_times, _phase, worker_id); 63 _itr.weak_oops_do(is_alive, keep_alive); 64 } 65 66 template <bool CONCURRENT> 67 ShenandoahWeakRoots<CONCURRENT>::ShenandoahWeakRoots() : 68 _jni_roots(JNIHandles::weak_global_handles(), ShenandoahPhaseTimings::JNIWeakRoots), 69 _string_table_roots(StringTable::weak_storage(), ShenandoahPhaseTimings::StringTableRoots), 70 _resolved_method_table_roots(ResolvedMethodTable::weak_storage(), ShenandoahPhaseTimings::ResolvedMethodTableRoots), 71 _vm_roots(SystemDictionary::vm_weak_oop_storage(), ShenandoahPhaseTimings::VMWeakRoots) { 72 } 73 74 template <bool CONCURRENT> 75 template <typename Closure> 76 void ShenandoahWeakRoots<CONCURRENT>::oops_do(Closure* cl, uint worker_id) { 77 _jni_roots.oops_do(cl, worker_id); 78 _string_table_roots.oops_do(cl, worker_id); 79 _resolved_method_table_roots.oops_do(cl, worker_id); 80 _vm_roots.oops_do(cl, worker_id); 81 } 82 83 inline ShenandoahWeakRoots<false /* concurrent */>::ShenandoahWeakRoots() : 84 _jni_roots(JNIHandles::weak_global_handles(), ShenandoahPhaseTimings::JNIWeakRoots), 85 _string_table_roots(StringTable::weak_storage(), ShenandoahPhaseTimings::StringTableRoots), 86 _resolved_method_table_roots(ResolvedMethodTable::weak_storage(), ShenandoahPhaseTimings::ResolvedMethodTableRoots), 87 _vm_roots(SystemDictionary::vm_weak_oop_storage(), ShenandoahPhaseTimings::VMWeakRoots) { 88 } 89 90 template <typename IsAliveClosure, typename KeepAliveClosure> 91 void ShenandoahWeakRoots<false /* concurrent*/>::weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id) { 92 _jni_roots.weak_oops_do(is_alive, keep_alive, worker_id); 93 _string_table_roots.weak_oops_do(is_alive, keep_alive, worker_id); 94 _resolved_method_table_roots.weak_oops_do(is_alive, keep_alive, worker_id); 95 _vm_roots.weak_oops_do(is_alive, keep_alive, worker_id); 96 } 97 98 template <typename Closure> 99 void ShenandoahWeakRoots<false /* concurrent */>::oops_do(Closure* cl, uint worker_id) { 100 AlwaysTrueClosure always_true; 101 weak_oops_do<AlwaysTrueClosure, Closure>(&always_true, cl, worker_id); 102 } 103 104 template <bool CONCURRENT> 105 ShenandoahJNIHandleRoots<CONCURRENT>::ShenandoahJNIHandleRoots() : 106 _itr(JNIHandles::global_handles()) { 107 } 108 109 template <bool CONCURRENT> 110 template <typename T> 111 void ShenandoahJNIHandleRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) { 112 if (CONCURRENT) { 113 _itr.oops_do(cl); 114 } else { 115 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 116 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::JNIRoots, worker_id); 117 _itr.oops_do(cl); 118 } 119 } 120 121 template <typename ITR> 122 ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots() { 123 nmethod::oops_do_marking_prologue(); 124 } 125 126 template <typename ITR> 127 void ShenandoahCodeCacheRoots<ITR>::code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id) { 128 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 129 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CodeCacheRoots, worker_id); 130 _coderoots_iterator.possibly_parallel_blobs_do(blob_cl); 131 } 132 133 template <typename ITR> 134 ShenandoahCodeCacheRoots<ITR>::~ShenandoahCodeCacheRoots() { 135 nmethod::oops_do_marking_epilogue(); 136 } 137 138 class ShenandoahParallelOopsDoThreadClosure : public ThreadClosure { 139 private: 140 OopClosure* _f; 141 CodeBlobClosure* _cf; 142 ThreadClosure* _thread_cl; 143 public: 144 ShenandoahParallelOopsDoThreadClosure(OopClosure* f, CodeBlobClosure* cf, ThreadClosure* thread_cl) : 145 _f(f), _cf(cf), _thread_cl(thread_cl) {} 146 147 void do_thread(Thread* t) { 148 if (_thread_cl != NULL) { 149 _thread_cl->do_thread(t); 150 } 151 t->oops_do(_f, _cf); 152 } 153 }; 154 155 template <typename ITR> 156 ShenandoahRootScanner<ITR>::ShenandoahRootScanner(uint n_workers, ShenandoahPhaseTimings::Phase phase) : 157 ShenandoahRootProcessor(phase), 158 _thread_roots(n_workers > 1) { 159 } 160 161 template <typename ITR> 162 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops) { 163 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong); 164 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations); 165 roots_do(worker_id, oops, &clds_cl, &blobs_cl); 166 } 167 168 template <typename ITR> 169 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops) { 170 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong); 171 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations); 172 strong_roots_do(worker_id, oops, &clds_cl, &blobs_cl); 173 } 174 175 template <typename ITR> 176 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure *tc) { 177 assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint() || 178 !ShenandoahHeap::heap()->unload_classes() || 179 ShenandoahHeap::heap()->heuristics()->can_do_traversal_gc(), 180 "Expect class unloading or traversal when Shenandoah cycle is running"); 181 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc); 182 ResourceMark rm; 183 184 _serial_roots.oops_do(oops, worker_id); 185 _jni_roots.oops_do(oops, worker_id); 186 _cld_roots.clds_do(clds, clds, worker_id); 187 _thread_roots.threads_do(&tc_cl, worker_id); 188 189 // With ShenandoahConcurrentScanCodeRoots, we avoid scanning the entire code cache here, 190 // and instead do that in concurrent phase under the relevant lock. This saves init mark 191 // pause time. 192 if (code != NULL && !ShenandoahConcurrentScanCodeRoots) { 193 _code_roots.code_blobs_do(code, worker_id); 194 } 195 } 196 197 template <typename ITR> 198 void ShenandoahRootScanner<ITR>::roots_do_unchecked(OopClosure* oops) { 199 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong); 200 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations); 201 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL); 202 ResourceMark rm; 203 204 _serial_roots.oops_do(oops, 0); 205 _jni_roots.oops_do(oops, 0); 206 _cld_roots.clds_do(&clds, &clds, 0); 207 _thread_roots.threads_do(&tc_cl, 0); 208 _code_roots.code_blobs_do(&code, 0); 209 } 210 211 template <typename ITR> 212 void ShenandoahRootScanner<ITR>::strong_roots_do_unchecked(OopClosure* oops) { 213 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong); 214 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations); 215 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL); 216 ResourceMark rm; 217 218 _serial_roots.oops_do(oops, 0); 219 _jni_roots.oops_do(oops, 0); 220 _cld_roots.clds_do(&clds, NULL, 0); 221 _thread_roots.threads_do(&tc_cl, 0); 222 } 223 224 template <typename ITR> 225 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure* tc) { 226 assert(ShenandoahHeap::heap()->unload_classes(), "Should be used during class unloading"); 227 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc); 228 ResourceMark rm; 229 230 _serial_roots.oops_do(oops, worker_id); 231 _jni_roots.oops_do(oops, worker_id); 232 _cld_roots.clds_do(clds, NULL, worker_id); 233 _thread_roots.threads_do(&tc_cl, worker_id); 234 } 235 236 template <typename IsAlive, typename KeepAlive> 237 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) { 238 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations); 239 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong); 240 CLDToOopClosure* weak_clds = ShenandoahHeap::heap()->unload_classes() ? NULL : &clds; 241 242 _serial_roots.oops_do(keep_alive, worker_id); 243 _jni_roots.oops_do(keep_alive, worker_id); 244 245 _thread_roots.oops_do(keep_alive, NULL, worker_id); 246 _cld_roots.clds_do(&clds, weak_clds, worker_id); 247 248 if(_update_code_cache) { 249 _code_roots.code_blobs_do(&update_blobs, worker_id); 250 } 251 252 _serial_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id); 253 _weak_roots.weak_oops_do(is_alive, keep_alive, worker_id); 254 _dedup_roots.oops_do(is_alive, keep_alive, worker_id); 255 } 256 257 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP