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!"); 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();)
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();
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) ? 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)
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) {
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) {
329       while(!(*_heap)->contains_blob(_code_blob)) {
330         ++_heap;
331       }
332       assert((*_heap)->contains_blob(_code_blob), "match not found");
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 && cm->is_unloading()) {
359           continue;
360         }
361       }
362 
363       return true;
364     }
365   }
366 
367   bool end()  const { return _code_blob == 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) {
380       _code_blob = CodeCache::first_blob(heap);
381       if (_code_blob == 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 && !Filter::apply(_code_blob)) {
390       _code_blob = CodeCache::next_blob(heap, _code_blob);
391     }
392     return _code_blob != 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