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 "gc/shared/oopStorageParState.inline.hpp" 29 #include "gc/shenandoah/shenandoahHeuristics.hpp" 30 #include "gc/shenandoah/shenandoahRootProcessor.hpp" 31 #include "gc/shenandoah/shenandoahTimingTracker.hpp" 32 #include "gc/shenandoah/shenandoahUtils.hpp" 33 #include "memory/resourceArea.hpp" 34 35 template <bool CONCURRENT> 36 ShenandoahJNIHandleRoots<CONCURRENT>::ShenandoahJNIHandleRoots() : 37 _claimed(false), 38 _itr(JNIHandles::global_handles()) { 39 } 40 41 template <bool CONCURRENT> 42 template <typename T> 43 void ShenandoahJNIHandleRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) { 44 if (CONCURRENT) { 45 _itr.oops_do(cl); 46 } else { 47 if (!_claimed && Atomic::cmpxchg(true, &_claimed, false) == false) { 48 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 49 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::JNIRoots, worker_id); 50 _itr.oops_do(cl); 51 } 52 } 53 } 54 55 template <typename IsAlive, typename KeepAlive> 56 void ShenandoahWeakRoots::oops_do(IsAlive* is_alive, KeepAlive* keep_alive, uint worker_id) { 57 _task.work<IsAlive, KeepAlive>(worker_id, is_alive, keep_alive); 58 } 59 60 template <bool CONCURRENT> 61 ShenandoahClassLoaderDataRoots<CONCURRENT>::ShenandoahClassLoaderDataRoots() { 62 ClassLoaderDataGraph::clear_claimed_marks(); 63 if (CONCURRENT) { 64 ClassLoaderDataGraph_lock->lock(); 65 } 66 } 67 68 template <bool CONCURRENT> 69 ShenandoahClassLoaderDataRoots<CONCURRENT>::~ShenandoahClassLoaderDataRoots() { 70 if (CONCURRENT) { 71 ClassLoaderDataGraph_lock->unlock(); 72 } 73 } 74 75 template <bool CONCURRENT> 76 void ShenandoahClassLoaderDataRoots<CONCURRENT>::always_strong_cld_do(CLDClosure* clds, uint worker_id) { 77 if (CONCURRENT) { 78 ClassLoaderDataGraph::always_strong_cld_do(clds); 79 } else { 80 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 81 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id); 82 ClassLoaderDataGraph::always_strong_cld_do(clds); 83 } 84 } 85 86 template <bool CONCURRENT> 87 void ShenandoahClassLoaderDataRoots<CONCURRENT>::cld_do(CLDClosure* clds, uint worker_id) { 88 if (CONCURRENT) { 89 ClassLoaderDataGraph::cld_do(clds); 90 } else { 91 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 92 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id); 93 ClassLoaderDataGraph::cld_do(clds); 94 } 95 } 96 97 template <typename ITR> 98 ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots() { 99 nmethod::oops_do_marking_prologue(); 100 } 101 102 template <typename ITR> 103 void ShenandoahCodeCacheRoots<ITR>::code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id) { 104 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 105 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CodeCacheRoots, worker_id); 106 _coderoots_iterator.possibly_parallel_blobs_do(blob_cl); 107 } 108 109 template <typename ITR> 110 ShenandoahCodeCacheRoots<ITR>::~ShenandoahCodeCacheRoots() { 111 nmethod::oops_do_marking_epilogue(); 112 } 113 114 class ShenandoahParallelOopsDoThreadClosure : public ThreadClosure { 115 private: 116 OopClosure* _f; 117 CodeBlobClosure* _cf; 118 ThreadClosure* _thread_cl; 119 public: 120 ShenandoahParallelOopsDoThreadClosure(OopClosure* f, CodeBlobClosure* cf, ThreadClosure* thread_cl) : 121 _f(f), _cf(cf), _thread_cl(thread_cl) {} 122 123 void do_thread(Thread* t) { 124 if (_thread_cl != NULL) { 125 _thread_cl->do_thread(t); 126 } 127 t->oops_do(_f, _cf); 128 } 129 }; 130 131 template <typename ITR> 132 ShenandoahRootScanner<ITR>::ShenandoahRootScanner(uint n_workers, ShenandoahPhaseTimings::Phase phase) : 133 ShenandoahRootProcessor(phase), 134 _thread_roots(n_workers > 1) { 135 } 136 137 template <typename ITR> 138 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops) { 139 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong); 140 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations); 141 roots_do(worker_id, oops, &clds_cl, &blobs_cl); 142 } 143 144 template <typename ITR> 145 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops) { 146 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong); 147 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations); 148 strong_roots_do(worker_id, oops, &clds_cl, &blobs_cl); 149 } 150 151 template <typename ITR> 152 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure *tc) { 153 assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint() || 154 !ShenandoahHeap::heap()->unload_classes() || 155 ShenandoahHeap::heap()->heuristics()->can_do_traversal_gc(), 156 "Expect class unloading or traversal when Shenandoah cycle is running"); 157 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc); 158 ResourceMark rm; 159 160 _serial_roots.oops_do(oops, worker_id); 161 _jni_roots.oops_do(oops, worker_id); 162 163 if (clds != NULL) { 164 _cld_roots.cld_do(clds, worker_id); 165 } else { 166 assert(ShenandoahHeap::heap()->is_concurrent_traversal_in_progress(), "Only possible with traversal GC"); 167 } 168 169 _thread_roots.threads_do(&tc_cl, worker_id); 170 171 // With ShenandoahConcurrentScanCodeRoots, we avoid scanning the entire code cache here, 172 // and instead do that in concurrent phase under the relevant lock. This saves init mark 173 // pause time. 174 if (code != NULL && !ShenandoahConcurrentScanCodeRoots) { 175 _code_roots.code_blobs_do(code, worker_id); 176 } 177 } 178 179 template <typename ITR> 180 void ShenandoahRootScanner<ITR>::roots_do_unchecked(OopClosure* oops) { 181 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong); 182 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations); 183 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL); 184 ResourceMark rm; 185 186 _serial_roots.oops_do(oops, 0); 187 _jni_roots.oops_do(oops, 0); 188 _cld_roots.cld_do(&clds, 0); 189 _thread_roots.threads_do(&tc_cl, 0); 190 _code_roots.code_blobs_do(&code, 0); 191 } 192 193 template <typename ITR> 194 void ShenandoahRootScanner<ITR>::strong_roots_do_unchecked(OopClosure* oops) { 195 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong); 196 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations); 197 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL); 198 ResourceMark rm; 199 200 _serial_roots.oops_do(oops, 0); 201 _jni_roots.oops_do(oops, 0); 202 _cld_roots.always_strong_cld_do(&clds, 0); 203 _thread_roots.threads_do(&tc_cl, 0); 204 } 205 206 template <typename ITR> 207 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure* tc) { 208 assert(ShenandoahHeap::heap()->unload_classes(), "Should be used during class unloading"); 209 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc); 210 ResourceMark rm; 211 212 _serial_roots.oops_do(oops, worker_id); 213 _jni_roots.oops_do(oops, worker_id); 214 _cld_roots.always_strong_cld_do(clds, worker_id); 215 _thread_roots.threads_do(&tc_cl, worker_id); 216 } 217 218 template <typename IsAlive, typename KeepAlive> 219 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) { 220 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations); 221 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong); 222 223 _serial_roots.oops_do(keep_alive, worker_id); 224 _jni_roots.oops_do(keep_alive, worker_id); 225 226 _thread_roots.oops_do(keep_alive, NULL, worker_id); 227 _cld_roots.cld_do(&clds, worker_id); 228 229 if(_update_code_cache) { 230 _code_roots.code_blobs_do(&update_blobs, worker_id); 231 } 232 233 _weak_roots.oops_do<IsAlive, KeepAlive>(is_alive, keep_alive, worker_id); 234 _dedup_roots.oops_do(is_alive, keep_alive, worker_id); 235 } 236 237 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP