/* * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2018 SAP SE. 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. * */ #ifndef SHARE_CODE_CODEHEAPSTATE_HPP #define SHARE_CODE_CODEHEAPSTATE_HPP // #include "code/codeBlob.hpp" // #include "memory/allocation.hpp" #include "memory/heap.hpp" // #include "memory/virtualspace.hpp" // #include "utilities/macros.hpp" #include "utilities/debug.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/ostream.hpp" class CodeHeapState : public CHeapObj { public: enum compType { noComp = 0, // must be! due to initialization by memset to zero c1, c2, jvmci, lastComp }; enum blobType { noType = 0, // must be! due to initialization by memset to zero // The nMethod_* values correspond 1:1 to the CompiledMethod enum values. nMethod_inuse, // executable. This is the "normal" state for a nmethod. nMethod_notused, // assumed inactive, marked not entrant. Could be revived if necessary. nMethod_notentrant, // no new activations allowed, marked for deoptimization. Old activations may still exist. // Will transition to "zombie" after all activations are gone. nMethod_zombie, // No more activations exist, ready for purge (remove from code cache). nMethod_unloaded, // No activations exist, should not be called. Transient state on the way to "zombie". nMethod_alive = nMethod_notentrant, // Combined state: nmethod may have activations, thus can't be purged. nMethod_dead = nMethod_zombie, // Combined state: nmethod does not have any activations. runtimeStub = nMethod_unloaded + 1, ricochetStub, deoptimizationStub, uncommonTrapStub, exceptionStub, safepointStub, adapterBlob, mh_adapterBlob, bufferBlob, lastType }; private: static void prepare_StatArray(outputStream* out, size_t nElem, size_t granularity, const char* heapName); static void prepare_FreeArray(outputStream* out, unsigned int nElem, const char* heapName); static void prepare_TopSizeArray(outputStream* out, unsigned int nElem, const char* heapName); static void prepare_SizeDistArray(outputStream* out, unsigned int nElem, const char* heapName); static void discard_StatArray(outputStream* out); static void discard_FreeArray(outputStream* out); static void discard_TopSizeArray(outputStream* out); static void discard_SizeDistArray(outputStream* out); static void update_SizeDistArray(outputStream* out, unsigned int len); static const char* get_heapName(CodeHeap* heap); static unsigned int findHeapIndex(outputStream* out, const char* heapName); static void get_HeapStatGlobals(outputStream* out, const char* heapName); static void set_HeapStatGlobals(outputStream* out, const char* heapName); static void printBox(outputStream* out, const char border, const char* text1, const char* text2); static void print_blobType_legend(outputStream* out); static void print_space_legend(outputStream* out); static void print_age_legend(outputStream* out); static void print_blobType_single(outputStream *ast, u2 /* blobType */ type); static void print_count_single(outputStream *ast, unsigned short count); static void print_space_single(outputStream *ast, unsigned short space); static void print_age_single(outputStream *ast, unsigned int age); static void print_line_delim(outputStream* out, bufferedStream *sst, char* low_bound, unsigned int ix, unsigned int gpl); static void print_line_delim(outputStream* out, outputStream *sst, char* low_bound, unsigned int ix, unsigned int gpl); static blobType get_cbType(CodeBlob* cb); public: static void discard(outputStream* out, CodeHeap* heap); static void aggregate(outputStream* out, CodeHeap* heap, const char* granularity); static void print_usedSpace(outputStream* out, CodeHeap* heap); static void print_freeSpace(outputStream* out, CodeHeap* heap); static void print_count(outputStream* out, CodeHeap* heap); static void print_space(outputStream* out, CodeHeap* heap); static void print_age(outputStream* out, CodeHeap* heap); static void print_names(outputStream* out, CodeHeap* heap); }; //---------------- // 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 // CodeHeapState::compType compiler; // compiler which generated this blob // CodeHeapState::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; size_t segment_size; // 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; }; #endif // SHARE_CODE_CODEHEAPSTATE_HPP