--- old/src/share/vm/code/codeCache.cpp 2013-10-09 15:17:14.916404556 +0200 +++ new/src/share/vm/code/codeCache.cpp 2013-10-09 15:17:14.316404579 +0200 @@ -48,8 +48,8 @@ #include "trace/tracing.hpp" #include "utilities/xmlstream.hpp" -// Helper class for printing in CodeCache +// Helper class for printing in CodeCache class CodeBlob_sizes { private: int count; @@ -115,64 +115,182 @@ } }; -// CodeCache implementation +// Iterate over all CodeHeaps +#define FOR_ALL_HEAPS(it) for (GrowableArrayIterator it = _heaps->begin(); it != _heaps->end(); ++it) +// Iterate over all CodeHeaps containing nmethods +#define FOR_ALL_METHOD_HEAPS(it) for (GrowableArrayFilterIterator it(_heaps->begin(), IsMethodPredicate()); it != _heaps->end(); ++it) +// Iterate over all CodeBlobs (cb) on the given CodeHeap +#define FOR_ALL_BLOBS(cb, heap) for (CodeBlob* cb = first_blob(heap); cb != NULL; cb = next_blob(heap, cb)) +// Iterate over all alive CodeBlobs (cb) on the given CodeHeap +#define FOR_ALL_ALIVE_BLOBS(cb, heap) for (CodeBlob* cb = first_alive_blob(heap); cb != NULL; cb = next_alive_blob(heap, cb)) -CodeHeap * CodeCache::_heap = new CodeHeap(); +address CodeCache::_low_bound = 0; +address CodeCache::_high_bound = 0; int CodeCache::_number_of_blobs = 0; int CodeCache::_number_of_adapters = 0; int CodeCache::_number_of_nmethods = 0; int CodeCache::_number_of_nmethods_with_dependencies = 0; bool CodeCache::_needs_cache_clean = false; nmethod* CodeCache::_scavenge_root_nmethods = NULL; - int CodeCache::_codemem_full_count = 0; -CodeBlob* CodeCache::first() { - assert_locked_or_safepoint(CodeCache_lock); - return (CodeBlob*)_heap->first(); +// Initialize array of CodeHeaps +GrowableArray* CodeCache::_heaps = new(ResourceObj::C_HEAP, mtCode) GrowableArray (3, true); + +void CodeCache::initialize_heaps() { + // Per default (with TieredCompilation) we use 2/3 of the ReservedCodeCacheSize + // for non-profiled methods and 1/3 for profiled methods. If we no not need one + // of the heaps, we use all space for the remaining heap. + if (FLAG_IS_DEFAULT(NonProfiledCodeHeapSize) && heap_available(CodeBlobType::NonMethod)) { + FLAG_SET_DEFAULT(NonProfiledCodeHeapSize, ReservedCodeCacheSize * (heap_available(CodeBlobType::MethodProfile) ? (double)2/3 : 1)); + } else if (!heap_available(CodeBlobType::MethodNoProfile)) { + FLAG_SET_DEFAULT(NonProfiledCodeHeapSize, 0); + } + if (FLAG_IS_DEFAULT(ProfiledCodeHeapSize) && heap_available(CodeBlobType::MethodProfile)) { + FLAG_SET_DEFAULT(ProfiledCodeHeapSize, ReservedCodeCacheSize * (heap_available(CodeBlobType::MethodNoProfile) ? (double)1/3 : 1)); + } else if (!heap_available(CodeBlobType::MethodProfile)) { + FLAG_SET_DEFAULT(ProfiledCodeHeapSize, 0); + } + // Check sizes + assert(ProfiledCodeHeapSize + NonProfiledCodeHeapSize <= ReservedCodeCacheSize, "CodeHeap size check"); + + // Compute reserved sizes of CodeHeaps + // We need at most 8mb for the non method heap + size_t non_method_size = ReservedCodeSpace::allocation_align_size_up(MIN2(ReservedCodeCacheSize, 8*M)); + size_t no_profile_size = ReservedCodeSpace::allocation_align_size_up(NonProfiledCodeHeapSize); + size_t profile_size = ProfiledCodeHeapSize; + if (profile_size > non_method_size) { + profile_size = ProfiledCodeHeapSize - non_method_size; + } + profile_size = ReservedCodeSpace::allocation_align_size_up(profile_size); + + // Compute initial sizes of CodeHeaps + size_t init_non_method_size = MIN2(InitialCodeCacheSize, non_method_size); + size_t init_no_profile_size = MIN2(InitialCodeCacheSize, no_profile_size); + size_t init_profile_size = MIN2(InitialCodeCacheSize, profile_size); + + // Reserve one continuous chunk of memory for CodeHeaps and split it into + // parts for the individual heaps. The memory layout looks like this: + // ---------- high ----------- + // Non-methods + // Tier 2 and tier 3 methods + // Tier 1 and Tier 4 methods + // ---------- low ------------ + ReservedCodeSpace rs = reserve_heap_memory(no_profile_size + profile_size + non_method_size); + ReservedSpace no_profile_space = rs.first_part(no_profile_size); + ReservedSpace rest = rs.last_part(no_profile_size); + ReservedSpace profile_space = rest.first_part(profile_size); + ReservedSpace non_method_space = rest.last_part(profile_size); + + // Tier 1 and tier 4 methods (+ native) + add_heap(no_profile_space, "Tier 1 and tier 4 methods", init_no_profile_size, CodeBlobType::MethodNoProfile); + // Tier 2 and tier 3 methods + add_heap(profile_space, "Tier 2 and tier 3 methods", init_profile_size, CodeBlobType::MethodProfile); + // Non-methods + add_heap(non_method_space, "Non-methods", init_non_method_size, CodeBlobType::NonMethod); +} + +ReservedCodeSpace CodeCache::reserve_heap_memory(size_t size) { + // Determine alignment + const size_t page_size = os::can_execute_large_page_memory() ? + os::page_size_for_region(InitialCodeCacheSize, size, 8) : + os::vm_page_size(); + const size_t granularity = os::vm_allocation_granularity(); + const size_t r_align = MAX2(page_size, granularity); + const size_t r_size = align_size_up(size, r_align); + const size_t rs_align = page_size == (size_t) os::vm_page_size() ? 0 : + MAX2(page_size, granularity); + + ReservedCodeSpace rs(r_size, rs_align, rs_align > 0); + + // Initialize bounds + _low_bound = (address)rs.base(); + _high_bound = _low_bound + rs.size(); + guarantee(low_bound() < high_bound(), "Bound check"); + + return rs; +} + +bool CodeCache::heap_available(int code_blob_type) { + if (TieredCompilation || code_blob_type == CodeBlobType::NonMethod) { + // Use all heaps for TieredCompilation + return true; + } else { +#ifdef COMPILER2 + // We only need the heap for C2 + return (code_blob_type == CodeBlobType::MethodNoProfile); +#else + // We need both heaps + return true; +#endif + } } +void CodeCache::add_heap(ReservedSpace rs, const char* name, size_t size_initial, int code_blob_type) { + // Check if heap is needed + if (!heap_available(code_blob_type)) { + return; + } + + // Create CodeHeap + CodeHeap* heap = new CodeHeap(name, code_blob_type); + _heaps->append(heap); -CodeBlob* CodeCache::next(CodeBlob* cb) { - assert_locked_or_safepoint(CodeCache_lock); - return (CodeBlob*)_heap->next(cb); -} + // Reserve Space + size_initial = round_to(size_initial, os::vm_page_size()); + if (!heap->reserve(rs, size_initial, CodeCacheSegmentSize)) { + vm_exit_during_initialization("Could not reserve enough space for code cache"); + } -CodeBlob* CodeCache::alive(CodeBlob *cb) { - assert_locked_or_safepoint(CodeCache_lock); - while (cb != NULL && !cb->is_alive()) cb = next(cb); - return cb; + // Register the CodeHeap + MemoryService::add_code_heap_memory_pool(heap, name); } +CodeHeap* CodeCache::get_code_heap(int code_blob_type) { + FOR_ALL_HEAPS(it) { + if ((*it)->accepts(code_blob_type)) { + return (*it); + } + } + return NULL; +} -nmethod* CodeCache::alive_nmethod(CodeBlob* cb) { +CodeBlob* CodeCache::first_blob(CodeHeap* heap) { assert_locked_or_safepoint(CodeCache_lock); - while (cb != NULL && (!cb->is_alive() || !cb->is_nmethod())) cb = next(cb); - return (nmethod*)cb; + if (heap != NULL) { + return (CodeBlob*)heap->first(); + } + return NULL; } -nmethod* CodeCache::first_nmethod() { +CodeBlob* CodeCache::next_blob(CodeHeap* heap, CodeBlob* cb) { assert_locked_or_safepoint(CodeCache_lock); - CodeBlob* cb = first(); - while (cb != NULL && !cb->is_nmethod()) { - cb = next(cb); + if (heap != NULL) { + return (CodeBlob*)heap->next(cb); } - return (nmethod*)cb; + return NULL; } -nmethod* CodeCache::next_nmethod (CodeBlob* cb) { +CodeBlob* CodeCache::first_alive_blob(CodeHeap* heap) { assert_locked_or_safepoint(CodeCache_lock); - cb = next(cb); - while (cb != NULL && !cb->is_nmethod()) { - cb = next(cb); + CodeBlob* cb = first_blob(heap); + while (cb != NULL && !cb->is_alive()) { + cb = next_blob(heap, cb); } - return (nmethod*)cb; + return cb; } -static size_t maxCodeCacheUsed = 0; +CodeBlob* CodeCache::next_alive_blob(CodeHeap* heap, CodeBlob* cb) { + assert_locked_or_safepoint(CodeCache_lock); + cb = next_blob(heap, cb); + while (cb != NULL && !cb->is_alive()) { + cb = next_blob(heap, cb); + } + return cb; +} -CodeBlob* CodeCache::allocate(int size, bool is_critical) { +CodeBlob* CodeCache::allocate(int size, int code_blob_type, bool is_critical) { // Do not seize the CodeCache lock here--if the caller has not // already done so, we are going to lose bigtime, since the code // cache will contain a garbage CodeBlob until the caller can @@ -182,28 +300,33 @@ assert_locked_or_safepoint(CodeCache_lock); CodeBlob* cb = NULL; _number_of_blobs++; + + // Get CodeHeap for the given CodeBlobType + CodeHeap* heap = get_code_heap(code_blob_type); + assert (heap != NULL, "Heap exists"); + while (true) { - cb = (CodeBlob*)_heap->allocate(size, is_critical); + cb = (CodeBlob*)heap->allocate(size, is_critical); if (cb != NULL) break; - if (!_heap->expand_by(CodeCacheExpansionSize)) { + if (!heap->expand_by(CodeCacheExpansionSize)) { // Expansion failed return NULL; } if (PrintCodeCacheExtension) { ResourceMark rm; - tty->print_cr("code cache extended to [" INTPTR_FORMAT ", " INTPTR_FORMAT "] (%d bytes)", - (intptr_t)_heap->low_boundary(), (intptr_t)_heap->high(), - (address)_heap->high() - (address)_heap->low_boundary()); + tty->print_cr("CodeHeap '%s' extended to [" INTPTR_FORMAT ", " INTPTR_FORMAT "] (%d bytes)", + heap->name(), (intptr_t)heap->low_boundary(), (intptr_t)heap->high(), + (address)heap->high() - (address)heap->low_boundary()); } } - maxCodeCacheUsed = MAX2(maxCodeCacheUsed, ((address)_heap->high_boundary() - - (address)_heap->low_boundary()) - unallocated_capacity()); + verify_if_often(); print_trace("allocation", cb, size); + return cb; } -void CodeCache::free(CodeBlob* cb) { +void CodeCache::free(CodeBlob* cb, int code_blob_type) { assert_locked_or_safepoint(CodeCache_lock); verify_if_often(); @@ -219,13 +342,13 @@ } _number_of_blobs--; - _heap->deallocate(cb); + // Get heap for given CodeBlobType and deallocate + get_code_heap(code_blob_type)->deallocate(cb); verify_if_often(); assert(_number_of_blobs >= 0, "sanity check"); } - void CodeCache::commit(CodeBlob* cb) { // this is called by nmethod::nmethod, which must already own CodeCache_lock assert_locked_or_safepoint(CodeCache_lock); @@ -243,94 +366,115 @@ ICache::invalidate_range(cb->content_begin(), cb->content_size()); } - -void CodeCache::flush() { - assert_locked_or_safepoint(CodeCache_lock); - Unimplemented(); -} - - -// Iteration over CodeBlobs - -#define FOR_ALL_BLOBS(var) for (CodeBlob *var = first() ; var != NULL; var = next(var) ) -#define FOR_ALL_ALIVE_BLOBS(var) for (CodeBlob *var = alive(first()); var != NULL; var = alive(next(var))) -#define FOR_ALL_ALIVE_NMETHODS(var) for (nmethod *var = alive_nmethod(first()); var != NULL; var = alive_nmethod(next(var))) - - bool CodeCache::contains(void *p) { // It should be ok to call contains without holding a lock - return _heap->contains(p); + FOR_ALL_HEAPS(it) { + if ((*it)->contains(p)) { + return true; + } + } + return false; } - -// This method is safe to call without holding the CodeCache_lock, as long as a dead codeblob is not -// looked up (i.e., one that has been marked for deletion). It only dependes on the _segmap to contain +// This method is safe to call without holding the CodeCache_lock, as long as a dead CodeBlob is not +// looked up (i.e., one that has been marked for deletion). It only depends on the _segmap to contain // valid indices, which it will always do, as long as the CodeBlob is not in the process of being recycled. CodeBlob* CodeCache::find_blob(void* start) { CodeBlob* result = find_blob_unsafe(start); - if (result == NULL) return NULL; - // We could potientially look up non_entrant methods - guarantee(!result->is_zombie() || result->is_locked_by_vm() || is_error_reported(), "unsafe access to zombie method"); + // We could potentially look up non_entrant methods + guarantee(result == NULL || !result->is_zombie() || result->is_locked_by_vm() || is_error_reported(), "unsafe access to zombie method"); return result; } +// Lookup that does not fail if you lookup a zombie method (if you call this, be sure to know +// what you are doing) +CodeBlob* CodeCache::find_blob_unsafe(void* start) { + // NMT can walk the stack before code cache is created + if (_heaps->first() == NULL) return NULL; + + FOR_ALL_HEAPS(it) { + CodeBlob* result = (CodeBlob*) (*it)->find_start(start); + if (result != NULL && result->blob_contains((address)start)) { + return result; + } + } + return NULL; +} + nmethod* CodeCache::find_nmethod(void* start) { - CodeBlob *cb = find_blob(start); - assert(cb == NULL || cb->is_nmethod(), "did not find an nmethod"); + CodeBlob* cb = find_blob(start); + assert(cb->is_nmethod(), "did not find an nmethod"); return (nmethod*)cb; } +bool CodeCache::contains_nmethod(nmethod* nm) { + FOR_ALL_METHOD_HEAPS(it) { + if ((*it)->contains(nm)) { + return true; + } + } + return false; +} void CodeCache::blobs_do(void f(CodeBlob* nm)) { assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_BLOBS(p) { - f(p); + FOR_ALL_HEAPS(it) { + FOR_ALL_BLOBS(cb, *it) { + f(cb); + } } } - void CodeCache::nmethods_do(void f(nmethod* nm)) { assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_BLOBS(nm) { - if (nm->is_nmethod()) f((nmethod*)nm); + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_BLOBS(cb, *it) { + f((nmethod*)cb); + } } } void CodeCache::alive_nmethods_do(void f(nmethod* nm)) { assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_ALIVE_NMETHODS(nm) { - f(nm); + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + f((nmethod*)cb); + } } } int CodeCache::alignment_unit() { - return (int)_heap->alignment_unit(); + return (int)_heaps->first()->alignment_unit(); } - int CodeCache::alignment_offset() { - return (int)_heap->alignment_offset(); + return (int)_heaps->first()->alignment_offset(); } - -// Mark nmethods for unloading if they contain otherwise unreachable -// oops. +// Mark nmethods for unloading if they contain otherwise unreachable oops. void CodeCache::do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred) { assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_ALIVE_NMETHODS(nm) { - nm->do_unloading(is_alive, unloading_occurred); + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + nm->do_unloading(is_alive, unloading_occurred); + } } } void CodeCache::blobs_do(CodeBlobClosure* f) { assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_ALIVE_BLOBS(cb) { - f->do_code_blob(cb); + FOR_ALL_HEAPS(it) { + FOR_ALL_BLOBS(cb, *it) { + if (cb->is_alive()) { + f->do_code_blob(cb); #ifdef ASSERT - if (cb->is_nmethod()) - ((nmethod*)cb)->verify_scavenge_root_oops(); + if (cb->is_nmethod()) + ((nmethod*)cb)->verify_scavenge_root_oops(); #endif //ASSERT + } + } } } @@ -434,9 +578,9 @@ // Temporarily mark nmethods that are claimed to be on the non-perm list. void CodeCache::mark_scavenge_root_nmethods() { - FOR_ALL_ALIVE_BLOBS(cb) { - if (cb->is_nmethod()) { - nmethod *nm = (nmethod*)cb; + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; assert(nm->scavenge_root_not_marked(), "clean state"); if (nm->on_scavenge_root_list()) nm->set_scavenge_root_marked(); @@ -447,32 +591,29 @@ // If the closure is given, run it on the unlisted nmethods. // Also make sure that the effects of mark_scavenge_root_nmethods is gone. void CodeCache::verify_perm_nmethods(CodeBlobClosure* f_or_null) { - FOR_ALL_ALIVE_BLOBS(cb) { - bool call_f = (f_or_null != NULL); - if (cb->is_nmethod()) { - nmethod *nm = (nmethod*)cb; + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + bool call_f = (f_or_null != NULL); assert(nm->scavenge_root_not_marked(), "must be already processed"); if (nm->on_scavenge_root_list()) call_f = false; // don't show this one to the client nm->verify_scavenge_root_oops(); - } else { - call_f = false; // not an nmethod + if (call_f) f_or_null->do_code_blob(nm); } - if (call_f) f_or_null->do_code_blob(cb); } } #endif //PRODUCT - void CodeCache::gc_prologue() { assert(!nmethod::oops_do_marking_is_active(), "oops_do_marking_epilogue must be called"); } void CodeCache::gc_epilogue() { assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_ALIVE_BLOBS(cb) { - if (cb->is_nmethod()) { - nmethod *nm = (nmethod*)cb; + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; assert(!nm->is_unloaded(), "Tautology"); if (needs_cache_clean()) { nm->cleanup_inline_caches(); @@ -488,8 +629,8 @@ #ifdef ASSERT // make sure that we aren't leaking icholders int count = 0; - FOR_ALL_BLOBS(cb) { - if (cb->is_nmethod()) { + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_BLOBS(cb, *it) { RelocIterator iter((nmethod*)cb); while(iter.next()) { if (iter.type() == relocInfo::virtual_call_type) { @@ -512,38 +653,53 @@ #endif } - void CodeCache::verify_oops() { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); VerifyOopClosure voc; - FOR_ALL_ALIVE_BLOBS(cb) { - if (cb->is_nmethod()) { - nmethod *nm = (nmethod*)cb; + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; nm->oops_do(&voc); nm->verify_oop_relocations(); } } } - -address CodeCache::first_address() { - assert_locked_or_safepoint(CodeCache_lock); - return (address)_heap->low_boundary(); +size_t CodeCache::capacity() { + size_t cap = 0; + FOR_ALL_HEAPS(it) { + cap += (*it)->capacity(); + } + return cap; } +size_t CodeCache::unallocated_capacity() { + size_t unallocated_cap = 0; + FOR_ALL_HEAPS(it) { + unallocated_cap += (*it)->unallocated_capacity(); + } + return unallocated_cap; +} -address CodeCache::last_address() { - assert_locked_or_safepoint(CodeCache_lock); - return (address)_heap->high(); +size_t CodeCache::max_capacity() { + size_t max_cap = 0; + FOR_ALL_HEAPS(it) { + max_cap += (*it)->max_capacity(); + } + return max_cap; } /** * Returns the reverse free ratio. E.g., if 25% (1/4) of the code cache * is free, reverse_free_ratio() returns 4. */ -double CodeCache::reverse_free_ratio() { - double unallocated_capacity = (double)(CodeCache::unallocated_capacity() - CodeCacheMinimumFreeSpace); - double max_capacity = (double)CodeCache::max_capacity(); +double CodeCache::reverse_free_ratio(int code_blob_type) { + CodeHeap* heap = get_code_heap(code_blob_type); + if (heap == NULL) { + return 0; + } + double unallocated_capacity = (double)(heap->unallocated_capacity() - CodeCacheMinimumFreeSpace); + double max_capacity = (double)heap->max_capacity(); return max_capacity / unallocated_capacity; } @@ -559,13 +715,9 @@ // the code cache to the page size. In particular, Solaris is moving to a larger // default page size. CodeCacheExpansionSize = round_to(CodeCacheExpansionSize, os::vm_page_size()); - InitialCodeCacheSize = round_to(InitialCodeCacheSize, os::vm_page_size()); - ReservedCodeCacheSize = round_to(ReservedCodeCacheSize, os::vm_page_size()); - if (!_heap->reserve(ReservedCodeCacheSize, InitialCodeCacheSize, CodeCacheSegmentSize)) { - vm_exit_during_initialization("Could not reserve enough space for code cache"); - } - MemoryService::add_code_heap_memory_pool(_heap); + // Reserve space and create heaps + initialize_heaps(); // Initialize ICache flush mechanism // This service is needed for os::register_code_area @@ -574,10 +726,9 @@ // Give OS a chance to register generated code area. // This is used on Windows 64 bit platforms to register // Structured Exception Handlers for our generated code. - os::register_code_area(_heap->low_boundary(), _heap->high_boundary()); + os::register_code_area((char*)low_bound(), (char*)high_bound()); } - void codeCache_init() { CodeCache::initialize(); } @@ -588,13 +739,6 @@ return _number_of_nmethods_with_dependencies; } -void CodeCache::clear_inline_caches() { - assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_ALIVE_NMETHODS(nm) { - nm->clear_inline_caches(); - } -} - #ifndef PRODUCT // used to keep track of how much time is spent in mark_for_deoptimization static elapsedTimer dependentCheckTime; @@ -628,14 +772,17 @@ if (VerifyDependencies) { // Turn off dependency tracing while actually testing deps. NOT_PRODUCT( FlagSetting fs(TraceDependencies, false) ); - FOR_ALL_ALIVE_NMETHODS(nm) { - if (!nm->is_marked_for_deoptimization() && - nm->check_all_dependencies()) { - ResourceMark rm; - tty->print_cr("Should have been marked for deoptimization:"); - changes.print(); - nm->print(); - nm->print_dependencies(); + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + if (!nm->is_marked_for_deoptimization() && + nm->check_all_dependencies()) { + ResourceMark rm; + tty->print_cr("Should have been marked for deoptimization:"); + changes.print(); + nm->print(); + nm->print_dependencies(); + } } } } @@ -665,16 +812,19 @@ } } - FOR_ALL_ALIVE_NMETHODS(nm) { - if (nm->is_marked_for_deoptimization()) { - // ...Already marked in the previous pass; don't count it again. - } else if (nm->is_evol_dependent_on(dependee())) { - ResourceMark rm; - nm->mark_for_deoptimization(); - number_of_marked_CodeBlobs++; - } else { - // flush caches in case they refer to a redefined Method* - nm->clear_inline_caches(); + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + if (nm->is_marked_for_deoptimization()) { + // ...Already marked in the previous pass; don't count it again. + } else if (nm->is_evol_dependent_on(dependee())) { + ResourceMark rm; + nm->mark_for_deoptimization(); + number_of_marked_CodeBlobs++; + } else { + // flush caches in case they refer to a redefined Method* + nm->clear_inline_caches(); + } } } @@ -686,21 +836,26 @@ // Deoptimize all methods void CodeCache::mark_all_nmethods_for_deoptimization() { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); - FOR_ALL_ALIVE_NMETHODS(nm) { - nm->mark_for_deoptimization(); + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + nm->mark_for_deoptimization(); + } } } - int CodeCache::mark_for_deoptimization(Method* dependee) { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); int number_of_marked_CodeBlobs = 0; - FOR_ALL_ALIVE_NMETHODS(nm) { - if (nm->is_dependent_on_method(dependee)) { - ResourceMark rm; - nm->mark_for_deoptimization(); - number_of_marked_CodeBlobs++; + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + if (nm->is_dependent_on_method(dependee)) { + ResourceMark rm; + nm->mark_for_deoptimization(); + number_of_marked_CodeBlobs++; + } } } @@ -709,20 +864,23 @@ void CodeCache::make_marked_nmethods_zombies() { assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); - FOR_ALL_ALIVE_NMETHODS(nm) { - if (nm->is_marked_for_deoptimization()) { - - // If the nmethod has already been made non-entrant and it can be converted - // then zombie it now. Otherwise make it non-entrant and it will eventually - // be zombied when it is no longer seen on the stack. Note that the nmethod - // might be "entrant" and not on the stack and so could be zombied immediately - // but we can't tell because we don't track it on stack until it becomes - // non-entrant. + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + if (nm->is_marked_for_deoptimization()) { - if (nm->is_not_entrant() && nm->can_not_entrant_be_converted()) { - nm->make_zombie(); - } else { - nm->make_not_entrant(); + // If the nmethod has already been made non-entrant and it can be converted + // then zombie it now. Otherwise make it non-entrant and it will eventually + // be zombied when it is no longer seen on the stack. Note that the nmethod + // might be "entrant" and not on the stack and so could be zombied immediately + // but we can't tell because we don't track it on stack until it becomes + // non-entrant. + + if (nm->is_not_entrant() && nm->can_not_entrant_be_converted()) { + nm->make_zombie(); + } else { + nm->make_not_entrant(); + } } } } @@ -730,31 +888,61 @@ void CodeCache::make_marked_nmethods_not_entrant() { assert_locked_or_safepoint(CodeCache_lock); - FOR_ALL_ALIVE_NMETHODS(nm) { - if (nm->is_marked_for_deoptimization()) { - nm->make_not_entrant(); + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_ALIVE_BLOBS(cb, *it) { + nmethod* nm = (nmethod*)cb; + if (nm->is_marked_for_deoptimization()) { + nm->make_not_entrant(); + } } } } void CodeCache::verify() { - _heap->verify(); - FOR_ALL_ALIVE_BLOBS(p) { - p->verify(); + assert_locked_or_safepoint(CodeCache_lock); + FOR_ALL_HEAPS(it) { + CodeHeap* heap = *it; + heap->verify(); + FOR_ALL_BLOBS(cb, heap) { + if (cb->is_alive()) { + cb->verify(); + } + } } } -void CodeCache::report_codemem_full() { +void CodeCache::report_codemem_full(int code_blob_type) { + // Get nmethod heap for the given CodeBlobType and build CodeCacheFull event + CodeHeap* heap = get_code_heap(code_blob_type); + + if (!heap->was_full()) { + // Not yet reported for this heap, report + heap->report_full(); + warning("CodeHeap for %s is full. Compilation for these methods has been delayed.", CodeCache::get_heap_name(code_blob_type)); + warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize="); + + ResourceMark rm; + stringStream s; + // Dump CodeCache summary into a buffer before locking the tty + { + MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); + print_summary(&s, true); + } + ttyLocker ttyl; + tty->print(s.as_string()); + } + _codemem_full_count++; EventCodeCacheFull event; if (event.should_commit()) { - event.set_startAddress((u8)low_bound()); - event.set_commitedTopAddress((u8)high()); - event.set_reservedTopAddress((u8)high_bound()); + event.set_codeBlobType(code_blob_type); + event.set_startAddress((u8)heap->low_boundary()); + event.set_commitedTopAddress((u8)heap->high()); + event.set_reservedTopAddress((u8)heap->high_boundary()); event.set_entryCount(nof_blobs()); event.set_methodCount(nof_nmethods()); event.set_adaptorCount(nof_adapters()); - event.set_unallocatedCapacity(unallocated_capacity()/K); + event.set_unallocatedCapacity(heap->unallocated_capacity()/K); event.set_fullCount(_codemem_full_count); event.commit(); } @@ -767,7 +955,9 @@ void CodeCache::verify_if_often() { if (VerifyCodeCacheOften) { - _heap->verify(); + FOR_ALL_HEAPS(it) { + (*it)->verify(); + } } } @@ -796,45 +986,50 @@ int maxCodeSize = 0; ResourceMark rm; - CodeBlob *cb; - for (cb = first(); cb != NULL; cb = next(cb)) { - total++; - if (cb->is_nmethod()) { - nmethod* nm = (nmethod*)cb; - - if (Verbose && nm->method() != NULL) { - ResourceMark rm; - char *method_name = nm->method()->name_and_sig_as_C_string(); - tty->print("%s", method_name); - if(nm->is_alive()) { tty->print_cr(" alive"); } - if(nm->is_not_entrant()) { tty->print_cr(" not-entrant"); } - if(nm->is_zombie()) { tty->print_cr(" zombie"); } - } + int i = 0; + FOR_ALL_HEAPS(it) { + if (Verbose) { + tty->print_cr("## Heap '%s' ##", (*it)->name()); + } + FOR_ALL_BLOBS(cb, *it) { + total++; + if (cb->is_nmethod()) { + nmethod* nm = (nmethod*)cb; + + if (Verbose && nm->method() != NULL) { + ResourceMark rm; + char *method_name = nm->method()->name_and_sig_as_C_string(); + tty->print("%s %d", method_name, nm->comp_level()); + if(nm->is_alive()) { tty->print_cr(" alive"); } + if(nm->is_not_entrant()) { tty->print_cr(" not-entrant"); } + if(nm->is_zombie()) { tty->print_cr(" zombie"); } + } - nmethodCount++; - - if(nm->is_alive()) { nmethodAlive++; } - if(nm->is_not_entrant()) { nmethodNotEntrant++; } - if(nm->is_zombie()) { nmethodZombie++; } - if(nm->is_unloaded()) { nmethodUnloaded++; } - if(nm->is_native_method()) { nmethodNative++; } + nmethodCount++; - if(nm->method() != NULL && nm->is_java_method()) { - nmethodJava++; - if (nm->insts_size() > maxCodeSize) { - maxCodeSize = nm->insts_size(); + if(nm->is_alive()) { nmethodAlive++; } + if(nm->is_not_entrant()) { nmethodNotEntrant++; } + if(nm->is_zombie()) { nmethodZombie++; } + if(nm->is_unloaded()) { nmethodUnloaded++; } + if(nm->method() != NULL && nm->is_native_method()) { nmethodNative++; } + + if(nm->method() != NULL && nm->is_java_method()) { + nmethodJava++; + if (nm->insts_size() > maxCodeSize) { + maxCodeSize = nm->insts_size(); + } } + } else if (cb->is_runtime_stub()) { + runtimeStubCount++; + } else if (cb->is_deoptimization_stub()) { + deoptimizationStubCount++; + } else if (cb->is_uncommon_trap_stub()) { + uncommonTrapStubCount++; + } else if (cb->is_adapter_blob()) { + adapterCount++; + } else if (cb->is_buffer_blob()) { + bufferBlobCount++; } - } else if (cb->is_runtime_stub()) { - runtimeStubCount++; - } else if (cb->is_deoptimization_stub()) { - deoptimizationStubCount++; - } else if (cb->is_uncommon_trap_stub()) { - uncommonTrapStubCount++; - } else if (cb->is_adapter_blob()) { - adapterCount++; - } else if (cb->is_buffer_blob()) { - bufferBlobCount++; } } @@ -843,10 +1038,10 @@ int *buckets = NEW_C_HEAP_ARRAY(int, bucketLimit, mtCode); memset(buckets,0,sizeof(int) * bucketLimit); - for (cb = first(); cb != NULL; cb = next(cb)) { - if (cb->is_nmethod()) { + FOR_ALL_METHOD_HEAPS(it) { + FOR_ALL_BLOBS(cb, *it) { nmethod* nm = (nmethod*)cb; - if(nm->is_java_method()) { + if(nm->method() != NULL && nm->is_java_method()) { buckets[nm->insts_size() / bucketSize]++; } } @@ -868,7 +1063,7 @@ tty->print_cr("\nnmethod size distribution (non-zombie java)"); tty->print_cr("-------------------------------------------------"); - for(int i=0; iprint("%d - %d bytes",i*bucketSize,(i+1)*bucketSize); tty->fill_to(40); @@ -890,11 +1085,13 @@ CodeBlob_sizes live; CodeBlob_sizes dead; - FOR_ALL_BLOBS(p) { - if (!p->is_alive()) { - dead.add(p); - } else { - live.add(p); + FOR_ALL_HEAPS(it) { + FOR_ALL_BLOBS(cb, *it) { + if (!cb->is_alive()) { + dead.add(cb); + } else { + live.add(cb); + } } } @@ -910,21 +1107,22 @@ dead.print("dead"); } - if (WizardMode) { // print the oop_map usage int code_size = 0; int number_of_blobs = 0; int number_of_oop_maps = 0; int map_size = 0; - FOR_ALL_BLOBS(p) { - if (p->is_alive()) { - number_of_blobs++; - code_size += p->code_size(); - OopMapSet* set = p->oop_maps(); - if (set != NULL) { - number_of_oop_maps += set->size(); - map_size += set->heap_size(); + FOR_ALL_HEAPS(it) { + FOR_ALL_BLOBS(cb, *it) { + if (cb->is_alive()) { + number_of_blobs++; + code_size += cb->code_size(); + OopMapSet* set = cb->oop_maps(); + if (set != NULL) { + number_of_oop_maps += set->size(); + map_size += set->heap_size(); + } } } } @@ -939,20 +1137,26 @@ } void CodeCache::print_summary(outputStream* st, bool detailed) { - size_t total = (_heap->high_boundary() - _heap->low_boundary()); - st->print_cr("CodeCache: size=" SIZE_FORMAT "Kb used=" SIZE_FORMAT - "Kb max_used=" SIZE_FORMAT "Kb free=" SIZE_FORMAT "Kb", - total/K, (total - unallocated_capacity())/K, - maxCodeCacheUsed/K, unallocated_capacity()/K); + st->print_cr("CodeCache Summary:"); + FOR_ALL_HEAPS(it) { + CodeHeap* heap = (*it); + size_t total = (heap->high_boundary() - heap->low_boundary()); + st->print_cr("Heap '%s': size=" SIZE_FORMAT "Kb used=" SIZE_FORMAT + "Kb max_used=" SIZE_FORMAT "Kb free=" SIZE_FORMAT "Kb", + heap->name(), total/K, (total - heap->unallocated_capacity())/K, + heap->max_allocated_capacity()/K, heap->unallocated_capacity()/K); + + if (detailed) { + st->print_cr(" bounds [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT "]", + heap->low_boundary(), + heap->high(), + heap->high_boundary()); + + } + } if (detailed) { - st->print_cr(" bounds [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT "]", - _heap->low_boundary(), - _heap->high(), - _heap->high_boundary()); - st->print_cr(" total_blobs=" UINT32_FORMAT " nmethods=" UINT32_FORMAT - " adapters=" UINT32_FORMAT, - nof_blobs(), nof_nmethods(), nof_adapters()); + log_state(st); st->print_cr(" compilation: %s", CompileBroker::should_compile_new_jobs() ? "enabled" : Arguments::mode() == Arguments::_int ? "disabled (interpreter mode)" : @@ -962,8 +1166,7 @@ void CodeCache::log_state(outputStream* st) { st->print(" total_blobs='" UINT32_FORMAT "' nmethods='" UINT32_FORMAT "'" - " adapters='" UINT32_FORMAT "' free_code_cache='" SIZE_FORMAT "'", - nof_blobs(), nof_nmethods(), nof_adapters(), - unallocated_capacity()); + " adapters='" UINT32_FORMAT "'", + nof_blobs(), nof_nmethods(), nof_adapters()); }