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 <typename ITR> 61 ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots() { 62 nmethod::oops_do_marking_prologue(); 63 } 64 65 template <typename ITR> 66 void ShenandoahCodeCacheRoots<ITR>::code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id) { 67 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times(); 68 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CodeCacheRoots, worker_id); 69 _coderoots_iterator.possibly_parallel_blobs_do(blob_cl); 70 } 71 72 template <typename ITR> 73 ShenandoahCodeCacheRoots<ITR>::~ShenandoahCodeCacheRoots() { 74 nmethod::oops_do_marking_epilogue(); 75 } 76 77 class ShenandoahParallelOopsDoThreadClosure : public ThreadClosure { 78 private: 79 OopClosure* _f; 80 CodeBlobClosure* _cf; 81 ThreadClosure* _thread_cl; 82 public: 83 ShenandoahParallelOopsDoThreadClosure(OopClosure* f, CodeBlobClosure* cf, ThreadClosure* thread_cl) : 84 _f(f), _cf(cf), _thread_cl(thread_cl) {} 85 86 void do_thread(Thread* t) { 87 if (_thread_cl != NULL) { 88 _thread_cl->do_thread(t); 89 } 90 t->oops_do(_f, _cf); 91 } 92 }; 93 94 template <typename ITR> 95 ShenandoahRootScanner<ITR>::ShenandoahRootScanner(uint n_workers, ShenandoahPhaseTimings::Phase phase) : 96 ShenandoahRootProcessor(phase), 97 _thread_roots(n_workers > 1) { 98 } 99 100 template <typename ITR> 101 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops) { 102 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong); 103 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations); 104 roots_do(worker_id, oops, &clds_cl, &blobs_cl); 105 } 106 107 template <typename ITR> 108 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops) { 109 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong); 110 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations); 111 strong_roots_do(worker_id, oops, &clds_cl, &blobs_cl); 112 } 113 114 template <typename ITR> 115 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure *tc) { 116 assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint() || 117 !ShenandoahHeap::heap()->unload_classes() || 118 ShenandoahHeap::heap()->heuristics()->can_do_traversal_gc(), 119 "Expect class unloading or traversal when Shenandoah cycle is running"); 120 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc); 121 ResourceMark rm; 122 123 _serial_roots.oops_do(oops, worker_id); 124 _jni_roots.oops_do(oops, worker_id); 125 _cld_roots.clds_do(clds, clds, worker_id); 126 _thread_roots.threads_do(&tc_cl, worker_id); 127 128 // With ShenandoahConcurrentScanCodeRoots, we avoid scanning the entire code cache here, 129 // and instead do that in concurrent phase under the relevant lock. This saves init mark 130 // pause time. 131 if (code != NULL && !ShenandoahConcurrentScanCodeRoots) { 132 _code_roots.code_blobs_do(code, worker_id); 133 } 134 } 135 136 template <typename ITR> 137 void ShenandoahRootScanner<ITR>::roots_do_unchecked(OopClosure* oops) { 138 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong); 139 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations); 140 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL); 141 ResourceMark rm; 142 143 _serial_roots.oops_do(oops, 0); 144 _jni_roots.oops_do(oops, 0); 145 _cld_roots.clds_do(&clds, &clds, 0); 146 _thread_roots.threads_do(&tc_cl, 0); 147 _code_roots.code_blobs_do(&code, 0); 148 } 149 150 template <typename ITR> 151 void ShenandoahRootScanner<ITR>::strong_roots_do_unchecked(OopClosure* oops) { 152 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong); 153 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations); 154 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL); 155 ResourceMark rm; 156 157 _serial_roots.oops_do(oops, 0); 158 _jni_roots.oops_do(oops, 0); 159 _cld_roots.clds_do(&clds, NULL, 0); 160 _thread_roots.threads_do(&tc_cl, 0); 161 } 162 163 template <typename ITR> 164 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure* tc) { 165 assert(ShenandoahHeap::heap()->unload_classes(), "Should be used during class unloading"); 166 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc); 167 ResourceMark rm; 168 169 _serial_roots.oops_do(oops, worker_id); 170 _jni_roots.oops_do(oops, worker_id); 171 _cld_roots.clds_do(clds, NULL, worker_id); 172 _thread_roots.threads_do(&tc_cl, worker_id); 173 } 174 175 template <typename IsAlive, typename KeepAlive> 176 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) { 177 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations); 178 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong); 179 CLDToOopClosure* weak_clds = ShenandoahHeap::heap()->unload_classes() ? NULL : &clds; 180 181 _serial_roots.oops_do(keep_alive, worker_id); 182 _jni_roots.oops_do(keep_alive, worker_id); 183 184 _thread_roots.oops_do(keep_alive, NULL, worker_id); 185 _cld_roots.clds_do(&clds, weak_clds, worker_id); 186 187 if(_update_code_cache) { 188 _code_roots.code_blobs_do(&update_blobs, worker_id); 189 } 190 191 _weak_roots.oops_do<IsAlive, KeepAlive>(is_alive, keep_alive, worker_id); 192 _dedup_roots.oops_do(is_alive, keep_alive, worker_id); 193 } 194 195 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP