231 lines
11 KiB
C++
231 lines
11 KiB
C++
/*
|
|
* 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 "memory/heap.hpp"
|
|
#include "utilities/debug.hpp"
|
|
#include "utilities/globalDefinitions.hpp"
|
|
#include "utilities/ostream.hpp"
|
|
|
|
class CodeHeapState : public CHeapObj<mtCode> {
|
|
|
|
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);
|
|
static bool is_readable_pointer(const void* p);
|
|
|
|
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<mtCode> {
|
|
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. Type is CodeHeapState::compType
|
|
u2 type; // used only if granularity == segment_size. Type is CodeHeapState::blobType
|
|
};
|
|
|
|
//-----------
|
|
// 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<mtCode> {
|
|
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<mtCode> {
|
|
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<mtCode> {
|
|
// 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 {
|
|
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
|