< prev index next >

src/hotspot/share/code/codeCache.hpp

Print this page

 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

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);

 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 class NativePostCallNop;
 80 
 81 class CodeCache : AllStatic {
 82   friend class VMStructs;
 83   friend class JVMCIVMStructs;
 84   template <class T, class Filter> friend class CodeBlobIterator;
 85   friend class WhiteBox;
 86   friend class CodeCacheLoader;
 87   friend class ShenandoahParallelCodeHeapIterator;
 88  private:
 89   // CodeHeaps of the cache
 90   static GrowableArray<CodeHeap*>* _heaps;
 91   static GrowableArray<CodeHeap*>* _compiled_heaps;
 92   static GrowableArray<CodeHeap*>* _nmethod_heaps;
 93   static GrowableArray<CodeHeap*>* _allocable_heaps;
 94 
 95   static address _low_bound;                            // Lower bound of CodeHeap addresses
 96   static address _high_bound;                           // Upper bound of CodeHeap addresses
 97   static int _number_of_nmethods_with_dependencies;     // Total number of nmethods with dependencies
 98   static uint8_t _unloading_cycle;                      // Global state for recognizing old nmethods that need to be unloaded
 99   static uint64_t _marking_cycle;
100 
101   static ExceptionCache* volatile _exception_cache_purge_list;
102 
103   // CodeHeap management
104   static void initialize_heaps();                             // Initializes the CodeHeaps
105   // Check the code heap sizes set by the user via command line
106   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);
107   // Creates a new heap with the given name and size, containing CodeBlobs of the given type
108   static void add_heap(ReservedSpace rs, const char* name, int code_blob_type);
109   static CodeHeap* get_code_heap_containing(void* p);         // Returns the CodeHeap containing the given pointer, or NULL
110   static CodeHeap* get_code_heap(const CodeBlob* cb);         // Returns the CodeHeap for the given CodeBlob
111   static CodeHeap* get_code_heap(int code_blob_type);         // Returns the CodeHeap for the given CodeBlobType
112   // Returns the name of the VM option to set the size of the corresponding CodeHeap
113   static const char* get_code_heap_flag_name(int code_blob_type);
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   // Make private to prevent unsafe calls.  Not all CodeBlob*'s are embedded in a CodeHeap.
126   static bool contains(CodeBlob *p) { fatal("don't call me!"); return false; }
127   static CodeBlob* patch_nop(NativePostCallNop* nop, void* pc, int& slot);
128 
129  public:
130   // Initialization
131   static void initialize();
132   static size_t page_size(bool aligned = true, size_t min_pages = 1); // Returns the page size used by the CodeCache
133 
134   static int code_heap_compare(CodeHeap* const &lhs, CodeHeap* const &rhs);
135 
136   static void add_heap(CodeHeap* heap);
137   static const GrowableArray<CodeHeap*>* heaps() { return _heaps; }
138   static const GrowableArray<CodeHeap*>* compiled_heaps() { return _compiled_heaps; }
139   static const GrowableArray<CodeHeap*>* nmethod_heaps() { return _nmethod_heaps; }
140 
141   // Allocation/administration
142   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
143   static void commit(CodeBlob* cb);                        // called when the allocated CodeBlob has been filled
144   static int  alignment_unit();                            // guaranteed alignment of all CodeBlobs
145   static int  alignment_offset();                          // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header)
146   static void free(CodeBlob* cb);                          // frees a CodeBlob
147   static void free_unused_tail(CodeBlob* cb, size_t used); // frees the unused tail of a CodeBlob (only used by TemplateInterpreter::initialize())
148   static bool contains(void *p);                           // returns whether p is included
149   static bool contains(nmethod* nm);                       // returns whether nm is included
150   static void blobs_do(void f(CodeBlob* cb));              // iterates over all CodeBlobs
151   static void blobs_do(CodeBlobClosure* f);                // iterates over all CodeBlobs
152   static void nmethods_do(void f(nmethod* nm));            // iterates over all nmethods
153   static void metadata_do(MetadataClosure* f);             // iterates over metadata in alive nmethods
154 
155   // Lookup
156   static CodeBlob* find_blob(void* start);              // Returns the CodeBlob containing the given address
157   static CodeBlob* find_blob_unsafe(void* start);       // Same as find_blob but does not fail if looking up a zombie method
158   static CodeBlob* find_blob_fast(void* start);         // Returns the CodeBlob containing the given address
159   static CodeBlob* find_blob_and_oopmap(void* start, int& slot);         // Returns the CodeBlob containing the given address
160   static int find_oopmap_slot_fast(void* start);        // Returns a fast oopmap slot if there is any; -1 otherwise
161   static nmethod*  find_nmethod(void* start);           // Returns the nmethod containing the given address
162   static CompiledMethod* find_compiled(void* start);
163 
164   static int       blob_count();                        // Returns the total number of CodeBlobs in the cache
165   static int       blob_count(int code_blob_type);
166   static int       adapter_count();                     // Returns the total number of Adapters in the cache
167   static int       adapter_count(int code_blob_type);
168   static int       nmethod_count();                     // Returns the total number of nmethods in the cache
169   static int       nmethod_count(int code_blob_type);
170 
171   // GC support
172   static void verify_oops();
173   // If any oops are not marked this method unloads (i.e., breaks root links
174   // to) any unmarked codeBlobs in the cache.  Sets "marked_for_unloading"
175   // to "true" iff some code got unloaded.
176   // "unloading_occurred" controls whether metadata should be cleaned because of class unloading.
177   class UnloadingScope: StackObj {
178     ClosureIsUnloadingBehaviour _is_unloading_behaviour;
179     IsUnloadingBehaviour*       _saved_behaviour;
180 
181   public:
182     UnloadingScope(BoolObjectClosure* is_alive);
183     ~UnloadingScope();
184   };
185 
186   static void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred);
187   static uint8_t unloading_cycle() { return _unloading_cycle; }
188   static void increment_unloading_cycle();
189   static void increment_marking_cycle();
190   static uint64_t marking_cycle() { return _marking_cycle; }
191   static void release_exception_cache(ExceptionCache* entry);
192   static void purge_exception_caches();
193 
194   // Printing/debugging
195   static void print();                           // prints summary
196   static void print_internals();
197   static void print_memory_overhead();
198   static void verify();                          // verifies the code cache
199   static void print_trace(const char* event, CodeBlob* cb, int size = 0) PRODUCT_RETURN;
200   static void print_summary(outputStream* st, bool detailed = true); // Prints a summary of the code cache usage
201   static void log_state(outputStream* st);
202   LINUX_ONLY(static void write_perf_map();)
203   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"); }
204   static void report_codemem_full(int code_blob_type, bool print);
205 
206   // Dcmd (Diagnostic commands)
207   static void print_codelist(outputStream* st);
208   static void print_layout(outputStream* st);
209 
210   // The full limits of the codeCache

