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