1 /*
2 * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2017, 2022, Red Hat, Inc. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "code/codeCache.hpp"
27 #include "code/nmethod.hpp"
28 #include "gc/shared/classUnloadingContext.hpp"
29 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
30 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
31 #include "gc/shenandoah/shenandoahNMethod.inline.hpp"
32 #include "gc/shenandoah/shenandoahUtils.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "memory/universe.hpp"
35 #include "runtime/atomicAccess.hpp"
36 #include "utilities/events.hpp"
37 #include "utilities/powerOfTwo.hpp"
38
39
40 ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;
41 int ShenandoahCodeRoots::_disarmed_value = 1;
42
43 void ShenandoahCodeRoots::initialize() {
44 _nmethod_table = new ShenandoahNMethodTable();
45 }
46
47 void ShenandoahCodeRoots::register_nmethod(nmethod* nm) {
48 assert(CodeCache_lock->owned_by_self(), "Must have CodeCache_lock held");
49 _nmethod_table->register_nmethod(nm);
50 }
51
52 void ShenandoahCodeRoots::unregister_nmethod(nmethod* nm) {
53 assert_locked_or_safepoint(CodeCache_lock);
54 _nmethod_table->unregister_nmethod(nm);
55 }
56
57 void ShenandoahCodeRoots::arm_nmethods() {
58 char gc_state = ShenandoahHeap::heap()->gc_state();
59 Events::log(Thread::current(), "Arming nmethods, GC state: %d [%s%s%s%s%s%s%s]",
60 gc_state,
61 ((gc_state & ShenandoahHeap::HAS_FORWARDED) > 0) ? "HAS_FORWARDED " : "",
62 ((gc_state & ShenandoahHeap::MARKING) > 0) ? "MARKING " : "",
63 ((gc_state & ShenandoahHeap::EVACUATION) > 0) ? "EVACUATION " : "",
64 ((gc_state & ShenandoahHeap::UPDATE_REFS) > 0) ? "UPDATE_REFS " : "",
65 ((gc_state & ShenandoahHeap::WEAK_ROOTS) > 0) ? "WEAK_ROOTS " : "",
66 ((gc_state & ShenandoahHeap::YOUNG_MARKING) > 0) ? "YOUNG_MARKING " : "",
67 ((gc_state & ShenandoahHeap::OLD_MARKING) > 0) ? "OLD_MARKING " : ""
68 );
69 log_info(gc)("Arming nmethods with GC state: %d [%s%s%s%s%s%s%s]",
70 gc_state,
71 ((gc_state & ShenandoahHeap::HAS_FORWARDED) > 0) ? "HAS_FORWARDED " : "",
72 ((gc_state & ShenandoahHeap::MARKING) > 0) ? "MARKING " : "",
73 ((gc_state & ShenandoahHeap::EVACUATION) > 0) ? "EVACUATION " : "",
74 ((gc_state & ShenandoahHeap::UPDATE_REFS) > 0) ? "UPDATE_REFS " : "",
75 ((gc_state & ShenandoahHeap::WEAK_ROOTS) > 0) ? "WEAK_ROOTS " : "",
76 ((gc_state & ShenandoahHeap::YOUNG_MARKING) > 0) ? "YOUNG_MARKING " : "",
77 ((gc_state & ShenandoahHeap::OLD_MARKING) > 0) ? "OLD_MARKING " : ""
78 );
79 BarrierSet::barrier_set()->barrier_set_nmethod()->arm_all_nmethods();
80 }
81
82 class ShenandoahDisarmNMethodClosure : public NMethodClosure {
83 public:
84 virtual void do_nmethod(nmethod* nm) {
85 ShenandoahNMethod::complete_and_disarm_nmethod(nm);
86 }
87 };
88
89 class ShenandoahDisarmNMethodsTask : public WorkerTask {
90 private:
91 ShenandoahDisarmNMethodClosure _cl;
92 ShenandoahConcurrentNMethodIterator _iterator;
93
94 public:
95 ShenandoahDisarmNMethodsTask() :
96 WorkerTask("Shenandoah Disarm NMethods"),
97 _iterator(ShenandoahCodeRoots::table()) {}
98
99 virtual void work(uint worker_id) {
100 ShenandoahParallelWorkerSession worker_session(worker_id);
101 _iterator.nmethods_do(&_cl);
102 }
103 };
104
105 void ShenandoahCodeRoots::disarm_nmethods() {
106 Events::log(Thread::current(), "Disarming nmethod barriers");
107 log_info(gc)("Disarming nmethod barriers");
108
109 ShenandoahDisarmNMethodsTask task;
110 ShenandoahHeap::heap()->workers()->run_task(&task);
111
112 Events::log(Thread::current(), "Disarming nmethod barriers complete");
113 log_info(gc)("Disarming nmethod barriers complete");
114 }
115
116 #ifdef ASSERT
117 class ShenandoahCheckNMethodClosure : public NMethodClosure {
118 bool const _armed;
119 public:
120 ShenandoahCheckNMethodClosure(int armed) : _armed(armed) {}
121 virtual void do_nmethod(nmethod* nm) {
122 ShenandoahNMethod::assert_barriers(nm, _armed);
123 }
124 };
125
126 class ShenandoahCheckNMethodsTask : public WorkerTask {
127 private:
128 ShenandoahCheckNMethodClosure _cl;
129 ShenandoahConcurrentNMethodIterator _iterator;
130
131 public:
132 ShenandoahCheckNMethodsTask() :
133 WorkerTask("Shenandoah Check NMethods"),
134 _cl(!ShenandoahHeap::heap()->is_idle()),
135 _iterator(ShenandoahCodeRoots::table()) {}
136
137 virtual void work(uint worker_id) {
138 _iterator.nmethods_do(&_cl);
139 }
140 };
141
142 void ShenandoahCodeRoots::check_barriers() {
143 ShenandoahCheckNMethodsTask task;
144 ShenandoahHeap::heap()->workers()->run_task(&task);
145 }
146 #endif
147
148 class ShenandoahNMethodUnlinkClosure : public NMethodClosure {
149 private:
150 bool _unloading_occurred;
151 ShenandoahHeap* const _heap;
152 BarrierSetNMethod* const _bs;
153
154 public:
155 ShenandoahNMethodUnlinkClosure(bool unloading_occurred) :
156 _unloading_occurred(unloading_occurred),
157 _heap(ShenandoahHeap::heap()),
158 _bs(ShenandoahBarrierSet::barrier_set()->barrier_set_nmethod()) {}
159
160 virtual void do_nmethod(nmethod* nm) {
161 assert(_heap->is_concurrent_weak_root_in_progress(), "Only this phase");
162
163 ShenandoahNMethod* nm_data = ShenandoahNMethod::gc_data(nm);
164 assert(!nm_data->is_unregistered(), "Should not see unregistered entry");
165
166 if (nm->is_unloading()) {
167 ShenandoahNMethodLocker locker(nm_data->lock());
168 nm->unlink();
169 return;
170 }
171
172 if (_heap->is_evacuation_in_progress()) {
173 ShenandoahNMethodLocker locker(nm_data->lock());
174
175 // Heal oops
176 if (_bs->is_armed(nm)) {
177 ShenandoahNMethod::heal_nmethod_metadata(nm_data);
178 // Must remain armed to complete remaining work in nmethod entry barrier
179 assert(_bs->is_armed(nm), "Should remain armed");
180 }
181 }
182
183 // Clear compiled ICs and exception caches
184 ShenandoahNMethodLocker locker(nm_data->ic_lock());
185 nm->unload_nmethod_caches(_unloading_occurred);
186 }
187 };
188
189 class ShenandoahUnlinkTask : public WorkerTask {
190 private:
191 ShenandoahNMethodUnlinkClosure _cl;
192 ShenandoahConcurrentNMethodIterator _iterator;
193
194 public:
195 ShenandoahUnlinkTask(bool unloading_occurred) :
196 WorkerTask("Shenandoah Unlink NMethods"),
197 _cl(unloading_occurred),
198 _iterator(ShenandoahCodeRoots::table()) {}
199
200 virtual void work(uint worker_id) {
201 _iterator.nmethods_do(&_cl);
202 }
203 };
204
205 void ShenandoahCodeRoots::unlink(WorkerThreads* workers, bool unloading_occurred) {
206 assert(ShenandoahHeap::heap()->unload_classes(), "Only when running concurrent class unloading");
207
208 ShenandoahUnlinkTask task(unloading_occurred);
209 workers->run_task(&task);
210 }
211
212 void ShenandoahCodeRoots::purge() {
213 assert(ShenandoahHeap::heap()->unload_classes(), "Only when running concurrent class unloading");
214
215 ClassUnloadingContext::context()->purge_and_free_nmethods();
216 }
217
218 ShenandoahCodeRootsIterator::ShenandoahCodeRootsIterator() :
219 _table_snapshot(nullptr) {
220 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint");
221 MutexLocker locker(CodeCache_lock, Mutex::_no_safepoint_check_flag);
222 _table_snapshot = ShenandoahCodeRoots::table()->snapshot_for_iteration();
223 }
224
225 ShenandoahCodeRootsIterator::~ShenandoahCodeRootsIterator() {
226 MonitorLocker locker(CodeCache_lock, Mutex::_no_safepoint_check_flag);
227 ShenandoahCodeRoots::table()->finish_iteration(_table_snapshot);
228 _table_snapshot = nullptr;
229 locker.notify_all();
230 }
231
232 void ShenandoahCodeRootsIterator::possibly_parallel_nmethods_do(NMethodClosure *f) {
233 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint");
234 assert(_table_snapshot != nullptr, "Sanity");
235 _table_snapshot->parallel_nmethods_do(f);
236 }