src/hotspot/share/code/codeHeapState.hpp - platform/libcore - Git at Google

 /*
  * 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 to the CompiledMethod enum values.
     // We can't use the CompiledMethod values 1:1 because we depend on noType == 0.
     nMethod_inconstruction, // under construction. Very soon, the type will transition to "in_use".
     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<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_inconstr;
     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
	/*
	* 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 to the CompiledMethod enum values.
	// We can't use the CompiledMethod values 1:1 because we depend on noType == 0.
	nMethod_inconstruction, // under construction. Very soon, the type will transition to "in_use".
	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<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_inconstr;
	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