1 /*
2 * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2019, 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
27 #include "gc/shenandoah/shenandoahClosures.inline.hpp"
28 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
29 #include "gc/shenandoah/shenandoahNMethod.inline.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "runtime/continuation.hpp"
32 #include "runtime/safepointVerifiers.hpp"
33
34 ShenandoahNMethod::ShenandoahNMethod(nmethod* nm, GrowableArray<oop*>& oops, bool non_immediate_oops) :
35 _nm(nm), _oops(nullptr), _oops_count(0), _unregistered(false), _lock(), _ic_lock() {
36
37 if (!oops.is_empty()) {
38 _oops_count = oops.length();
39 _oops = NEW_C_HEAP_ARRAY(oop*, _oops_count, mtGC);
40 for (int c = 0; c < _oops_count; c++) {
41 _oops[c] = oops.at(c);
42 }
43 }
44 _has_non_immed_oops = non_immediate_oops;
45
46 assert_same_oops();
47 }
48
49 ShenandoahNMethod::~ShenandoahNMethod() {
50 if (_oops != nullptr) {
51 FREE_C_HEAP_ARRAY(_oops);
52 }
53 }
54
55 void ShenandoahNMethod::update() {
56 ResourceMark rm;
57 bool non_immediate_oops = false;
58 GrowableArray<oop*> oops;
59
60 detect_reloc_oops(nm(), oops, non_immediate_oops);
61 if (oops.length() != _oops_count) {
62 if (_oops != nullptr) {
63 FREE_C_HEAP_ARRAY(_oops);
64 _oops = nullptr;
65 }
66
67 _oops_count = oops.length();
68 if (_oops_count > 0) {
69 _oops = NEW_C_HEAP_ARRAY(oop*, _oops_count, mtGC);
70 }
71 }
72
73 for (int index = 0; index < _oops_count; index ++) {
74 _oops[index] = oops.at(index);
75 }
76 _has_non_immed_oops = non_immediate_oops;
77
78 assert_same_oops();
79 }
80
81 void ShenandoahNMethod::detect_reloc_oops(nmethod* nm, GrowableArray<oop*>& oops, bool& has_non_immed_oops) {
82 has_non_immed_oops = false;
83 // Find all oops relocations
84 RelocIterator iter(nm);
85 while (iter.next()) {
86 if (iter.type() != relocInfo::oop_type) {
87 // Not an oop
88 continue;
89 }
90
91 oop_Relocation* r = iter.oop_reloc();
92 if (!r->oop_is_immediate()) {
93 // Non-immediate oop found
94 has_non_immed_oops = true;
95 continue;
96 }
97
98 oop value = r->oop_value();
99 if (value != nullptr) {
100 oop* addr = r->oop_addr();
101 shenandoah_assert_correct(addr, value);
102 shenandoah_assert_not_in_cset_except(addr, value, ShenandoahHeap::heap()->cancelled_gc());
103 shenandoah_assert_not_forwarded(addr, value);
104 // Non-null immediate oop found. null oops can safely be
105 // ignored since the method will be re-registered if they
106 // are later patched to be non-null.
107 oops.push(addr);
108 }
109 }
110 }
111
112 ShenandoahNMethod* ShenandoahNMethod::for_nmethod(nmethod* nm) {
113 ResourceMark rm;
114 bool non_immediate_oops = false;
115 GrowableArray<oop*> oops;
116
117 detect_reloc_oops(nm, oops, non_immediate_oops);
118 return new ShenandoahNMethod(nm, oops, non_immediate_oops);
119 }
120
121 void ShenandoahNMethod::heal_nmethod(nmethod* nm) {
122 ShenandoahNMethod* data = gc_data(nm);
123 assert(data != nullptr, "Sanity");
124 assert(data->lock()->owned_by_self(), "Must hold the lock");
125
126 ShenandoahHeap* const heap = ShenandoahHeap::heap();
127 if (heap->is_concurrent_weak_root_in_progress() ||
128 heap->is_concurrent_strong_root_in_progress()) {
129 heal_nmethod_metadata(data);
130 } else if (heap->is_concurrent_mark_in_progress()) {
131 ShenandoahKeepAliveClosure cl;
132 data->oops_do(&cl);
133 } else {
134 // There is possibility that GC is cancelled when it arrives final mark.
135 // In this case, concurrent root phase is skipped and degenerated GC should be
136 // followed, where nmethods are disarmed.
137 }
138 }
139
140 #ifdef ASSERT
141 void ShenandoahNMethod::assert_correct() {
142 ShenandoahHeap* heap = ShenandoahHeap::heap();
143 for (int c = 0; c < _oops_count; c++) {
144 oop *loc = _oops[c];
145 assert(_nm->code_contains((address) loc) || _nm->oops_contains(loc), "nmethod should contain the oop*");
146 oop o = RawAccess<>::oop_load(loc);
147 shenandoah_assert_correct_except(loc, o, o == nullptr || heap->is_full_gc_move_in_progress());
148 }
149
150 oop* const begin = _nm->oops_begin();
151 oop* const end = _nm->oops_end();
152 for (oop* p = begin; p < end; p++) {
153 if (*p != Universe::non_oop_word()) {
154 oop o = RawAccess<>::oop_load(p);
155 shenandoah_assert_correct_except(p, o, o == nullptr || heap->is_full_gc_move_in_progress());
156 }
157 }
158 }
159
160 class ShenandoahNMethodOopDetector : public OopClosure {
161 private:
162 ResourceMark rm; // For growable array allocation below.
163 GrowableArray<oop*> _oops;
164
165 public:
166 ShenandoahNMethodOopDetector() : _oops(10) {};
167
168 void do_oop(oop* o) {
169 _oops.append(o);
170 }
171 void do_oop(narrowOop* o) {
172 fatal("NMethods should not have compressed oops embedded.");
173 }
174
175 GrowableArray<oop*>* oops() {
176 return &_oops;
177 }
178 };
179
180 void ShenandoahNMethod::assert_same_oops() {
181 ShenandoahNMethodOopDetector detector;
182 nm()->oops_do(&detector);
183
184 GrowableArray<oop*>* oops = detector.oops();
185
186 int count = _oops_count;
187 for (int index = 0; index < _oops_count; index ++) {
188 assert(oops->contains(_oops[index]), "Must contain this oop");
189 }
190
191 for (oop* p = nm()->oops_begin(); p < nm()->oops_end(); p ++) {
192 if (*p == Universe::non_oop_word()) continue;
193 count++;
194 assert(oops->contains(p), "Must contain this oop");
195 }
196
197 if (oops->length() < count) {
198 stringStream debug_stream;
199 debug_stream.print_cr("detected locs: %d", oops->length());
200 for (int i = 0; i < oops->length(); i++) {
201 debug_stream.print_cr("-> " PTR_FORMAT, p2i(oops->at(i)));
202 }
203 debug_stream.print_cr("recorded oops: %d", _oops_count);
204 for (int i = 0; i < _oops_count; i++) {
205 debug_stream.print_cr("-> " PTR_FORMAT, p2i(_oops[i]));
206 }
207 GrowableArray<oop*> check;
208 bool non_immed;
209 detect_reloc_oops(nm(), check, non_immed);
210 debug_stream.print_cr("check oops: %d", check.length());
211 for (int i = 0; i < check.length(); i++) {
212 debug_stream.print_cr("-> " PTR_FORMAT, p2i(check.at(i)));
213 }
214 fatal("Must match #detected: %d, #recorded: %d, #total: %d, begin: " PTR_FORMAT ", end: " PTR_FORMAT "\n%s",
215 oops->length(), _oops_count, count, p2i(nm()->oops_begin()), p2i(nm()->oops_end()), debug_stream.freeze());
216 }
217 }
218 #endif
219
220 ShenandoahNMethodTable::ShenandoahNMethodTable() :
221 _heap(ShenandoahHeap::heap()),
222 _index(0),
223 _itr_cnt(0) {
224 _list = new ShenandoahNMethodList(minSize);
225 }
226
227 ShenandoahNMethodTable::~ShenandoahNMethodTable() {
228 assert(_list != nullptr, "Sanity");
229 _list->release();
230 }
231
232 void ShenandoahNMethodTable::register_nmethod(nmethod* nm) {
233 assert(CodeCache_lock->owned_by_self(), "Must have CodeCache_lock held");
234 assert(_index >= 0 && _index <= _list->size(), "Sanity");
235
236 ShenandoahNMethod* data = ShenandoahNMethod::gc_data(nm);
237
238 if (data != nullptr) {
239 assert(contain(nm), "Must have been registered");
240 assert(nm == data->nm(), "Must be same nmethod");
241 // Prevent updating a nmethod while concurrent iteration is in progress.
242 wait_until_concurrent_iteration_done();
243 ShenandoahNMethodLocker data_locker(data->lock());
244 data->update();
245 } else {
246 // For a new nmethod, we can safely append it to the list, because
247 // concurrent iteration will not touch it.
248 data = ShenandoahNMethod::for_nmethod(nm);
249 assert(data != nullptr, "Sanity");
250 ShenandoahNMethod::attach_gc_data(nm, data);
251 ShenandoahLocker locker(&_lock);
252 log_register_nmethod(nm);
253 append(data);
254 }
255 // Disarm new nmethod
256 ShenandoahNMethod::disarm_nmethod(nm);
257 }
258
259 void ShenandoahNMethodTable::unregister_nmethod(nmethod* nm) {
260 assert_locked_or_safepoint(CodeCache_lock);
261
262 ShenandoahNMethod* data = ShenandoahNMethod::gc_data(nm);
263 assert(data != nullptr, "Sanity");
264 log_unregister_nmethod(nm);
265 ShenandoahLocker locker(&_lock);
266 assert(contain(nm), "Must have been registered");
267
268 int idx = index_of(nm);
269 assert(idx >= 0 && idx < _index, "Invalid index");
270 ShenandoahNMethod::attach_gc_data(nm, nullptr);
271 remove(idx);
272 }
273
274 bool ShenandoahNMethodTable::contain(nmethod* nm) const {
275 return index_of(nm) != -1;
276 }
277
278 ShenandoahNMethod* ShenandoahNMethodTable::at(int index) const {
279 assert(index >= 0 && index < _index, "Out of bound");
280 return _list->at(index);
281 }
282
283 int ShenandoahNMethodTable::index_of(nmethod* nm) const {
284 for (int index = 0; index < length(); index ++) {
285 if (at(index)->nm() == nm) {
286 return index;
287 }
288 }
289 return -1;
290 }
291
292 void ShenandoahNMethodTable::remove(int idx) {
293 shenandoah_assert_locked_or_safepoint(CodeCache_lock);
294 assert(_index >= 0 && _index <= _list->size(), "Sanity");
295
296 assert(idx >= 0 && idx < _index, "Out of bound");
297 ShenandoahNMethod* snm = _list->at(idx);
298 ShenandoahNMethod* tmp = _list->at(_index - 1);
299 _list->set(idx, tmp);
300 _index --;
301
302 delete snm;
303 }
304
305 void ShenandoahNMethodTable::wait_until_concurrent_iteration_done() {
306 assert(CodeCache_lock->owned_by_self(), "Lock must be held");
307 while (iteration_in_progress()) {
308 CodeCache_lock->wait_without_safepoint_check();
309 }
310 }
311
312 void ShenandoahNMethodTable::append(ShenandoahNMethod* snm) {
313 if (is_full()) {
314 int new_size = 2 * _list->size();
315 // Rebuild table and replace current one
316 rebuild(new_size);
317 }
318
319 _list->set(_index++, snm);
320 assert(_index >= 0 && _index <= _list->size(), "Sanity");
321 }
322
323 void ShenandoahNMethodTable::rebuild(int size) {
324 ShenandoahNMethodList* new_list = new ShenandoahNMethodList(size);
325 new_list->transfer(_list, _index);
326
327 // Release old list
328 _list->release();
329 _list = new_list;
330 }
331
332 ShenandoahNMethodTableSnapshot* ShenandoahNMethodTable::snapshot_for_iteration() {
333 assert(CodeCache_lock->owned_by_self(), "Must have CodeCache_lock held");
334 _itr_cnt++;
335 return new ShenandoahNMethodTableSnapshot(this);
336 }
337
338 void ShenandoahNMethodTable::finish_iteration(ShenandoahNMethodTableSnapshot* snapshot) {
339 assert(CodeCache_lock->owned_by_self(), "Must have CodeCache_lock held");
340 assert(iteration_in_progress(), "Why we here?");
341 assert(snapshot != nullptr, "No snapshot");
342 _itr_cnt--;
343
344 delete snapshot;
345 }
346
347 void ShenandoahNMethodTable::log_register_nmethod(nmethod* nm) {
348 LogTarget(Debug, gc, nmethod) log;
349 if (!log.is_enabled()) {
350 return;
351 }
352
353 ResourceMark rm;
354 log.print("Register NMethod: %s.%s [" PTR_FORMAT "] (%s)",
355 nm->method()->method_holder()->external_name(),
356 nm->method()->name()->as_C_string(),
357 p2i(nm),
358 nm->compiler_name());
359 }
360
361 void ShenandoahNMethodTable::log_unregister_nmethod(nmethod* nm) {
362 LogTarget(Debug, gc, nmethod) log;
363 if (!log.is_enabled()) {
364 return;
365 }
366
367 ResourceMark rm;
368 log.print("Unregister NMethod: %s.%s [" PTR_FORMAT "]",
369 nm->method()->method_holder()->external_name(),
370 nm->method()->name()->as_C_string(),
371 p2i(nm));
372 }
373
374 #ifdef ASSERT
375 void ShenandoahNMethodTable::assert_nmethods_correct() {
376 assert_locked_or_safepoint(CodeCache_lock);
377
378 for (int index = 0; index < length(); index ++) {
379 ShenandoahNMethod* m = _list->at(index);
380 // Concurrent unloading may have dead nmethods to be cleaned by sweeper
381 if (m->is_unregistered()) continue;
382 m->assert_correct();
383 }
384 }
385 #endif
386
387
388 ShenandoahNMethodList::ShenandoahNMethodList(int size) :
389 _size(size), _ref_count(1) {
390 _list = NEW_C_HEAP_ARRAY(ShenandoahNMethod*, size, mtGC);
391 }
392
393 ShenandoahNMethodList::~ShenandoahNMethodList() {
394 assert(_list != nullptr, "Sanity");
395 assert(_ref_count == 0, "Must be");
396 FREE_C_HEAP_ARRAY(_list);
397 }
398
399 void ShenandoahNMethodList::transfer(ShenandoahNMethodList* const list, int limit) {
400 assert(limit <= size(), "Sanity");
401 ShenandoahNMethod** old_list = list->list();
402 for (int index = 0; index < limit; index++) {
403 _list[index] = old_list[index];
404 }
405 }
406
407 ShenandoahNMethodList* ShenandoahNMethodList::acquire() {
408 assert_locked_or_safepoint(CodeCache_lock);
409 _ref_count++;
410 return this;
411 }
412
413 void ShenandoahNMethodList::release() {
414 assert_locked_or_safepoint(CodeCache_lock);
415 _ref_count--;
416 if (_ref_count == 0) {
417 delete this;
418 }
419 }
420
421 ShenandoahNMethodTableSnapshot::ShenandoahNMethodTableSnapshot(ShenandoahNMethodTable* table) :
422 _heap(ShenandoahHeap::heap()), _list(table->_list->acquire()), _limit(table->_index), _claimed(0) {
423 }
424
425 ShenandoahNMethodTableSnapshot::~ShenandoahNMethodTableSnapshot() {
426 _list->release();
427 }
428
429 void ShenandoahNMethodTableSnapshot::parallel_nmethods_do(NMethodClosure *f) {
430 size_t stride = 256; // educated guess
431
432 ShenandoahNMethod** const list = _list->list();
433
434 size_t max = (size_t)_limit;
435 while (_claimed.load_relaxed() < max) {
436 size_t cur = _claimed.fetch_then_add(stride, memory_order_relaxed);
437 size_t start = cur;
438 size_t end = MIN2(cur + stride, max);
439 if (start >= max) break;
440
441 for (size_t idx = start; idx < end; idx++) {
442 ShenandoahNMethod* nmr = list[idx];
443 assert(nmr != nullptr, "Sanity");
444 if (nmr->is_unregistered()) {
445 continue;
446 }
447
448 nmr->assert_correct();
449 f->do_nmethod(nmr->nm());
450 }
451 }
452 }
453
454 void ShenandoahNMethodTableSnapshot::concurrent_nmethods_do(NMethodClosure* cl) {
455 size_t stride = 256; // educated guess
456
457 ShenandoahNMethod** list = _list->list();
458 size_t max = (size_t)_limit;
459 while (_claimed.load_relaxed() < max) {
460 size_t cur = _claimed.fetch_then_add(stride, memory_order_relaxed);
461 size_t start = cur;
462 size_t end = MIN2(cur + stride, max);
463 if (start >= max) break;
464
465 for (size_t idx = start; idx < end; idx++) {
466 ShenandoahNMethod* data = list[idx];
467 assert(data != nullptr, "Should not be null");
468 if (!data->is_unregistered()) {
469 cl->do_nmethod(data->nm());
470 }
471 }
472 }
473 }
474
475 ShenandoahConcurrentNMethodIterator::ShenandoahConcurrentNMethodIterator(ShenandoahNMethodTable* table) :
476 _table(table),
477 _table_snapshot(nullptr),
478 _started_workers(0),
479 _finished_workers(0) {}
480
481 void ShenandoahConcurrentNMethodIterator::nmethods_do(NMethodClosure* cl) {
482 // Cannot safepoint when iteration is running, because this can cause deadlocks
483 // with other threads waiting on iteration to be over.
484 NoSafepointVerifier nsv;
485
486 MutexLocker ml(CodeCache_lock, Mutex::_no_safepoint_check_flag);
487
488 if (_finished_workers > 0) {
489 // Some threads have already finished. We are now in rampdown: we are now
490 // waiting for all currently recorded workers to finish. No new workers
491 // should start.
492 return;
493 }
494
495 // Record a new worker and initialize the snapshot if it is a first visitor.
496 if (_started_workers++ == 0) {
497 _table_snapshot = _table->snapshot_for_iteration();
498 }
499
500 // All set, relinquish the lock and go concurrent.
501 {
502 MutexUnlocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
503 _table_snapshot->concurrent_nmethods_do(cl);
504 }
505
506 // Record completion. Last worker shuts down the iterator and notifies any waiters.
507 uint count = ++_finished_workers;
508 if (count == _started_workers) {
509 _table->finish_iteration(_table_snapshot);
510 CodeCache_lock->notify_all();
511 }
512 }