< prev index next >

src/hotspot/share/code/codeCache.cpp

Print this page

   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 "code/codeBlob.hpp"
  26 #include "code/codeCache.hpp"
  27 #include "code/codeHeapState.hpp"
  28 #include "code/compiledIC.hpp"
  29 #include "code/dependencies.hpp"
  30 #include "code/dependencyContext.hpp"
  31 #include "code/nmethod.hpp"
  32 #include "code/pcDesc.hpp"

  33 #include "compiler/compilationPolicy.hpp"
  34 #include "compiler/compileBroker.hpp"
  35 #include "compiler/compilerDefinitions.inline.hpp"
  36 #include "compiler/oopMap.hpp"
  37 #include "gc/shared/barrierSetNMethod.hpp"
  38 #include "gc/shared/classUnloadingContext.hpp"
  39 #include "gc/shared/collectedHeap.hpp"
  40 #include "jfr/jfrEvents.hpp"
  41 #include "jvm_io.h"
  42 #include "logging/log.hpp"
  43 #include "logging/logStream.hpp"
  44 #include "memory/allocation.inline.hpp"
  45 #include "memory/iterator.hpp"
  46 #include "memory/memoryReserver.hpp"
  47 #include "memory/resourceArea.hpp"
  48 #include "memory/universe.hpp"
  49 #include "oops/method.inline.hpp"
  50 #include "oops/objArrayOop.hpp"
  51 #include "oops/oop.inline.hpp"
  52 #include "oops/verifyOopClosure.hpp"

 153       scopes_data_size += nm->scopes_data_size();
 154       scopes_pcs_size  += nm->scopes_pcs_size();
 155     } else {
 156       code_size        += cb->code_size();
 157     }
 158   }
 159 };
 160 
 161 // Iterate over all CodeHeaps
 162 #define FOR_ALL_HEAPS(heap) for (GrowableArrayIterator<CodeHeap*> heap = _heaps->begin(); heap != _heaps->end(); ++heap)
 163 #define FOR_ALL_ALLOCABLE_HEAPS(heap) for (GrowableArrayIterator<CodeHeap*> heap = _allocable_heaps->begin(); heap != _allocable_heaps->end(); ++heap)
 164 
 165 // Iterate over all CodeBlobs (cb) on the given CodeHeap
 166 #define FOR_ALL_BLOBS(cb, heap) for (CodeBlob* cb = first_blob(heap); cb != nullptr; cb = next_blob(heap, cb))
 167 
 168 address CodeCache::_low_bound = nullptr;
 169 address CodeCache::_high_bound = nullptr;
 170 volatile int CodeCache::_number_of_nmethods_with_dependencies = 0;
 171 ExceptionCache* volatile CodeCache::_exception_cache_purge_list = nullptr;
 172 


 173 // Initialize arrays of CodeHeap subsets
 174 GrowableArray<CodeHeap*>* CodeCache::_heaps = new(mtCode) GrowableArray<CodeHeap*> (static_cast<int>(CodeBlobType::All), mtCode);
 175 GrowableArray<CodeHeap*>* CodeCache::_nmethod_heaps = new(mtCode) GrowableArray<CodeHeap*> (static_cast<int>(CodeBlobType::All), mtCode);
 176 GrowableArray<CodeHeap*>* CodeCache::_allocable_heaps = new(mtCode) GrowableArray<CodeHeap*> (static_cast<int>(CodeBlobType::All), mtCode);
 177 
 178 static void check_min_size(const char* codeheap, size_t size, size_t required_size) {
 179   if (size < required_size) {
 180     log_debug(codecache)("Code heap (%s) size %zuK below required minimal size %zuK",
 181                          codeheap, size/K, required_size/K);
 182     err_msg title("Not enough space in %s to run VM", codeheap);
 183     err_msg message("%zuK < %zuK", size/K, required_size/K);
 184     vm_exit_during_initialization(title, message);
 185   }
 186 }
 187 
 188 struct CodeHeapInfo {
 189   size_t size;
 190   bool set;
 191   bool enabled;
 192 };
 193 
 194 static void set_size_of_unset_code_heap(CodeHeapInfo* heap, size_t available_size, size_t used_size, size_t min_size) {
 195   assert(!heap->set, "sanity");
 196   heap->size = (available_size > (used_size + min_size)) ? (available_size - used_size) : min_size;
 197 }
 198 
 199 void CodeCache::initialize_heaps() {
 200 
 201   CodeHeapInfo non_nmethod = {NonNMethodCodeHeapSize, FLAG_IS_CMDLINE(NonNMethodCodeHeapSize), true};
 202   CodeHeapInfo profiled = {ProfiledCodeHeapSize, FLAG_IS_CMDLINE(ProfiledCodeHeapSize), true};
 203   CodeHeapInfo non_profiled = {NonProfiledCodeHeapSize, FLAG_IS_CMDLINE(NonProfiledCodeHeapSize), true};
 204 
 205   const bool cache_size_set   = FLAG_IS_CMDLINE(ReservedCodeCacheSize);
 206   const size_t ps             = page_size(false, 8);
 207   const size_t min_size       = MAX2(os::vm_allocation_granularity(), ps);
 208   const size_t min_cache_size = CodeCacheMinimumUseSpace DEBUG_ONLY(* 3); // Make sure we have enough space for VM internal code
 209   size_t cache_size           = align_up(ReservedCodeCacheSize, min_size);
 210 
 211   // Prerequisites
 212   if (!heap_available(CodeBlobType::MethodProfiled)) {
 213     // For compatibility reasons, disabled tiered compilation overrides
 214     // segment size even if it is set explicitly.
 215     non_profiled.size += profiled.size;
 216     // Profiled code heap is not available, forcibly set size to 0
 217     profiled.size = 0;
 218     profiled.set = true;
 219     profiled.enabled = false;
 220   }
 221 
 222   assert(heap_available(CodeBlobType::MethodNonProfiled), "MethodNonProfiled heap is always available for segmented code heap");
 223 
 224   size_t compiler_buffer_size = 0;
 225   COMPILER1_PRESENT(compiler_buffer_size += CompilationPolicy::c1_count() * Compiler::code_buffer_size());
 226   COMPILER2_PRESENT(compiler_buffer_size += CompilationPolicy::c2_count() * C2Compiler::initial_code_buffer_size());

 227 
 228   if (!non_nmethod.set) {
 229     non_nmethod.size += compiler_buffer_size;
 230     // Further down, just before FLAG_SET_ERGO(), all segment sizes are
 231     // aligned down to the next lower multiple of min_size. For large page
 232     // sizes, this may result in (non_nmethod.size == 0) which is not acceptable.
 233     // Therefore, force non_nmethod.size to at least min_size.
 234     non_nmethod.size = MAX2(non_nmethod.size, min_size);
 235   }
 236 
 237   if (!profiled.set && !non_profiled.set) {
 238     non_profiled.size = profiled.size = (cache_size > non_nmethod.size + 2 * min_size) ?
 239                                         (cache_size - non_nmethod.size) / 2 : min_size;
 240   }
 241 
 242   if (profiled.set && !non_profiled.set) {
 243     set_size_of_unset_code_heap(&non_profiled, cache_size, non_nmethod.size + profiled.size, min_size);
 244   }
 245 
 246   if (!profiled.set && non_profiled.set) {

 301     if (ps < lg_ps) {
 302       log_warning(codecache)("Code cache size too small for " PROPERFMT " pages. "
 303                              "Reverting to smaller page size (" PROPERFMT ").",
 304                              PROPERFMTARGS(lg_ps), PROPERFMTARGS(ps));
 305     }
 306   }
 307 
 308   // Note: if large page support is enabled, min_size is at least the large
 309   // page size. This ensures that the code cache is covered by large pages.
 310   non_profiled.size += non_nmethod.size & alignment_mask(min_size);
 311   non_profiled.size += profiled.size & alignment_mask(min_size);
 312   non_nmethod.size = align_down(non_nmethod.size, min_size);
 313   profiled.size = align_down(profiled.size, min_size);
 314   non_profiled.size = align_down(non_profiled.size, min_size);
 315 
 316   FLAG_SET_ERGO(NonNMethodCodeHeapSize, non_nmethod.size);
 317   FLAG_SET_ERGO(ProfiledCodeHeapSize, profiled.size);
 318   FLAG_SET_ERGO(NonProfiledCodeHeapSize, non_profiled.size);
 319   FLAG_SET_ERGO(ReservedCodeCacheSize, cache_size);
 320 



 321   ReservedSpace rs = reserve_heap_memory(cache_size, ps);
 322 
 323   // Register CodeHeaps with LSan as we sometimes embed pointers to malloc memory.
 324   LSAN_REGISTER_ROOT_REGION(rs.base(), rs.size());
 325 
 326   size_t offset = 0;






 327   if (profiled.enabled) {
 328     ReservedSpace profiled_space = rs.partition(offset, profiled.size);
 329     offset += profiled.size;
 330     // Tier 2 and tier 3 (profiled) methods
 331     add_heap(profiled_space, "CodeHeap 'profiled nmethods'", CodeBlobType::MethodProfiled);
 332   }
 333 
 334   ReservedSpace non_method_space = rs.partition(offset, non_nmethod.size);
 335   offset += non_nmethod.size;
 336   // Non-nmethods (stubs, adapters, ...)
 337   add_heap(non_method_space, "CodeHeap 'non-nmethods'", CodeBlobType::NonNMethod);
 338 
 339   if (non_profiled.enabled) {
 340     ReservedSpace non_profiled_space  = rs.partition(offset, non_profiled.size);
 341     // Tier 1 and tier 4 (non-profiled) methods and native methods
 342     add_heap(non_profiled_space, "CodeHeap 'non-profiled nmethods'", CodeBlobType::MethodNonProfiled);
 343   }
 344 }
 345 








 346 size_t CodeCache::page_size(bool aligned, size_t min_pages) {
 347   return aligned ? os::page_size_for_region_aligned(ReservedCodeCacheSize, min_pages) :
 348                    os::page_size_for_region_unaligned(ReservedCodeCacheSize, min_pages);
 349 }
 350 
 351 ReservedSpace CodeCache::reserve_heap_memory(size_t size, size_t rs_ps) {
 352   // Align and reserve space for code cache
 353   const size_t rs_align = MAX2(rs_ps, os::vm_allocation_granularity());
 354   const size_t rs_size = align_up(size, rs_align);
 355 
 356   ReservedSpace rs = CodeMemoryReserver::reserve(rs_size, rs_align, rs_ps);
 357   if (!rs.is_reserved()) {
 358     vm_exit_during_initialization(err_msg("Could not reserve enough space for code cache (%zuK)",
 359                                           rs_size/K));
 360   }
 361 
 362   // Initialize bounds
 363   _low_bound = (address)rs.base();
 364   _high_bound = _low_bound + rs.size();
 365   return rs;

1188                             AnyObj::RESOURCE_AREA, mtInternal,
1189                             &DependencySignature::hash,
1190                             &DependencySignature::equals> DepTable;
1191 
1192   DepTable* table = new DepTable();
1193 
1194   // Iterate over live nmethods and check dependencies of all nmethods that are not
1195   // marked for deoptimization. A particular dependency is only checked once.
1196   NMethodIterator iter(NMethodIterator::not_unloading);
1197   while(iter.next()) {
1198     nmethod* nm = iter.method();
1199     // Only notify for live nmethods
1200     if (!nm->is_marked_for_deoptimization()) {
1201       for (Dependencies::DepStream deps(nm); deps.next(); ) {
1202         // Construct abstraction of a dependency.
1203         DependencySignature* current_sig = new DependencySignature(deps);
1204 
1205         // Determine if dependency is already checked. table->put(...) returns
1206         // 'true' if the dependency is added (i.e., was not in the hashtable).
1207         if (table->put(*current_sig, 1)) {
1208           if (deps.check_dependency() != nullptr) {

1209             // Dependency checking failed. Print out information about the failed
1210             // dependency and finally fail with an assert. We can fail here, since
1211             // dependency checking is never done in a product build.
1212             tty->print_cr("Failed dependency:");
1213             changes.print();
1214             nm->print();
1215             nm->print_dependencies_on(tty);
1216             assert(false, "Should have been marked for deoptimization");
1217           }
1218         }
1219       }
1220     }
1221   }
1222 }
1223 #endif
1224 
1225 void CodeCache::mark_for_deoptimization(DeoptimizationScope* deopt_scope, KlassDepChange& changes) {
1226   MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1227 
1228   // search the hierarchy looking for nmethods which are affected by the loading of this class
1229 
1230   // then search the interfaces this class implements looking for nmethods
1231   // which might be dependent of the fact that an interface only had one
1232   // implementor.
1233   // nmethod::check_all_dependencies works only correctly, if no safepoint
1234   // can happen
1235   NoSafepointVerifier nsv;
1236   for (DepChange::ContextStream str(changes, nsv); str.next(); ) {
1237     InstanceKlass* d = str.klass();







1238     d->mark_dependent_nmethods(deopt_scope, changes);
1239   }
1240 
1241 #ifndef PRODUCT
1242   if (VerifyDependencies) {
1243     // Object pointers are used as unique identifiers for dependency arguments. This
1244     // is only possible if no safepoint, i.e., GC occurs during the verification code.
1245     dependentCheckTime.start();
1246     check_live_nmethods_dependencies(changes);
1247     dependentCheckTime.stop();
1248   }
1249 #endif
1250 }
1251 
1252 #if INCLUDE_JVMTI
1253 // RedefineClasses support for saving nmethods that are dependent on "old" methods.
1254 // We don't really expect this table to grow very large.  If it does, it can become a hashtable.
1255 static GrowableArray<nmethod*>* old_nmethod_table = nullptr;
1256 
1257 static void add_to_old_table(nmethod* c) {

1476 }
1477 PRAGMA_DIAG_POP
1478 
1479 void CodeCache::print_memory_overhead() {
1480   size_t wasted_bytes = 0;
1481   FOR_ALL_ALLOCABLE_HEAPS(heap) {
1482       CodeHeap* curr_heap = *heap;
1483       for (CodeBlob* cb = (CodeBlob*)curr_heap->first(); cb != nullptr; cb = (CodeBlob*)curr_heap->next(cb)) {
1484         HeapBlock* heap_block = ((HeapBlock*)cb) - 1;
1485         wasted_bytes += heap_block->length() * CodeCacheSegmentSize - cb->size();
1486       }
1487   }
1488   // Print bytes that are allocated in the freelist
1489   ttyLocker ttl;
1490   tty->print_cr("Number of elements in freelist: %zd",       freelists_length());
1491   tty->print_cr("Allocated in freelist:          %zdkB",  bytes_allocated_in_freelists()/K);
1492   tty->print_cr("Unused bytes in CodeBlobs:      %zdkB",  (wasted_bytes/K));
1493   tty->print_cr("Segment map size:               %zdkB",  allocated_segments()/K); // 1 byte per segment
1494 }
1495 















































































1496 //------------------------------------------------------------------------------------------------
1497 // Non-product version
1498 
1499 #ifndef PRODUCT
1500 
1501 void CodeCache::print_trace(const char* event, CodeBlob* cb, uint size) {
1502   if (PrintCodeCache2) {  // Need to add a new flag
1503     ResourceMark rm;
1504     if (size == 0) {
1505       int s = cb->size();
1506       assert(s >= 0, "CodeBlob size is negative: %d", s);
1507       size = (uint) s;
1508     }
1509     tty->print_cr("CodeCache %s:  addr: " INTPTR_FORMAT ", size: 0x%x", event, p2i(cb), size);
1510   }
1511 }
1512 
1513 void CodeCache::print_internals() {
1514   int nmethodCount = 0;
1515   int runtimeStubCount = 0;
1516   int upcallStubCount = 0;
1517   int adapterCount = 0;
1518   int mhAdapterCount = 0;
1519   int vtableBlobCount = 0;
1520   int deoptimizationStubCount = 0;
1521   int uncommonTrapStubCount = 0;
1522   int exceptionStubCount = 0;
1523   int safepointStubCount = 0;
1524   int bufferBlobCount = 0;
1525   int total = 0;
1526   int nmethodNotEntrant = 0;
1527   int nmethodJava = 0;
1528   int nmethodNative = 0;
1529   int max_nm_size = 0;
1530   ResourceMark rm;
1531 
1532   int i = 0;
1533   FOR_ALL_ALLOCABLE_HEAPS(heap) {
1534     if ((_nmethod_heaps->length() >= 1) && Verbose) {
1535       tty->print_cr("-- %s --", (*heap)->name());
1536     }
1537     FOR_ALL_BLOBS(cb, *heap) {
1538       total++;

1539       if (cb->is_nmethod()) {
1540         nmethod* nm = (nmethod*)cb;
1541 
1542         if (Verbose && nm->method() != nullptr) {
1543           ResourceMark rm;
1544           char *method_name = nm->method()->name_and_sig_as_C_string();
1545           tty->print("%s", method_name);
1546           if(nm->is_not_entrant()) { tty->print_cr(" not-entrant"); }
1547         }
1548 
1549         nmethodCount++;
1550 
1551         if(nm->is_not_entrant()) { nmethodNotEntrant++; }
1552         if(nm->method() != nullptr && nm->is_native_method()) { nmethodNative++; }
1553 
1554         if(nm->method() != nullptr && nm->is_java_method()) {
1555           nmethodJava++;
1556           max_nm_size = MAX2(max_nm_size, nm->size());
1557         }
1558       } else if (cb->is_runtime_stub()) {
1559         runtimeStubCount++;
1560       } else if (cb->is_upcall_stub()) {
1561         upcallStubCount++;
1562       } else if (cb->is_deoptimization_stub()) {
1563         deoptimizationStubCount++;
1564       } else if (cb->is_uncommon_trap_stub()) {
1565         uncommonTrapStubCount++;
1566       } else if (cb->is_exception_stub()) {
1567         exceptionStubCount++;

1724       FOR_ALL_BLOBS(cb, *heap) {
1725         number_of_blobs++;
1726         code_size += cb->code_size();
1727         ImmutableOopMapSet* set = cb->oop_maps();
1728         if (set != nullptr) {
1729           number_of_oop_maps += set->count();
1730           map_size           += set->nr_of_bytes();
1731         }
1732       }
1733     }
1734     tty->print_cr("OopMaps");
1735     tty->print_cr("  #blobs    = %d", number_of_blobs);
1736     tty->print_cr("  code size = %d", code_size);
1737     tty->print_cr("  #oop_maps = %d", number_of_oop_maps);
1738     tty->print_cr("  map size  = %d", map_size);
1739   }
1740 
1741 #endif // !PRODUCT
1742 }
1743 



















1744 void CodeCache::print_summary(outputStream* st, bool detailed) {
1745   int full_count = 0;
1746   julong total_used = 0;
1747   julong total_max_used = 0;
1748   julong total_free = 0;
1749   julong total_size = 0;
1750   FOR_ALL_HEAPS(heap_iterator) {
1751     CodeHeap* heap = (*heap_iterator);
1752     size_t total = (heap->high_boundary() - heap->low_boundary());
1753     if (_heaps->length() >= 1) {
1754       st->print("%s:", heap->name());
1755     } else {
1756       st->print("CodeCache:");
1757     }
1758     size_t size = total/K;
1759     size_t used = (total - heap->unallocated_capacity())/K;
1760     size_t max_used = heap->max_allocated_capacity()/K;
1761     size_t free = heap->unallocated_capacity()/K;
1762     total_size += size;
1763     total_used += used;

   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 "cds/cdsAccess.hpp"
  26 #include "code/codeBlob.hpp"
  27 #include "code/codeCache.hpp"
  28 #include "code/codeHeapState.hpp"
  29 #include "code/compiledIC.hpp"
  30 #include "code/dependencies.hpp"
  31 #include "code/dependencyContext.hpp"
  32 #include "code/nmethod.hpp"
  33 #include "code/pcDesc.hpp"
  34 #include "code/SCCache.hpp"
  35 #include "compiler/compilationPolicy.hpp"
  36 #include "compiler/compileBroker.hpp"
  37 #include "compiler/compilerDefinitions.inline.hpp"
  38 #include "compiler/oopMap.hpp"
  39 #include "gc/shared/barrierSetNMethod.hpp"
  40 #include "gc/shared/classUnloadingContext.hpp"
  41 #include "gc/shared/collectedHeap.hpp"
  42 #include "jfr/jfrEvents.hpp"
  43 #include "jvm_io.h"
  44 #include "logging/log.hpp"
  45 #include "logging/logStream.hpp"
  46 #include "memory/allocation.inline.hpp"
  47 #include "memory/iterator.hpp"
  48 #include "memory/memoryReserver.hpp"
  49 #include "memory/resourceArea.hpp"
  50 #include "memory/universe.hpp"
  51 #include "oops/method.inline.hpp"
  52 #include "oops/objArrayOop.hpp"
  53 #include "oops/oop.inline.hpp"
  54 #include "oops/verifyOopClosure.hpp"

 155       scopes_data_size += nm->scopes_data_size();
 156       scopes_pcs_size  += nm->scopes_pcs_size();
 157     } else {
 158       code_size        += cb->code_size();
 159     }
 160   }
 161 };
 162 
 163 // Iterate over all CodeHeaps
 164 #define FOR_ALL_HEAPS(heap) for (GrowableArrayIterator<CodeHeap*> heap = _heaps->begin(); heap != _heaps->end(); ++heap)
 165 #define FOR_ALL_ALLOCABLE_HEAPS(heap) for (GrowableArrayIterator<CodeHeap*> heap = _allocable_heaps->begin(); heap != _allocable_heaps->end(); ++heap)
 166 
 167 // Iterate over all CodeBlobs (cb) on the given CodeHeap
 168 #define FOR_ALL_BLOBS(cb, heap) for (CodeBlob* cb = first_blob(heap); cb != nullptr; cb = next_blob(heap, cb))
 169 
 170 address CodeCache::_low_bound = nullptr;
 171 address CodeCache::_high_bound = nullptr;
 172 volatile int CodeCache::_number_of_nmethods_with_dependencies = 0;
 173 ExceptionCache* volatile CodeCache::_exception_cache_purge_list = nullptr;
 174 
 175 static ReservedSpace _cds_code_space;
 176 
 177 // Initialize arrays of CodeHeap subsets
 178 GrowableArray<CodeHeap*>* CodeCache::_heaps = new(mtCode) GrowableArray<CodeHeap*> (static_cast<int>(CodeBlobType::All), mtCode);
 179 GrowableArray<CodeHeap*>* CodeCache::_nmethod_heaps = new(mtCode) GrowableArray<CodeHeap*> (static_cast<int>(CodeBlobType::All), mtCode);
 180 GrowableArray<CodeHeap*>* CodeCache::_allocable_heaps = new(mtCode) GrowableArray<CodeHeap*> (static_cast<int>(CodeBlobType::All), mtCode);
 181 
 182 static void check_min_size(const char* codeheap, size_t size, size_t required_size) {
 183   if (size < required_size) {
 184     log_debug(codecache)("Code heap (%s) size %zuK below required minimal size %zuK",
 185                          codeheap, size/K, required_size/K);
 186     err_msg title("Not enough space in %s to run VM", codeheap);
 187     err_msg message("%zuK < %zuK", size/K, required_size/K);
 188     vm_exit_during_initialization(title, message);
 189   }
 190 }
 191 
 192 struct CodeHeapInfo {
 193   size_t size;
 194   bool set;
 195   bool enabled;
 196 };
 197 
 198 static void set_size_of_unset_code_heap(CodeHeapInfo* heap, size_t available_size, size_t used_size, size_t min_size) {
 199   assert(!heap->set, "sanity");
 200   heap->size = (available_size > (used_size + min_size)) ? (available_size - used_size) : min_size;
 201 }
 202 
 203 void CodeCache::initialize_heaps() {

 204   CodeHeapInfo non_nmethod = {NonNMethodCodeHeapSize, FLAG_IS_CMDLINE(NonNMethodCodeHeapSize), true};
 205   CodeHeapInfo profiled = {ProfiledCodeHeapSize, FLAG_IS_CMDLINE(ProfiledCodeHeapSize), true};
 206   CodeHeapInfo non_profiled = {NonProfiledCodeHeapSize, FLAG_IS_CMDLINE(NonProfiledCodeHeapSize), true};
 207 
 208   const bool cache_size_set   = FLAG_IS_CMDLINE(ReservedCodeCacheSize);
 209   const size_t ps             = page_size(false, 8);
 210   const size_t min_size       = MAX2(os::vm_allocation_granularity(), ps);
 211   const size_t min_cache_size = CodeCacheMinimumUseSpace DEBUG_ONLY(* 3); // Make sure we have enough space for VM internal code
 212   size_t cache_size           = align_up(ReservedCodeCacheSize, min_size);
 213 
 214   // Prerequisites
 215   if (!heap_available(CodeBlobType::MethodProfiled)) {
 216     // For compatibility reasons, disabled tiered compilation overrides
 217     // segment size even if it is set explicitly.
 218     non_profiled.size += profiled.size;
 219     // Profiled code heap is not available, forcibly set size to 0
 220     profiled.size = 0;
 221     profiled.set = true;
 222     profiled.enabled = false;
 223   }
 224 
 225   assert(heap_available(CodeBlobType::MethodNonProfiled), "MethodNonProfiled heap is always available for segmented code heap");
 226 
 227   size_t compiler_buffer_size = 0;
 228   COMPILER1_PRESENT(compiler_buffer_size += CompilationPolicy::c1_count() * Compiler::code_buffer_size());
 229   COMPILER2_PRESENT(compiler_buffer_size += CompilationPolicy::c2_count() * C2Compiler::initial_code_buffer_size());
 230   COMPILER2_PRESENT(compiler_buffer_size += (CompilationPolicy::c2_count() + CompilationPolicy::c3_count()) * C2Compiler::initial_code_buffer_size());
 231 
 232   if (!non_nmethod.set) {
 233     non_nmethod.size += compiler_buffer_size;
 234     // Further down, just before FLAG_SET_ERGO(), all segment sizes are
 235     // aligned down to the next lower multiple of min_size. For large page
 236     // sizes, this may result in (non_nmethod.size == 0) which is not acceptable.
 237     // Therefore, force non_nmethod.size to at least min_size.
 238     non_nmethod.size = MAX2(non_nmethod.size, min_size);
 239   }
 240 
 241   if (!profiled.set && !non_profiled.set) {
 242     non_profiled.size = profiled.size = (cache_size > non_nmethod.size + 2 * min_size) ?
 243                                         (cache_size - non_nmethod.size) / 2 : min_size;
 244   }
 245 
 246   if (profiled.set && !non_profiled.set) {
 247     set_size_of_unset_code_heap(&non_profiled, cache_size, non_nmethod.size + profiled.size, min_size);
 248   }
 249 
 250   if (!profiled.set && non_profiled.set) {

 305     if (ps < lg_ps) {
 306       log_warning(codecache)("Code cache size too small for " PROPERFMT " pages. "
 307                              "Reverting to smaller page size (" PROPERFMT ").",
 308                              PROPERFMTARGS(lg_ps), PROPERFMTARGS(ps));
 309     }
 310   }
 311 
 312   // Note: if large page support is enabled, min_size is at least the large
 313   // page size. This ensures that the code cache is covered by large pages.
 314   non_profiled.size += non_nmethod.size & alignment_mask(min_size);
 315   non_profiled.size += profiled.size & alignment_mask(min_size);
 316   non_nmethod.size = align_down(non_nmethod.size, min_size);
 317   profiled.size = align_down(profiled.size, min_size);
 318   non_profiled.size = align_down(non_profiled.size, min_size);
 319 
 320   FLAG_SET_ERGO(NonNMethodCodeHeapSize, non_nmethod.size);
 321   FLAG_SET_ERGO(ProfiledCodeHeapSize, profiled.size);
 322   FLAG_SET_ERGO(NonProfiledCodeHeapSize, non_profiled.size);
 323   FLAG_SET_ERGO(ReservedCodeCacheSize, cache_size);
 324 
 325   const size_t cds_code_size = align_up(CDSAccess::get_cached_code_size(), min_size);
 326   cache_size += cds_code_size;
 327 
 328   ReservedSpace rs = reserve_heap_memory(cache_size, ps);
 329 
 330   // Register CodeHeaps with LSan as we sometimes embed pointers to malloc memory.
 331   LSAN_REGISTER_ROOT_REGION(rs.base(), rs.size());
 332 
 333   size_t offset = 0;
 334   if (cds_code_size > 0) {
 335     // FIXME: use CodeHeapInfo for this hack ...
 336     _cds_code_space = rs.partition(offset, cds_code_size);
 337     offset += cds_code_size;
 338   }
 339 
 340   if (profiled.enabled) {
 341     ReservedSpace profiled_space = rs.partition(offset, profiled.size);
 342     offset += profiled.size;
 343     // Tier 2 and tier 3 (profiled) methods
 344     add_heap(profiled_space, "CodeHeap 'profiled nmethods'", CodeBlobType::MethodProfiled);
 345   }
 346 
 347   ReservedSpace non_method_space = rs.partition(offset, non_nmethod.size);
 348   offset += non_nmethod.size;
 349   // Non-nmethods (stubs, adapters, ...)
 350   add_heap(non_method_space, "CodeHeap 'non-nmethods'", CodeBlobType::NonNMethod);
 351 
 352   if (non_profiled.enabled) {
 353     ReservedSpace non_profiled_space  = rs.partition(offset, non_profiled.size);
 354     // Tier 1 and tier 4 (non-profiled) methods and native methods
 355     add_heap(non_profiled_space, "CodeHeap 'non-profiled nmethods'", CodeBlobType::MethodNonProfiled);
 356   }
 357 }
 358 
 359 void* CodeCache::map_cached_code() {
 360   if (_cds_code_space.size() > 0 && CDSAccess::map_cached_code(_cds_code_space)) {
 361     return _cds_code_space.base();
 362   } else {
 363     return nullptr;
 364   }
 365 }
 366 
 367 size_t CodeCache::page_size(bool aligned, size_t min_pages) {
 368   return aligned ? os::page_size_for_region_aligned(ReservedCodeCacheSize, min_pages) :
 369                    os::page_size_for_region_unaligned(ReservedCodeCacheSize, min_pages);
 370 }
 371 
 372 ReservedSpace CodeCache::reserve_heap_memory(size_t size, size_t rs_ps) {
 373   // Align and reserve space for code cache
 374   const size_t rs_align = MAX2(rs_ps, os::vm_allocation_granularity());
 375   const size_t rs_size = align_up(size, rs_align);
 376 
 377   ReservedSpace rs = CodeMemoryReserver::reserve(rs_size, rs_align, rs_ps);
 378   if (!rs.is_reserved()) {
 379     vm_exit_during_initialization(err_msg("Could not reserve enough space for code cache (%zuK)",
 380                                           rs_size/K));
 381   }
 382 
 383   // Initialize bounds
 384   _low_bound = (address)rs.base();
 385   _high_bound = _low_bound + rs.size();
 386   return rs;

1209                             AnyObj::RESOURCE_AREA, mtInternal,
1210                             &DependencySignature::hash,
1211                             &DependencySignature::equals> DepTable;
1212 
1213   DepTable* table = new DepTable();
1214 
1215   // Iterate over live nmethods and check dependencies of all nmethods that are not
1216   // marked for deoptimization. A particular dependency is only checked once.
1217   NMethodIterator iter(NMethodIterator::not_unloading);
1218   while(iter.next()) {
1219     nmethod* nm = iter.method();
1220     // Only notify for live nmethods
1221     if (!nm->is_marked_for_deoptimization()) {
1222       for (Dependencies::DepStream deps(nm); deps.next(); ) {
1223         // Construct abstraction of a dependency.
1224         DependencySignature* current_sig = new DependencySignature(deps);
1225 
1226         // Determine if dependency is already checked. table->put(...) returns
1227         // 'true' if the dependency is added (i.e., was not in the hashtable).
1228         if (table->put(*current_sig, 1)) {
1229           Klass* witness = deps.check_dependency();
1230           if (witness != nullptr) {
1231             // Dependency checking failed. Print out information about the failed
1232             // dependency and finally fail with an assert. We can fail here, since
1233             // dependency checking is never done in a product build.
1234             deps.print_dependency(tty, witness, true);
1235             changes.print();
1236             nm->print();
1237             nm->print_dependencies_on(tty);
1238             assert(false, "Should have been marked for deoptimization");
1239           }
1240         }
1241       }
1242     }
1243   }
1244 }
1245 #endif
1246 
1247 void CodeCache::mark_for_deoptimization(DeoptimizationScope* deopt_scope, KlassDepChange& changes) {
1248   MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
1249 
1250   // search the hierarchy looking for nmethods which are affected by the loading of this class
1251 
1252   // then search the interfaces this class implements looking for nmethods
1253   // which might be dependent of the fact that an interface only had one
1254   // implementor.
1255   // nmethod::check_all_dependencies works only correctly, if no safepoint
1256   // can happen
1257   NoSafepointVerifier nsv;
1258   for (DepChange::ContextStream str(changes, nsv); str.next(); ) {
1259     InstanceKlass* d = str.klass();
1260     {
1261       LogStreamHandle(Trace, dependencies) log;
1262       if (log.is_enabled()) {
1263         log.print("Processing context ");
1264         d->name()->print_value_on(&log);
1265       }
1266     }
1267     d->mark_dependent_nmethods(deopt_scope, changes);
1268   }
1269 
1270 #ifndef PRODUCT
1271   if (VerifyDependencies) {
1272     // Object pointers are used as unique identifiers for dependency arguments. This
1273     // is only possible if no safepoint, i.e., GC occurs during the verification code.
1274     dependentCheckTime.start();
1275     check_live_nmethods_dependencies(changes);
1276     dependentCheckTime.stop();
1277   }
1278 #endif
1279 }
1280 
1281 #if INCLUDE_JVMTI
1282 // RedefineClasses support for saving nmethods that are dependent on "old" methods.
1283 // We don't really expect this table to grow very large.  If it does, it can become a hashtable.
1284 static GrowableArray<nmethod*>* old_nmethod_table = nullptr;
1285 
1286 static void add_to_old_table(nmethod* c) {

1505 }
1506 PRAGMA_DIAG_POP
1507 
1508 void CodeCache::print_memory_overhead() {
1509   size_t wasted_bytes = 0;
1510   FOR_ALL_ALLOCABLE_HEAPS(heap) {
1511       CodeHeap* curr_heap = *heap;
1512       for (CodeBlob* cb = (CodeBlob*)curr_heap->first(); cb != nullptr; cb = (CodeBlob*)curr_heap->next(cb)) {
1513         HeapBlock* heap_block = ((HeapBlock*)cb) - 1;
1514         wasted_bytes += heap_block->length() * CodeCacheSegmentSize - cb->size();
1515       }
1516   }
1517   // Print bytes that are allocated in the freelist
1518   ttyLocker ttl;
1519   tty->print_cr("Number of elements in freelist: %zd",       freelists_length());
1520   tty->print_cr("Allocated in freelist:          %zdkB",  bytes_allocated_in_freelists()/K);
1521   tty->print_cr("Unused bytes in CodeBlobs:      %zdkB",  (wasted_bytes/K));
1522   tty->print_cr("Segment map size:               %zdkB",  allocated_segments()/K); // 1 byte per segment
1523 }
1524 
1525 static void print_helper1(outputStream* st, const char* prefix, int total, int not_entrant, int used) {
1526   if (total > 0) {
1527     double ratio = (100.0 * used) / total;
1528     st->print("%s %3d nmethods: %3d not_entrant, %d used (%2.1f%%)", prefix, total, not_entrant, used, ratio);
1529   }
1530 }
1531 
1532 void CodeCache::print_nmethod_statistics_on(outputStream* st) {
1533   int stats     [2][6][3][2] = {0};
1534   int stats_used[2][6][3][2] = {0};
1535 
1536   int total_osr = 0;
1537   int total_entrant = 0;
1538   int total_non_entrant = 0;
1539   int total_other = 0;
1540   int total_used = 0;
1541 
1542   NMethodIterator iter(NMethodIterator::all);
1543   while (iter.next()) {
1544     nmethod* nm = iter.method();
1545     if (nm->is_in_use()) {
1546       ++total_entrant;
1547     } else if (nm->is_not_entrant()) {
1548       ++total_non_entrant;
1549     } else {
1550       ++total_other;
1551     }
1552     if (nm->is_osr_method()) {
1553       ++total_osr;
1554     }
1555     if (nm->used()) {
1556       ++total_used;
1557     }
1558     assert(!nm->preloaded() || nm->comp_level() == CompLevel_full_optimization, "");
1559 
1560     int idx1 = nm->is_scc() ? 1 : 0;
1561     int idx2 = nm->comp_level() + (nm->preloaded() ? 1 : 0);
1562     int idx3 = (nm->is_in_use()      ? 0 :
1563                (nm->is_not_entrant() ? 1 :
1564                                        2));
1565     int idx4 = (nm->is_osr_method() ? 1 : 0);
1566     stats[idx1][idx2][idx3][idx4] += 1;
1567     if (nm->used()) {
1568       stats_used[idx1][idx2][idx3][idx4] += 1;
1569     }
1570   }
1571 
1572   st->print("Total: %d methods (%d entrant / %d not_entrant; osr: %d ",
1573                total_entrant + total_non_entrant + total_other,
1574                total_entrant, total_non_entrant, total_osr);
1575   if (total_other > 0) {
1576     st->print("; %d other", total_other);
1577   }
1578   st->print_cr(")");
1579 
1580   for (int i = CompLevel_simple; i <= CompLevel_full_optimization; i++) {
1581     int total_normal = stats[0][i][0][0] + stats[0][i][1][0] + stats[0][i][2][0];
1582     int total_osr    = stats[0][i][0][1] + stats[0][i][1][1] + stats[0][i][2][1];
1583     if (total_normal + total_osr > 0) {
1584       st->print("  Tier%d:", i);
1585       print_helper1(st,      "", total_normal, stats[0][i][1][0], stats_used[0][i][0][0] + stats_used[0][i][1][0]);
1586       print_helper1(st, "; osr:", total_osr,    stats[0][i][1][1], stats_used[0][i][0][1] + stats_used[0][i][1][1]);
1587       st->cr();
1588     }
1589   }
1590   st->cr();
1591   for (int i = CompLevel_simple; i <= CompLevel_full_optimization + 1; i++) {
1592     int total_normal = stats[1][i][0][0] + stats[1][i][1][0] + stats[1][i][2][0];
1593     int total_osr    = stats[1][i][0][1] + stats[1][i][1][1] + stats[1][i][2][1];
1594     assert(total_osr == 0, "sanity");
1595     if (total_normal + total_osr > 0) {
1596       st->print("  SC T%d:", i);
1597       print_helper1(st,      "", total_normal, stats[1][i][1][0], stats_used[1][i][0][0] + stats_used[1][i][1][0]);
1598       print_helper1(st, "; osr:", total_osr,    stats[1][i][1][1], stats_used[1][i][0][1] + stats_used[1][i][1][1]);
1599       st->cr();
1600     }
1601   }
1602 }
1603 
1604 //------------------------------------------------------------------------------------------------
1605 // Non-product version
1606 
1607 #ifndef PRODUCT
1608 
1609 void CodeCache::print_trace(const char* event, CodeBlob* cb, uint size) {
1610   if (PrintCodeCache2) {  // Need to add a new flag
1611     ResourceMark rm;
1612     if (size == 0) {
1613       int s = cb->size();
1614       assert(s >= 0, "CodeBlob size is negative: %d", s);
1615       size = (uint) s;
1616     }
1617     tty->print_cr("CodeCache %s:  addr: " INTPTR_FORMAT ", size: 0x%x", event, p2i(cb), size);
1618   }
1619 }
1620 
1621 void CodeCache::print_internals() {
1622   int nmethodCount = 0;
1623   int runtimeStubCount = 0;
1624   int upcallStubCount = 0;
1625   int adapterCount = 0;
1626   int mhAdapterCount = 0;
1627   int vtableBlobCount = 0;
1628   int deoptimizationStubCount = 0;
1629   int uncommonTrapStubCount = 0;
1630   int exceptionStubCount = 0;
1631   int safepointStubCount = 0;
1632   int bufferBlobCount = 0;
1633   int total = 0;
1634   int nmethodNotEntrant = 0;
1635   int nmethodJava = 0;
1636   int nmethodNative = 0;
1637   int max_nm_size = 0;
1638   ResourceMark rm;
1639 
1640   int i = 0;
1641   FOR_ALL_ALLOCABLE_HEAPS(heap) {
1642     int heap_total = 0;
1643     tty->print_cr("-- %s --", (*heap)->name());

1644     FOR_ALL_BLOBS(cb, *heap) {
1645       total++;
1646       heap_total++;
1647       if (cb->is_nmethod()) {
1648         nmethod* nm = (nmethod*)cb;
1649 
1650         tty->print("%4d: ", heap_total);
1651         CompileTask::print(tty, nm, (nm->is_not_entrant() ? "non-entrant" : ""), true, true);




1652 
1653         nmethodCount++;
1654 
1655         if(nm->is_not_entrant()) { nmethodNotEntrant++; }
1656         if(nm->method() != nullptr && nm->is_native_method()) { nmethodNative++; }
1657 
1658         if(nm->method() != nullptr && nm->is_java_method()) {
1659           nmethodJava++;
1660           max_nm_size = MAX2(max_nm_size, nm->size());
1661         }
1662       } else if (cb->is_runtime_stub()) {
1663         runtimeStubCount++;
1664       } else if (cb->is_upcall_stub()) {
1665         upcallStubCount++;
1666       } else if (cb->is_deoptimization_stub()) {
1667         deoptimizationStubCount++;
1668       } else if (cb->is_uncommon_trap_stub()) {
1669         uncommonTrapStubCount++;
1670       } else if (cb->is_exception_stub()) {
1671         exceptionStubCount++;

1828       FOR_ALL_BLOBS(cb, *heap) {
1829         number_of_blobs++;
1830         code_size += cb->code_size();
1831         ImmutableOopMapSet* set = cb->oop_maps();
1832         if (set != nullptr) {
1833           number_of_oop_maps += set->count();
1834           map_size           += set->nr_of_bytes();
1835         }
1836       }
1837     }
1838     tty->print_cr("OopMaps");
1839     tty->print_cr("  #blobs    = %d", number_of_blobs);
1840     tty->print_cr("  code size = %d", code_size);
1841     tty->print_cr("  #oop_maps = %d", number_of_oop_maps);
1842     tty->print_cr("  map size  = %d", map_size);
1843   }
1844 
1845 #endif // !PRODUCT
1846 }
1847 
1848 void CodeCache::print_nmethods_on(outputStream* st) {
1849   ResourceMark rm;
1850   int i = 0;
1851   FOR_ALL_ALLOCABLE_HEAPS(heap) {
1852     st->print_cr("-- %s --", (*heap)->name());
1853     FOR_ALL_BLOBS(cb, *heap) {
1854       i++;
1855       if (cb->is_nmethod()) {
1856         nmethod* nm = (nmethod*)cb;
1857         st->print("%4d: ", i);
1858         CompileTask::print(st, nm, nullptr, true, false);
1859 
1860         const char non_entrant_char = (nm->is_not_entrant() ? 'N' : ' ');
1861         st->print_cr(" %c", non_entrant_char);
1862       }
1863     }
1864   }
1865 }
1866 
1867 void CodeCache::print_summary(outputStream* st, bool detailed) {
1868   int full_count = 0;
1869   julong total_used = 0;
1870   julong total_max_used = 0;
1871   julong total_free = 0;
1872   julong total_size = 0;
1873   FOR_ALL_HEAPS(heap_iterator) {
1874     CodeHeap* heap = (*heap_iterator);
1875     size_t total = (heap->high_boundary() - heap->low_boundary());
1876     if (_heaps->length() >= 1) {
1877       st->print("%s:", heap->name());
1878     } else {
1879       st->print("CodeCache:");
1880     }
1881     size_t size = total/K;
1882     size_t used = (total - heap->unallocated_capacity())/K;
1883     size_t max_used = heap->max_allocated_capacity()/K;
1884     size_t free = heap->unallocated_capacity()/K;
1885     total_size += size;
1886     total_used += used;
< prev index next >