1 /*
2 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
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_CODE_CODECACHE_HPP
26 #define SHARE_CODE_CODECACHE_HPP
27
28 #include "code/codeBlob.hpp"
29 #include "code/nmethod.hpp"
30 #include "gc/shared/gcBehaviours.hpp"
31 #include "memory/allocation.hpp"
32 #include "memory/heap.hpp"
33 #include "oops/instanceKlass.hpp"
34 #include "oops/oopsHierarchy.hpp"
35 #include "runtime/mutexLocker.hpp"
36 #include "utilities/numberSeq.hpp"
37
38 // The CodeCache implements the code cache for various pieces of generated
39 // code, e.g., compiled java methods, runtime stubs, transition frames, etc.
40 // The entries in the CodeCache are all CodeBlob's.
41
42 // -- Implementation --
43 // The CodeCache consists of one or more CodeHeaps, each of which contains
44 // CodeBlobs of a specific CodeBlobType. Currently heaps for the following
45 // types are available:
46 // - Non-nmethods: Non-nmethods like Buffers, Adapters and Runtime Stubs
47 // - Profiled nmethods: nmethods that are profiled, i.e., those
48 // executed at level 2 or 3
49 // - Non-Profiled nmethods: nmethods that are not profiled, i.e., those
50 // executed at level 1 or 4 and native methods
51 // - All: Used for code of all types if code cache segmentation is disabled.
52 //
53 // In the rare case of the non-nmethod code heap getting full, non-nmethod code
54 // will be stored in the non-profiled code heap as a fallback solution.
55 //
56 // Depending on the availability of compilers and compilation mode there
57 // may be fewer heaps. The size of the code heaps depends on the values of
58 // ReservedCodeCacheSize, NonProfiledCodeHeapSize and ProfiledCodeHeapSize
59 // (see CodeCache::heap_available(..) and CodeCache::initialize_heaps(..)
60 // for details).
61 //
62 // Code cache segmentation is controlled by the flag SegmentedCodeCache.
63 // If turned off, all code types are stored in a single code heap. By default
64 // code cache segmentation is turned on if tiered mode is enabled and
65 // ReservedCodeCacheSize >= 240 MB.
66 //
67 // All methods of the CodeCache accepting a CodeBlobType only apply to
68 // CodeBlobs of the given type. For example, iteration over the
69 // CodeBlobs of a specific type can be done by using CodeCache::first_blob(..)
70 // and CodeCache::next_blob(..) and providing the corresponding CodeBlobType.
71 //
72 // IMPORTANT: If you add new CodeHeaps to the code cache or change the
73 // existing ones, make sure to adapt the dtrace scripts (jhelper.d) for
74 // Solaris and BSD.
75
76 class ExceptionCache;
77 class KlassDepChange;
78 class OopClosure;
79 class ShenandoahParallelCodeHeapIterator;
80 class NativePostCallNop;
81 class DeoptimizationScope;
82 class ReservedSpace;
83
84 #ifdef LINUX
85 #define DEFAULT_PERFMAP_FILENAME "/tmp/perf-%p.map"
86 #endif
87
88 class CodeCache : AllStatic {
89 friend class VMStructs;
90 friend class JVMCIVMStructs;
91 template <class T, class Filter, bool is_relaxed> friend class CodeBlobIterator;
92 friend class WhiteBox;
93 friend class CodeCacheLoader;
94 friend class ShenandoahParallelCodeHeapIterator;
95 private:
96 // CodeHeaps of the cache
97 static GrowableArray<CodeHeap*>* _heaps;
98 static GrowableArray<CodeHeap*>* _nmethod_heaps;
99 static GrowableArray<CodeHeap*>* _allocable_heaps;
100
101 static address _low_bound; // Lower bound of CodeHeap addresses
102 static address _high_bound; // Upper bound of CodeHeap addresses
103 static volatile int _number_of_nmethods_with_dependencies; // Total number of nmethods with dependencies
104
105 static uint8_t _unloading_cycle; // Global state for recognizing old nmethods that need to be unloaded
106 static uint64_t _gc_epoch; // Global state for tracking when nmethods were found to be on-stack
107 static uint64_t _cold_gc_count; // Global state for determining how many GCs are needed before an nmethod is cold
108 static size_t _last_unloading_used;
109 static double _last_unloading_time;
110 static TruncatedSeq _unloading_gc_intervals;
111 static TruncatedSeq _unloading_allocation_rates;
112 static volatile bool _unloading_threshold_gc_requested;
113
114 static ExceptionCache* volatile _exception_cache_purge_list;
115
116 // CodeHeap management
117 static void initialize_heaps(); // Initializes the CodeHeaps
118
119 // Creates a new heap with the given name and size, containing CodeBlobs of the given type
120 static void add_heap(ReservedSpace rs, const char* name, CodeBlobType code_blob_type);
121 static CodeHeap* get_code_heap_containing(void* p); // Returns the CodeHeap containing the given pointer, or nullptr
122 static CodeHeap* get_code_heap(const void* cb); // Returns the CodeHeap for the given CodeBlob
123 static CodeHeap* get_code_heap(CodeBlobType code_blob_type); // Returns the CodeHeap for the given CodeBlobType
124 // Returns the name of the VM option to set the size of the corresponding CodeHeap
125 static const char* get_code_heap_flag_name(CodeBlobType code_blob_type);
126 static ReservedSpace reserve_heap_memory(size_t size, size_t rs_ps); // Reserves one continuous chunk of memory for the CodeHeaps
127
128 // Iteration
129 static CodeBlob* first_blob(CodeHeap* heap); // Returns the first CodeBlob on the given CodeHeap
130 static CodeBlob* first_blob(CodeBlobType code_blob_type); // Returns the first CodeBlob of the given type
131 static CodeBlob* next_blob(CodeHeap* heap, CodeBlob* cb); // Returns the next CodeBlob on the given CodeHeap
132
133 private:
134 static size_t bytes_allocated_in_freelists();
135 static int allocated_segments();
136 static size_t freelists_length();
137
138 // Make private to prevent unsafe calls. Not all CodeBlob*'s are embedded in a CodeHeap.
139 static bool contains(CodeBlob *p) { fatal("don't call me!"); return false; }
140
141 public:
142 // Initialization
143 static void initialize();
144 static size_t page_size(bool aligned = true, size_t min_pages = 1); // Returns the page size used by the CodeCache
145
146 static int code_heap_compare(CodeHeap* const &lhs, CodeHeap* const &rhs);
147
148 static void add_heap(CodeHeap* heap);
149 static const GrowableArray<CodeHeap*>* heaps() { return _heaps; }
150 static const GrowableArray<CodeHeap*>* nmethod_heaps() { return _nmethod_heaps; }
151
152 static void* map_cached_code();
153 // Allocation/administration
154 static CodeBlob* allocate(uint size, CodeBlobType code_blob_type, bool handle_alloc_failure = true, CodeBlobType orig_code_blob_type = CodeBlobType::All); // allocates a new CodeBlob
155 static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled
156 static void free(CodeBlob* cb); // frees a CodeBlob
157 static void free_unused_tail(CodeBlob* cb, size_t used); // frees the unused tail of a CodeBlob (only used by TemplateInterpreter::initialize())
158 static bool contains(void *p); // returns whether p is included
159 static bool contains(nmethod* nm); // returns whether nm is included
160 static void blobs_do(void f(CodeBlob* cb)); // iterates over all CodeBlobs
161 static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods
162 static void nmethods_do(NMethodClosure* cl); // iterates over all nmethods
163 static void metadata_do(MetadataClosure* f); // iterates over metadata in alive nmethods
164
165 // Lookup
166 static CodeBlob* find_blob(void* start); // Returns the CodeBlob containing the given address
167 static CodeBlob* find_blob_fast(void* start); // Returns the CodeBlob containing the given address
168 static CodeBlob* find_blob_and_oopmap(void* start, int& slot); // Returns the CodeBlob containing the given address
169 static int find_oopmap_slot_fast(void* start); // Returns a fast oopmap slot if there is any; -1 otherwise
170 static nmethod* find_nmethod(void* start); // Returns the nmethod containing the given address
171
172 static int blob_count(); // Returns the total number of CodeBlobs in the cache
173 static int blob_count(CodeBlobType code_blob_type);
174 static int adapter_count(); // Returns the total number of Adapters in the cache
175 static int adapter_count(CodeBlobType code_blob_type);
176 static int nmethod_count(); // Returns the total number of nmethods in the cache
177 static int nmethod_count(CodeBlobType code_blob_type);
178
179 // GC support
180 static void verify_oops();
181
182 // Helper scope object managing code cache unlinking behavior, i.e. sets and
183 // restores the closure that determines which nmethods are going to be removed
184 // during the unlinking part of code cache unloading.
185 class UnlinkingScope : StackObj {
186 ClosureIsUnloadingBehaviour _is_unloading_behaviour;
187 IsUnloadingBehaviour* _saved_behaviour;
188
189 public:
190 UnlinkingScope(BoolObjectClosure* is_alive);
191 ~UnlinkingScope();
192 };
193
194 // Code cache unloading heuristics
195 static uint64_t cold_gc_count();
196 static void update_cold_gc_count();
197 static void gc_on_allocation();
198
199 // The GC epoch and marking_cycle code below is there to support sweeping
200 // nmethods in loom stack chunks.
201 static uint64_t gc_epoch();
202 static bool is_gc_marking_cycle_active();
203 static uint64_t previous_completed_gc_marking_cycle();
204 static void on_gc_marking_cycle_start();
205 static void on_gc_marking_cycle_finish();
206 // Arm nmethods so that special actions are taken (nmethod_entry_barrier) for
207 // on-stack nmethods. It's used in two places:
208 // 1. Used before the start of concurrent marking so that oops inside
209 // on-stack nmethods are visited.
210 // 2. Used at the end of (stw/concurrent) marking so that nmethod::_gc_epoch
211 // is up-to-date, which provides more accurate estimate of
212 // nmethod::is_cold.
213 static void arm_all_nmethods();
214
215 static void maybe_restart_compiler(size_t freed_memory);
216 static void do_unloading(bool unloading_occurred);
217 static uint8_t unloading_cycle() { return _unloading_cycle; }
218
219 static void increment_unloading_cycle();
220
221 static void release_exception_cache(ExceptionCache* entry);
222 static void purge_exception_caches();
223
224 // Printing/debugging
225 static void print(); // prints summary
226 static void print_internals();
227 static void print_nmethods_on(outputStream* st);
228 static void print_memory_overhead();
229 static void verify(); // verifies the code cache
230 static void print_trace(const char* event, CodeBlob* cb, uint size = 0) PRODUCT_RETURN;
231 static void print_summary(outputStream* st, bool detailed = true); // Prints a summary of the code cache usage
232 static void log_state(outputStream* st);
233 LINUX_ONLY(static void write_perf_map(const char* filename, outputStream* st);) // Prints warnings and error messages to outputStream
234 static const char* get_code_heap_name(CodeBlobType code_blob_type) { return (heap_available(code_blob_type) ? get_code_heap(code_blob_type)->name() : "Unused"); }
235 static void report_codemem_full(CodeBlobType code_blob_type, bool print);
236
237 static void print_nmethod_statistics_on(outputStream* st);
238
239 // Dcmd (Diagnostic commands)
240 static void print_codelist(outputStream* st);
241 static void print_layout(outputStream* st);
242
243 // The full limits of the codeCache
244 static address low_bound() { return _low_bound; }
245 static address low_bound(CodeBlobType code_blob_type);
246 static address high_bound() { return _high_bound; }
247 static address high_bound(CodeBlobType code_blob_type);
248
249 // Profiling
250 static size_t capacity();
251 static size_t unallocated_capacity(CodeBlobType code_blob_type);
252 static size_t unallocated_capacity();
253 static size_t max_capacity();
254
255 static double reverse_free_ratio();
256
257 static size_t max_distance_to_non_nmethod();
258 static bool is_non_nmethod(address addr);
259
260 static void clear_inline_caches(); // clear all inline caches
261 static void cleanup_inline_caches_whitebox(); // clean bad nmethods from inline caches
262
263 // Returns true if an own CodeHeap for the given CodeBlobType is available
264 static bool heap_available(CodeBlobType code_blob_type);
265
266 // Returns the CodeBlobType for the given nmethod
267 static CodeBlobType get_code_blob_type(nmethod* nm) {
268 return get_code_heap(nm)->code_blob_type();
269 }
270
271 static bool code_blob_type_accepts_nmethod(CodeBlobType type) {
272 return type == CodeBlobType::All || type <= CodeBlobType::MethodProfiled;
273 }
274
275 static bool code_blob_type_accepts_allocable(CodeBlobType type) {
276 return type <= CodeBlobType::All;
277 }
278
279
280 // Returns the CodeBlobType for the given compilation level
281 static CodeBlobType get_code_blob_type(int comp_level) {
282 if (comp_level == CompLevel_none ||
283 comp_level == CompLevel_simple ||
284 comp_level == CompLevel_full_optimization) {
285 // Non profiled methods
286 return CodeBlobType::MethodNonProfiled;
287 } else if (comp_level == CompLevel_limited_profile ||
288 comp_level == CompLevel_full_profile) {
289 // Profiled methods
290 return CodeBlobType::MethodProfiled;
291 }
292 ShouldNotReachHere();
293 return static_cast<CodeBlobType>(0);
294 }
295
296 static void verify_clean_inline_caches();
297
298 // Deoptimization
299 private:
300 static void mark_for_deoptimization(DeoptimizationScope* deopt_scope, KlassDepChange& changes);
301
302 public:
303 static void mark_all_nmethods_for_deoptimization(DeoptimizationScope* deopt_scope);
304 static void mark_for_deoptimization(DeoptimizationScope* deopt_scope, Method* dependee);
305 static void make_marked_nmethods_deoptimized();
306
307 // Marks dependents during classloading
308 static void mark_dependents_on(DeoptimizationScope* deopt_scope, InstanceKlass* dependee);
309
310 // RedefineClasses support
311 // Marks in case of evolution
312 static void mark_dependents_for_evol_deoptimization(DeoptimizationScope* deopt_scope);
313 static void mark_all_nmethods_for_evol_deoptimization(DeoptimizationScope* deopt_scope);
314 static void old_nmethods_do(MetadataClosure* f) NOT_JVMTI_RETURN;
315 static void unregister_old_nmethod(nmethod* c) NOT_JVMTI_RETURN;
316
317 // Support for fullspeed debugging
318 static void mark_dependents_on_method_for_breakpoint(const methodHandle& dependee);
319
320 // tells if there are nmethods with dependencies
321 static bool has_nmethods_with_dependencies();
322
323 static int get_codemem_full_count(CodeBlobType code_blob_type) {
324 CodeHeap* heap = get_code_heap(code_blob_type);
325 return (heap != nullptr) ? heap->full_count() : 0;
326 }
327
328 // CodeHeap State Analytics.
329 // interface methods for CodeHeap printing, called by CompileBroker
330 static void aggregate(outputStream *out, size_t granularity);
331 static void discard(outputStream *out);
332 static void print_usedSpace(outputStream *out);
333 static void print_freeSpace(outputStream *out);
334 static void print_count(outputStream *out);
335 static void print_space(outputStream *out);
336 static void print_age(outputStream *out);
337 static void print_names(outputStream *out);
338 };
339
340
341 // Iterator to iterate over code blobs in the CodeCache.
342 // The relaxed iterators only hold the CodeCache_lock across next calls
343 template <class T, class Filter, bool is_relaxed> class CodeBlobIterator : public StackObj {
344 public:
345 enum LivenessFilter { all, not_unloading };
346
347 private:
348 CodeBlob* _code_blob; // Current CodeBlob
349 GrowableArrayIterator<CodeHeap*> _heap;
350 GrowableArrayIterator<CodeHeap*> _end;
351 bool _not_unloading; // Those nmethods that are not unloading
352
353 void initialize_iteration(T* nm) {
354 }
355
356 bool next_impl() {
357 for (;;) {
358 // Walk through heaps as required
359 if (!next_blob()) {
360 if (_heap == _end) {
361 return false;
362 }
363 ++_heap;
364 continue;
365 }
366
367 // Filter is_unloading as required
368 if (_not_unloading) {
369 nmethod* nm = _code_blob->as_nmethod_or_null();
370 if (nm != nullptr && nm->is_unloading()) {
371 continue;
372 }
373 }
374
375 return true;
376 }
377 }
378
379 public:
380 CodeBlobIterator(LivenessFilter filter, T* nm = nullptr)
381 : _not_unloading(filter == not_unloading)
382 {
383 if (Filter::heaps() == nullptr) {
384 // The iterator is supposed to shortcut since we have
385 // _heap == _end, but make sure we do not have garbage
386 // in other fields as well.
387 _code_blob = nullptr;
388 return;
389 }
390 _heap = Filter::heaps()->begin();
391 _end = Filter::heaps()->end();
392 // If set to nullptr, initialized by first call to next()
393 _code_blob = nm;
394 if (nm != nullptr) {
395 while(!(*_heap)->contains(_code_blob)) {
396 ++_heap;
397 }
398 assert((*_heap)->contains(_code_blob), "match not found");
399 }
400 }
401
402 // Advance iterator to next blob
403 bool next() {
404 if (is_relaxed) {
405 MutexLocker ml(CodeCache_lock, Mutex::_no_safepoint_check_flag);
406 return next_impl();
407 } else {
408 assert_locked_or_safepoint(CodeCache_lock);
409 return next_impl();
410 }
411 }
412
413 bool end() const { return _code_blob == nullptr; }
414 T* method() const { return (T*)_code_blob; }
415
416 private:
417
418 // Advance iterator to the next blob in the current code heap
419 bool next_blob() {
420 if (_heap == _end) {
421 return false;
422 }
423 CodeHeap *heap = *_heap;
424 // Get first method CodeBlob
425 if (_code_blob == nullptr) {
426 _code_blob = CodeCache::first_blob(heap);
427 if (_code_blob == nullptr) {
428 return false;
429 } else if (Filter::apply(_code_blob)) {
430 return true;
431 }
432 }
433 // Search for next method CodeBlob
434 _code_blob = CodeCache::next_blob(heap, _code_blob);
435 while (_code_blob != nullptr && !Filter::apply(_code_blob)) {
436 _code_blob = CodeCache::next_blob(heap, _code_blob);
437 }
438 return _code_blob != nullptr;
439 }
440 };
441
442 struct NMethodFilter {
443 static bool apply(CodeBlob* cb) { return cb->is_nmethod(); }
444 static const GrowableArray<CodeHeap*>* heaps() { return CodeCache::nmethod_heaps(); }
445 };
446
447 struct AllCodeBlobsFilter {
448 static bool apply(CodeBlob* cb) { return true; }
449 static const GrowableArray<CodeHeap*>* heaps() { return CodeCache::heaps(); }
450 };
451
452 typedef CodeBlobIterator<nmethod, NMethodFilter, false /* is_relaxed */> NMethodIterator;
453 typedef CodeBlobIterator<nmethod, NMethodFilter, true /* is_relaxed */> RelaxedNMethodIterator;
454 typedef CodeBlobIterator<CodeBlob, AllCodeBlobsFilter, false /* is_relaxed */> AllCodeBlobsIterator;
455
456 #endif // SHARE_CODE_CODECACHE_HPP