255       return CodeBlobType::MethodNonProfiled;
256     } else if (comp_level == CompLevel_limited_profile ||
257                comp_level == CompLevel_full_profile) {
258       // Profiled methods
259       return CodeBlobType::MethodProfiled;
260     }
261     ShouldNotReachHere();
262     return 0;
263   }
264 
265   static void verify_clean_inline_caches();
266   static void verify_icholder_relocations();
267 
268   // Deoptimization
269  private:
270   static int  mark_for_deoptimization(KlassDepChange& changes);
271 
272  public:
273   static void mark_all_nmethods_for_deoptimization();
274   static int  mark_for_deoptimization(Method* dependee);
275   static void make_marked_nmethods_not_entrant(GrowableArray<CompiledMethod*>* marked);
276   static void make_marked_nmethods_deoptimized(GrowableArray<CompiledMethod*>* marked);
277 
278   // Flushing and deoptimization
279   static void flush_dependents_on(InstanceKlass* dependee);
280 
281   // RedefineClasses support
282   // Flushing and deoptimization in case of evolution
283   static int  mark_dependents_for_evol_deoptimization();
284   static void mark_all_nmethods_for_evol_deoptimization();
285   static void flush_evol_dependents();
286   static void old_nmethods_do(MetadataClosure* f) NOT_JVMTI_RETURN;
287   static void unregister_old_nmethod(CompiledMethod* c) NOT_JVMTI_RETURN;
288 
289   // Support for fullspeed debugging
290   static void flush_dependents_on_method(const methodHandle& dependee);
291 
292   // tells how many nmethods have dependencies
293   static int number_of_nmethods_with_dependencies();
294 
295   static int get_codemem_full_count(int code_blob_type) {
296     CodeHeap* heap = get_code_heap(code_blob_type);
< prev index next >