/* * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "precompiled.hpp" #include "compiler/compileBroker.hpp" #include "memory/heap.hpp" #include "oops/oop.inline.hpp" #include "runtime/os.hpp" #include "runtime/sweeper.hpp" #include "services/memTracker.hpp" #include "utilities/align.hpp" size_t CodeHeap::header_size() { return sizeof(HeapBlock); } // Implementation of Heap CodeHeap::CodeHeap(const char* name, const int code_blob_type) : _code_blob_type(code_blob_type) { _name = name; _number_of_committed_segments = 0; _number_of_reserved_segments = 0; _segment_size = 0; _log2_segment_size = 0; _next_segment = 0; _freelist = NULL; _freelist_segments = 0; _freelist_length = 0; _max_allocated_capacity = 0; _blob_count = 0; _nmethod_count = 0; _adapter_count = 0; _full_count = 0; } void CodeHeap::mark_segmap_as_free(size_t beg, size_t end) { assert( beg < _number_of_committed_segments, "interval begin out of bounds"); assert(beg < end && end <= _number_of_committed_segments, "interval end out of bounds"); // setup _segmap pointers for faster indexing address p = (address)_segmap.low() + beg; address q = (address)_segmap.low() + end; // initialize interval while (p < q) *p++ = free_sentinel; } void CodeHeap::mark_segmap_as_used(size_t beg, size_t end) { assert( beg < _number_of_committed_segments, "interval begin out of bounds"); assert(beg < end && end <= _number_of_committed_segments, "interval end out of bounds"); // setup _segmap pointers for faster indexing address p = (address)_segmap.low() + beg; address q = (address)_segmap.low() + end; // initialize interval int i = 0; while (p < q) { *p++ = i++; if (i == free_sentinel) i = 1; } } static size_t align_to_page_size(size_t size) { const size_t alignment = (size_t)os::vm_page_size(); assert(is_power_of_2(alignment), "no kidding ???"); return (size + alignment - 1) & ~(alignment - 1); } void CodeHeap::on_code_mapping(char* base, size_t size) { #ifdef LINUX extern void linux_wrap_code(char* base, size_t size); linux_wrap_code(base, size); #endif } bool CodeHeap::reserve(ReservedSpace rs, size_t committed_size, size_t segment_size) { assert(rs.size() >= committed_size, "reserved < committed"); assert(segment_size >= sizeof(FreeBlock), "segment size is too small"); assert(is_power_of_2(segment_size), "segment_size must be a power of 2"); _segment_size = segment_size; _log2_segment_size = exact_log2(segment_size); // Reserve and initialize space for _memory. size_t page_size = os::vm_page_size(); if (os::can_execute_large_page_memory()) { const size_t min_pages = 8; page_size = MIN2(os::page_size_for_region_aligned(committed_size, min_pages), os::page_size_for_region_aligned(rs.size(), min_pages)); } const size_t granularity = os::vm_allocation_granularity(); const size_t c_size = align_up(committed_size, page_size); os::trace_page_sizes(_name, committed_size, rs.size(), page_size, rs.base(), rs.size()); if (!_memory.initialize(rs, c_size)) { return false; } on_code_mapping(_memory.low(), _memory.committed_size()); _number_of_committed_segments = size_to_segments(_memory.committed_size()); _number_of_reserved_segments = size_to_segments(_memory.reserved_size()); assert(_number_of_reserved_segments >= _number_of_committed_segments, "just checking"); const size_t reserved_segments_alignment = MAX2((size_t)os::vm_page_size(), granularity); const size_t reserved_segments_size = align_up(_number_of_reserved_segments, reserved_segments_alignment); const size_t committed_segments_size = align_to_page_size(_number_of_committed_segments); // reserve space for _segmap if (!_segmap.initialize(reserved_segments_size, committed_segments_size)) { return false; } MemTracker::record_virtual_memory_type((address)_segmap.low_boundary(), mtCode); assert(_segmap.committed_size() >= (size_t) _number_of_committed_segments, "could not commit enough space for segment map"); assert(_segmap.reserved_size() >= (size_t) _number_of_reserved_segments , "could not reserve enough space for segment map"); assert(_segmap.reserved_size() >= _segmap.committed_size() , "just checking"); // initialize remaining instance variables clear(); return true; } bool CodeHeap::expand_by(size_t size) { // expand _memory space size_t dm = align_to_page_size(_memory.committed_size() + size) - _memory.committed_size(); if (dm > 0) { // Use at least the available uncommitted space if 'size' is larger if (_memory.uncommitted_size() != 0 && dm > _memory.uncommitted_size()) { dm = _memory.uncommitted_size(); } char* base = _memory.low() + _memory.committed_size(); if (!_memory.expand_by(dm)) return false; on_code_mapping(base, dm); size_t i = _number_of_committed_segments; _number_of_committed_segments = size_to_segments(_memory.committed_size()); assert(_number_of_reserved_segments == size_to_segments(_memory.reserved_size()), "number of reserved segments should not change"); assert(_number_of_reserved_segments >= _number_of_committed_segments, "just checking"); // expand _segmap space size_t ds = align_to_page_size(_number_of_committed_segments) - _segmap.committed_size(); if ((ds > 0) && !_segmap.expand_by(ds)) { return false; } assert(_segmap.committed_size() >= (size_t) _number_of_committed_segments, "just checking"); // initialize additional segmap entries mark_segmap_as_free(i, _number_of_committed_segments); } return true; } void CodeHeap::clear() { _next_segment = 0; mark_segmap_as_free(0, _number_of_committed_segments); } void* CodeHeap::allocate(size_t instance_size) { size_t number_of_segments = size_to_segments(instance_size + header_size()); assert(segments_to_size(number_of_segments) >= sizeof(FreeBlock), "not enough room for FreeList"); // First check if we can satisfy request from freelist NOT_PRODUCT(verify()); HeapBlock* block = search_freelist(number_of_segments); NOT_PRODUCT(verify()); if (block != NULL) { assert(block->length() >= number_of_segments && block->length() < number_of_segments + CodeCacheMinBlockLength, "sanity check"); assert(!block->free(), "must be marked free"); guarantee((char*) block >= _memory.low_boundary() && (char*) block < _memory.high(), "The newly allocated block " INTPTR_FORMAT " is not within the heap " "starting with " INTPTR_FORMAT " and ending with " INTPTR_FORMAT, p2i(block), p2i(_memory.low_boundary()), p2i(_memory.high())); DEBUG_ONLY(memset((void*)block->allocated_space(), badCodeHeapNewVal, instance_size)); _max_allocated_capacity = MAX2(_max_allocated_capacity, allocated_capacity()); _blob_count++; return block->allocated_space(); } // Ensure minimum size for allocation to the heap. number_of_segments = MAX2((int)CodeCacheMinBlockLength, (int)number_of_segments); if (_next_segment + number_of_segments <= _number_of_committed_segments) { mark_segmap_as_used(_next_segment, _next_segment + number_of_segments); HeapBlock* b = block_at(_next_segment); b->initialize(number_of_segments); _next_segment += number_of_segments; guarantee((char*) b >= _memory.low_boundary() && (char*) block < _memory.high(), "The newly allocated block " INTPTR_FORMAT " is not within the heap " "starting with " INTPTR_FORMAT " and ending with " INTPTR_FORMAT, p2i(b), p2i(_memory.low_boundary()), p2i(_memory.high())); DEBUG_ONLY(memset((void *)b->allocated_space(), badCodeHeapNewVal, instance_size)); _max_allocated_capacity = MAX2(_max_allocated_capacity, allocated_capacity()); _blob_count++; return b->allocated_space(); } else { return NULL; } } void CodeHeap::deallocate_tail(void* p, size_t used_size) { assert(p == find_start(p), "illegal deallocation"); // Find start of HeapBlock HeapBlock* b = (((HeapBlock *)p) - 1); assert(b->allocated_space() == p, "sanity check"); size_t used_number_of_segments = size_to_segments(used_size + header_size()); size_t actual_number_of_segments = b->length(); guarantee(used_number_of_segments <= actual_number_of_segments, "Must be!"); guarantee(b == block_at(_next_segment - actual_number_of_segments), "Intermediate allocation!"); size_t number_of_segments_to_deallocate = actual_number_of_segments - used_number_of_segments; _next_segment -= number_of_segments_to_deallocate; mark_segmap_as_free(_next_segment, _next_segment + number_of_segments_to_deallocate); b->initialize(used_number_of_segments); } void CodeHeap::deallocate(void* p) { assert(p == find_start(p), "illegal deallocation"); // Find start of HeapBlock HeapBlock* b = (((HeapBlock *)p) - 1); assert(b->allocated_space() == p, "sanity check"); guarantee((char*) b >= _memory.low_boundary() && (char*) b < _memory.high(), "The block to be deallocated " INTPTR_FORMAT " is not within the heap " "starting with " INTPTR_FORMAT " and ending with " INTPTR_FORMAT, p2i(b), p2i(_memory.low_boundary()), p2i(_memory.high())); DEBUG_ONLY(memset((void *)b->allocated_space(), badCodeHeapFreeVal, segments_to_size(b->length()) - sizeof(HeapBlock))); add_to_freelist(b); NOT_PRODUCT(verify()); } /** * Uses segment map to find the the start (header) of a nmethod. This works as follows: * The memory of the code cache is divided into 'segments'. The size of a segment is * determined by -XX:CodeCacheSegmentSize=XX. Allocation in the code cache can only * happen at segment boundaries. A pointer in the code cache can be mapped to a segment * by calling segment_for(addr). Each time memory is requested from the code cache, * the segmap is updated accordingly. See the following example, which illustrates the * state of code cache and the segment map: (seg -> segment, nm ->nmethod) * * code cache segmap * ----------- --------- * seg 1 | nm 1 | -> | 0 | * seg 2 | nm 1 | -> | 1 | * ... | nm 1 | -> | .. | * seg m | nm 2 | -> | 0 | * seg m+1 | nm 2 | -> | 1 | * ... | nm 2 | -> | 2 | * ... | nm 2 | -> | .. | * ... | nm 2 | -> | 0xFE | * seg m+n | nm 2 | -> | 1 | * ... | nm 2 | -> | | * * A value of '0' in the segmap indicates that this segment contains the beginning of * an nmethod. Let's walk through a simple example: If we want to find the start of * an nmethod that falls into seg 2, we read the value of the segmap[2]. The value * is an offset that points to the segment that contains the start of the nmethod. * Another example: If we want to get the start of nm 2, and we happen to get a pointer * that points to seg m+n, we first read seg[n+m], which returns '1'. So we have to * do one more read of the segmap[m+n-1] to finally get the segment header. */ void* CodeHeap::find_start(void* p) const { if (!contains(p)) { return NULL; } size_t seg_idx = segment_for(p); address seg_map = (address)_segmap.low(); if (is_segment_unused(seg_map[seg_idx])) { return NULL; } while (seg_map[seg_idx] > 0) { seg_idx -= (int)seg_map[seg_idx]; } HeapBlock* h = block_at(seg_idx); if (h->free()) { return NULL; } return h->allocated_space(); } CodeBlob* CodeHeap::find_blob_unsafe(void* start) const { CodeBlob* result = (CodeBlob*)CodeHeap::find_start(start); if (result != NULL && result->blob_contains((address)start)) { return result; } return NULL; } size_t CodeHeap::alignment_unit() const { // this will be a power of two return _segment_size; } size_t CodeHeap::alignment_offset() const { // The lowest address in any allocated block will be // equal to alignment_offset (mod alignment_unit). return sizeof(HeapBlock) & (_segment_size - 1); } // Returns the current block if available and used. // If not, it returns the subsequent block (if available), NULL otherwise. // Free blocks are merged, therefore there is at most one free block // between two used ones. As a result, the subsequent block (if available) is // guaranteed to be used. void* CodeHeap::next_used(HeapBlock* b) const { if (b != NULL && b->free()) b = next_block(b); assert(b == NULL || !b->free(), "must be in use or at end of heap"); return (b == NULL) ? NULL : b->allocated_space(); } // Returns the first used HeapBlock HeapBlock* CodeHeap::first_block() const { if (_next_segment > 0) return block_at(0); return NULL; } HeapBlock* CodeHeap::block_start(void* q) const { HeapBlock* b = (HeapBlock*)find_start(q); if (b == NULL) return NULL; return b - 1; } // Returns the next Heap block an offset into one HeapBlock* CodeHeap::next_block(HeapBlock *b) const { if (b == NULL) return NULL; size_t i = segment_for(b) + b->length(); if (i < _next_segment) return block_at(i); return NULL; } // Returns current capacity size_t CodeHeap::capacity() const { return _memory.committed_size(); } size_t CodeHeap::max_capacity() const { return _memory.reserved_size(); } int CodeHeap::allocated_segments() const { return (int)_next_segment; } size_t CodeHeap::allocated_capacity() const { // size of used heap - size on freelist return segments_to_size(_next_segment - _freelist_segments); } // Returns size of the unallocated heap block size_t CodeHeap::heap_unallocated_capacity() const { // Total number of segments - number currently used return segments_to_size(_number_of_reserved_segments - _next_segment); } // Free list management FreeBlock* CodeHeap::following_block(FreeBlock *b) { return (FreeBlock*)(((address)b) + _segment_size * b->length()); } // Inserts block b after a void CodeHeap::insert_after(FreeBlock* a, FreeBlock* b) { assert(a != NULL && b != NULL, "must be real pointers"); // Link b into the list after a b->set_link(a->link()); a->set_link(b); // See if we can merge blocks merge_right(b); // Try to make b bigger merge_right(a); // Try to make a include b } // Try to merge this block with the following block bool CodeHeap::merge_right(FreeBlock* a) { assert(a->free(), "must be a free block"); if (following_block(a) == a->link()) { assert(a->link() != NULL && a->link()->free(), "must be free too"); // Update block a to include the following block a->set_length(a->length() + a->link()->length()); a->set_link(a->link()->link()); // Update find_start map size_t beg = segment_for(a); mark_segmap_as_used(beg, beg + a->length()); _freelist_length--; return true; } return false; } void CodeHeap::add_to_freelist(HeapBlock* a) { FreeBlock* b = (FreeBlock*)a; _freelist_length++; assert(b != _freelist, "cannot be removed twice"); // Mark as free and update free space count _freelist_segments += b->length(); b->set_free(); // First element in list? if (_freelist == NULL) { _freelist = b; b->set_link(NULL); return; } // Since the freelist is ordered (smaller addresses -> larger addresses) and the // element we want to insert into the freelist has a smaller address than the first // element, we can simply add 'b' as the first element and we are done. if (b < _freelist) { // Insert first in list b->set_link(_freelist); _freelist = b; merge_right(_freelist); return; } // Scan for right place to put into list. List // is sorted by increasing addresses FreeBlock* prev = _freelist; FreeBlock* cur = _freelist->link(); while(cur != NULL && cur < b) { assert(prev < cur, "Freelist must be ordered"); prev = cur; cur = cur->link(); } assert((prev < b) && (cur == NULL || b < cur), "free-list must be ordered"); insert_after(prev, b); } /** * Search freelist for an entry on the list with the best fit. * @return NULL, if no one was found */ FreeBlock* CodeHeap::search_freelist(size_t length) { FreeBlock* found_block = NULL; FreeBlock* found_prev = NULL; size_t found_length = 0; FreeBlock* prev = NULL; FreeBlock* cur = _freelist; // Search for first block that fits while(cur != NULL) { if (cur->length() >= length) { // Remember block, its previous element, and its length found_block = cur; found_prev = prev; found_length = found_block->length(); break; } // Next element in list prev = cur; cur = cur->link(); } if (found_block == NULL) { // None found return NULL; } // Exact (or at least good enough) fit. Remove from list. // Don't leave anything on the freelist smaller than CodeCacheMinBlockLength. if (found_length - length < CodeCacheMinBlockLength) { _freelist_length--; length = found_length; if (found_prev == NULL) { assert(_freelist == found_block, "sanity check"); _freelist = _freelist->link(); } else { assert((found_prev->link() == found_block), "sanity check"); // Unmap element found_prev->set_link(found_block->link()); } } else { // Truncate block and return a pointer to the following block // Set used bit and length on new block found_block->set_length(found_length - length); found_block = following_block(found_block); size_t beg = segment_for(found_block); mark_segmap_as_used(beg, beg + length); found_block->set_length(length); } found_block->set_used(); _freelist_segments -= length; return found_block; } //---------------------------------------------------------------------------- // Non-product code #ifndef PRODUCT void CodeHeap::print() { tty->print_cr("The Heap"); } void CodeHeap::verify() { if (VerifyCodeCache) { size_t len = 0; int count = 0; for(FreeBlock* b = _freelist; b != NULL; b = b->link()) { len += b->length(); count++; // Check if we have merged all free blocks assert(merge_right(b) == false, "Missed merging opportunity"); } // Verify that freelist contains the right amount of free space assert(len == _freelist_segments, "wrong freelist"); for(HeapBlock* h = first_block(); h != NULL; h = next_block(h)) { if (h->free()) count--; } // Verify that the freelist contains the same number of blocks // than free blocks found on the full list. assert(count == 0, "missing free blocks"); // Verify that the number of free blocks is not out of hand. static int free_block_threshold = 10000; if (count > free_block_threshold) { warning("CodeHeap: # of free blocks > %d", free_block_threshold); // Double the warning limit free_block_threshold *= 2; } } } #endif //---< BEGIN >--- 8198691: CodeHeap State Analytics. // // With this declaration macro, it is possible to switch between // - direct output into an argument-passed outputStream and // - buffered output into a bufferedStream with subsequent flush // of the filled buffer to the outputStream. #define USE_STRINGSTREAM #define HEX32_FORMAT "0x%x" // just a helper format string used below multiple times // // Writing to a bufferedStream buffer first has a significant advantage: // It uses noticeably less cpu cycles and reduces (when wirting to a // network file) the required bandwidth by at least a factor of ten. // That clearly makes up for the increased code complexity. #if defined(USE_STRINGSTREAM) #define STRINGSTREAM_DECL(_anyst, _outst) \ /* _anyst name of the stream as used in the code */ \ /* _outst stream where final output will go to */ \ ResourceMark rm; \ bufferedStream _sstobj = bufferedStream(2*K); \ bufferedStream* _sstbuf = &_sstobj; \ outputStream* _outbuf = _outst; \ bufferedStream* _anyst = &_sstobj; /* any stream. Use this to just print - no buffer flush. */ #define STRINGSTREAM_FLUSH(termString) \ _sstbuf->print("%s", termString); \ _outbuf->print("%s", _sstbuf->as_string()); \ _sstbuf->reset(); #else #define STRINGSTREAM_DECL(_anyst, _outst) \ outputStream* _outbuf = _outst; \ outputStream* _anyst = _outst; /* any stream. Use this to just print - no buffer flush. */ #define STRINGSTREAM_FLUSH(termString) \ _outbuf->print("%s", termString); #endif const char blobTypeChar[] = {' ', 'N', 'I', 'X', 'Z', 'U', 'R', '?', 'D', 'T', 'E', 'S', 'A', 'M', 'B', 'L' }; const char* blobTypeName[] = {"noType" , "nMethod (active)" , "nMethod (inactive)" , "nMethod (deopt)" , "nMethod (zombie)" , "nMethod (unloaded)" , "runtime stub" , "ricochet stub" , "deopt stub" , "uncommon trap stub" , "exception stub" , "safepoint stub" , "adapter blob" , "MH adapter blob" , "buffer blob" , "lastType" }; const char* compTypeName[] = { "none", "c1", "c2", "jvmci" }; //---------------- // StatElement //---------------- // Each analysis granule is represented by an instance of // this StatElement struct. It collects and aggregates all // information describing the allocated contents of the granule. // Free (unallocated) contents is not considered (see FreeBlk for that). // All StatElements of a heap segment are stored in the related StatArray. // Current size: 40 bytes + 8 bytes class header. class StatElement : public CHeapObj { public: // A note on ages: The compilation_id easily overflows unsigned short in large systems unsigned int t1_age; // oldest compilation_id of tier1 nMethods. unsigned int t2_age; // oldest compilation_id of tier2 nMethods. unsigned int tx_age; // oldest compilation_id of inactive/not entrant nMethods. unsigned short t1_space; // in units of _segment_size to "prevent" overflow unsigned short t2_space; // in units of _segment_size to "prevent" overflow unsigned short tx_space; // in units of _segment_size to "prevent" overflow unsigned short dead_space; // in units of _segment_size to "prevent" overflow unsigned short stub_space; // in units of _segment_size to "prevent" overflow unsigned short t1_count; unsigned short t2_count; unsigned short tx_count; unsigned short dead_count; unsigned short stub_count; CompLevel level; // optimization level (see globalDefinitions.hpp) //---< replaced the correct enum typing with u2 to save space. u2 compiler; // compiler which generated this blob u2 type; // used only if granularity == segment_size // CodeHeap::compType compiler; // compiler which generated this blob // CodeHeap::blobType type; // used only if granularity == segment_size }; //----------- // FreeBlk //----------- // Each free block in the code heap is represented by an instance // of this FreeBlk struct. It collects all information we need to // know about each free block. // All FreeBlks of a heap segment are stored in the related FreeArray. struct FreeBlk : public CHeapObj { HeapBlock *start; // address of free block unsigned int len; // length of free block unsigned int gap; // gap to next free block unsigned int index; // sequential number of free block unsigned short n_gapBlocks; // # used blocks in gap bool stubs_in_gap; // The occupied space between this and the next free block contains (unmovable) stubs or blobs. }; //-------------- // TopSizeBlk //-------------- // The n largest blocks in the code heap are represented in an instance // of this TopSizeBlk struct. It collects all information we need to // know about those largest blocks. // All TopSizeBlks of a heap segment are stored in the related TopSizeArray. struct TopSizeBlk : public CHeapObj { HeapBlock *start; // address of block unsigned int len; // length of block, in _segment_size units. Will never overflow int. unsigned int index; // ordering index, 0 is largest block // contains array index of next smaller block // -1 indicates end of list CompLevel level; // optimization level (see globalDefinitions.hpp) u2 compiler; // compiler which generated this blob u2 type; // blob type }; //--------------------------- // SizeDistributionElement //--------------------------- // During CodeHeap analysis, each allocated code block is associated with a // SizeDistributionElement according to its size. Later on, the array of // SizeDistributionElements is used to print a size distribution bar graph. // All SizeDistributionElements of a heap segment are stored in the related SizeDistributionArray. struct SizeDistributionElement : public CHeapObj { // Range is [rangeStart..rangeEnd). unsigned int rangeStart; // start of length range, in _segment_size units. unsigned int rangeEnd; // end of length range, in _segment_size units. unsigned int lenSum; // length of block, in _segment_size units. Will never overflow int. unsigned int count; // number of blocks assigned to this range. }; //---------------- // CodeHeapStat //---------------- // Because we have to deal with multiple CodeHeaps, we need to // collect "global" information in a segment-specific way as well. // Thats what the CodeHeapStat and CodeHeapStatArray are used for. // Before a heap segment is processed, the contents of the CodeHeapStat // element is copied to the global variables (get_HeapStatGlobals). // When processing is done, the possibly modified global variables are // copied back (set_HeapStatGlobals) to the CodeHeapStat element. struct CodeHeapStat { // struct StatElement *StatArray; StatElement *StatArray; struct FreeBlk *FreeArray; struct TopSizeBlk *TopSizeArray; struct SizeDistributionElement *SizeDistributionArray; const char *heapName; // StatElement data size_t alloc_granules; size_t granule_size; bool segment_granules; unsigned int nBlocks_t1; unsigned int nBlocks_t2; unsigned int nBlocks_alive; unsigned int nBlocks_dead; unsigned int nBlocks_unloaded; unsigned int nBlocks_stub; // FreeBlk data unsigned int alloc_freeBlocks; // UsedBlk data unsigned int alloc_topSizeBlocks; unsigned int used_topSizeBlocks; // method hotness data. Temperature range is [-reset_val..+reset_val] int avgTemp; int maxTemp; int minTemp; }; // Be prepared for ten different Code Heaps. Should be enough for a few years. const unsigned int nSizeDistElements = 31; // logarithmic range growth, max size: 2**32 const unsigned int maxTopSizeBlocks = 50; const unsigned int tsbStopper = 2*maxTopSizeBlocks; const unsigned int maxHeaps = 10; static unsigned int nHeaps = 0; static struct CodeHeapStat CodeHeapStatArray[maxHeaps]; // static struct StatElement *StatArray = NULL; static StatElement *StatArray = NULL; static size_t alloc_granules = 0; static size_t granule_size = 0; static bool segment_granules = false; static unsigned int nBlocks_t1 = 0; // counting "in_use" nmethods only. static unsigned int nBlocks_t2 = 0; // counting "in_use" nmethods only. static unsigned int nBlocks_alive = 0; // counting "not_used" and "not_entrant" nmethods only. static unsigned int nBlocks_dead = 0; // counting "zombie" and "unloaded" methods only. static unsigned int nBlocks_unloaded = 0; // counting "unloaded" nmethods only. This is a transien state. static unsigned int nBlocks_stub = 0; static struct FreeBlk *FreeArray = NULL; static unsigned int alloc_freeBlocks = 0; static struct TopSizeBlk *TopSizeArray = NULL; static unsigned int alloc_topSizeBlocks = 0; static unsigned int used_topSizeBlocks = 0; static struct SizeDistributionElement *SizeDistributionArray = NULL; // nMethod temperature (hotness) indicators. static int avgTemp = 0; static int maxTemp = 0; static int minTemp = 0; static unsigned int latest_compilation_id = 0; static volatile bool initialization_complete = false; const char* CodeHeap::get_heapName() { if (SegmentedCodeCache) return name(); else return "CodeHeap"; } // returns the index to be used for the heap being processed. // < nHeaps: entry found. Use this index. // == nHeaps: entry not found. Use this index for new entry. // == maxHeaps: entry not found. No space for a new entry. unsigned int CodeHeap::findHeapIndex(outputStream *out, const char *heapName) { if (SegmentedCodeCache) { unsigned int ix = 0; while ( (ix < nHeaps) && ((CodeHeapStatArray[ix].heapName == NULL) || strcmp(heapName, CodeHeapStatArray[ix].heapName)) ) { ix++; } if (ix < nHeaps) { // existing entry found return ix; } if ((ix == nHeaps) && (nHeaps < maxHeaps)) { // new entry allocated nHeaps++; CodeHeapStatArray[ix].heapName = heapName; return ix; } out->print_cr("Too many heap segments, please adapt maxHeaps in heap.cpp"); return maxHeaps; } else { nHeaps = 1; CodeHeapStatArray[0].heapName = heapName; return 0; // This is the default index if CodeCache is not segmented. } } void CodeHeap::get_HeapStatGlobals(outputStream *out, const char *heapName) { unsigned int ix = (heapName == NULL) ? maxHeaps : findHeapIndex(out, heapName); // Coverity CID 696443 - also check for index being smaller than maxHeaps. // This coverity finding is bullshit. Looking at the implementation // of findHeapIndex(), we learn that nHeaps will never grow beyond maxHeaps, // making (ix < nHeaps) a safe check. // But anyway, making coverity happy is more important than correct code. if ((ix < nHeaps) && (ix < maxHeaps)) { StatArray = CodeHeapStatArray[ix].StatArray; alloc_granules = CodeHeapStatArray[ix].alloc_granules; granule_size = CodeHeapStatArray[ix].granule_size; segment_granules = CodeHeapStatArray[ix].segment_granules; nBlocks_t1 = CodeHeapStatArray[ix].nBlocks_t1; nBlocks_t2 = CodeHeapStatArray[ix].nBlocks_t2; nBlocks_alive = CodeHeapStatArray[ix].nBlocks_alive; nBlocks_dead = CodeHeapStatArray[ix].nBlocks_dead; nBlocks_unloaded = CodeHeapStatArray[ix].nBlocks_unloaded; nBlocks_stub = CodeHeapStatArray[ix].nBlocks_stub; FreeArray = CodeHeapStatArray[ix].FreeArray; alloc_freeBlocks = CodeHeapStatArray[ix].alloc_freeBlocks; TopSizeArray = CodeHeapStatArray[ix].TopSizeArray; alloc_topSizeBlocks = CodeHeapStatArray[ix].alloc_topSizeBlocks; used_topSizeBlocks = CodeHeapStatArray[ix].used_topSizeBlocks; SizeDistributionArray = CodeHeapStatArray[ix].SizeDistributionArray; avgTemp = CodeHeapStatArray[ix].avgTemp; maxTemp = CodeHeapStatArray[ix].maxTemp; minTemp = CodeHeapStatArray[ix].minTemp; } else { StatArray = NULL; alloc_granules = 0; granule_size = 0; segment_granules = false; nBlocks_t1 = 0; nBlocks_t2 = 0; nBlocks_alive = 0; nBlocks_dead = 0; nBlocks_unloaded = 0; nBlocks_stub = 0; FreeArray = NULL; alloc_freeBlocks = 0; TopSizeArray = NULL; alloc_topSizeBlocks = 0; used_topSizeBlocks = 0; SizeDistributionArray = NULL; avgTemp = 0; maxTemp = 0; minTemp = 0; } } void CodeHeap::set_HeapStatGlobals(outputStream *out, const char *heapName) { unsigned int ix = (heapName == NULL) ? maxHeaps : findHeapIndex(out, heapName); if (ix < nHeaps) { CodeHeapStatArray[ix].StatArray = StatArray; CodeHeapStatArray[ix].alloc_granules = alloc_granules; CodeHeapStatArray[ix].granule_size = granule_size; CodeHeapStatArray[ix].segment_granules = segment_granules; CodeHeapStatArray[ix].nBlocks_t1 = nBlocks_t1; CodeHeapStatArray[ix].nBlocks_t2 = nBlocks_t2; CodeHeapStatArray[ix].nBlocks_alive = nBlocks_alive; CodeHeapStatArray[ix].nBlocks_dead = nBlocks_dead; CodeHeapStatArray[ix].nBlocks_unloaded = nBlocks_unloaded; CodeHeapStatArray[ix].nBlocks_stub = nBlocks_stub; CodeHeapStatArray[ix].FreeArray = FreeArray; CodeHeapStatArray[ix].alloc_freeBlocks = alloc_freeBlocks; CodeHeapStatArray[ix].TopSizeArray = TopSizeArray; CodeHeapStatArray[ix].alloc_topSizeBlocks = alloc_topSizeBlocks; CodeHeapStatArray[ix].used_topSizeBlocks = used_topSizeBlocks; CodeHeapStatArray[ix].SizeDistributionArray = SizeDistributionArray; CodeHeapStatArray[ix].avgTemp = avgTemp; CodeHeapStatArray[ix].maxTemp = maxTemp; CodeHeapStatArray[ix].minTemp = minTemp; } } //---< get a new statistics array >--- void CodeHeap::prepare_StatArray(outputStream *out, size_t nElem, size_t granularity, const char* heapName) { if (StatArray == NULL) { StatArray = new StatElement[nElem]; //---< reset some counts >--- alloc_granules = nElem; granule_size = granularity; } if (StatArray == NULL) { //---< just do nothing if allocation failed >--- out->print_cr("Statistics could not be collected for %s, probably out of memory.", heapName); out->print_cr("Current granularity is " SIZE_FORMAT " bytes. Try a coarser granularity.", granularity); alloc_granules = 0; granule_size = 0; } else { //---< initialize statistics array >--- memset(StatArray, 0, nElem*sizeof(StatElement)); } } //---< get a new free block array >--- void CodeHeap::prepare_FreeArray(outputStream *out, unsigned int nElem, const char* heapName) { if (FreeArray == NULL) { FreeArray = new FreeBlk[nElem]; //---< reset some counts >--- alloc_freeBlocks = nElem; } if (FreeArray == NULL) { //---< just do nothing if allocation failed >--- out->print_cr("Free space analysis cannot be done for %s, probably out of memory.", heapName); alloc_freeBlocks = 0; } else { //---< initialize free block array >--- memset(FreeArray, 0, alloc_freeBlocks*sizeof(FreeBlk)); } } //---< get a new TopSizeArray >--- void CodeHeap::prepare_TopSizeArray(outputStream *out, unsigned int nElem, const char* heapName) { if (TopSizeArray == NULL) { TopSizeArray = new TopSizeBlk[nElem]; //---< reset some counts >--- alloc_topSizeBlocks = nElem; used_topSizeBlocks = 0; } if (TopSizeArray == NULL) { //---< just do nothing if allocation failed >--- out->print_cr("Top-%d list of largest CodeHeap blocks can not be collected for %s, probably out of memory.", nElem, heapName); alloc_topSizeBlocks = 0; } else { //---< initialize TopSizeArray >--- memset(TopSizeArray, 0, nElem*sizeof(TopSizeBlk)); used_topSizeBlocks = 0; } } //---< get a new SizeDistributionArray >--- void CodeHeap::prepare_SizeDistArray(outputStream *out, unsigned int nElem, const char* heapName) { if (SizeDistributionArray == NULL) { SizeDistributionArray = new SizeDistributionElement[nElem]; } if (SizeDistributionArray == NULL) { //---< just do nothing if allocation failed >--- out->print_cr("Size distribution can not be collected for %s, probably out of memory.", heapName); } else { //---< initialize SizeDistArray >--- memset(SizeDistributionArray, 0, nElem*sizeof(SizeDistributionElement)); // Logarithmic range growth. First range starts at _segment_size. SizeDistributionArray[_log2_segment_size-1].rangeEnd = 1U; for (unsigned int i = _log2_segment_size; i < nElem; i++) { SizeDistributionArray[i].rangeStart = 1U << (i - _log2_segment_size); SizeDistributionArray[i].rangeEnd = 1U << ((i+1) - _log2_segment_size); } } } //---< get a new SizeDistributionArray >--- void CodeHeap::update_SizeDistArray(outputStream *out, unsigned int len) { if (SizeDistributionArray != NULL) { for (unsigned int i = _log2_segment_size-1; i < nSizeDistElements; i++) { if ((SizeDistributionArray[i].rangeStart <= len) && (len < SizeDistributionArray[i].rangeEnd)) { SizeDistributionArray[i].lenSum += len; SizeDistributionArray[i].count++; break; } } } } void CodeHeap::discard_StatArray(outputStream *out) { if (StatArray != NULL) { delete StatArray; StatArray = NULL; alloc_granules = 0; granule_size = 0; } } void CodeHeap::discard_FreeArray(outputStream *out) { if (FreeArray != NULL) { delete[] FreeArray; FreeArray = NULL; alloc_freeBlocks = 0; } } void CodeHeap::discard_TopSizeArray(outputStream *out) { if (TopSizeArray != NULL) { delete[] TopSizeArray; TopSizeArray = NULL; alloc_topSizeBlocks = 0; used_topSizeBlocks = 0; } } void CodeHeap::discard_SizeDistArray(outputStream *out) { if (SizeDistributionArray != NULL) { delete[] SizeDistributionArray; SizeDistributionArray = NULL; } } void CodeHeap::discard(outputStream *out) { if (!initialization_complete) return; if (SegmentedCodeCache) { for (unsigned int ix = 0; ix < nHeaps; ix++) { get_HeapStatGlobals(out, CodeHeapStatArray[ix].heapName); discard_StatArray(out); discard_FreeArray(out); discard_TopSizeArray(out); discard_SizeDistArray(out); set_HeapStatGlobals(out, CodeHeapStatArray[ix].heapName); CodeHeapStatArray[ix].heapName = NULL; } } else { get_HeapStatGlobals(out, CodeHeapStatArray[0].heapName); discard_StatArray(out); discard_FreeArray(out); discard_TopSizeArray(out); discard_SizeDistArray(out); set_HeapStatGlobals(out, CodeHeapStatArray[0].heapName); CodeHeapStatArray[0].heapName = NULL; } } void CodeHeap::aggregate(outputStream *out, const char* granularity_request) { unsigned int nBlocks_free = 0; unsigned int nBlocks_used = 0; unsigned int nBlocks_zomb = 0; unsigned int nBlocks_disconn = 0; unsigned int nBlocks_notentr = 0; //---< max & min of TopSizeArray >--- // it is sufficient to have these sizes as 32bit unsigned ints. // The CodeHeap is limited in size to 4GB. Furthermore, the sizes // are stored in _segment_size units, scaling them down by a factor of 64 (at least). unsigned int currMax = 0; unsigned int currMin = 0; unsigned int currMin_ix = 0; unsigned long total_iterations = 0; bool done = false; const int min_granules = 256; const int max_granules = 512*K; // limits analyzable CodeHeap (with segment_granules) to 32M..128M // results in StatArray size of 20M (= max_granules * 40 Bytes per element) // For a 1GB CodeHeap, the granule size must be at least 2kB to not violate the max_granles limit. const char *heapName = get_heapName(); if (!initialization_complete) { memset(CodeHeapStatArray, 0, sizeof(CodeHeapStatArray)); initialization_complete = true; printBox(out, '=', "C O D E H E A P A N A L Y S I S (general remarks)", NULL); out->print_cr(" The code heap analysis function provides deep insights into\n" " the inner workings and the internal state of the Java VM's\n" " code cache - the place where all the JVM generated machine\n" " code is stored.\n" " \n" " This function is designed and provided for support engineers\n" " to help them understand and solve issues in customer systems.\n" " It is not intended for use and interpretation by other persons.\n" " \n"); } get_HeapStatGlobals(out, heapName); // Since we are (and must be) analyzing the CodeHeap contents under the CodeCache_lock, // all heap information is "constant" and can be safely extracted/calculated before we // enter the while() loop. Actually, the loop will only be iterated once. char* low_bound = low_boundary(); size_t size = capacity(); size_t res_size = max_capacity(); // Calculate granularity of analysis (and output). // The CodeHeap is managed (allocated) in segments (units) of CodeCacheSegmentSize. // The CodeHeap can become fairly large, in particular in productive real-life systems. // // It is often neither feasible nor desirable to aggregate the data with the highest possible // level of detail, i.e. inspecting and printing each segment on its own. // // The granularity parameter allows to specify the level of detail available in the analysis. // It must be a positive multiple of the segment size and should be selected such that enough // detail is provided while, at the same time, the printed output does not explode. // // By manipulating the granularity value, we enforce that at least min_granules units // of analysis are available. We also enforce an upper limit of max_granules units to // keep the amount of allocated storage in check. // // Finally, we adjust the granularity such that each granule covers at most 64k-1 segments. // This is necessary to prevent an unsigned short overflow while accumulating space information. // size_t granularity = strtol(granularity_request, NULL, 0); if (granularity > size) granularity = size; if (size/granularity < min_granules) granularity = size/min_granules; // at least min_granules granules granularity = granularity & (~(_segment_size - 1)); // must be multiple of _segment_size if (granularity < _segment_size) granularity = _segment_size; // must be at least _segment_size if (size/granularity > max_granules) granularity = size/max_granules; // at most max_granules granules granularity = granularity & (~(_segment_size - 1)); // must be multiple of _segment_size if (granularity>>_log2_segment_size >= (1L<--- prepare_StatArray(out, granules, granularity, heapName); if (StatArray == NULL) { set_HeapStatGlobals(out, heapName); return; } prepare_TopSizeArray(out, maxTopSizeBlocks, heapName); prepare_SizeDistArray(out, nSizeDistElements, heapName); latest_compilation_id = CompileBroker::get_compilation_id(); unsigned int highest_compilation_id = 0; size_t usedSpace = 0; size_t t1Space = 0; size_t t2Space = 0; size_t aliveSpace = 0; size_t disconnSpace = 0; size_t notentrSpace = 0; size_t deadSpace = 0; size_t unloadedSpace = 0; size_t stubSpace = 0; size_t freeSpace = 0; size_t maxFreeSize = 0; HeapBlock* maxFreeBlock = NULL; bool insane = false; int64_t hotnessAccumulator = 0; unsigned int n_methods = 0; avgTemp = 0; minTemp = (int)(res_size > M ? (res_size/M)*2 : 1); maxTemp = -minTemp; for (HeapBlock *h = first_block(); h != NULL && !insane; h = next_block(h)) { unsigned int hb_len = (unsigned int)h->length(); // despite being size_t, length can never overflow an unsigned int. size_t hb_bytelen = ((size_t)hb_len)<<_log2_segment_size; unsigned int ix_beg = (unsigned int)(((char*)h-low_bound)/granule_size); unsigned int ix_end = (unsigned int)(((char*)h-low_bound+(hb_bytelen-1))/granule_size); unsigned int compile_id = 0; CompLevel comp_lvl = CompLevel_none; compType cType = noComp; blobType cbType = noType; //---< some sanity checks >--- // Do not assert here, just check, print error message and return. // This is a diagnostic function. It is not supposed to tear down the VM. if ((char*)h < low_bound ) { insane = true; out->print_cr("Sanity check: HeapBlock @%p below low bound (%p)", (char*)h, low_bound); } if (ix_end >= granules ) { insane = true; out->print_cr("Sanity check: end index (%d) out of bounds (" SIZE_FORMAT ")", ix_end, granules); } if (size != capacity()) { insane = true; out->print_cr("Sanity check: code heap capacity has changed (" SIZE_FORMAT "K to " SIZE_FORMAT "K)", size/(size_t)K, capacity()/(size_t)K); } if (ix_beg > ix_end ) { insane = true; out->print_cr("Sanity check: end index (%d) lower than begin index (%d)", ix_end, ix_beg); } if (insane) continue; if (h->free()) { nBlocks_free++; freeSpace += hb_bytelen; if (hb_bytelen > maxFreeSize) { maxFreeSize = hb_bytelen; maxFreeBlock = h; } } else { update_SizeDistArray(out, hb_len); nBlocks_used++; usedSpace += hb_bytelen; CodeBlob *cb = (CodeBlob*) find_start(h); if (cb != NULL) { cbType = get_cbType(cb); if (cb->is_nmethod()) { compile_id = ((nmethod*)cb)->compile_id(); comp_lvl = (CompLevel)((nmethod*)cb)->comp_level(); if (((nmethod*)cb)->is_compiled_by_c1()) cType = c1; if (((nmethod*)cb)->is_compiled_by_c2()) cType = c2; if (((nmethod*)cb)->is_compiled_by_jvmci()) cType = jvmci; switch (cbType) { case nMethod_inuse: { // only for executable methods!!! // space for these cbs is accounted for later. int temperature = ((nmethod*)cb)->hotness_counter(); hotnessAccumulator += temperature; n_methods++; maxTemp = (temperature > maxTemp) ? temperature : maxTemp; minTemp = (temperature < minTemp) ? temperature : minTemp; break; } case nMethod_notused: nBlocks_alive++; nBlocks_disconn++; aliveSpace += hb_bytelen; disconnSpace += hb_bytelen; break; case nMethod_notentrant: // equivalent to nMethod_alive nBlocks_alive++; nBlocks_notentr++; aliveSpace += hb_bytelen; notentrSpace += hb_bytelen; break; case nMethod_unloaded: nBlocks_unloaded++; unloadedSpace += hb_bytelen; break; case nMethod_dead: nBlocks_dead++; deadSpace += hb_bytelen; break; default: break; } } //------------------------------------------ //---< register block in TopSizeArray >--- //------------------------------------------ if (alloc_topSizeBlocks > 0) { if (used_topSizeBlocks == 0) { TopSizeArray[0].start = h; TopSizeArray[0].len = hb_len; TopSizeArray[0].index = tsbStopper; TopSizeArray[0].compiler = cType; TopSizeArray[0].level = comp_lvl; TopSizeArray[0].type = cbType; currMax = hb_len; currMin = hb_len; currMin_ix = 0; // out->print_cr("usedTSB = %d, ix = %d, len = %d, next_ix = %d, next_len = %d", 0, 0, hb_len, TopSizeArray[0].index, TopSizeArray[0].index >= 0 ? TopSizeArray[TopSizeArray[0].index].len : -1); used_topSizeBlocks++; // This check roughly cuts 5000 iterations (JVM98, mixed, dbg, termination stats): } else if ((used_topSizeBlocks < alloc_topSizeBlocks) && (hb_len < currMin)) { //---< all blocks in list are larger, but there is room left in array >--- TopSizeArray[currMin_ix].index = used_topSizeBlocks; TopSizeArray[used_topSizeBlocks].start = h; TopSizeArray[used_topSizeBlocks].len = hb_len; TopSizeArray[used_topSizeBlocks].index = tsbStopper; TopSizeArray[used_topSizeBlocks].compiler = cType; TopSizeArray[used_topSizeBlocks].level = comp_lvl; TopSizeArray[used_topSizeBlocks].type = cbType; currMin = hb_len; currMin_ix = used_topSizeBlocks; // out->print_cr("usedTSB = %d, ix = %d, len = %d, next_ix = %d, next_len = %d (app MIN)", used_topSizeBlocks, used_topSizeBlocks, hb_len, TopSizeArray[used_topSizeBlocks].index, TopSizeArray[used_topSizeBlocks].index >= 0 ? TopSizeArray[TopSizeArray[used_topSizeBlocks].index].len : -1); used_topSizeBlocks++; } else { // This check cuts total_iterations by a factor of 6 (JVM98, mixed, dbg, termination stats): // We don't need to search the list if we know beforehand that the current block size is // smaller than the currently recorded minimum and there is no free entry left in the list. if (!((used_topSizeBlocks == alloc_topSizeBlocks) && (hb_len <= currMin))) { if (currMax < hb_len) { currMax = hb_len; } unsigned int i; unsigned int prev_i = tsbStopper; unsigned int limit_i = 0; for (i = 0; i != tsbStopper; i = TopSizeArray[i].index) { if (limit_i++ >= alloc_topSizeBlocks) { insane = true; break; } // emergency exit if ( i >= used_topSizeBlocks) { insane = true; break; } // emergency exit total_iterations++; if (TopSizeArray[i].len < hb_len) { //---< We want to insert here, element is smaller than the current one >--- if (used_topSizeBlocks < alloc_topSizeBlocks) { // still room for a new entry to insert // old entry gets moved to the next free element of the array. // That's necessary to keep the entry for the largest block at index 0. // This move might cause the current minimum to be moved to another place if (i == currMin_ix) { assert(TopSizeArray[i].len == currMin, "sort error"); currMin_ix = used_topSizeBlocks; } memcpy(&TopSizeArray[used_topSizeBlocks], &TopSizeArray[i], sizeof(TopSizeBlk)); TopSizeArray[i].start = h; TopSizeArray[i].len = hb_len; TopSizeArray[i].index = used_topSizeBlocks; TopSizeArray[i].compiler = cType; TopSizeArray[i].level = comp_lvl; TopSizeArray[i].type = cbType; // out->print_cr("usedTSB = %d, ix = %d, len = %d, next_ix = %d, next_len = %d (new APP)", used_topSizeBlocks, i, hb_len, TopSizeArray[i].index, TopSizeArray[i].index >= 0 ? TopSizeArray[TopSizeArray[i].index].len : -1); used_topSizeBlocks++; } else { // no room for new entries, current block replaces entry for smallest block //---< Find last entry (entry for smallest remembered block) >--- unsigned int j = i; unsigned int prev_j = tsbStopper; unsigned int limit_j = 0; while (TopSizeArray[j].index != tsbStopper) { if (limit_j++ >= alloc_topSizeBlocks) { insane = true; break; } // emergency exit if ( j >= used_topSizeBlocks) { insane = true; break; } // emergency exit total_iterations++; prev_j = j; j = TopSizeArray[j].index; } if (!insane) { if (prev_j == tsbStopper) { //---< Above while loop did not iterate, we already are the min entry >--- //---< We have to just replace the smallest entry >--- currMin = hb_len; currMin_ix = j; TopSizeArray[j].start = h; TopSizeArray[j].len = hb_len; TopSizeArray[j].index = tsbStopper; // already set!! TopSizeArray[j].compiler = cType; TopSizeArray[j].level = comp_lvl; TopSizeArray[j].type = cbType; // out->print_cr("usedTSB = %d, ix = %d, len = %d, next_ix = %d, next_len = %d (new MIN)", used_topSizeBlocks, j, hb_len, TopSizeArray[j].index, TopSizeArray[j].index >= 0 ? TopSizeArray[TopSizeArray[j].index].len : -1); } else { //---< second-smallest entry is now smallest >--- TopSizeArray[prev_j].index = tsbStopper; currMin = TopSizeArray[prev_j].len; currMin_ix = prev_j; //---< smallest entry gets overwritten >--- memcpy(&TopSizeArray[j], &TopSizeArray[i], sizeof(TopSizeBlk)); TopSizeArray[i].start = h; TopSizeArray[i].len = hb_len; TopSizeArray[i].index = j; TopSizeArray[i].compiler = cType; TopSizeArray[i].level = comp_lvl; TopSizeArray[i].type = cbType; // out->print_cr("usedTSB = %d, ix = %d, len = %d, next_ix = %d, next_len = %d (new INS)", used_topSizeBlocks, hb_len, i, TopSizeArray[i].index, TopSizeArray[i].index >= 0 ? TopSizeArray[TopSizeArray[i].index].len : -1); } } // insane } break; } prev_i = i; } if (insane) { // Note: regular analysis could probably continue by resetting "insane" flag. out->print_cr("Possible loop in TopSizeBlocks list detected. Analysis aborted."); discard_TopSizeArray(out); } } } } //---------------------------------------------- //---< END register block in TopSizeArray >--- //---------------------------------------------- } else { nBlocks_zomb++; } if (ix_beg == ix_end) { StatArray[ix_beg].type = cbType; switch (cbType) { case nMethod_inuse: if (highest_compilation_id < compile_id) highest_compilation_id = compile_id; if (comp_lvl < CompLevel_full_optimization) { nBlocks_t1++; t1Space += hb_bytelen; StatArray[ix_beg].t1_count++; StatArray[ix_beg].t1_space += (unsigned short)hb_len; StatArray[ix_beg].t1_age = StatArray[ix_beg].t1_age < compile_id ? compile_id : StatArray[ix_beg].t1_age; } else { nBlocks_t2++; t2Space += hb_bytelen; StatArray[ix_beg].t2_count++; StatArray[ix_beg].t2_space += (unsigned short)hb_len; StatArray[ix_beg].t2_age = StatArray[ix_beg].t2_age < compile_id ? compile_id : StatArray[ix_beg].t2_age; } StatArray[ix_beg].level = comp_lvl; StatArray[ix_beg].compiler = cType; break; case nMethod_alive: StatArray[ix_beg].tx_count++; StatArray[ix_beg].tx_space += (unsigned short)hb_len; StatArray[ix_beg].tx_age = StatArray[ix_beg].tx_age < compile_id ? compile_id : StatArray[ix_beg].tx_age; StatArray[ix_beg].level = comp_lvl; StatArray[ix_beg].compiler = cType; break; case nMethod_dead: case nMethod_unloaded: StatArray[ix_beg].dead_count++; StatArray[ix_beg].dead_space += (unsigned short)hb_len; break; default: // must be a stub, if it's not a dead or alive nMethod nBlocks_stub++; stubSpace += hb_bytelen; StatArray[ix_beg].stub_count++; StatArray[ix_beg].stub_space += (unsigned short)hb_len; break; } } else { unsigned int beg_space = (unsigned int)(granule_size - ((char*)h - low_bound - ix_beg*granule_size)); unsigned int end_space = (unsigned int)(hb_bytelen - beg_space - (ix_end-ix_beg-1)*granule_size); beg_space = beg_space>>_log2_segment_size; // store in units of _segment_size end_space = end_space>>_log2_segment_size; // store in units of _segment_size StatArray[ix_beg].type = cbType; StatArray[ix_end].type = cbType; switch (cbType) { case nMethod_inuse: if (highest_compilation_id < compile_id) highest_compilation_id = compile_id; if (comp_lvl < CompLevel_full_optimization) { nBlocks_t1++; t1Space += hb_bytelen; StatArray[ix_beg].t1_count++; StatArray[ix_beg].t1_space += (unsigned short)beg_space; StatArray[ix_beg].t1_age = StatArray[ix_beg].t1_age < compile_id ? compile_id : StatArray[ix_beg].t1_age; StatArray[ix_end].t1_count++; StatArray[ix_end].t1_space += (unsigned short)end_space; StatArray[ix_end].t1_age = StatArray[ix_end].t1_age < compile_id ? compile_id : StatArray[ix_end].t1_age; } else { nBlocks_t2++; t2Space += hb_bytelen; StatArray[ix_beg].t2_count++; StatArray[ix_beg].t2_space += (unsigned short)beg_space; StatArray[ix_beg].t2_age = StatArray[ix_beg].t2_age < compile_id ? compile_id : StatArray[ix_beg].t2_age; StatArray[ix_end].t2_count++; StatArray[ix_end].t2_space += (unsigned short)end_space; StatArray[ix_end].t2_age = StatArray[ix_end].t2_age < compile_id ? compile_id : StatArray[ix_end].t2_age; } StatArray[ix_beg].level = comp_lvl; StatArray[ix_beg].compiler = cType; StatArray[ix_end].level = comp_lvl; StatArray[ix_end].compiler = cType; break; case nMethod_alive: StatArray[ix_beg].tx_count++; StatArray[ix_beg].tx_space += (unsigned short)beg_space; StatArray[ix_beg].tx_age = StatArray[ix_beg].tx_age < compile_id ? compile_id : StatArray[ix_beg].tx_age; StatArray[ix_end].tx_count++; StatArray[ix_end].tx_space += (unsigned short)end_space; StatArray[ix_end].tx_age = StatArray[ix_end].tx_age < compile_id ? compile_id : StatArray[ix_end].tx_age; StatArray[ix_beg].level = comp_lvl; StatArray[ix_beg].compiler = cType; StatArray[ix_end].level = comp_lvl; StatArray[ix_end].compiler = cType; break; case nMethod_dead: case nMethod_unloaded: StatArray[ix_beg].dead_count++; StatArray[ix_beg].dead_space += (unsigned short)beg_space; StatArray[ix_end].dead_count++; StatArray[ix_end].dead_space += (unsigned short)end_space; break; default: // must be a stub, if it's not a dead or alive nMethod nBlocks_stub++; stubSpace += hb_bytelen; StatArray[ix_beg].stub_count++; StatArray[ix_beg].stub_space += (unsigned short)beg_space; StatArray[ix_end].stub_count++; StatArray[ix_end].stub_space += (unsigned short)end_space; break; } for (unsigned int ix = ix_beg+1; ix < ix_end; ix++) { StatArray[ix].type = cbType; switch (cbType) { case nMethod_inuse: if (comp_lvl < CompLevel_full_optimization) { StatArray[ix].t1_count++; StatArray[ix].t1_space += (unsigned short)(granule_size>>_log2_segment_size); StatArray[ix].t1_age = StatArray[ix].t1_age < compile_id ? compile_id : StatArray[ix].t1_age; } else { StatArray[ix].t2_count++; StatArray[ix].t2_space += (unsigned short)(granule_size>>_log2_segment_size); StatArray[ix].t2_age = StatArray[ix].t2_age < compile_id ? compile_id : StatArray[ix].t2_age; } StatArray[ix].level = comp_lvl; StatArray[ix].compiler = cType; break; case nMethod_alive: StatArray[ix].tx_count++; StatArray[ix].tx_space += (unsigned short)(granule_size>>_log2_segment_size); StatArray[ix].tx_age = StatArray[ix].tx_age < compile_id ? compile_id : StatArray[ix].tx_age; StatArray[ix].level = comp_lvl; StatArray[ix].compiler = cType; break; case nMethod_dead: case nMethod_unloaded: StatArray[ix].dead_count++; StatArray[ix].dead_space += (unsigned short)(granule_size>>_log2_segment_size); break; default: // must be a stub, if it's not a dead or alive nMethod StatArray[ix].stub_count++; StatArray[ix].stub_space += (unsigned short)(granule_size>>_log2_segment_size); break; } } } } } if (n_methods > 0) { avgTemp = hotnessAccumulator/n_methods; } else { avgTemp = 0; } done = true; if (!insane) { ttyLocker ttyl; // keep this statistics block together printBox(out, '-', "Global CodeHeap statistics for segment ", heapName); out->print_cr("freeSpace = " SIZE_FORMAT_W(8) "k, nBlocks_free = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", freeSpace/(size_t)K, nBlocks_free, (100.0*freeSpace)/size, (100.0*freeSpace)/res_size); out->print_cr("usedSpace = " SIZE_FORMAT_W(8) "k, nBlocks_used = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", usedSpace/(size_t)K, nBlocks_used, (100.0*usedSpace)/size, (100.0*usedSpace)/res_size); out->print_cr(" Tier1 Space = " SIZE_FORMAT_W(8) "k, nBlocks_t1 = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", t1Space/(size_t)K, nBlocks_t1, (100.0*t1Space)/size, (100.0*t1Space)/res_size); out->print_cr(" Tier2 Space = " SIZE_FORMAT_W(8) "k, nBlocks_t2 = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", t2Space/(size_t)K, nBlocks_t2, (100.0*t2Space)/size, (100.0*t2Space)/res_size); out->print_cr(" Alive Space = " SIZE_FORMAT_W(8) "k, nBlocks_alive = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", aliveSpace/(size_t)K, nBlocks_alive, (100.0*aliveSpace)/size, (100.0*aliveSpace)/res_size); out->print_cr(" disconnected = " SIZE_FORMAT_W(8) "k, nBlocks_disconn = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", disconnSpace/(size_t)K, nBlocks_disconn, (100.0*disconnSpace)/size, (100.0*disconnSpace)/res_size); out->print_cr(" not entrant = " SIZE_FORMAT_W(8) "k, nBlocks_notentr = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", notentrSpace/(size_t)K, nBlocks_notentr, (100.0*notentrSpace)/size, (100.0*notentrSpace)/res_size); out->print_cr(" unloadedSpace = " SIZE_FORMAT_W(8) "k, nBlocks_unloaded = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", unloadedSpace/(size_t)K, nBlocks_unloaded, (100.0*unloadedSpace)/size, (100.0*unloadedSpace)/res_size); out->print_cr(" deadSpace = " SIZE_FORMAT_W(8) "k, nBlocks_dead = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", deadSpace/(size_t)K, nBlocks_dead, (100.0*deadSpace)/size, (100.0*deadSpace)/res_size); out->print_cr(" stubSpace = " SIZE_FORMAT_W(8) "k, nBlocks_stub = %6d, %10.3f%% of capacity, %10.3f%% of max_capacity", stubSpace/(size_t)K, nBlocks_stub, (100.0*stubSpace)/size, (100.0*stubSpace)/res_size); out->print_cr("ZombieBlocks = %8d. These are HeapBlocks which could not be identified as CodeBlobs.", nBlocks_zomb); out->print_cr("latest allocated compilation id = %d", latest_compilation_id); out->print_cr("highest observed compilation id = %d", highest_compilation_id); out->print_cr("Building TopSizeList iterations = %ld", total_iterations); out->cr(); int reset_val = NMethodSweeper::hotness_counter_reset_val(); double reverse_free_ratio = (res_size > size) ? (double)res_size/(double)(res_size-size) : (double)res_size; printBox(out, '-', "Method hotness information at time of this analysis", NULL); out->print_cr("Highest possible method temperature: %12d", reset_val); out->print_cr("Threshold for method to be considered 'cold': %12.3f", -reset_val + reverse_free_ratio * NmethodSweepActivity); out->print_cr("min. hotness = %6d", minTemp); out->print_cr("avg. hotness = %6d", avgTemp); out->print_cr("max. hotness = %6d", maxTemp); out->cr(); out->print("Verifying collected data..."); for (unsigned int ix = 0; ix < granules; ix++) { if (StatArray[ix].t1_count > granule_size>>_log2_segment_size) out->print_cr("t1_count[%d] = %d", ix, StatArray[ix].t1_count); if (StatArray[ix].t2_count > granule_size>>_log2_segment_size) out->print_cr("t2_count[%d] = %d", ix, StatArray[ix].t2_count); if (StatArray[ix].stub_count > granule_size>>_log2_segment_size) out->print_cr("stub_count[%d] = %d", ix, StatArray[ix].stub_count); if (StatArray[ix].dead_count > granule_size>>_log2_segment_size) out->print_cr("dead_count[%d] = %d", ix, StatArray[ix].dead_count); if (StatArray[ix].t1_space > granule_size>>_log2_segment_size) out->print_cr("t1_space[%d] = %d", ix, StatArray[ix].t1_space); if (StatArray[ix].t2_space > granule_size>>_log2_segment_size) out->print_cr("t2_space[%d] = %d", ix, StatArray[ix].t2_space); if (StatArray[ix].stub_space > granule_size>>_log2_segment_size) out->print_cr("stub_space[%d] = %d", ix, StatArray[ix].stub_space); if (StatArray[ix].dead_space > granule_size>>_log2_segment_size) out->print_cr("dead_space[%d] = %d", ix, StatArray[ix].dead_space); // this cast is awful! I need it because NT/Intel reports a signed/unsigned mismatch. if ((size_t)(StatArray[ix].t1_count+StatArray[ix].t2_count+StatArray[ix].stub_count+StatArray[ix].dead_count) > granule_size>>_log2_segment_size) out->print_cr("t1_count[%d] = %d, t2_count[%d] = %d, stub_count[%d] = %d", ix, StatArray[ix].t1_count, ix, StatArray[ix].t2_count, ix, StatArray[ix].stub_count); if ((size_t)(StatArray[ix].t1_space+StatArray[ix].t2_space+StatArray[ix].stub_space+StatArray[ix].dead_space) > granule_size>>_log2_segment_size) out->print_cr("t1_space[%d] = %d, t2_space[%d] = %d, stub_space[%d] = %d", ix, StatArray[ix].t1_space, ix, StatArray[ix].t2_space, ix, StatArray[ix].stub_space); } if (used_topSizeBlocks > 0) { unsigned int j = 0; if (TopSizeArray[0].len != currMax) out->print_cr("currMax(%d) differs from TopSizeArray[0].len(%d)", currMax, TopSizeArray[0].len); for (unsigned int i = 0; (TopSizeArray[i].index != tsbStopper) && (j++ < alloc_topSizeBlocks); i = TopSizeArray[i].index) { if (TopSizeArray[i].len < TopSizeArray[TopSizeArray[i].index].len) { out->print_cr("sort error at index %d: %d !>= %d", i, TopSizeArray[i].len, TopSizeArray[TopSizeArray[i].index].len); } } if (j >= alloc_topSizeBlocks) { out->print_cr("Possible loop in TopSizeArray chaining!\n allocBlocks = %d, usedBlocks = %d", alloc_topSizeBlocks, used_topSizeBlocks); for (unsigned int i = 0; i < alloc_topSizeBlocks; i++) { out->print_cr(" TopSizeArray[%d].index = %d, len = %d", i, TopSizeArray[i].index, TopSizeArray[i].len); } } } out->print_cr("...done"); out->cr(); out->cr(); } else { // insane heap state detected. Analysis data incomplete. Just throw it away. discard_StatArray(out); discard_TopSizeArray(out); } } done = false; while (!done && (nBlocks_free > 0)) { printBox(out, '=', "C O D E H E A P A N A L Y S I S (free blocks) for segment ", heapName); out->print_cr("The aggregate step collects information about all free blocks in CodeHeap.\n" "Subsequent print functions create their output based on this snapshot.\n"); out->print_cr("Free space in %s is distributed over %d free blocks.", heapName, nBlocks_free); out->print_cr("Each free block takes " SIZE_FORMAT " bytes of C heap for statistics data, that is " SIZE_FORMAT "K in total.", sizeof(FreeBlk), (sizeof(FreeBlk)*nBlocks_free)/K); out->cr(); //---------------------------------------- //-- Prepare the FreeArray of FreeBlks -- //---------------------------------------- //---< discard old array if size does not match >--- if (nBlocks_free != alloc_freeBlocks) { discard_FreeArray(out); } prepare_FreeArray(out, nBlocks_free, heapName); if (FreeArray == NULL) { done = true; continue; } //---------------------------------------- //-- Collect all FreeBlks in FreeArray -- //---------------------------------------- unsigned int ix = 0; FreeBlock *cur = _freelist; while (cur != NULL) { if (ix < alloc_freeBlocks) { // don't index out of bounds if _freelist has more blocks than anticipated FreeArray[ix].start = cur; FreeArray[ix].len = (unsigned int)(cur->length()<<_log2_segment_size); FreeArray[ix].index = ix; } cur = cur->link(); ix++; } if (ix != alloc_freeBlocks) { out->print_cr("Free block count mismatch. Expected %d free blocks, but found %d.", alloc_freeBlocks, ix); out->print_cr("I will update the counter and retry data collection"); out->cr(); nBlocks_free = ix; continue; } done = true; } if (!done || (nBlocks_free == 0)) { if (nBlocks_free == 0) { printBox(out, '-', "no free blocks found in", heapName); } else if (!done) { out->print_cr("Free block count mismatch could not be resolved."); out->print_cr("Try to run \"aggregate\" function to update counters"); } //---< discard old array and update global values >--- discard_FreeArray(out); set_HeapStatGlobals(out, heapName); return; } //---< calculate and fill remaining fields >--- for (unsigned int ix = 0; ix < alloc_freeBlocks-1; ix++) { size_t lenSum = 0; // Make sure FreeArray is not NULL [coverity]. // Program logic makes this impossible, but we need Coverity be happy. guarantee(FreeArray != NULL, "CodeHeap::aggregate - FreeArray must not be NULL"); FreeArray[ix].gap = (unsigned int)((address)FreeArray[ix+1].start - ((address)FreeArray[ix].start + FreeArray[ix].len)); for (HeapBlock *h = next_block(FreeArray[ix].start); (h != NULL) && (h != FreeArray[ix+1].start); h = next_block(h)) { CodeBlob *cb = (CodeBlob*) find_start(h); if ((cb != NULL) && !cb->is_nmethod()) { FreeArray[ix].stubs_in_gap = true; } FreeArray[ix].n_gapBlocks++; lenSum += h->length()<<_log2_segment_size; if (((address)h < ((address)FreeArray[ix].start+FreeArray[ix].len)) || (h >= FreeArray[ix+1].start)) { out->print_cr("unsorted occupied CodeHeap block found @ %p, gap interval [%p, %p)", h, (address)FreeArray[ix].start+FreeArray[ix].len, FreeArray[ix+1].start); } } if (lenSum != FreeArray[ix].gap) { out->print_cr("Length mismatch for gap between FreeBlk[%d] and FreeBlk[%d]. Calculated: %d, accumulated: %d.", ix, ix+1, FreeArray[ix].gap, (unsigned int)lenSum); } } set_HeapStatGlobals(out, heapName); printBox(out, '=', "C O D E H E A P A N A L Y S I S C O M P L E T E for segment ", heapName); } void CodeHeap::print_usedSpace(outputStream *out) { if (!initialization_complete) return; const char *heapName = get_heapName(); get_HeapStatGlobals(out, heapName); if ((StatArray == NULL) || (TopSizeArray == NULL) || (used_topSizeBlocks == 0)) return; const char *frameLine; const char *textLine; STRINGSTREAM_DECL(ast, out) { ttyLocker ttyl; // keep the header and legend block together printBox(out, '=', "U S E D S P A C E S T A T I S T I C S for ", heapName); ast->print_cr("Note: The Top%d list of the largest used blocks associates method names\n" " and other identifying information with the block size data.\n" "\n" " Method names are dynamically retrieved from the code cache at print time.\n" " Due to the living nature of the code cache and because the CodeCache_lock\n" " is not continuously held, the displayed name might be wrong or no name\n" " might be found at all. The likelihood for that to happen increases\n" " over time passed between analysis and print step.\n", used_topSizeBlocks); STRINGSTREAM_FLUSH("\n") } //---------------------------- //-- Print Top Used Blocks -- //---------------------------- { ttyLocker ttyl; // keep this statistics block together char* low_bound = low_boundary(); printBox(out, '-', "Largest Used Blocks in ", heapName); print_blobType_legend(ast); STRINGSTREAM_FLUSH("") ast->fill_to(51); ast->print("%4s", "blob"); ast->fill_to(56); ast->print("%9s", "compiler"); ast->fill_to(66); ast->print_cr("%6s", "method"); ast->print_cr("%18s %13s %17s %4s %9s %5s %s", "Addr(module) ", "offset", "size", "type", " type lvl", " temp", "Name"); STRINGSTREAM_FLUSH("") //---< print Top Ten Used Blocks >--- if (used_topSizeBlocks > 0) { unsigned int printed_topSizeBlocks = 0; for (unsigned int i = 0; i != tsbStopper; i = TopSizeArray[i].index) { printed_topSizeBlocks++; CodeBlob* this_blob = (CodeBlob *) find_start(TopSizeArray[i].start); nmethod* nm = NULL; const char* blob_name = "unnamed blob"; if (this_blob != NULL) { blob_name = this_blob->name(); nm = this_blob->as_nmethod_or_null(); //---< blob address >--- ast->print("%p", this_blob); ast->fill_to(19); //---< blob offset from CodeHeap begin >--- ast->print("(+" PTR32_FORMAT ")", (unsigned int)((char*)this_blob-low_bound)); ast->fill_to(33); } else { //---< block address >--- ast->print("%p", TopSizeArray[i].start); ast->fill_to(19); //---< block offset from CodeHeap begin >--- ast->print("(+" PTR32_FORMAT ")", (unsigned int)((char*)TopSizeArray[i].start-low_bound)); ast->fill_to(33); } //---< print size, name, and signature (for nMethods) >--- if ((nm != NULL) && (nm->method() != NULL)) { ResourceMark rm; //---< nMethod size in hex >--- unsigned int total_size = nm->total_size(); ast->print(PTR32_FORMAT, total_size); ast->print("(%4ldK)", total_size/K); ast->fill_to(51); ast->print(" %c", blobTypeChar[TopSizeArray[i].type]); //---< compiler information >--- ast->fill_to(56); ast->print("%5s %3d", compTypeName[TopSizeArray[i].compiler], TopSizeArray[i].level); //---< method temperature >--- ast->fill_to(67); ast->print("%5d", nm->hotness_counter()); //---< name and signature >--- ast->fill_to(67+6); if (nm->is_in_use()) {blob_name = nm->method()->name_and_sig_as_C_string(); } if (nm->is_not_entrant()) {blob_name = nm->method()->name_and_sig_as_C_string(); } if (nm->is_zombie()) {ast->print("%14s", " zombie method"); } ast->print("%s", blob_name); } else { //---< block size in hex >--- ast->print(PTR32_FORMAT, (unsigned int)(TopSizeArray[i].len<<_log2_segment_size)); ast->print("(%4ldK)", (TopSizeArray[i].len<<_log2_segment_size)/K); //---< no compiler information >--- ast->fill_to(56); //---< name and signature >--- ast->fill_to(67+6); ast->print("%s", blob_name); } STRINGSTREAM_FLUSH("\n") } if (used_topSizeBlocks != printed_topSizeBlocks) { ast->print_cr("used blocks: %d, printed blocks: %d", used_topSizeBlocks, printed_topSizeBlocks); STRINGSTREAM_FLUSH("") for (unsigned int i = 0; i < alloc_topSizeBlocks; i++) { ast->print_cr(" TopSizeArray[%d].index = %d, len = %d", i, TopSizeArray[i].index, TopSizeArray[i].len); STRINGSTREAM_FLUSH("") } } out->cr(); out->cr(); } } //----------------------------- //-- Print Usage Histogram -- //----------------------------- if (SizeDistributionArray != NULL) { unsigned long total_count = 0; unsigned long total_size = 0; const unsigned long pctFactor = 200; for (unsigned int i = 0; i < nSizeDistElements; i++) { total_count += SizeDistributionArray[i].count; total_size += SizeDistributionArray[i].lenSum; } if ((total_count > 0) && (total_size > 0)) { printBox(out, '-', "Block count histogram for ", heapName); ast->print_cr("Note: The histogram indicates how many blocks (as a percentage\n" " of all blocks) have a size in the given range.\n" " %ld characters are printed per percentage point.\n", pctFactor/100); ast->print_cr("total size of all blocks: %7ldM", (total_size<<_log2_segment_size)/M); ast->print_cr("total number of all blocks: %7ld\n", total_count); ast->print_cr("[Size Range)------avg.-size-+----count-+"); STRINGSTREAM_FLUSH("") for (unsigned int i = 0; i < nSizeDistElements; i++) { if (SizeDistributionArray[i].rangeStart<<_log2_segment_size < K) { ast->print("[%5d ..%5d ): " ,(SizeDistributionArray[i].rangeStart<<_log2_segment_size) ,(SizeDistributionArray[i].rangeEnd<<_log2_segment_size) ); } else if (SizeDistributionArray[i].rangeStart<<_log2_segment_size < M) { ast->print("[%5ldK..%5ldK): " ,(SizeDistributionArray[i].rangeStart<<_log2_segment_size)/K ,(SizeDistributionArray[i].rangeEnd<<_log2_segment_size)/K ); } else { ast->print("[%5ldM..%5ldM): " ,(SizeDistributionArray[i].rangeStart<<_log2_segment_size)/M ,(SizeDistributionArray[i].rangeEnd<<_log2_segment_size)/M ); } ast->print(" %8d | %8d |", SizeDistributionArray[i].count > 0 ? (SizeDistributionArray[i].lenSum<<_log2_segment_size)/SizeDistributionArray[i].count : 0, SizeDistributionArray[i].count); unsigned int percent = pctFactor*SizeDistributionArray[i].count/total_count; for (unsigned int j = 1; j <= percent; j++) { ast->print("%c", (j%((pctFactor/100)*10) == 0) ? ('0'+j/(((unsigned int)pctFactor/100)*10)) : '*'); } STRINGSTREAM_FLUSH("\n") } out->print_cr("----------------------------+----------+\n\n"); printBox(out, '-', "Contribution per size range to total size for ", heapName); ast->print_cr("Note: The histogram indicates how much space (as a percentage of all\n" " occupied space) is used by the blocks in the given size range.\n" " %ld characters are printed per percentage point.\n", pctFactor/100); ast->print_cr("total size of all blocks: %7ldM", (total_size<<_log2_segment_size)/M); ast->print_cr("total number of all blocks: %7ld\n", total_count); ast->print_cr("[Size Range)------avg.-size-+----count-+"); STRINGSTREAM_FLUSH("") for (unsigned int i = 0; i < nSizeDistElements; i++) { if (SizeDistributionArray[i].rangeStart<<_log2_segment_size < K) { ast->print("[%5d ..%5d ): " ,(SizeDistributionArray[i].rangeStart<<_log2_segment_size) ,(SizeDistributionArray[i].rangeEnd<<_log2_segment_size) ); } else if (SizeDistributionArray[i].rangeStart<<_log2_segment_size < M) { ast->print("[%5ldK..%5ldK): " ,(SizeDistributionArray[i].rangeStart<<_log2_segment_size)/K ,(SizeDistributionArray[i].rangeEnd<<_log2_segment_size)/K ); } else { ast->print("[%5ldM..%5ldM): " ,(SizeDistributionArray[i].rangeStart<<_log2_segment_size)/M ,(SizeDistributionArray[i].rangeEnd<<_log2_segment_size)/M ); } ast->print(" %8d | %8d |", SizeDistributionArray[i].count > 0 ? (SizeDistributionArray[i].lenSum<<_log2_segment_size)/SizeDistributionArray[i].count : 0, SizeDistributionArray[i].count); unsigned int percent = pctFactor*(unsigned long)SizeDistributionArray[i].lenSum/total_size; for (unsigned int j = 1; j <= percent; j++) { ast->print("%c", (j%((pctFactor/100)*10) == 0) ? ('0'+j/(((unsigned int)pctFactor/100)*10)) : '*'); } STRINGSTREAM_FLUSH("\n") } out->print_cr("----------------------------+----------+\n\n"); } } } void CodeHeap::print_freeSpace(outputStream *out) { if (!initialization_complete) return; const char *heapName = get_heapName(); get_HeapStatGlobals(out, heapName); if ((StatArray == NULL) || (FreeArray == NULL) || (alloc_granules == 0)) return; const char *frameLine; const char *textLine; STRINGSTREAM_DECL(ast, out) { ttyLocker ttyl; // keep the header and legend block together printBox(out, '=', "F R E E S P A C E S T A T I S T I C S for ", heapName); ast->print_cr("Note: in this context, a gap is the occupied space between two free blocks.\n" " Those gaps are of interest if there is a chance that they become\n" " unoccupied, e.g. by class unloading. Then, the two adjacent free\n" " blocks, together with the now unoccupied space, form a new, large\n" " free block."); ast->cr(); STRINGSTREAM_FLUSH("") } { ttyLocker ttyl; // keep this statistics block together printBox(out, '-', "List of all Free Blocks in ", heapName); unsigned int ix = 0; for (ix = 0; ix < alloc_freeBlocks-1; ix++) { ast->print("%p: Len[%4d] = " HEX32_FORMAT ",", FreeArray[ix].start, ix, FreeArray[ix].len); ast->fill_to(38); ast->print("Gap[%4d..%4d]: " HEX32_FORMAT " bytes,", ix, ix+1, FreeArray[ix].gap); ast->fill_to(71); ast->print("block count: %6d", FreeArray[ix].n_gapBlocks); if (FreeArray[ix].stubs_in_gap) { ast->print(" !! permanent gap, contains stubs and/or blobs !!"); } ast->cr(); STRINGSTREAM_FLUSH("") } ast->print_cr("%p: Len[%4d] = " HEX32_FORMAT, FreeArray[ix].start, ix, FreeArray[ix].len); STRINGSTREAM_FLUSH("") out->cr(); out->cr(); } //----------------------------------------- //-- Find and Print Top Ten Free Blocks -- //----------------------------------------- //---< find Top Ten Free Blocks >--- const unsigned int nTop = 10; unsigned int currMax10 = 0; struct FreeBlk *FreeTopTen[nTop]; memset(FreeTopTen, 0, sizeof(FreeTopTen)); for (unsigned int ix = 0; ix < alloc_freeBlocks; ix++) { if (FreeArray[ix].len > currMax10) { // larger than the ten largest found so far unsigned int currSize = FreeArray[ix].len; unsigned int iy; for (iy = 0; iy < nTop && FreeTopTen[iy] != NULL; iy++) { if (FreeTopTen[iy]->len < currSize) { for (unsigned int iz = nTop-1; iz > iy; iz--) { // make room to insert new free block FreeTopTen[iz] = FreeTopTen[iz-1]; } FreeTopTen[iy] = &FreeArray[ix]; // insert new free block if (FreeTopTen[nTop-1] != NULL) {currMax10 = FreeTopTen[nTop-1]->len; /*out->print_cr("new currMax10 = 0x%8.8d", currMax10);*/ } break; // done with this, check next free block } } if (iy >= nTop) { out->print_cr("Internal logic error. New Max10 = %d detected, but could not be merged. Old Max10 = %d", currSize, currMax10); continue; } if (FreeTopTen[iy] == NULL) { FreeTopTen[iy] = &FreeArray[ix]; if (iy == (nTop-1)) {currMax10 = currSize; /*out->print_cr("new currMax10 = 0x%8.8d", currMax10);*/ } } } } { ttyLocker ttyl; // keep this statistics block together printBox(out, '-', "Top Ten Free Blocks in ", heapName); //---< print Top Ten Free Blocks >--- for (unsigned int iy = 0; (iy < nTop) && (FreeTopTen[iy] != NULL); iy++) { ast->print("Pos %3d: Block %4d - size " HEX32_FORMAT ",", iy+1, FreeTopTen[iy]->index, FreeTopTen[iy]->len); ast->fill_to(39); if (FreeTopTen[iy]->index == (alloc_freeBlocks-1)) { ast->print("last free block in list."); } else { ast->print("Gap (to next) " HEX32_FORMAT ",", FreeTopTen[iy]->gap); ast->fill_to(63); ast->print("#blocks (in gap) %d", FreeTopTen[iy]->n_gapBlocks); } ast->cr(); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); } //-------------------------------------------------------- //-- Find and Print Top Ten Free-Occupied-Free Triples -- //-------------------------------------------------------- //---< find and print Top Ten Triples (Free-Occupied-Free) >--- currMax10 = 0; struct FreeBlk *FreeTopTenTriple[nTop]; memset(FreeTopTenTriple, 0, sizeof(FreeTopTenTriple)); for (unsigned int ix = 0; ix < alloc_freeBlocks-1; ix++) { // If there are stubs in the gap, this gap will never become completely free. // The triple will thus never merge to one free block. unsigned int lenTriple = FreeArray[ix].len + (FreeArray[ix].stubs_in_gap ? 0 : FreeArray[ix].gap + FreeArray[ix+1].len); FreeArray[ix].len = lenTriple; if (lenTriple > currMax10) { // larger than the ten largest found so far unsigned int iy; for (iy = 0; (iy < nTop) && (FreeTopTenTriple[iy] != NULL); iy++) { if (FreeTopTenTriple[iy]->len < lenTriple) { for (unsigned int iz = nTop-1; iz > iy; iz--) { FreeTopTenTriple[iz] = FreeTopTenTriple[iz-1]; } FreeTopTenTriple[iy] = &FreeArray[ix]; if (FreeTopTenTriple[nTop-1] != NULL) {currMax10 = FreeTopTenTriple[nTop-1]->len; } break; } } if (iy == nTop) { out->print_cr("Internal logic error. New Max10 = %d detected, but could not be merged. Old Max10 = %d", lenTriple, currMax10); continue; } if (FreeTopTenTriple[iy] == NULL) { FreeTopTenTriple[iy] = &FreeArray[ix]; if (iy == (nTop-1)) {currMax10 = lenTriple; } } } } { ttyLocker ttyl; // keep this statistics block together printBox(out, '-', "Top Ten Free-Occupied-Free Triples in ", heapName); ast->print_cr(" Use this information to judge how likely it is that a large(r) free block\n" " might get created by code cache sweeping.\n" " If all the occupied blocks can be swept, the three free blocks will be\n" " merged into one (much larger) free block. That would reduce free space\n" " fragmentation.\n"); STRINGSTREAM_FLUSH("") //---< print Top Ten Free-Occupied-Free Triples >--- for (unsigned int iy = 0; (iy < nTop) && (FreeTopTenTriple[iy] != NULL); iy++) { ast->print("Pos %3d: Block %4d - size " HEX32_FORMAT ",", iy+1, FreeTopTenTriple[iy]->index, FreeTopTenTriple[iy]->len); ast->fill_to(39); ast->print("Gap (to next) " HEX32_FORMAT ",", FreeTopTenTriple[iy]->gap); ast->fill_to(63); ast->print("#blocks (in gap) %d", FreeTopTenTriple[iy]->n_gapBlocks); STRINGSTREAM_FLUSH("\n") } out->cr(); out->cr(); } } void CodeHeap::print_count(outputStream *out) { if (!initialization_complete) return; const char *heapName = get_heapName(); get_HeapStatGlobals(out, heapName); if ((StatArray == NULL) || (alloc_granules == 0)) return; unsigned int granules_per_line = 32; char* low_bound = low_boundary(); const char *frameLine; const char *textLine; STRINGSTREAM_DECL(ast, out) { ttyLocker ttyl; // keep the header and legend block together printBox(out, '=', "B L O C K C O U N T S for ", heapName); ast->print_cr(" Each granule contains an individual number of heap blocks. Large blocks\n" " may span multiple granules and are counted for each granule they touch.\n"); if (segment_granules) { ast->print_cr(" You have selected granule size to be as small as segment size.\n" " As a result, each granule contains exactly one block (or a part of one block)\n" " or is displayed as empty (' ') if it's BlobType does not match the selection.\n" " Occupied granules show their BlobType character, see legend.\n"); print_blobType_legend(ast); } STRINGSTREAM_FLUSH("") } { ttyLocker ttyl; // keep this statistics block together if (segment_granules) { printBox(out, '-', "Total (all types) count for granule size == segment size", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_blobType_single(ast, StatArray[ix].type); } } else { printBox(out, '-', "Total (all tiers) count, 0x1..0xf. '*' indicates >= 16 blocks, ' ' indicates empty", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); unsigned int count = StatArray[ix].t1_count + StatArray[ix].t2_count + StatArray[ix].tx_count + StatArray[ix].stub_count + StatArray[ix].dead_count; print_count_single(ast, count); } } STRINGSTREAM_FLUSH("|") out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_t1 > 0) { printBox(out, '-', "Tier1 nMethod count only, 0x1..0xf. '*' indicates >= 16 blocks, ' ' indicates empty", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].t1_count > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_count_single(ast, StatArray[ix].t1_count); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier1 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_t2 > 0) { printBox(out, '-', "Tier2 nMethod count only, 0x1..0xf. '*' indicates >= 16 blocks, ' ' indicates empty", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].t2_count > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_count_single(ast, StatArray[ix].t2_count); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier2 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_alive > 0) { printBox(out, '-', "not_used/not_entrant nMethod count only, 0x1..0xf. '*' indicates >= 16 blocks, ' ' indicates empty", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].tx_count > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_count_single(ast, StatArray[ix].tx_count); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No not_used/not_entrant nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_stub > 0) { printBox(out, '-', "Stub & Blob count only, 0x1..0xf. '*' indicates >= 16 blocks, ' ' indicates empty", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].stub_count > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_count_single(ast, StatArray[ix].stub_count); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No Stubs and Blobs found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_dead > 0) { printBox(out, '-', "Dead nMethod count only, 0x1..0xf. '*' indicates >= 16 blocks, ' ' indicates empty", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].dead_count > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_count_single(ast, StatArray[ix].dead_count); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No dead nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (!segment_granules) { // Prevent totally redundant printouts printBox(out, '-', "Count by tier (combined, no dead blocks): <#t1>:<#t2>:<#s>, 0x0..0xf. '*' indicates >= 16 blocks", NULL); granules_per_line = 24; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_count_single(ast, StatArray[ix].t1_count); ast->print(":"); print_count_single(ast, StatArray[ix].t2_count); ast->print(":"); if (segment_granules && StatArray[ix].stub_count > 0) print_blobType_single(ast, StatArray[ix].type); else print_count_single(ast, StatArray[ix].stub_count); ast->print(" "); } STRINGSTREAM_FLUSH("|") out->cr(); out->cr(); out->cr(); } } } void CodeHeap::print_space(outputStream *out) { if (!initialization_complete) return; const char *heapName = get_heapName(); get_HeapStatGlobals(out, heapName); if ((StatArray == NULL) || (alloc_granules == 0)) return; unsigned int granules_per_line = 32; const char *frameLine; const char *textLine; STRINGSTREAM_DECL(ast, out) { ttyLocker ttyl; // keep the header and legend block together printBox(out, '=', "S P A C E U S A G E & F R A G M E N T A T I O N for ", heapName); ast->print_cr(" The heap space covered by one granule is occupied to a various extend.\n" " The granule occupancy is displayed by one decimal digit per granule.\n"); if (segment_granules) { ast->print_cr(" You have selected granule size to be as small as segment size.\n" " As a result, each granule contains exactly one block (or a part of one block)\n" " or is displayed as empty (' ') if it's BlobType does not match the selection.\n" " Occupied granules show their BlobType character, see legend.\n"); print_blobType_legend(ast); } else { ast->print_cr(" These digits represent a fill percentage range (see legend).\n"); print_space_legend(ast); } STRINGSTREAM_FLUSH("") } { ttyLocker ttyl; // keep this statistics block together if (segment_granules) { printBox(out, '-', "Total (all types) space consumption for granule size == segment size", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_blobType_single(ast, StatArray[ix].type); } } else { printBox(out, '-', "Total (all types) space consumption. ' ' indicates empty, '*' indicates full.", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); unsigned int space = StatArray[ix].t1_space + StatArray[ix].t2_space + StatArray[ix].tx_space + StatArray[ix].stub_space + StatArray[ix].dead_space; print_space_single(ast, space); } } STRINGSTREAM_FLUSH("|") out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_t1 > 0) { printBox(out, '-', "Tier1 space consumption. ' ' indicates empty, '*' indicates full", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].t1_space > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_space_single(ast, StatArray[ix].t1_space); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier1 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_t2 > 0) { printBox(out, '-', "Tier2 space consumption. ' ' indicates empty, '*' indicates full", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].t2_space > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_space_single(ast, StatArray[ix].t2_space); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier2 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_alive > 0) { printBox(out, '-', "not_used/not_entrant space consumption. ' ' indicates empty, '*' indicates full", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].tx_space > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_space_single(ast, StatArray[ix].tx_space); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier2 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_stub > 0) { printBox(out, '-', "Stub and Blob space consumption. ' ' indicates empty, '*' indicates full", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].stub_space > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_space_single(ast, StatArray[ix].stub_space); } } STRINGSTREAM_FLUSH("|") } else { ast->print("No Stubs and Blobs found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_dead > 0) { printBox(out, '-', "Dead space consumption. ' ' indicates empty, '*' indicates full", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_space_single(ast, StatArray[ix].dead_space); } STRINGSTREAM_FLUSH("|") } else { ast->print("No dead nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (!segment_granules) { // Prevent totally redundant printouts printBox(out, '-', "Space consumption by tier (combined): ::. ' ' indicates empty, '*' indicates full", NULL); granules_per_line = 24; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); if (segment_granules && StatArray[ix].t1_space > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_space_single(ast, StatArray[ix].t1_space); } ast->print(":"); if (segment_granules && StatArray[ix].t2_space > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_space_single(ast, StatArray[ix].t2_space); } ast->print(":"); if (segment_granules && StatArray[ix].stub_space > 0) { print_blobType_single(ast, StatArray[ix].type); } else { print_space_single(ast, StatArray[ix].stub_space); } ast->print(" "); } STRINGSTREAM_FLUSH("|") out->cr(); out->cr(); out->cr(); } } } void CodeHeap::print_age(outputStream *out) { if (!initialization_complete) return; const char *heapName = get_heapName(); get_HeapStatGlobals(out, heapName); if ((StatArray == NULL) || (alloc_granules == 0)) return; unsigned int granules_per_line = 32; const char *frameLine; const char *textLine; STRINGSTREAM_DECL(ast, out) { ttyLocker ttyl; // keep the header and legend block together printBox(out, '=', "M E T H O D A G E by CompileID for ", heapName); ast->print_cr(" The age of a compiled method in the CodeHeap is not available as a\n" " time stamp. Instead, a relative age is deducted from the method's compilation ID.\n" " Age information is available for tier1 and tier2 methods only. There is no\n" " age information for stubs and blobs, because they have no compilation ID assigned.\n" " Information for the youngest method (highest ID) in the granule is printed.\n" " Refer to the legend to learn how method age is mapped to the displayed digit."); print_age_legend(ast); STRINGSTREAM_FLUSH("") } { ttyLocker ttyl; // keep this statistics block together printBox(out, '-', "Age distribution. '0' indicates youngest 1/256, '8': oldest half, ' ': no age information", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); unsigned int age1 = StatArray[ix].t1_age; unsigned int age2 = StatArray[ix].t2_age; unsigned int agex = StatArray[ix].tx_age; unsigned int age = age1 > age2 ? age1 : age2; age = age > agex ? age : agex; print_age_single(ast, age); } STRINGSTREAM_FLUSH("|") out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_t1 > 0) { printBox(out, '-', "Tier1 age distribution. '0' indicates youngest 1/256, '8': oldest half, ' ': no age information", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_age_single(ast, StatArray[ix].t1_age); } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier1 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_t2 > 0) { printBox(out, '-', "Tier2 age distribution. '0' indicates youngest 1/256, '8': oldest half, ' ': no age information", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_age_single(ast, StatArray[ix].t2_age); } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier2 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (nBlocks_alive > 0) { printBox(out, '-', "not_used/not_entrant age distribution. '0' indicates youngest 1/256, '8': oldest half, ' ': no age information", NULL); granules_per_line = 128; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_age_single(ast, StatArray[ix].tx_age); } STRINGSTREAM_FLUSH("|") } else { ast->print("No Tier2 nMethods found in CodeHeap."); STRINGSTREAM_FLUSH("") } out->cr(); out->cr(); out->cr(); } { ttyLocker ttyl; // keep this statistics block together if (!segment_granules) { // Prevent totally redundant printouts printBox(out, '-', "age distribution by tier :. '0' indicates youngest 1/256, '8': oldest half, ' ': no age information", NULL); granules_per_line = 32; for (unsigned int ix = 0; ix < alloc_granules; ix++) { print_line_delim(out, ast, ix, granules_per_line); print_age_single(ast, StatArray[ix].t1_age); ast->print(":"); print_age_single(ast, StatArray[ix].t2_age); ast->print(" "); } STRINGSTREAM_FLUSH("|") out->cr(); out->cr(); out->cr(); } } } void CodeHeap::print_names(outputStream *out) { if (!initialization_complete) return; const char *heapName = get_heapName(); get_HeapStatGlobals(out, heapName); if ((StatArray == NULL) || (alloc_granules == 0)) return; unsigned int granules_per_line = 128; char* low_bound = low_boundary(); CodeBlob* last_blob = NULL; bool name_in_addr_range = true; STRINGSTREAM_DECL(ast, out) //---< print at least 128K per block >--- if (granules_per_line*granule_size < 128*K) { granules_per_line = (unsigned int)((128*K)/granule_size); } ttyLocker ttyl; // keep this statistics block together printBox(out, '=', "M E T H O D N A M E S for ", heapName); ast->print_cr(" Method names are dynamically retrieved from the code cache at print time.\n" " Due to the living nature of the code heap and because the CodeCache_lock\n" " is not continuously held, the displayed name might be wrong or no name\n" " might be found at all. The likelihood for that to happen increases\n" " over time passed between analysis and print step.\n"); STRINGSTREAM_FLUSH("") for (unsigned int ix = 0; ix < alloc_granules; ix++) { //---< print a new blob on a new line >--- if (ix%granules_per_line == 0) { if (!name_in_addr_range) ast->print_cr("No methods, blobs, or stubs found in this address range"); name_in_addr_range = false; ast->cr(); ast->print_cr("--------------------------------------------------------------------"); ast->print_cr("Address range [%p,%p), " SIZE_FORMAT "k", low_bound+ix*granule_size, low_bound+(ix+granules_per_line)*granule_size, granules_per_line*granule_size/(size_t)K); ast->print_cr("--------------------------------------------------------------------"); STRINGSTREAM_FLUSH("") } for (unsigned int is = 0; is < granule_size; is+=(unsigned int)_segment_size) { CodeBlob* this_blob = (CodeBlob *) find_start(low_bound+ix*granule_size+is); if ((this_blob != NULL) && (this_blob != last_blob)) { if (!name_in_addr_range) { name_in_addr_range = true; ast->fill_to(51); ast->print("%9s", "compiler"); ast->fill_to(61); ast->print_cr("%6s", "method"); ast->print_cr("%18s %13s %17s %9s %5s %18s %s", "Addr(module) ", "offset", "size", " type lvl", " temp", "blobType ", "Name"); } //---< Print blobTypeName as recorded during analysis >--- ast->print("%p", this_blob); ast->fill_to(19); ast->print("(+" PTR32_FORMAT ")", (unsigned int)((char*)this_blob-low_bound)); ast->fill_to(33); //---< print size, name, and signature (for nMethods) >--- const char *blob_name = this_blob->name(); nmethod* nm = this_blob->as_nmethod_or_null(); blobType cbType = noType; if (segment_granules) { cbType = (blobType)StatArray[ix].type; } else { cbType = get_cbType(this_blob); } if ((nm != NULL) && (nm->method() != NULL)) { ResourceMark rm; //---< nMethod size in hex >--- unsigned int total_size = nm->total_size(); ast->print(PTR32_FORMAT, total_size); ast->print("(%4ldK)", total_size/K); //---< compiler information >--- ast->fill_to(51); ast->print("%5s %3d", compTypeName[StatArray[ix].compiler], StatArray[ix].level); //---< method temperature >--- ast->fill_to(62); ast->print("%5d", nm->hotness_counter()); //---< name and signature >--- ast->fill_to(62+6); ast->print("%s", blobTypeName[cbType]); ast->fill_to(82+6); if (nm->is_in_use()) {blob_name = nm->method()->name_and_sig_as_C_string(); } if (nm->is_not_entrant()) {blob_name = nm->method()->name_and_sig_as_C_string(); } if (nm->is_zombie()) {ast->print("%14s", " zombie method"); } ast->print("%s", blob_name); } else { ast->fill_to(62+6); ast->print("%s", blobTypeName[cbType]); ast->fill_to(82+6); ast->print("%s", blob_name); } STRINGSTREAM_FLUSH("\n") last_blob = this_blob; } } } out->cr(); out->cr(); } void CodeHeap::printBox(outputStream* out, const char border, const char* text1, const char* text2) { int lineLen = 1 + 2 + 2 +1; char edge, frame; STRINGSTREAM_DECL(ast, out) if (text1 != NULL) lineLen += strlen(text1); if (text2 != NULL) lineLen += strlen(text2); if (border == '-') { edge = '+'; frame = '|'; } else { edge = border; frame = border; } ast->print("%c", edge); for (int i = 0; i < lineLen-2; i++) { ast->print("%c", border); } ast->print_cr("%c", edge); ast->print("%c ", frame); if (text1 != NULL) ast->print("%s", text1); if (text2 != NULL) ast->print("%s", text2); ast->print_cr(" %c", frame); ast->print("%c", edge); for (int i = 0; i < lineLen-2; i++) { ast->print("%c", border); } ast->print_cr("%c", edge); STRINGSTREAM_FLUSH("") } void CodeHeap::print_blobType_legend(outputStream *out) { out->cr(); out->print_cr(" +---------------------------------------------------+"); out->print_cr(" | Block types used in the following CodeHeap dump |"); out->print_cr(" +---------------------------------------------------+"); for (int type = noType; type < lastType; type += 1) { out->print_cr(" %c - %s", blobTypeChar[type], blobTypeName[type]); } out->print_cr(" -----------------------------------------------------"); out->cr(); } void CodeHeap::print_space_legend(outputStream *out) { unsigned int indicator = 0; unsigned int age_range = 256; unsigned int range_beg = latest_compilation_id; out->cr(); out->print_cr(" +--------------------------------------------+"); out->print_cr(" | Space ranges, based on granule occupancy |"); out->print_cr(" +--------------------------------------------+"); out->print_cr(" - 0%% == occupancy"); for (int i=0; i<=9; i++) { out->print_cr(" %d - %3d%% < occupancy < %3d%%", i, 10*i, 10*(i+1)); } out->print_cr(" * - 100%% == occupancy"); out->print_cr(" ----------------------------------------------"); out->cr(); } void CodeHeap::print_age_legend(outputStream *out) { unsigned int indicator = 0; unsigned int age_range = 256; unsigned int range_beg = latest_compilation_id; out->cr(); out->print_cr(" +---------------------------------------+"); out->print_cr(" | Age ranges, based on compilation id |"); out->print_cr(" +---------------------------------------+"); while (age_range > 0) { out->print_cr(" %d - %6d to %6d", indicator, range_beg, latest_compilation_id - latest_compilation_id/age_range); range_beg = latest_compilation_id - latest_compilation_id/age_range; age_range /= 2; indicator += 1; } out->print_cr(" -----------------------------------------"); out->cr(); } void CodeHeap::print_blobType_single(outputStream *out, u2 /* blobType */ type) { out->print("%c", blobTypeChar[type]); } void CodeHeap::print_count_single(outputStream *out, unsigned short count) { if (count >= 16) out->print("*"); else if (count > 0) out->print("%1.1x", count); else out->print(" "); } void CodeHeap::print_space_single(outputStream *out, unsigned short space) { size_t space_in_bytes = ((unsigned int)space)<<_log2_segment_size; char fraction = (space == 0) ? ' ' : (space_in_bytes >= granule_size-1) ? '*' : char('0'+10*space_in_bytes/granule_size); out->print("%c", fraction); } void CodeHeap::print_age_single(outputStream *out, unsigned int age) { unsigned int indicator = 0; unsigned int age_range = 256; if (age > 0) { while ((age_range > 0) && (latest_compilation_id-age > latest_compilation_id/age_range)) { age_range /= 2; indicator += 1; } out->print("%c", char('0'+indicator)); } else { out->print(" "); } } void CodeHeap::print_line_delim(outputStream *out, outputStream* ast, unsigned int ix, unsigned int gpl) { if (ix % gpl == 0) { char* low_bound = low_boundary(); if (ix > 0) { ast->print("|"); } ast->cr(); assert(out == ast, "must use the same stream!"); ast->print("%p", low_bound + ix*granule_size); ast->fill_to(19); ast->print("(+" PTR32_FORMAT "): |", (unsigned int)(ix*granule_size)); } } void CodeHeap::print_line_delim(outputStream *out, bufferedStream* ast, unsigned int ix, unsigned int gpl) { if (ix % gpl == 0) { char* low_bound = low_boundary(); if (ix > 0) { ast->print("|"); } ast->cr(); assert(out != ast, "must not use the same stream!"); out->print("%s", ast->as_string()); ast->reset(); ast->print("%p", low_bound + ix*granule_size); ast->fill_to(19); ast->print("(+" PTR32_FORMAT "): |", (unsigned int)(ix*granule_size)); } } CodeHeap::blobType CodeHeap::get_cbType(CodeBlob* cb) { if (cb != NULL ) { if (cb->is_runtime_stub()) return runtimeStub; if (cb->is_deoptimization_stub()) return deoptimizationStub; if (cb->is_uncommon_trap_stub()) return uncommonTrapStub; if (cb->is_exception_stub()) return exceptionStub; if (cb->is_safepoint_stub()) return safepointStub; if (cb->is_adapter_blob()) return adapterBlob; if (cb->is_method_handles_adapter_blob()) return mh_adapterBlob; if (cb->is_buffer_blob()) return bufferBlob; if (cb->is_nmethod() ) { if (((nmethod*)cb)->is_in_use()) return nMethod_inuse; if (((nmethod*)cb)->is_alive() && !(((nmethod*)cb)->is_not_entrant())) return nMethod_notused; if (((nmethod*)cb)->is_alive()) return nMethod_alive; if (((nmethod*)cb)->is_unloaded()) return nMethod_unloaded; if (((nmethod*)cb)->is_zombie()) return nMethod_dead; tty->print_cr("unhandled nmethod state"); return nMethod_dead; } } return noType; } //---< END >--- 8198691: CodeHeap State Analytics.