1 /* 2 * Copyright (c) 1997, 2018, 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_VM_CODE_CODECACHE_HPP 26 #define SHARE_VM_CODE_CODECACHE_HPP 27 28 #include "code/codeBlob.hpp" 29 #include "code/nmethod.hpp" 30 #include "memory/allocation.hpp" 31 #include "memory/heap.hpp" 32 #include "oops/instanceKlass.hpp" 33 #include "oops/oopsHierarchy.hpp" 34 #include "runtime/mutexLocker.hpp" 35 36 // The CodeCache implements the code cache for various pieces of generated 37 // code, e.g., compiled java methods, runtime stubs, transition frames, etc. 38 // The entries in the CodeCache are all CodeBlob's. 39 40 // -- Implementation -- 41 // The CodeCache consists of one or more CodeHeaps, each of which contains 42 // CodeBlobs of a specific CodeBlobType. Currently heaps for the following 43 // types are available: 44 // - Non-nmethods: Non-nmethods like Buffers, Adapters and Runtime Stubs 45 // - Profiled nmethods: nmethods that are profiled, i.e., those 46 // executed at level 2 or 3 47 // - Non-Profiled nmethods: nmethods that are not profiled, i.e., those 48 // executed at level 1 or 4 and native methods 49 // - All: Used for code of all types if code cache segmentation is disabled. 50 // 51 // In the rare case of the non-nmethod code heap getting full, non-nmethod code 52 // will be stored in the non-profiled code heap as a fallback solution. 53 // 54 // Depending on the availability of compilers and TieredCompilation there 55 // may be fewer heaps. The size of the code heaps depends on the values of 56 // ReservedCodeCacheSize, NonProfiledCodeHeapSize and ProfiledCodeHeapSize 57 // (see CodeCache::heap_available(..) and CodeCache::initialize_heaps(..) 58 // for details). 59 // 60 // Code cache segmentation is controlled by the flag SegmentedCodeCache. 61 // If turned off, all code types are stored in a single code heap. By default 62 // code cache segmentation is turned on if TieredCompilation is enabled and 63 // ReservedCodeCacheSize >= 240 MB. 64 // 65 // All methods of the CodeCache accepting a CodeBlobType only apply to 66 // CodeBlobs of the given type. For example, iteration over the 67 // CodeBlobs of a specific type can be done by using CodeCache::first_blob(..) 68 // and CodeCache::next_blob(..) and providing the corresponding CodeBlobType. 69 // 70 // IMPORTANT: If you add new CodeHeaps to the code cache or change the 71 // existing ones, make sure to adapt the dtrace scripts (jhelper.d) for 72 // Solaris and BSD. 73 74 class ExceptionCache; 75 class KlassDepChange; 76 class OopClosure; 77 78 class CodeCache : AllStatic { 79 friend class VMStructs; 80 friend class JVMCIVMStructs; 81 template <class T, class Filter> friend class CodeBlobIterator; 82 friend class WhiteBox; 83 friend class CodeCacheLoader; 84 private: 85 // CodeHeaps of the cache 86 static GrowableArray<CodeHeap*>* _heaps; 87 static GrowableArray<CodeHeap*>* _compiled_heaps; 88 static GrowableArray<CodeHeap*>* _nmethod_heaps; 89 static GrowableArray<CodeHeap*>* _allocable_heaps; 90 91 static address _low_bound; // Lower bound of CodeHeap addresses 92 static address _high_bound; // Upper bound of CodeHeap addresses 93 static int _number_of_nmethods_with_dependencies; // Total number of nmethods with dependencies 94 static bool _needs_cache_clean; // True if inline caches of the nmethods needs to be flushed 95 static nmethod* _scavenge_root_nmethods; // linked via nm->scavenge_root_link() 96 97 static ExceptionCache* volatile _exception_cache_purge_list; 98 99 static void mark_scavenge_root_nmethods() PRODUCT_RETURN; 100 static void verify_perm_nmethods(CodeBlobClosure* f_or_null) PRODUCT_RETURN; 101 102 // CodeHeap management 103 static void initialize_heaps(); // Initializes the CodeHeaps 104 // Check the code heap sizes set by the user via command line 105 static void check_heap_sizes(size_t non_nmethod_size, size_t profiled_size, size_t non_profiled_size, size_t cache_size, bool all_set); 106 // Creates a new heap with the given name and size, containing CodeBlobs of the given type 107 static void add_heap(ReservedSpace rs, const char* name, int code_blob_type); 108 static CodeHeap* get_code_heap_containing(void* p); // Returns the CodeHeap containing the given pointer, or NULL 109 static CodeHeap* get_code_heap(const CodeBlob* cb); // Returns the CodeHeap for the given CodeBlob 110 static CodeHeap* get_code_heap(int code_blob_type); // Returns the CodeHeap for the given CodeBlobType 111 // Returns the name of the VM option to set the size of the corresponding CodeHeap 112 static const char* get_code_heap_flag_name(int code_blob_type); 113 static size_t page_size(bool aligned = true); // Returns the page size used by the CodeCache 114 static ReservedCodeSpace reserve_heap_memory(size_t size); // Reserves one continuous chunk of memory for the CodeHeaps 115 116 // Iteration 117 static CodeBlob* first_blob(CodeHeap* heap); // Returns the first CodeBlob on the given CodeHeap 118 static CodeBlob* first_blob(int code_blob_type); // Returns the first CodeBlob of the given type 119 static CodeBlob* next_blob(CodeHeap* heap, CodeBlob* cb); // Returns the next CodeBlob on the given CodeHeap 120 121 static size_t bytes_allocated_in_freelists(); 122 static int allocated_segments(); 123 static size_t freelists_length(); 124 125 static void set_scavenge_root_nmethods(nmethod* nm) { _scavenge_root_nmethods = nm; } 126 static void prune_scavenge_root_nmethods(); 127 static void unlink_scavenge_root_nmethod(nmethod* nm, nmethod* prev); 128 129 // Make private to prevent unsafe calls. Not all CodeBlob*'s are embedded in a CodeHeap. 130 static bool contains(CodeBlob *p) { fatal("don't call me!"); return false; } 131 132 public: 133 // Initialization 134 static void initialize(); 135 136 static int code_heap_compare(CodeHeap* const &lhs, CodeHeap* const &rhs); 137 138 static void add_heap(CodeHeap* heap); 139 static const GrowableArray<CodeHeap*>* heaps() { return _heaps; } 140 static const GrowableArray<CodeHeap*>* compiled_heaps() { return _compiled_heaps; } 141 static const GrowableArray<CodeHeap*>* nmethod_heaps() { return _nmethod_heaps; } 142 143 // Allocation/administration 144 static CodeBlob* allocate(int size, int code_blob_type, int orig_code_blob_type = CodeBlobType::All); // allocates a new CodeBlob 145 static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled 146 static int alignment_unit(); // guaranteed alignment of all CodeBlobs 147 static int alignment_offset(); // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header) 148 static void free(CodeBlob* cb); // frees a CodeBlob 149 static void free_unused_tail(CodeBlob* cb, size_t used); // frees the unused tail of a CodeBlob (only used by TemplateInterpreter::initialize()) 150 static bool contains(void *p); // returns whether p is included 151 static bool contains(nmethod* nm); // returns whether nm is included 152 static void blobs_do(void f(CodeBlob* cb)); // iterates over all CodeBlobs 153 static void blobs_do(CodeBlobClosure* f); // iterates over all CodeBlobs 154 static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods 155 static void metadata_do(void f(Metadata* m)); // iterates over metadata in alive nmethods 156 157 // Lookup 158 static CodeBlob* find_blob(void* start); // Returns the CodeBlob containing the given address 159 static CodeBlob* find_blob_unsafe(void* start); // Same as find_blob but does not fail if looking up a zombie method 160 static nmethod* find_nmethod(void* start); // Returns the nmethod containing the given address 161 static CompiledMethod* find_compiled(void* start); 162 163 static int blob_count(); // Returns the total number of CodeBlobs in the cache 164 static int blob_count(int code_blob_type); 165 static int adapter_count(); // Returns the total number of Adapters in the cache 166 static int adapter_count(int code_blob_type); 167 static int nmethod_count(); // Returns the total number of nmethods in the cache 168 static int nmethod_count(int code_blob_type); 169 170 // GC support 171 static void gc_epilogue(); 172 static void gc_prologue(); 173 static void verify_oops(); 174 // If any oops are not marked this method unloads (i.e., breaks root links 175 // to) any unmarked codeBlobs in the cache. Sets "marked_for_unloading" 176 // to "true" iff some code got unloaded. 177 // "unloading_occurred" controls whether metadata should be cleaned because of class unloading. 178 static void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred); 179 static void asserted_non_scavengable_nmethods_do(CodeBlobClosure* f = NULL) PRODUCT_RETURN; 180 static void release_exception_cache(ExceptionCache* entry); 181 static void purge_exception_caches(); 182 183 // Apply f to every live code blob in scavengable nmethods. Prune nmethods 184 // from the list of scavengable nmethods if f->fix_relocations() and a nmethod 185 // no longer has scavengable oops. If f->fix_relocations(), then f must copy 186 // objects to their new location immediately to avoid fixing nmethods on the 187 // basis of the old object locations. 188 static void scavenge_root_nmethods_do(CodeBlobToOopClosure* f); 189 190 static nmethod* scavenge_root_nmethods() { return _scavenge_root_nmethods; } 191 // register_scavenge_root_nmethod() conditionally adds the nmethod to the list 192 // if it is not already on the list and has a scavengeable root 193 static void register_scavenge_root_nmethod(nmethod* nm); 194 static void verify_scavenge_root_nmethod(nmethod* nm); 195 static void add_scavenge_root_nmethod(nmethod* nm); 196 static void drop_scavenge_root_nmethod(nmethod* nm); 197 198 // Printing/debugging 199 static void print(); // prints summary 200 static void print_internals(); 201 static void print_memory_overhead(); 202 static void verify(); // verifies the code cache 203 static void print_trace(const char* event, CodeBlob* cb, int size = 0) PRODUCT_RETURN; 204 static void print_summary(outputStream* st, bool detailed = true); // Prints a summary of the code cache usage 205 static void log_state(outputStream* st); 206 static const char* get_code_heap_name(int code_blob_type) { return (heap_available(code_blob_type) ? get_code_heap(code_blob_type)->name() : "Unused"); } 207 static void report_codemem_full(int code_blob_type, bool print); 208 209 // Dcmd (Diagnostic commands) 210 static void print_codelist(outputStream* st); 211 static void print_layout(outputStream* st); 212 213 // The full limits of the codeCache 214 static address low_bound() { return _low_bound; } 215 static address low_bound(int code_blob_type); 216 static address high_bound() { return _high_bound; } 217 static address high_bound(int code_blob_type); 218 219 // Have to use far call instructions to call this pc. 220 static bool is_far_target(address pc); 221 222 // Profiling 223 static size_t capacity(); 224 static size_t unallocated_capacity(int code_blob_type); 225 static size_t unallocated_capacity(); 226 static size_t max_capacity(); 227 228 static double reverse_free_ratio(int code_blob_type); 229 230 static bool needs_cache_clean() { return _needs_cache_clean; } 231 static void set_needs_cache_clean(bool v) { _needs_cache_clean = v; } 232 233 static void clear_inline_caches(); // clear all inline caches 234 static void cleanup_inline_caches(); // clean unloaded/zombie nmethods from inline caches 235 static void do_unloading_nmethod_caches(bool class_unloading_occurred); // clean all nmethod caches for unloading, including inline caches 236 237 // Returns true if an own CodeHeap for the given CodeBlobType is available 238 static bool heap_available(int code_blob_type); 239 240 // Returns the CodeBlobType for the given CompiledMethod 241 static int get_code_blob_type(CompiledMethod* cm) { 242 return get_code_heap(cm)->code_blob_type(); 243 } 244 245 static bool code_blob_type_accepts_compiled(int type) { 246 bool result = type == CodeBlobType::All || type <= CodeBlobType::MethodProfiled; 247 AOT_ONLY( result = result || type == CodeBlobType::AOT; ) 248 return result; 249 } 250 251 static bool code_blob_type_accepts_nmethod(int type) { 252 return type == CodeBlobType::All || type <= CodeBlobType::MethodProfiled; 253 } 254 255 static bool code_blob_type_accepts_allocable(int type) { 256 return type <= CodeBlobType::All; 257 } 258 259 260 // Returns the CodeBlobType for the given compilation level 261 static int get_code_blob_type(int comp_level) { 262 if (comp_level == CompLevel_none || 263 comp_level == CompLevel_simple || 264 comp_level == CompLevel_full_optimization) { 265 // Non profiled methods 266 return CodeBlobType::MethodNonProfiled; 267 } else if (comp_level == CompLevel_limited_profile || 268 comp_level == CompLevel_full_profile) { 269 // Profiled methods 270 return CodeBlobType::MethodProfiled; 271 } 272 ShouldNotReachHere(); 273 return 0; 274 } 275 276 static void verify_clean_inline_caches(); 277 static void verify_icholder_relocations(); 278 279 // Deoptimization 280 private: 281 static int mark_for_deoptimization(KlassDepChange& changes); 282 #ifdef HOTSWAP 283 static int mark_for_evol_deoptimization(InstanceKlass* dependee); 284 #endif // HOTSWAP 285 286 public: 287 static void mark_all_nmethods_for_deoptimization(); 288 static int mark_for_deoptimization(Method* dependee); 289 static void make_marked_nmethods_not_entrant(); 290 291 // Flushing and deoptimization 292 static void flush_dependents_on(InstanceKlass* dependee); 293 #ifdef HOTSWAP 294 // Flushing and deoptimization in case of evolution 295 static void flush_evol_dependents_on(InstanceKlass* dependee); 296 #endif // HOTSWAP 297 // Support for fullspeed debugging 298 static void flush_dependents_on_method(const methodHandle& dependee); 299 300 // tells how many nmethods have dependencies 301 static int number_of_nmethods_with_dependencies(); 302 303 static int get_codemem_full_count(int code_blob_type) { 304 CodeHeap* heap = get_code_heap(code_blob_type); 305 return (heap != NULL) ? heap->full_count() : 0; 306 } 307 308 // CodeHeap State Analytics. 309 // interface methods for CodeHeap printing, called by CompileBroker 310 static void aggregate(outputStream *out, const char* granularity); 311 static void discard(outputStream *out); 312 static void print_usedSpace(outputStream *out); 313 static void print_freeSpace(outputStream *out); 314 static void print_count(outputStream *out); 315 static void print_space(outputStream *out); 316 static void print_age(outputStream *out); 317 static void print_names(outputStream *out); 318 }; 319 320 321 // Iterator to iterate over nmethods in the CodeCache. 322 template <class T, class Filter> class CodeBlobIterator : public StackObj { 323 private: 324 CodeBlob* _code_blob; // Current CodeBlob 325 GrowableArrayIterator<CodeHeap*> _heap; 326 GrowableArrayIterator<CodeHeap*> _end; 327 328 public: 329 CodeBlobIterator(T* nm = NULL) { 330 if (Filter::heaps() == NULL) { 331 return; 332 } 333 _heap = Filter::heaps()->begin(); 334 _end = Filter::heaps()->end(); 335 // If set to NULL, initialized by first call to next() 336 _code_blob = (CodeBlob*)nm; 337 if (nm != NULL) { 338 while(!(*_heap)->contains_blob(_code_blob)) { 339 ++_heap; 340 } 341 assert((*_heap)->contains_blob(_code_blob), "match not found"); 342 } 343 } 344 345 // Advance iterator to next blob 346 bool next() { 347 assert_locked_or_safepoint(CodeCache_lock); 348 349 bool result = next_blob(); 350 while (!result && _heap != _end) { 351 // Advance to next code heap of segmented code cache 352 if (++_heap == _end) { 353 break; 354 } 355 result = next_blob(); 356 } 357 358 return result; 359 } 360 361 // Advance iterator to next alive blob 362 bool next_alive() { 363 bool result = next(); 364 while(result && !_code_blob->is_alive()) { 365 result = next(); 366 } 367 return result; 368 } 369 370 bool end() const { return _code_blob == NULL; } 371 T* method() const { return (T*)_code_blob; } 372 373 private: 374 375 // Advance iterator to the next blob in the current code heap 376 bool next_blob() { 377 if (_heap == _end) { 378 return false; 379 } 380 CodeHeap *heap = *_heap; 381 // Get first method CodeBlob 382 if (_code_blob == NULL) { 383 _code_blob = CodeCache::first_blob(heap); 384 if (_code_blob == NULL) { 385 return false; 386 } else if (Filter::apply(_code_blob)) { 387 return true; 388 } 389 } 390 // Search for next method CodeBlob 391 _code_blob = CodeCache::next_blob(heap, _code_blob); 392 while (_code_blob != NULL && !Filter::apply(_code_blob)) { 393 _code_blob = CodeCache::next_blob(heap, _code_blob); 394 } 395 return _code_blob != NULL; 396 } 397 }; 398 399 400 struct CompiledMethodFilter { 401 static bool apply(CodeBlob* cb) { return cb->is_compiled(); } 402 static const GrowableArray<CodeHeap*>* heaps() { return CodeCache::compiled_heaps(); } 403 }; 404 405 406 struct NMethodFilter { 407 static bool apply(CodeBlob* cb) { return cb->is_nmethod(); } 408 static const GrowableArray<CodeHeap*>* heaps() { return CodeCache::nmethod_heaps(); } 409 }; 410 411 412 typedef CodeBlobIterator<CompiledMethod, CompiledMethodFilter> CompiledMethodIterator; 413 typedef CodeBlobIterator<nmethod, NMethodFilter> NMethodIterator; 414 415 #endif // SHARE_VM_CODE_CODECACHE_HPP