102 weak_oops_do<AlwaysTrueClosure, Closure>(&always_true, cl, worker_id);
103 }
104
105 template <bool CONCURRENT>
106 ShenandoahJNIHandleRoots<CONCURRENT>::ShenandoahJNIHandleRoots() :
107 _itr(JNIHandles::global_handles()) {
108 }
109
110 template <bool CONCURRENT>
111 template <typename T>
112 void ShenandoahJNIHandleRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
113 if (CONCURRENT) {
114 _itr.oops_do(cl);
115 } else {
116 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
117 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::JNIRoots, worker_id);
118 _itr.oops_do(cl);
119 }
120 }
121
122 template <bool SINGLE_THREADED>
123 ShenandoahClassLoaderDataRoots<SINGLE_THREADED>::ShenandoahClassLoaderDataRoots() {
124 if (!SINGLE_THREADED) {
125 ClassLoaderDataGraph::clear_claimed_marks();
126 }
127 }
128
129 template <bool SINGLE_THREADED>
130 void ShenandoahClassLoaderDataRoots<SINGLE_THREADED>::always_strong_cld_do(CLDClosure* clds, uint worker_id) {
131 if (SINGLE_THREADED) {
132 assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
133 assert(Thread::current()->is_VM_thread(), "Single threaded CLDG iteration can only be done by VM thread");
134 ClassLoaderDataGraph::always_strong_cld_do(clds);
135 } else {
136 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
137 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
138 ClassLoaderDataGraph::always_strong_cld_do(clds);
139 }
140 }
141
142 template <bool SINGLE_THREADED>
143 void ShenandoahClassLoaderDataRoots<SINGLE_THREADED>::cld_do(CLDClosure* clds, uint worker_id) {
144 if (SINGLE_THREADED) {
145 assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
146 assert(Thread::current()->is_VM_thread(), "Single threaded CLDG iteration can only be done by VM thread");
147 ClassLoaderDataGraph::cld_do(clds);
148 } else {
149 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
150 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
151 ClassLoaderDataGraph::cld_do(clds);
152 }
153 }
154
155 template <typename ITR>
156 ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots() {
157 nmethod::oops_do_marking_prologue();
158 }
159
160 template <typename ITR>
161 void ShenandoahCodeCacheRoots<ITR>::code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id) {
162 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
163 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CodeCacheRoots, worker_id);
164 _coderoots_iterator.possibly_parallel_blobs_do(blob_cl);
165 }
166
167 template <typename ITR>
|
102 weak_oops_do<AlwaysTrueClosure, Closure>(&always_true, cl, worker_id);
103 }
104
105 template <bool CONCURRENT>
106 ShenandoahJNIHandleRoots<CONCURRENT>::ShenandoahJNIHandleRoots() :
107 _itr(JNIHandles::global_handles()) {
108 }
109
110 template <bool CONCURRENT>
111 template <typename T>
112 void ShenandoahJNIHandleRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
113 if (CONCURRENT) {
114 _itr.oops_do(cl);
115 } else {
116 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
117 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::JNIRoots, worker_id);
118 _itr.oops_do(cl);
119 }
120 }
121
122 template <bool CONCURRENT, bool SINGLE_THREADED>
123 ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::ShenandoahClassLoaderDataRoots() {
124 if (!SINGLE_THREADED) {
125 ClassLoaderDataGraph::clear_claimed_marks();
126 }
127 if (CONCURRENT) {
128 ClassLoaderDataGraph_lock->lock();
129 }
130 }
131
132 template <bool CONCURRENT, bool SINGLE_THREADED>
133 ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::~ShenandoahClassLoaderDataRoots() {
134 if (CONCURRENT) {
135 ClassLoaderDataGraph_lock->unlock();
136 }
137 }
138
139
140 template <bool CONCURRENT, bool SINGLE_THREADED>
141 void ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::always_strong_cld_do(CLDClosure* clds, uint worker_id) {
142 if (SINGLE_THREADED) {
143 assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
144 assert(Thread::current()->is_VM_thread(), "Single threaded CLDG iteration can only be done by VM thread");
145 ClassLoaderDataGraph::always_strong_cld_do(clds);
146 } else if (CONCURRENT) {
147 ClassLoaderDataGraph::always_strong_cld_do(clds);
148 } else {
149 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
150 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
151 ClassLoaderDataGraph::always_strong_cld_do(clds);
152 }
153 }
154
155 template <bool CONCURRENT, bool SINGLE_THREADED>
156 void ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::cld_do(CLDClosure* clds, uint worker_id) {
157 if (SINGLE_THREADED) {
158 assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
159 assert(Thread::current()->is_VM_thread(), "Single threaded CLDG iteration can only be done by VM thread");
160 ClassLoaderDataGraph::cld_do(clds);
161 } else if (CONCURRENT) {
162 ClassLoaderDataGraph::cld_do(clds);
163 } else {
164 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
165 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
166 ClassLoaderDataGraph::cld_do(clds);
167 }
168 }
169
170 template <typename ITR>
171 ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots() {
172 nmethod::oops_do_marking_prologue();
173 }
174
175 template <typename ITR>
176 void ShenandoahCodeCacheRoots<ITR>::code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id) {
177 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
178 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CodeCacheRoots, worker_id);
179 _coderoots_iterator.possibly_parallel_blobs_do(blob_cl);
180 }
181
182 template <typename ITR>
|