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
25 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
26 #define SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
27
28 #include "classfile/classLoaderDataGraph.hpp"
29 #include "classfile/stringTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "gc/shared/oopStorageParState.inline.hpp"
32 #include "gc/shared/oopStorageSet.hpp"
33 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
34 #include "gc/shenandoah/shenandoahConcurrentRoots.hpp"
35 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
36 #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
37 #include "gc/shenandoah/shenandoahRootProcessor.hpp"
38 #include "gc/shenandoah/shenandoahUtils.hpp"
39 #include "gc/shenandoah/heuristics/shenandoahHeuristics.hpp"
40 #include "memory/resourceArea.hpp"
41 #include "prims/resolvedMethodTable.hpp"
42 #include "runtime/safepoint.hpp"
43
44 template <bool CONCURRENT>
45 inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage,
46 ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
47 _itr(storage), _phase(phase), _par_phase(par_phase) {
48 }
49
50 template <bool CONCURRENT>
51 template <typename Closure>
52 inline void ShenandoahVMRoot<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
53 ShenandoahWorkerTimingsTracker timer(_phase, _par_phase, worker_id);
54 _itr.oops_do(cl);
55 }
56
57 template <bool CONCURRENT>
58 inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage,
59 ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
60 ShenandoahVMRoot<CONCURRENT>(storage, phase, par_phase) {
61 }
62
63 inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage,
64 ShenandoahPhaseTimings::Phase phase, ShenandoahPhaseTimings::ParPhase par_phase) :
65 _itr(storage), _phase(phase), _par_phase(par_phase) {
66 }
67
68 template <typename IsAliveClosure, typename KeepAliveClosure>
69 void ShenandoahWeakRoot<false /* concurrent */>::weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id) {
70 ShenandoahWorkerTimingsTracker timer(_phase, _par_phase, worker_id);
71 _itr.weak_oops_do(is_alive, keep_alive);
72 }
73
74 template <bool CONCURRENT>
75 ShenandoahWeakRoots<CONCURRENT>::ShenandoahWeakRoots() :
76 _jni_roots(OopStorageSet::jni_weak(), ShenandoahPhaseTimings::JNIWeakRoots),
77 _string_table_roots(OopStorageSet::string_table_weak(), ShenandoahPhaseTimings::StringTableRoots),
78 _resolved_method_table_roots(OopStorageSet::resolved_method_table_weak(), ShenandoahPhaseTimings::ResolvedMethodTableRoots),
79 _vm_roots(OopStorageSet::vm_weak(), ShenandoahPhaseTimings::VMWeakRoots) {
80 }
81
82 template <bool CONCURRENT>
83 template <typename Closure>
84 void ShenandoahWeakRoots<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
85 _jni_roots.oops_do(cl, worker_id);
86 _string_table_roots.oops_do(cl, worker_id);
87 _resolved_method_table_roots.oops_do(cl, worker_id);
88 _vm_roots.oops_do(cl, worker_id);
89 }
90
91 inline ShenandoahWeakRoots<false /* concurrent */>::ShenandoahWeakRoots(ShenandoahPhaseTimings::Phase phase) :
92 _jni_roots(OopStorageSet::jni_weak(), phase, ShenandoahPhaseTimings::JNIWeakRoots),
93 _string_table_roots(OopStorageSet::string_table_weak(), phase, ShenandoahPhaseTimings::StringTableRoots),
94 _resolved_method_table_roots(OopStorageSet::resolved_method_table_weak(), phase, ShenandoahPhaseTimings::ResolvedMethodTableRoots),
95 _vm_roots(OopStorageSet::vm_weak(), phase, ShenandoahPhaseTimings::VMWeakRoots) {
96 }
97
98 template <typename IsAliveClosure, typename KeepAliveClosure>
99 void ShenandoahWeakRoots<false /* concurrent*/>::weak_oops_do(IsAliveClosure* is_alive, KeepAliveClosure* keep_alive, uint worker_id) {
100 _jni_roots.weak_oops_do(is_alive, keep_alive, worker_id);
101 _string_table_roots.weak_oops_do(is_alive, keep_alive, worker_id);
102 _resolved_method_table_roots.weak_oops_do(is_alive, keep_alive, worker_id);
103 _vm_roots.weak_oops_do(is_alive, keep_alive, worker_id);
104 }
105
106 template <typename Closure>
107 void ShenandoahWeakRoots<false /* concurrent */>::oops_do(Closure* cl, uint worker_id) {
108 AlwaysTrueClosure always_true;
109 weak_oops_do<AlwaysTrueClosure, Closure>(&always_true, cl, worker_id);
110 }
111
112 template <bool CONCURRENT>
113 ShenandoahVMRoots<CONCURRENT>::ShenandoahVMRoots(ShenandoahPhaseTimings::Phase phase) :
114 _jni_handle_roots(OopStorageSet::jni_global(), phase, ShenandoahPhaseTimings::JNIRoots),
115 _vm_global_roots(OopStorageSet::vm_global(), phase, ShenandoahPhaseTimings::VMGlobalRoots) {
116 }
117
118 template <bool CONCURRENT>
119 template <typename T>
120 void ShenandoahVMRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
121 _jni_handle_roots.oops_do(cl, worker_id);
122 _vm_global_roots.oops_do(cl, worker_id);
123 }
124
125 template <bool CONCURRENT, bool SINGLE_THREADED>
126 ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::ShenandoahClassLoaderDataRoots(ShenandoahPhaseTimings::Phase phase, uint n_workers) :
127 _semaphore(worker_count(n_workers)),
128 _phase(phase) {
129 if (!SINGLE_THREADED) {
130 ClassLoaderDataGraph::clear_claimed_marks();
131 }
132 if (CONCURRENT) {
133 ClassLoaderDataGraph_lock->lock();
134 }
135 }
136
137 template <bool CONCURRENT, bool SINGLE_THREADED>
138 ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::~ShenandoahClassLoaderDataRoots() {
139 if (CONCURRENT) {
140 ClassLoaderDataGraph_lock->unlock();
141 }
142 }
231 _cld_roots.always_strong_cld_do(&clds_cl, worker_id);
232 }
233 }
234
235 template <typename IsAlive, typename KeepAlive>
236 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {
237 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations);
238 ShenandoahCodeBlobAndDisarmClosure blobs_and_disarm_Cl(keep_alive);
239 CodeBlobToOopClosure* codes_cl = ShenandoahConcurrentRoots::can_do_concurrent_class_unloading() ?
240 static_cast<CodeBlobToOopClosure*>(&blobs_and_disarm_Cl) :
241 static_cast<CodeBlobToOopClosure*>(&update_blobs);
242
243 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
244
245 // Process serial-claiming roots first
246 _serial_roots.oops_do(keep_alive, worker_id);
247 _serial_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
248
249 // Process light-weight/limited parallel roots then
250 _vm_roots.oops_do(keep_alive, worker_id);
251 _weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
252 _dedup_roots.oops_do(is_alive, keep_alive, worker_id);
253 _cld_roots.cld_do(&clds, worker_id);
254
255 // Process heavy-weight/fully parallel roots the last
256 _code_roots.code_blobs_do(codes_cl, worker_id);
257 _thread_roots.oops_do(keep_alive, NULL, worker_id);
258 }
259
260 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
|
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
25 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
26 #define SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
27
28 #include "classfile/classLoaderDataGraph.hpp"
29 #include "classfile/stringTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "gc/shared/oopStorageSetParState.inline.hpp"
32 #include "gc/shared/oopStorageSet.hpp"
33 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
34 #include "gc/shenandoah/shenandoahConcurrentRoots.hpp"
35 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
36 #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
37 #include "gc/shenandoah/shenandoahRootProcessor.hpp"
38 #include "gc/shenandoah/shenandoahUtils.hpp"
39 #include "gc/shenandoah/heuristics/shenandoahHeuristics.hpp"
40 #include "memory/resourceArea.hpp"
41 #include "prims/resolvedMethodTable.hpp"
42 #include "runtime/safepoint.hpp"
43
44 template <bool CONCURRENT>
45 ShenandoahVMWeakRoots<CONCURRENT>::ShenandoahVMWeakRoots(ShenandoahPhaseTimings::Phase phase) :
46 _phase(phase) {
47 }
48
49 template <bool CONCURRENT>
50 template <typename T>
51 void ShenandoahVMWeakRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
52 ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::VMWeakRoots, worker_id);
53 _weak_roots.oops_do(cl);
54 }
55
56 template <bool CONCURRENT>
57 template <typename IsAlive, typename KeepAlive>
58 void ShenandoahVMWeakRoots<CONCURRENT>::weak_oops_do(IsAlive* is_alive, KeepAlive* keep_alive, uint worker_id) {
59 ShenandoahCleanUpdateWeakOopsClosure<CONCURRENT, IsAlive, KeepAlive> cl(is_alive, keep_alive);
60 ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::VMWeakRoots, worker_id);
61 _weak_roots.oops_do(&cl);
62 }
63
64 template <bool CONCURRENT>
65 void ShenandoahVMWeakRoots<CONCURRENT>::notify() {
66 _weak_roots.notify();
67 }
68
69 template <bool CONCURRENT>
70 ShenandoahVMRoots<CONCURRENT>::ShenandoahVMRoots(ShenandoahPhaseTimings::Phase phase) :
71 _phase(phase) {
72 }
73
74 template <bool CONCURRENT>
75 template <typename T>
76 void ShenandoahVMRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
77 ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::VMStrongRoots, worker_id);
78 _strong_roots.oops_do(cl);
79 }
80
81 template <bool CONCURRENT, bool SINGLE_THREADED>
82 ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::ShenandoahClassLoaderDataRoots(ShenandoahPhaseTimings::Phase phase, uint n_workers) :
83 _semaphore(worker_count(n_workers)),
84 _phase(phase) {
85 if (!SINGLE_THREADED) {
86 ClassLoaderDataGraph::clear_claimed_marks();
87 }
88 if (CONCURRENT) {
89 ClassLoaderDataGraph_lock->lock();
90 }
91 }
92
93 template <bool CONCURRENT, bool SINGLE_THREADED>
94 ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::~ShenandoahClassLoaderDataRoots() {
95 if (CONCURRENT) {
96 ClassLoaderDataGraph_lock->unlock();
97 }
98 }
187 _cld_roots.always_strong_cld_do(&clds_cl, worker_id);
188 }
189 }
190
191 template <typename IsAlive, typename KeepAlive>
192 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {
193 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations);
194 ShenandoahCodeBlobAndDisarmClosure blobs_and_disarm_Cl(keep_alive);
195 CodeBlobToOopClosure* codes_cl = ShenandoahConcurrentRoots::can_do_concurrent_class_unloading() ?
196 static_cast<CodeBlobToOopClosure*>(&blobs_and_disarm_Cl) :
197 static_cast<CodeBlobToOopClosure*>(&update_blobs);
198
199 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
200
201 // Process serial-claiming roots first
202 _serial_roots.oops_do(keep_alive, worker_id);
203 _serial_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
204
205 // Process light-weight/limited parallel roots then
206 _vm_roots.oops_do(keep_alive, worker_id);
207 _weak_roots.weak_oops_do<IsAlive, KeepAlive>(is_alive, keep_alive, worker_id);
208 _dedup_roots.oops_do(is_alive, keep_alive, worker_id);
209 _cld_roots.cld_do(&clds, worker_id);
210
211 // Process heavy-weight/fully parallel roots the last
212 _code_roots.code_blobs_do(codes_cl, worker_id);
213 _thread_roots.oops_do(keep_alive, NULL, worker_id);
214 }
215
216 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
|