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 83 class CodeCache : AllStatic { 84 friend class VMStructs; 85 friend class JVMCIVMStructs; 86 template <class T, class Filter, bool is_relaxed> friend class CodeBlobIterator; 87 friend class WhiteBox; 88 friend class CodeCacheLoader; 89 friend class ShenandoahParallelCodeHeapIterator; 90 private: 91 // CodeHeaps of the cache 92 static GrowableArray<CodeHeap*>* _heaps; 93 static GrowableArray<CodeHeap*>* _nmethod_heaps; 94 static GrowableArray<CodeHeap*>* _allocable_heaps; 95 96 static address _low_bound; // Lower bound of CodeHeap addresses 97 static address _high_bound; // Upper bound of CodeHeap addresses 98 static volatile int _number_of_nmethods_with_dependencies; // Total number of nmethods with dependencies 99 100 static uint8_t _unloading_cycle; // Global state for recognizing old nmethods that need to be unloaded 101 static uint64_t _gc_epoch; // Global state for tracking when nmethods were found to be on-stack 102 static uint64_t _cold_gc_count; // Global state for determining how many GCs are needed before an nmethod is cold 103 static size_t _last_unloading_used; 104 static double _last_unloading_time; 105 static TruncatedSeq _unloading_gc_intervals; 106 static TruncatedSeq _unloading_allocation_rates; 107 static volatile bool _unloading_threshold_gc_requested; 108 109 static ExceptionCache* volatile _exception_cache_purge_list; 110 111 // CodeHeap management 112 static void initialize_heaps(); // Initializes the CodeHeaps 113 114 // Creates a new heap with the given name and size, containing CodeBlobs of the given type 115 static void add_heap(ReservedSpace rs, const char* name, CodeBlobType code_blob_type); 116 static CodeHeap* get_code_heap_containing(void* p); // Returns the CodeHeap containing the given pointer, or nullptr 117 static CodeHeap* get_code_heap(const void* cb); // Returns the CodeHeap for the given CodeBlob 118 static CodeHeap* get_code_heap(CodeBlobType code_blob_type); // Returns the CodeHeap for the given CodeBlobType 119 // Returns the name of the VM option to set the size of the corresponding CodeHeap 120 static const char* get_code_heap_flag_name(CodeBlobType code_blob_type); 121 static ReservedCodeSpace reserve_heap_memory(size_t size, size_t rs_ps); // Reserves one continuous chunk of memory for the CodeHeaps 122 123 // Iteration 124 static CodeBlob* first_blob(CodeHeap* heap); // Returns the first CodeBlob on the given CodeHeap 125 static CodeBlob* first_blob(CodeBlobType code_blob_type); // Returns the first CodeBlob of the given type 126 static CodeBlob* next_blob(CodeHeap* heap, CodeBlob* cb); // Returns the next CodeBlob on the given CodeHeap 127 128 private: 129 static size_t bytes_allocated_in_freelists(); 130 static int allocated_segments(); 131 static size_t freelists_length(); 132 133 // Make private to prevent unsafe calls. Not all CodeBlob*'s are embedded in a CodeHeap. 134 static bool contains(CodeBlob *p) { fatal("don't call me!"); return false; } 135 136 public: 137 // Initialization 138 static void initialize(); 139 static size_t page_size(bool aligned = true, size_t min_pages = 1); // Returns the page size used by the CodeCache 140 141 static int code_heap_compare(CodeHeap* const &lhs, CodeHeap* const &rhs); 142 143 static void add_heap(CodeHeap* heap); 144 static const GrowableArray<CodeHeap*>* heaps() { return _heaps; } 145 static const GrowableArray<CodeHeap*>* nmethod_heaps() { return _nmethod_heaps; } 146 147 // Allocation/administration 148 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 149 static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled 150 static void free(CodeBlob* cb); // frees a CodeBlob 151 static void free_unused_tail(CodeBlob* cb, size_t used); // frees the unused tail of a CodeBlob (only used by TemplateInterpreter::initialize()) 152 static bool contains(void *p); // returns whether p is included 153 static bool contains(nmethod* nm); // returns whether nm is included 154 static void blobs_do(void f(CodeBlob* cb)); // iterates over all CodeBlobs 155 static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods 156 static void nmethods_do(NMethodClosure* cl); // iterates over all nmethods 157 static void metadata_do(MetadataClosure* f); // iterates over metadata in alive nmethods 158 159 // Lookup 160 static CodeBlob* find_blob(void* start); // Returns the CodeBlob containing the given address 161 static CodeBlob* find_blob_fast(void* start); // Returns the CodeBlob containing the given address 162 static CodeBlob* find_blob_and_oopmap(void* start, int& slot); // Returns the CodeBlob containing the given address 163 static int find_oopmap_slot_fast(void* start); // Returns a fast oopmap slot if there is any; -1 otherwise 164 static nmethod* find_nmethod(void* start); // Returns the nmethod containing the given address 165 166 static int blob_count(); // Returns the total number of CodeBlobs in the cache 167 static int blob_count(CodeBlobType code_blob_type); 168 static int adapter_count(); // Returns the total number of Adapters in the cache 169 static int adapter_count(CodeBlobType code_blob_type); 170 static int nmethod_count(); // Returns the total number of nmethods in the cache 171 static int nmethod_count(CodeBlobType code_blob_type); 172 173 // GC support 174 static void verify_oops(); 175 176 // Helper scope object managing code cache unlinking behavior, i.e. sets and 177 // restores the closure that determines which nmethods are going to be removed 178 // during the unlinking part of code cache unloading. 179 class UnlinkingScope : StackObj { 180 ClosureIsUnloadingBehaviour _is_unloading_behaviour; 181 IsUnloadingBehaviour* _saved_behaviour; 182 183 public: 184 UnlinkingScope(BoolObjectClosure* is_alive); 185 ~UnlinkingScope(); 186 }; 187 188 // Code cache unloading heuristics 189 static uint64_t cold_gc_count(); 190 static void update_cold_gc_count(); 191 static void gc_on_allocation(); 192 193 // The GC epoch and marking_cycle code below is there to support sweeping 194 // nmethods in loom stack chunks. 195 static uint64_t gc_epoch(); 196 static bool is_gc_marking_cycle_active(); 197 static uint64_t previous_completed_gc_marking_cycle(); 198 static void on_gc_marking_cycle_start(); 199 static void on_gc_marking_cycle_finish(); 200 // Arm nmethods so that special actions are taken (nmethod_entry_barrier) for 201 // on-stack nmethods. It's used in two places: 202 // 1. Used before the start of concurrent marking so that oops inside 203 // on-stack nmethods are visited. 204 // 2. Used at the end of (stw/concurrent) marking so that nmethod::_gc_epoch 205 // is up-to-date, which provides more accurate estimate of 206 // nmethod::is_cold. 207 static void arm_all_nmethods(); 208 209 static void maybe_restart_compiler(size_t freed_memory); 210 static void do_unloading(bool unloading_occurred); 211 static uint8_t unloading_cycle() { return _unloading_cycle; } 212 213 static void increment_unloading_cycle(); 214 215 static void release_exception_cache(ExceptionCache* entry); 216 static void purge_exception_caches(); 217 218 // Printing/debugging 219 static void print(); // prints summary 220 static void print_internals(); 221 static void print_memory_overhead(); 222 static void verify(); // verifies the code cache 223 static void print_trace(const char* event, CodeBlob* cb, uint size = 0) PRODUCT_RETURN; 224 static void print_summary(outputStream* st, bool detailed = true); // Prints a summary of the code cache usage 225 static void log_state(outputStream* st); 226 LINUX_ONLY(static void write_perf_map(const char* filename = nullptr);) 227 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"); } 228 static void report_codemem_full(CodeBlobType code_blob_type, bool print); 229 230 // Dcmd (Diagnostic commands) 231 static void print_codelist(outputStream* st); 232 static void print_layout(outputStream* st); 233 234 // The full limits of the codeCache 235 static address low_bound() { return _low_bound; } 236 static address low_bound(CodeBlobType code_blob_type); 237 static address high_bound() { return _high_bound; } 238 static address high_bound(CodeBlobType code_blob_type); 239 240 // Profiling 241 static size_t capacity(); 242 static size_t unallocated_capacity(CodeBlobType code_blob_type); 243 static size_t unallocated_capacity(); 244 static size_t max_capacity(); 245 246 static double reverse_free_ratio(); 247 248 static size_t max_distance_to_non_nmethod(); 249 static bool is_non_nmethod(address addr); 250 251 static void clear_inline_caches(); // clear all inline caches 252 static void cleanup_inline_caches_whitebox(); // clean bad nmethods from inline caches 253 254 // Returns true if an own CodeHeap for the given CodeBlobType is available 255 static bool heap_available(CodeBlobType code_blob_type); 256 257 // Returns the CodeBlobType for the given nmethod 258 static CodeBlobType get_code_blob_type(nmethod* nm) { 259 return get_code_heap(nm)->code_blob_type(); 260 } 261 262 static bool code_blob_type_accepts_nmethod(CodeBlobType type) { 263 return type == CodeBlobType::All || type <= CodeBlobType::MethodProfiled; 264 } 265 266 static bool code_blob_type_accepts_allocable(CodeBlobType type) { 267 return type <= CodeBlobType::All; 268 } 269 270 271 // Returns the CodeBlobType for the given compilation level 272 static CodeBlobType get_code_blob_type(int comp_level) { 273 if (comp_level == CompLevel_none || 274 comp_level == CompLevel_simple || 275 comp_level == CompLevel_full_optimization) { 276 // Non profiled methods 277 return CodeBlobType::MethodNonProfiled; 278 } else if (comp_level == CompLevel_limited_profile || 279 comp_level == CompLevel_full_profile) { 280 // Profiled methods 281 return CodeBlobType::MethodProfiled; 282 } 283 ShouldNotReachHere(); 284 return static_cast<CodeBlobType>(0); 285 } 286 287 static void verify_clean_inline_caches(); 288 289 // Deoptimization 290 private: 291 static void mark_for_deoptimization(DeoptimizationScope* deopt_scope, KlassDepChange& changes); 292 293 public: 294 static void mark_all_nmethods_for_deoptimization(DeoptimizationScope* deopt_scope); 295 static void mark_for_deoptimization(DeoptimizationScope* deopt_scope, Method* dependee); 296 static void make_marked_nmethods_deoptimized(); 297 298 // Marks dependents during classloading 299 static void mark_dependents_on(DeoptimizationScope* deopt_scope, InstanceKlass* dependee); 300 301 // RedefineClasses support 302 // Marks in case of evolution 303 static void mark_dependents_for_evol_deoptimization(DeoptimizationScope* deopt_scope); 304 static void mark_all_nmethods_for_evol_deoptimization(DeoptimizationScope* deopt_scope); 305 static void old_nmethods_do(MetadataClosure* f) NOT_JVMTI_RETURN; 306 static void unregister_old_nmethod(nmethod* c) NOT_JVMTI_RETURN; 307 308 // Support for fullspeed debugging 309 static void mark_dependents_on_method_for_breakpoint(const methodHandle& dependee); 310 311 // tells if there are nmethods with dependencies 312 static bool has_nmethods_with_dependencies(); 313 314 static int get_codemem_full_count(CodeBlobType code_blob_type) { 315 CodeHeap* heap = get_code_heap(code_blob_type); 316 return (heap != nullptr) ? heap->full_count() : 0; 317 } 318 319 // CodeHeap State Analytics. 320 // interface methods for CodeHeap printing, called by CompileBroker 321 static void aggregate(outputStream *out, size_t granularity); 322 static void discard(outputStream *out); 323 static void print_usedSpace(outputStream *out); 324 static void print_freeSpace(outputStream *out); 325 static void print_count(outputStream *out); 326 static void print_space(outputStream *out); 327 static void print_age(outputStream *out); 328 static void print_names(outputStream *out); 329 }; 330 331 332 // Iterator to iterate over code blobs in the CodeCache. 333 // The relaxed iterators only hold the CodeCache_lock across next calls 334 template <class T, class Filter, bool is_relaxed> class CodeBlobIterator : public StackObj { 335 public: 336 enum LivenessFilter { all, not_unloading }; 337 338 private: 339 CodeBlob* _code_blob; // Current CodeBlob 340 GrowableArrayIterator<CodeHeap*> _heap; 341 GrowableArrayIterator<CodeHeap*> _end; 342 bool _not_unloading; // Those nmethods that are not unloading 343 344 void initialize_iteration(T* nm) { 345 } 346 347 bool next_impl() { 348 for (;;) { 349 // Walk through heaps as required 350 if (!next_blob()) { 351 if (_heap == _end) { 352 return false; 353 } 354 ++_heap; 355 continue; 356 } 357 358 // Filter is_unloading as required 359 if (_not_unloading) { 360 nmethod* nm = _code_blob->as_nmethod_or_null(); 361 if (nm != nullptr && nm->is_unloading()) { 362 continue; 363 } 364 } 365 366 return true; 367 } 368 } 369 370 public: 371 CodeBlobIterator(LivenessFilter filter, T* nm = nullptr) 372 : _not_unloading(filter == not_unloading) 373 { 374 if (Filter::heaps() == nullptr) { 375 // The iterator is supposed to shortcut since we have 376 // _heap == _end, but make sure we do not have garbage 377 // in other fields as well. 378 _code_blob = nullptr; 379 return; 380 } 381 _heap = Filter::heaps()->begin(); 382 _end = Filter::heaps()->end(); 383 // If set to nullptr, initialized by first call to next() 384 _code_blob = nm; 385 if (nm != nullptr) { 386 while(!(*_heap)->contains(_code_blob)) { 387 ++_heap; 388 } 389 assert((*_heap)->contains(_code_blob), "match not found"); 390 } 391 } 392 393 // Advance iterator to next blob 394 bool next() { 395 if (is_relaxed) { 396 MutexLocker ml(CodeCache_lock, Mutex::_no_safepoint_check_flag); 397 return next_impl(); 398 } else { 399 assert_locked_or_safepoint(CodeCache_lock); 400 return next_impl(); 401 } 402 } 403 404 bool end() const { return _code_blob == nullptr; } 405 T* method() const { return (T*)_code_blob; } 406 407 private: 408 409 // Advance iterator to the next blob in the current code heap 410 bool next_blob() { 411 if (_heap == _end) { 412 return false; 413 } 414 CodeHeap *heap = *_heap; 415 // Get first method CodeBlob 416 if (_code_blob == nullptr) { 417 _code_blob = CodeCache::first_blob(heap); 418 if (_code_blob == nullptr) { 419 return false; 420 } else if (Filter::apply(_code_blob)) { 421 return true; 422 } 423 } 424 // Search for next method CodeBlob 425 _code_blob = CodeCache::next_blob(heap, _code_blob); 426 while (_code_blob != nullptr && !Filter::apply(_code_blob)) { 427 _code_blob = CodeCache::next_blob(heap, _code_blob); 428 } 429 return _code_blob != nullptr; 430 } 431 }; 432 433 struct NMethodFilter { 434 static bool apply(CodeBlob* cb) { return cb->is_nmethod(); } 435 static const GrowableArray<CodeHeap*>* heaps() { return CodeCache::nmethod_heaps(); } 436 }; 437 438 struct AllCodeBlobsFilter { 439 static bool apply(CodeBlob* cb) { return true; } 440 static const GrowableArray<CodeHeap*>* heaps() { return CodeCache::heaps(); } 441 }; 442 443 typedef CodeBlobIterator<nmethod, NMethodFilter, false /* is_relaxed */> NMethodIterator; 444 typedef CodeBlobIterator<nmethod, NMethodFilter, true /* is_relaxed */> RelaxedNMethodIterator; 445 typedef CodeBlobIterator<CodeBlob, AllCodeBlobsFilter, false /* is_relaxed */> AllCodeBlobsIterator; 446 447 #endif // SHARE_CODE_CODECACHE_HPP