1 /*

     2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright (c) 2018 SAP SE. All rights reserved.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    25 

    26 #include "precompiled.hpp"

    27 #include "code/codeHeapState.hpp"

    28 #include "compiler/compileBroker.hpp"

    29 #include "runtime/sweeper.hpp"

    30 

    31 // -------------------------

    32 // |  General Description  |

    33 // -------------------------

    34 // The CodeHeap state analytics are divided in two parts.

    35 // The first part examines the entire CodeHeap and aggregates all

    36 // information that is believed useful/important.

    37 //

    38 // Aggregation condenses the information of a piece of the CodeHeap

    39 // (4096 bytes by default) into an analysis granule. These granules

    40 // contain enough detail to gain initial insight while keeping the

    41 // internal sttructure sizes in check.

    42 //

    43 // The CodeHeap is a living thing. Therefore, the aggregate is collected

    44 // under the CodeCache_lock. The subsequent print steps are only locked

    45 // against concurrent aggregations. That keeps the impact on

    46 // "normal operation" (JIT compiler and sweeper activity) to a minimum.

    47 //

    48 // The second part, which consists of several, independent steps,

    49 // prints the previously collected information with emphasis on

    50 // various aspects.

    51 //

    52 // Data collection and printing is done on an "on request" basis.

    53 // While no request is being processed, there is no impact on performance.

    54 // The CodeHeap state analytics do have some memory footprint.

    55 // The "aggregate" step allocates some data structures to hold the aggregated

    56 // information for later output. These data structures live until they are

    57 // explicitly discarded (function "discard") or until the VM terminates.

    58 // There is one exception: the function "all" does not leave any data

    59 // structures allocated.

    60 //

    61 // Requests for real-time, on-the-fly analysis can be issued via

    62 //   jcmd <pid> Compiler.CodeHeap_Analytics [<function>] [<granularity>]

    63 //

    64 // If you are (only) interested in how the CodeHeap looks like after running

    65 // a sample workload, you can use the command line option

    66 //   -Xlog:codecache=Trace

    67 //

    68 // To see the CodeHeap state in case of a "CodeCache full" condition, start the

    69 // VM with the

    70 //   -Xlog:codecache=Debug

    71 // command line option. It will produce output only for the first time the

    72 // condition is recognized.

    73 //

    74 // Both command line option variants produce output identical to the jcmd function

    75 //   jcmd <pid> Compiler.CodeHeap_Analytics all 4096

    76 // ---------------------------------------------------------------------------------

    77 

    78 // With this declaration macro, it is possible to switch between

    79 //  - direct output into an argument-passed outputStream and

    80 //  - buffered output into a bufferedStream with subsequent flush

    81 //    of the filled buffer to the outputStream.

    82 #define USE_STRINGSTREAM

    83 #define HEX32_FORMAT  "0x%x"  // just a helper format string used below multiple times

    84 //

    85 // Writing to a bufferedStream buffer first has a significant advantage:

    86 // It uses noticeably less cpu cycles and reduces (when wirting to a

    87 // network file) the required bandwidth by at least a factor of ten.

    88 // That clearly makes up for the increased code complexity.

    89 #if defined(USE_STRINGSTREAM)

    90 #define STRINGSTREAM_DECL(_anyst, _outst)                 \

    91     /* _anyst  name of the stream as used in the code */  \

    92     /* _outst  stream where final output will go to   */  \

    93     ResourceMark rm;                                      \

    94     bufferedStream   _sstobj = bufferedStream(4*K);       \

    95     bufferedStream*  _sstbuf = &_sstobj;                  \

    96     outputStream*    _outbuf = _outst;                    \

    97     bufferedStream*  _anyst  = &_sstobj; /* any stream. Use this to just print - no buffer flush.  */

    98 

    99 #define STRINGSTREAM_FLUSH(termString)                    \

   100     _sstbuf->print("%s", termString);                     \

   101     _outbuf->print("%s", _sstbuf->as_string());           \

   102     _sstbuf->reset();

   103 

   104 #define STRINGSTREAM_FLUSH_LOCKED(termString)             \

   105     { ttyLocker ttyl;/* keep this output block together */\

   106       STRINGSTREAM_FLUSH(termString)                      \

   107     }

   108 #else

   109 #define STRINGSTREAM_DECL(_anyst, _outst)                 \

   110     outputStream*  _outbuf = _outst;                      \

   111     outputStream*  _anyst  = _outst;   /* any stream. Use this to just print - no buffer flush.  */

   112 

   113 #define STRINGSTREAM_FLUSH(termString)                    \

   114     _outbuf->print("%s", termString);

   115 

   116 #define STRINGSTREAM_FLUSH_LOCKED(termString)             \

   117     _outbuf->print("%s", termString);

   118 #endif

   119 

   120 const char  blobTypeChar[] = {' ', 'N', 'I', 'X', 'Z', 'U', 'R', '?', 'D', 'T', 'E', 'S', 'A', 'M', 'B', 'L' };

   121 const char* blobTypeName[] = {"noType"

   122                              ,     "nMethod (active)"

   123                              ,          "nMethod (inactive)"

   124                              ,               "nMethod (deopt)"

   125                              ,                    "nMethod (zombie)"

   126                              ,                         "nMethod (unloaded)"

   127                              ,                              "runtime stub"

   128                              ,                                   "ricochet stub"

   129                              ,                                        "deopt stub"

   130                              ,                                             "uncommon trap stub"

   131                              ,                                                  "exception stub"

   132                              ,                                                       "safepoint stub"

   133                              ,                                                            "adapter blob"

   134                              ,                                                                 "MH adapter blob"

   135                              ,                                                                      "buffer blob"

   136                              ,                                                                           "lastType"

   137                              };

   138 const char* compTypeName[] = { "none", "c1", "c2", "jvmci" };

   139 

   140 // Be prepared for ten different CodeHeap segments. Should be enough for a few years.

   141 const  unsigned int        nSizeDistElements = 31;  // logarithmic range growth, max size: 2**32

   142 const  unsigned int        maxTopSizeBlocks  = 50;

   143 const  unsigned int        tsbStopper        = 2 * maxTopSizeBlocks;

   144 const  unsigned int        maxHeaps          = 10;

   145 static unsigned int        nHeaps            = 0;

   146 static struct CodeHeapStat CodeHeapStatArray[maxHeaps];

   147 

   148 // static struct StatElement *StatArray      = NULL;

   149 static StatElement* StatArray             = NULL;

   150 static int          log2_seg_size         = 0;

   151 static size_t       seg_size              = 0;

   152 static size_t       alloc_granules        = 0;

   153 static size_t       granule_size          = 0;

   154 static bool         segment_granules      = false;

   155 static unsigned int nBlocks_t1            = 0;  // counting "in_use" nmethods only.

   156 static unsigned int nBlocks_t2            = 0;  // counting "in_use" nmethods only.

   157 static unsigned int nBlocks_alive         = 0;  // counting "not_used" and "not_entrant" nmethods only.

   158 static unsigned int nBlocks_dead          = 0;  // counting "zombie" and "unloaded" methods only.

   159 static unsigned int nBlocks_unloaded      = 0;  // counting "unloaded" nmethods only. This is a transien state.

   160 static unsigned int nBlocks_stub          = 0;

   161 

   162 static struct FreeBlk*          FreeArray = NULL;

   163 static unsigned int      alloc_freeBlocks = 0;

   164 

   165 static struct TopSizeBlk*    TopSizeArray = NULL;

   166 static unsigned int   alloc_topSizeBlocks = 0;

   167 static unsigned int    used_topSizeBlocks = 0;

   168 

   169 static struct SizeDistributionElement*  SizeDistributionArray = NULL;

   170 

   171 // nMethod temperature (hotness) indicators.

   172 static int                     avgTemp    = 0;

   173 static int                     maxTemp    = 0;

   174 static int                     minTemp    = 0;

   175 

   176 static unsigned int  latest_compilation_id   = 0;

   177 static volatile bool initialization_complete = false;

   178 

   179 const char* CodeHeapState::get_heapName(CodeHeap* heap) {

   180   if (SegmentedCodeCache) {

   181     return heap->name();

   182   } else {

   183     return "CodeHeap";

   184   }

   185 }

   186 

   187 // returns the index for the heap being processed.

   188 unsigned int CodeHeapState::findHeapIndex(outputStream* out, const char* heapName) {

   189   if (heapName == NULL) {

   190     return maxHeaps;

   191   }

   192   if (SegmentedCodeCache) {

   193     // Search for a pre-existing entry. If found, return that index.

   194     for (unsigned int i = 0; i < nHeaps; i++) {

   195       if (CodeHeapStatArray[i].heapName != NULL && strcmp(heapName, CodeHeapStatArray[i].heapName) == 0) {

   196         return i;

   197       }

   198     }

   199 

   200     // check if there are more code heap segments than we can handle.

   201     if (nHeaps == maxHeaps) {

   202       out->print_cr("Too many heap segments for current limit(%d).", maxHeaps);

   203       return maxHeaps;

   204     }

   205 

   206     // allocate new slot in StatArray.

   207     CodeHeapStatArray[nHeaps].heapName = heapName;

   208     return nHeaps++;

   209   } else {

   210     nHeaps = 1;

   211     CodeHeapStatArray[0].heapName = heapName;

   212     return 0; // This is the default index if CodeCache is not segmented.

   213   }

   214 }

   215 

   216 void CodeHeapState::get_HeapStatGlobals(outputStream* out, const char* heapName) {

   217   unsigned int ix = findHeapIndex(out, heapName);

   218   if (ix < maxHeaps) {

   219     StatArray             = CodeHeapStatArray[ix].StatArray;

   220     seg_size              = CodeHeapStatArray[ix].segment_size;

   221     log2_seg_size         = seg_size == 0 ? 0 : exact_log2(seg_size);

   222     alloc_granules        = CodeHeapStatArray[ix].alloc_granules;

   223     granule_size          = CodeHeapStatArray[ix].granule_size;

   224     segment_granules      = CodeHeapStatArray[ix].segment_granules;

   225     nBlocks_t1            = CodeHeapStatArray[ix].nBlocks_t1;

   226     nBlocks_t2            = CodeHeapStatArray[ix].nBlocks_t2;

   227     nBlocks_alive         = CodeHeapStatArray[ix].nBlocks_alive;

   228     nBlocks_dead          = CodeHeapStatArray[ix].nBlocks_dead;

   229     nBlocks_unloaded      = CodeHeapStatArray[ix].nBlocks_unloaded;

   230     nBlocks_stub          = CodeHeapStatArray[ix].nBlocks_stub;

   231     FreeArray             = CodeHeapStatArray[ix].FreeArray;

   232     alloc_freeBlocks      = CodeHeapStatArray[ix].alloc_freeBlocks;

   233     TopSizeArray          = CodeHeapStatArray[ix].TopSizeArray;

   234     alloc_topSizeBlocks   = CodeHeapStatArray[ix].alloc_topSizeBlocks;

   235     used_topSizeBlocks    = CodeHeapStatArray[ix].used_topSizeBlocks;

   236     SizeDistributionArray = CodeHeapStatArray[ix].SizeDistributionArray;

   237     avgTemp               = CodeHeapStatArray[ix].avgTemp;

   238     maxTemp               = CodeHeapStatArray[ix].maxTemp;

   239     minTemp               = CodeHeapStatArray[ix].minTemp;

   240   } else {

   241     StatArray             = NULL;

   242     seg_size              = 0;

   243     log2_seg_size         = 0;

   244     alloc_granules        = 0;

   245     granule_size          = 0;

   246     segment_granules      = false;

   247     nBlocks_t1            = 0;

   248     nBlocks_t2            = 0;

   249     nBlocks_alive         = 0;

   250     nBlocks_dead          = 0;

   251     nBlocks_unloaded      = 0;

   252     nBlocks_stub          = 0;

   253     FreeArray             = NULL;

   254     alloc_freeBlocks      = 0;

   255     TopSizeArray          = NULL;

   256     alloc_topSizeBlocks   = 0;

   257     used_topSizeBlocks    = 0;

   258     SizeDistributionArray = NULL;

   259     avgTemp               = 0;

   260     maxTemp               = 0;

   261     minTemp               = 0;

   262   }

   263 }

   264 

   265 void CodeHeapState::set_HeapStatGlobals(outputStream* out, const char* heapName) {

   266   unsigned int ix = findHeapIndex(out, heapName);

   267   if (ix < maxHeaps) {

   268     CodeHeapStatArray[ix].StatArray             = StatArray;

   269     CodeHeapStatArray[ix].segment_size          = seg_size;

   270     CodeHeapStatArray[ix].alloc_granules        = alloc_granules;

   271     CodeHeapStatArray[ix].granule_size          = granule_size;

   272     CodeHeapStatArray[ix].segment_granules      = segment_granules;

   273     CodeHeapStatArray[ix].nBlocks_t1            = nBlocks_t1;

   274     CodeHeapStatArray[ix].nBlocks_t2            = nBlocks_t2;

   275     CodeHeapStatArray[ix].nBlocks_alive         = nBlocks_alive;

   276     CodeHeapStatArray[ix].nBlocks_dead          = nBlocks_dead;

   277     CodeHeapStatArray[ix].nBlocks_unloaded      = nBlocks_unloaded;

   278     CodeHeapStatArray[ix].nBlocks_stub          = nBlocks_stub;

   279     CodeHeapStatArray[ix].FreeArray             = FreeArray;

   280     CodeHeapStatArray[ix].alloc_freeBlocks      = alloc_freeBlocks;

   281     CodeHeapStatArray[ix].TopSizeArray          = TopSizeArray;

   282     CodeHeapStatArray[ix].alloc_topSizeBlocks   = alloc_topSizeBlocks;

   283     CodeHeapStatArray[ix].used_topSizeBlocks    = used_topSizeBlocks;

   284     CodeHeapStatArray[ix].SizeDistributionArray = SizeDistributionArray;

   285     CodeHeapStatArray[ix].avgTemp               = avgTemp;

   286     CodeHeapStatArray[ix].maxTemp               = maxTemp;

   287     CodeHeapStatArray[ix].minTemp               = minTemp;

   288   }

   289 }

   290 

   291 //---<  get a new statistics array  >---

   292 void CodeHeapState::prepare_StatArray(outputStream* out, size_t nElem, size_t granularity, const char* heapName) {

   293   if (StatArray == NULL) {

   294     StatArray      = new StatElement[nElem];

   295     //---<  reset some counts  >---

   296     alloc_granules = nElem;

   297     granule_size   = granularity;

   298   }

   299 

   300   if (StatArray == NULL) {

   301     //---<  just do nothing if allocation failed  >---

   302     out->print_cr("Statistics could not be collected for %s, probably out of memory.", heapName);

   303     out->print_cr("Current granularity is " SIZE_FORMAT " bytes. Try a coarser granularity.", granularity);

   304     alloc_granules = 0;

   305     granule_size   = 0;

   306   } else {

   307     //---<  initialize statistics array  >---

   308     memset((void*)StatArray, 0, nElem*sizeof(StatElement));

   309   }

   310 }

   311 

   312 //---<  get a new free block array  >---

   313 void CodeHeapState::prepare_FreeArray(outputStream* out, unsigned int nElem, const char* heapName) {

   314   if (FreeArray == NULL) {

   315     FreeArray      = new FreeBlk[nElem];

   316     //---<  reset some counts  >---

   317     alloc_freeBlocks = nElem;

   318   }

   319 

   320   if (FreeArray == NULL) {

   321     //---<  just do nothing if allocation failed  >---

   322     out->print_cr("Free space analysis cannot be done for %s, probably out of memory.", heapName);

   323     alloc_freeBlocks = 0;

   324   } else {

   325     //---<  initialize free block array  >---

   326     memset((void*)FreeArray, 0, alloc_freeBlocks*sizeof(FreeBlk));

   327   }

   328 }

   329 

   330 //---<  get a new TopSizeArray  >---

   331 void CodeHeapState::prepare_TopSizeArray(outputStream* out, unsigned int nElem, const char* heapName) {

   332   if (TopSizeArray == NULL) {

   333     TopSizeArray   = new TopSizeBlk[nElem];

   334     //---<  reset some counts  >---

   335     alloc_topSizeBlocks = nElem;

   336     used_topSizeBlocks  = 0;

   337   }

   338 

   339   if (TopSizeArray == NULL) {

   340     //---<  just do nothing if allocation failed  >---

   341     out->print_cr("Top-%d list of largest CodeHeap blocks can not be collected for %s, probably out of memory.", nElem, heapName);

   342     alloc_topSizeBlocks = 0;

   343   } else {

   344     //---<  initialize TopSizeArray  >---

   345     memset((void*)TopSizeArray, 0, nElem*sizeof(TopSizeBlk));

   346     used_topSizeBlocks  = 0;

   347   }

   348 }

   349 

   350 //---<  get a new SizeDistributionArray  >---

   351 void CodeHeapState::prepare_SizeDistArray(outputStream* out, unsigned int nElem, const char* heapName) {

   352   if (SizeDistributionArray == NULL) {

   353     SizeDistributionArray = new SizeDistributionElement[nElem];

   354   }

   355 

   356   if (SizeDistributionArray == NULL) {

   357     //---<  just do nothing if allocation failed  >---

   358     out->print_cr("Size distribution can not be collected for %s, probably out of memory.", heapName);

   359   } else {

   360     //---<  initialize SizeDistArray  >---

   361     memset((void*)SizeDistributionArray, 0, nElem*sizeof(SizeDistributionElement));

   362     // Logarithmic range growth. First range starts at _segment_size.

   363     SizeDistributionArray[log2_seg_size-1].rangeEnd = 1U;

   364     for (unsigned int i = log2_seg_size; i < nElem; i++) {

   365       SizeDistributionArray[i].rangeStart = 1U << (i     - log2_seg_size);

   366       SizeDistributionArray[i].rangeEnd   = 1U << ((i+1) - log2_seg_size);

   367     }

   368   }

   369 }

   370 

   371 //---<  get a new SizeDistributionArray  >---

   372 void CodeHeapState::update_SizeDistArray(outputStream* out, unsigned int len) {

   373   if (SizeDistributionArray != NULL) {

   374     for (unsigned int i = log2_seg_size-1; i < nSizeDistElements; i++) {

   375       if ((SizeDistributionArray[i].rangeStart <= len) && (len < SizeDistributionArray[i].rangeEnd)) {

   376         SizeDistributionArray[i].lenSum += len;

   377         SizeDistributionArray[i].count++;

   378         break;

   379       }

   380     }

   381   }

   382 }

   383 

   384 void CodeHeapState::discard_StatArray(outputStream* out) {

   385   if (StatArray != NULL) {

   386     delete StatArray;

   387     StatArray        = NULL;

   388     alloc_granules   = 0;

   389     granule_size     = 0;

   390   }

   391 }

   392 

   393 void CodeHeapState::discard_FreeArray(outputStream* out) {

   394   if (FreeArray != NULL) {

   395     delete[] FreeArray;

   396     FreeArray        = NULL;

   397     alloc_freeBlocks = 0;

   398   }

   399 }

   400 

   401 void CodeHeapState::discard_TopSizeArray(outputStream* out) {

   402   if (TopSizeArray != NULL) {

   403     delete[] TopSizeArray;

   404     TopSizeArray        = NULL;

   405     alloc_topSizeBlocks = 0;

   406     used_topSizeBlocks  = 0;

   407   }

   408 }

   409 

   410 void CodeHeapState::discard_SizeDistArray(outputStream* out) {

   411   if (SizeDistributionArray != NULL) {

   412     delete[] SizeDistributionArray;

   413     SizeDistributionArray = NULL;

   414   }

   415 }

   416 

   417 // Discard all allocated internal data structures.

   418 // This should be done after an analysis session is completed.

   419 void CodeHeapState::discard(outputStream* out, CodeHeap* heap) {

   420   if (!initialization_complete) {

   421     return;

   422   }

   423 

   424   if (nHeaps > 0) {

   425     for (unsigned int ix = 0; ix < nHeaps; ix++) {

   426       get_HeapStatGlobals(out, CodeHeapStatArray[ix].heapName);

   427       discard_StatArray(out);

   428       discard_FreeArray(out);

   429       discard_TopSizeArray(out);

   430       discard_SizeDistArray(out);

   431       set_HeapStatGlobals(out, CodeHeapStatArray[ix].heapName);

   432       CodeHeapStatArray[ix].heapName = NULL;

   433     }

   434     nHeaps = 0;

   435   }

   436 }

   437 

   438 void CodeHeapState::aggregate(outputStream* out, CodeHeap* heap, const char* granularity_request) {

   439   unsigned int nBlocks_free    = 0;

   440   unsigned int nBlocks_used    = 0;

   441   unsigned int nBlocks_zomb    = 0;

   442   unsigned int nBlocks_disconn = 0;

   443   unsigned int nBlocks_notentr = 0;

   444 

   445   //---<  max & min of TopSizeArray  >---

   446   //  it is sufficient to have these sizes as 32bit unsigned ints.

   447   //  The CodeHeap is limited in size to 4GB. Furthermore, the sizes

   448   //  are stored in _segment_size units, scaling them down by a factor of 64 (at least).

   449   unsigned int  currMax          = 0;

   450   unsigned int  currMin          = 0;

   451   unsigned int  currMin_ix       = 0;

   452   unsigned long total_iterations = 0;

   453 

   454   bool  done             = false;

   455   const int min_granules = 256;

   456   const int max_granules = 512*K; // limits analyzable CodeHeap (with segment_granules) to 32M..128M

   457                                   // results in StatArray size of 20M (= max_granules * 40 Bytes per element)

   458                                   // For a 1GB CodeHeap, the granule size must be at least 2kB to not violate the max_granles limit.

   459   const char* heapName   = get_heapName(heap);

   460   STRINGSTREAM_DECL(ast, out)

   461 

   462   if (!initialization_complete) {

   463     memset(CodeHeapStatArray, 0, sizeof(CodeHeapStatArray));

   464     initialization_complete = true;

   465 

   466     printBox(ast, '=', "C O D E   H E A P   A N A L Y S I S   (general remarks)", NULL);

   467     ast->print_cr("   The code heap analysis function provides deep insights into\n"

   468                   "   the inner workings and the internal state of the Java VM's\n"

   469                   "   code cache - the place where all the JVM generated machine\n"

   470                   "   code is stored.\n"

   471                   "   \n"

   472                   "   This function is designed and provided for support engineers\n"

   473                   "   to help them understand and solve issues in customer systems.\n"

   474                   "   It is not intended for use and interpretation by other persons.\n"

   475                   "   \n");

   476     STRINGSTREAM_FLUSH("")

   477   }

   478   get_HeapStatGlobals(out, heapName);

   479 

   480 

   481   // Since we are (and must be) analyzing the CodeHeap contents under the CodeCache_lock,

   482   // all heap information is "constant" and can be safely extracted/calculated before we

   483   // enter the while() loop. Actually, the loop will only be iterated once.

   484   char*  low_bound     = heap->low_boundary();

   485   size_t size          = heap->capacity();

   486   size_t res_size      = heap->max_capacity();

   487   seg_size             = heap->segment_size();

   488   log2_seg_size        = seg_size == 0 ? 0 : exact_log2(seg_size);  // This is a global static value.

   489 

   490   if (seg_size == 0) {

   491     printBox(ast, '-', "Heap not fully initialized yet, segment size is zero for segment ", heapName);

   492     STRINGSTREAM_FLUSH("")

   493     return;

   494   }

   495 

   496   // Calculate granularity of analysis (and output).

   497   //   The CodeHeap is managed (allocated) in segments (units) of CodeCacheSegmentSize.

   498   //   The CodeHeap can become fairly large, in particular in productive real-life systems.

   499   //

   500   //   It is often neither feasible nor desirable to aggregate the data with the highest possible

   501   //   level of detail, i.e. inspecting and printing each segment on its own.

   502   //

   503   //   The granularity parameter allows to specify the level of detail available in the analysis.

   504   //   It must be a positive multiple of the segment size and should be selected such that enough

   505   //   detail is provided while, at the same time, the printed output does not explode.

   506   //

   507   //   By manipulating the granularity value, we enforce that at least min_granules units

   508   //   of analysis are available. We also enforce an upper limit of max_granules units to

   509   //   keep the amount of allocated storage in check.

   510   //

   511   //   Finally, we adjust the granularity such that each granule covers at most 64k-1 segments.

   512   //   This is necessary to prevent an unsigned short overflow while accumulating space information.

   513   //

   514   size_t granularity = strtol(granularity_request, NULL, 0);

   515   if (granularity > size) {

   516     granularity = size;

   517   }

   518   if (size/granularity < min_granules) {

   519     granularity = size/min_granules;                                   // at least min_granules granules

   520   }

   521   granularity = granularity & (~(seg_size - 1));                       // must be multiple of seg_size

   522   if (granularity < seg_size) {

   523     granularity = seg_size;                                            // must be at least seg_size

   524   }

   525   if (size/granularity > max_granules) {

   526     granularity = size/max_granules;                                   // at most max_granules granules

   527   }

   528   granularity = granularity & (~(seg_size - 1));                       // must be multiple of seg_size

   529   if (granularity>>log2_seg_size >= (1L<<sizeof(unsigned short)*8)) {

   530     granularity = ((1L<<(sizeof(unsigned short)*8))-1)<<log2_seg_size; // Limit: (64k-1) * seg_size

   531   }

   532   segment_granules = granularity == seg_size;

   533   size_t granules  = (size + (granularity-1))/granularity;

   534 

   535   printBox(ast, '=', "C O D E   H E A P   A N A L Y S I S   (used blocks) for segment ", heapName);

   536   ast->print_cr("   The aggregate step takes an aggregated snapshot of the CodeHeap.\n"

   537                 "   Subsequent print functions create their output based on this snapshot.\n"

   538                 "   The CodeHeap is a living thing, and every effort has been made for the\n"

   539                 "   collected data to be consistent. Only the method names and signatures\n"

   540                 "   are retrieved at print time. That may lead to rare cases where the\n"

   541                 "   name of a method is no longer available, e.g. because it was unloaded.\n");

   542   ast->print_cr("   CodeHeap committed size " SIZE_FORMAT "K (" SIZE_FORMAT "M), reserved size " SIZE_FORMAT "K (" SIZE_FORMAT "M), %d%% occupied.",

   543                 size/(size_t)K, size/(size_t)M, res_size/(size_t)K, res_size/(size_t)M, (unsigned int)(100.0*size/res_size));

   544   ast->print_cr("   CodeHeap allocation segment size is " SIZE_FORMAT " bytes. This is the smallest possible granularity.", seg_size);

   545   ast->print_cr("   CodeHeap (committed part) is mapped to " SIZE_FORMAT " granules of size " SIZE_FORMAT " bytes.", granules, granularity);

   546   ast->print_cr("   Each granule takes " SIZE_FORMAT " bytes of C heap, that is " SIZE_FORMAT "K in total for statistics data.", sizeof(StatElement), (sizeof(StatElement)*granules)/(size_t)K);

   547   ast->print_cr("   The number of granules is limited to %dk, requiring a granules size of at least %d bytes for a 1GB heap.", (unsigned int)(max_granules/K), (unsigned int)(G/max_granules));

   548   STRINGSTREAM_FLUSH("\n")

   549 

   550 

   551   while (!done) {

   552     //---<  reset counters with every aggregation  >---

   553     nBlocks_t1       = 0;

   554     nBlocks_t2       = 0;

   555     nBlocks_alive    = 0;

   556     nBlocks_dead     = 0;

   557     nBlocks_unloaded = 0;

   558     nBlocks_stub     = 0;

   559 

   560     nBlocks_free     = 0;

   561     nBlocks_used     = 0;

   562     nBlocks_zomb     = 0;

   563     nBlocks_disconn  = 0;

   564     nBlocks_notentr  = 0;

   565 

   566     //---<  discard old arrays if size does not match  >---

   567     if (granules != alloc_granules) {

   568       discard_StatArray(out);

   569       discard_TopSizeArray(out);

   570     }

   571 

   572     //---<  allocate arrays if they don't yet exist, initialize  >---

   573     prepare_StatArray(out, granules, granularity, heapName);

   574     if (StatArray == NULL) {

   575       set_HeapStatGlobals(out, heapName);

   576       return;

   577     }

   578     prepare_TopSizeArray(out, maxTopSizeBlocks, heapName);

   579     prepare_SizeDistArray(out, nSizeDistElements, heapName);

   580 

   581     latest_compilation_id = CompileBroker::get_compilation_id();

   582     unsigned int highest_compilation_id = 0;

   583     size_t       usedSpace     = 0;

   584     size_t       t1Space       = 0;

   585     size_t       t2Space       = 0;

   586     size_t       aliveSpace    = 0;

   587     size_t       disconnSpace  = 0;

   588     size_t       notentrSpace  = 0;

   589     size_t       deadSpace     = 0;

   590     size_t       unloadedSpace = 0;

   591     size_t       stubSpace     = 0;

   592     size_t       freeSpace     = 0;

   593     size_t       maxFreeSize   = 0;

   594     HeapBlock*   maxFreeBlock  = NULL;

   595     bool         insane        = false;

   596 

   597     int64_t hotnessAccumulator = 0;

   598     unsigned int n_methods     = 0;

   599     avgTemp       = 0;

   600     minTemp       = (int)(res_size > M ? (res_size/M)*2 : 1);

   601     maxTemp       = -minTemp;

   602 

   603     for (HeapBlock *h = heap->first_block(); h != NULL && !insane; h = heap->next_block(h)) {

   604       unsigned int hb_len     = (unsigned int)h->length();  // despite being size_t, length can never overflow an unsigned int.

   605       size_t       hb_bytelen = ((size_t)hb_len)<<log2_seg_size;

   606       unsigned int ix_beg     = (unsigned int)(((char*)h-low_bound)/granule_size);

   607       unsigned int ix_end     = (unsigned int)(((char*)h-low_bound+(hb_bytelen-1))/granule_size);

   608       unsigned int compile_id = 0;

   609       CompLevel    comp_lvl   = CompLevel_none;

   610       compType     cType      = noComp;

   611       blobType     cbType     = noType;

   612 

   613       //---<  some sanity checks  >---

   614       // Do not assert here, just check, print error message and return.

   615       // This is a diagnostic function. It is not supposed to tear down the VM.

   616       if ((char*)h <  low_bound ) {

   617         insane = true; ast->print_cr("Sanity check: HeapBlock @%p below low bound (%p)", (char*)h, low_bound);

   618       }

   619       if (ix_end   >= granules  ) {

   620         insane = true; ast->print_cr("Sanity check: end index (%d) out of bounds (" SIZE_FORMAT ")", ix_end, granules);

   621       }

   622       if (size     != heap->capacity()) {

   623         insane = true; ast->print_cr("Sanity check: code heap capacity has changed (" SIZE_FORMAT "K to " SIZE_FORMAT "K)", size/(size_t)K, heap->capacity()/(size_t)K);

   624       }

   625       if (ix_beg   >  ix_end    ) {

   626         insane = true; ast->print_cr("Sanity check: end index (%d) lower than begin index (%d)", ix_end, ix_beg);

   627       }

   628       if (insane) {

   629         STRINGSTREAM_FLUSH("")

   630         continue;

   631       }

   632 

   633       if (h->free()) {

   634         nBlocks_free++;

   635         freeSpace    += hb_bytelen;

   636         if (hb_bytelen > maxFreeSize) {

   637           maxFreeSize   = hb_bytelen;

   638           maxFreeBlock  = h;

   639         }

   640       } else {

   641         update_SizeDistArray(out, hb_len);

   642         nBlocks_used++;

   643         usedSpace    += hb_bytelen;

   644         CodeBlob* cb  = (CodeBlob*)heap->find_start(h);

   645         if (cb != NULL) {

   646           cbType = get_cbType(cb);

   647           if (cb->is_nmethod()) {

   648             compile_id = ((nmethod*)cb)->compile_id();

   649             comp_lvl   = (CompLevel)((nmethod*)cb)->comp_level();

   650             if (((nmethod*)cb)->is_compiled_by_c1()) {

   651               cType = c1;

   652             }

   653             if (((nmethod*)cb)->is_compiled_by_c2()) {

   654               cType = c2;

   655             }

   656             if (((nmethod*)cb)->is_compiled_by_jvmci()) {

   657               cType = jvmci;

   658             }

   659             switch (cbType) {

   660               case nMethod_inuse: { // only for executable methods!!!

   661                 // space for these cbs is accounted for later.

   662                 int temperature = ((nmethod*)cb)->hotness_counter();

   663                 hotnessAccumulator += temperature;

   664                 n_methods++;

   665                 maxTemp = (temperature > maxTemp) ? temperature : maxTemp;

   666                 minTemp = (temperature < minTemp) ? temperature : minTemp;

   667                 break;

   668               }

   669               case nMethod_notused:

   670                 nBlocks_alive++;

   671                 nBlocks_disconn++;

   672                 aliveSpace     += hb_bytelen;

   673                 disconnSpace   += hb_bytelen;

   674                 break;

   675               case nMethod_notentrant:  // equivalent to nMethod_alive

   676                 nBlocks_alive++;

   677                 nBlocks_notentr++;

   678                 aliveSpace     += hb_bytelen;

   679                 notentrSpace   += hb_bytelen;

   680                 break;

   681               case nMethod_unloaded:

   682                 nBlocks_unloaded++;

   683                 unloadedSpace  += hb_bytelen;

   684                 break;

   685               case nMethod_dead:

   686                 nBlocks_dead++;

   687                 deadSpace      += hb_bytelen;

   688                 break;

   689               default:

   690                 break;

   691             }

   692           }

   693 

   694           //------------------------------------------

   695           //---<  register block in TopSizeArray  >---

   696           //------------------------------------------

   697           if (alloc_topSizeBlocks > 0) {

   698             if (used_topSizeBlocks == 0) {

   699               TopSizeArray[0].start    = h;

   700               TopSizeArray[0].len      = hb_len;

   701               TopSizeArray[0].index    = tsbStopper;

   702               TopSizeArray[0].compiler = cType;

   703               TopSizeArray[0].level    = comp_lvl;

   704               TopSizeArray[0].type     = cbType;

   705               currMax    = hb_len;

   706               currMin    = hb_len;

   707               currMin_ix = 0;

   708               used_topSizeBlocks++;

   709             // This check roughly cuts 5000 iterations (JVM98, mixed, dbg, termination stats):

   710             } else if ((used_topSizeBlocks < alloc_topSizeBlocks) && (hb_len < currMin)) {

   711               //---<  all blocks in list are larger, but there is room left in array  >---

   712               TopSizeArray[currMin_ix].index = used_topSizeBlocks;

   713               TopSizeArray[used_topSizeBlocks].start    = h;

   714               TopSizeArray[used_topSizeBlocks].len      = hb_len;

   715               TopSizeArray[used_topSizeBlocks].index    = tsbStopper;

   716               TopSizeArray[used_topSizeBlocks].compiler = cType;

   717               TopSizeArray[used_topSizeBlocks].level    = comp_lvl;

   718               TopSizeArray[used_topSizeBlocks].type     = cbType;

   719               currMin    = hb_len;

   720               currMin_ix = used_topSizeBlocks;

   721               used_topSizeBlocks++;

   722             } else {

   723               // This check cuts total_iterations by a factor of 6 (JVM98, mixed, dbg, termination stats):

   724               //   We don't need to search the list if we know beforehand that the current block size is

   725               //   smaller than the currently recorded minimum and there is no free entry left in the list.

   726               if (!((used_topSizeBlocks == alloc_topSizeBlocks) && (hb_len <= currMin))) {

   727                 if (currMax < hb_len) {

   728                   currMax = hb_len;

   729                 }

   730                 unsigned int i;

   731                 unsigned int prev_i  = tsbStopper;

   732                 unsigned int limit_i =  0;

   733                 for (i = 0; i != tsbStopper; i = TopSizeArray[i].index) {

   734                   if (limit_i++ >= alloc_topSizeBlocks) {

   735                     insane = true; break; // emergency exit

   736                   }

   737                   if (i >= used_topSizeBlocks)  {

   738                     insane = true; break; // emergency exit

   739                   }

   740                   total_iterations++;

   741                   if (TopSizeArray[i].len < hb_len) {

   742                     //---<  We want to insert here, element <i> is smaller than the current one  >---

   743                     if (used_topSizeBlocks < alloc_topSizeBlocks) { // still room for a new entry to insert

   744                       // old entry gets moved to the next free element of the array.

   745                       // That's necessary to keep the entry for the largest block at index 0.

   746                       // This move might cause the current minimum to be moved to another place

   747                       if (i == currMin_ix) {

   748                         assert(TopSizeArray[i].len == currMin, "sort error");

   749                         currMin_ix = used_topSizeBlocks;

   750                       }

   751                       memcpy((void*)&TopSizeArray[used_topSizeBlocks], (void*)&TopSizeArray[i], sizeof(TopSizeBlk));

   752                       TopSizeArray[i].start    = h;

   753                       TopSizeArray[i].len      = hb_len;

   754                       TopSizeArray[i].index    = used_topSizeBlocks;

   755                       TopSizeArray[i].compiler = cType;

   756                       TopSizeArray[i].level    = comp_lvl;

   757                       TopSizeArray[i].type     = cbType;

   758                       used_topSizeBlocks++;

   759                     } else { // no room for new entries, current block replaces entry for smallest block

   760                       //---<  Find last entry (entry for smallest remembered block)  >---

   761                       unsigned int      j  = i;

   762                       unsigned int prev_j  = tsbStopper;

   763                       unsigned int limit_j = 0;

   764                       while (TopSizeArray[j].index != tsbStopper) {

   765                         if (limit_j++ >= alloc_topSizeBlocks) {

   766                           insane = true; break; // emergency exit

   767                         }

   768                         if (j >= used_topSizeBlocks)  {

   769                           insane = true; break; // emergency exit

   770                         }

   771                         total_iterations++;

   772                         prev_j = j;

   773                         j      = TopSizeArray[j].index;

   774                       }

   775                       if (!insane) {

   776                         if (prev_j == tsbStopper) {

   777                           //---<  Above while loop did not iterate, we already are the min entry  >---

   778                           //---<  We have to just replace the smallest entry                      >---

   779                           currMin    = hb_len;

   780                           currMin_ix = j;

   781                           TopSizeArray[j].start    = h;

   782                           TopSizeArray[j].len      = hb_len;

   783                           TopSizeArray[j].index    = tsbStopper; // already set!!

   784                           TopSizeArray[j].compiler = cType;

   785                           TopSizeArray[j].level    = comp_lvl;

   786                           TopSizeArray[j].type     = cbType;

   787                         } else {

   788                           //---<  second-smallest entry is now smallest  >---

   789                           TopSizeArray[prev_j].index = tsbStopper;

   790                           currMin    = TopSizeArray[prev_j].len;

   791                           currMin_ix = prev_j;

   792                           //---<  smallest entry gets overwritten  >---

   793                           memcpy((void*)&TopSizeArray[j], (void*)&TopSizeArray[i], sizeof(TopSizeBlk));

   794                           TopSizeArray[i].start    = h;

   795                           TopSizeArray[i].len      = hb_len;

   796                           TopSizeArray[i].index    = j;

   797                           TopSizeArray[i].compiler = cType;

   798                           TopSizeArray[i].level    = comp_lvl;

   799                           TopSizeArray[i].type     = cbType;

   800                         }

   801                       } // insane

   802                     }

   803                     break;

   804                   }

   805                   prev_i = i;

   806                 }

   807                 if (insane) {

   808                   // Note: regular analysis could probably continue by resetting "insane" flag.

   809                   out->print_cr("Possible loop in TopSizeBlocks list detected. Analysis aborted.");

   810                   discard_TopSizeArray(out);

   811                 }

   812               }

   813             }

   814           }

   815           //----------------------------------------------

   816           //---<  END register block in TopSizeArray  >---

   817           //----------------------------------------------

   818         } else {

   819           nBlocks_zomb++;

   820         }

   821 

   822         if (ix_beg == ix_end) {

   823           StatArray[ix_beg].type = cbType;

   824           switch (cbType) {

   825             case nMethod_inuse:

   826               highest_compilation_id = (highest_compilation_id >= compile_id) ? highest_compilation_id : compile_id;

   827               if (comp_lvl < CompLevel_full_optimization) {

   828                 nBlocks_t1++;

   829                 t1Space   += hb_bytelen;

   830                 StatArray[ix_beg].t1_count++;

   831                 StatArray[ix_beg].t1_space += (unsigned short)hb_len;

   832                 StatArray[ix_beg].t1_age    = StatArray[ix_beg].t1_age < compile_id ? compile_id : StatArray[ix_beg].t1_age;

   833               } else {

   834                 nBlocks_t2++;

   835                 t2Space   += hb_bytelen;

   836                 StatArray[ix_beg].t2_count++;

   837                 StatArray[ix_beg].t2_space += (unsigned short)hb_len;

   838                 StatArray[ix_beg].t2_age    = StatArray[ix_beg].t2_age < compile_id ? compile_id : StatArray[ix_beg].t2_age;

   839               }

   840               StatArray[ix_beg].level     = comp_lvl;

   841               StatArray[ix_beg].compiler  = cType;

   842               break;

   843             case nMethod_alive:

   844               StatArray[ix_beg].tx_count++;

   845               StatArray[ix_beg].tx_space += (unsigned short)hb_len;

   846               StatArray[ix_beg].tx_age    = StatArray[ix_beg].tx_age < compile_id ? compile_id : StatArray[ix_beg].tx_age;

   847               StatArray[ix_beg].level     = comp_lvl;

   848               StatArray[ix_beg].compiler  = cType;

   849               break;

   850             case nMethod_dead:

   851             case nMethod_unloaded:

   852               StatArray[ix_beg].dead_count++;

   853               StatArray[ix_beg].dead_space += (unsigned short)hb_len;

   854               break;

   855             default:

   856               // must be a stub, if it's not a dead or alive nMethod

   857               nBlocks_stub++;

   858               stubSpace   += hb_bytelen;

   859               StatArray[ix_beg].stub_count++;

   860               StatArray[ix_beg].stub_space += (unsigned short)hb_len;

   861               break;

   862           }

   863         } else {

   864           unsigned int beg_space = (unsigned int)(granule_size - ((char*)h - low_bound - ix_beg*granule_size));

   865           unsigned int end_space = (unsigned int)(hb_bytelen - beg_space - (ix_end-ix_beg-1)*granule_size);

   866           beg_space = beg_space>>log2_seg_size;  // store in units of _segment_size

   867           end_space = end_space>>log2_seg_size;  // store in units of _segment_size

   868           StatArray[ix_beg].type = cbType;

   869           StatArray[ix_end].type = cbType;

   870           switch (cbType) {

   871             case nMethod_inuse:

   872               highest_compilation_id = (highest_compilation_id >= compile_id) ? highest_compilation_id : compile_id;

   873               if (comp_lvl < CompLevel_full_optimization) {

   874                 nBlocks_t1++;

   875                 t1Space   += hb_bytelen;

   876                 StatArray[ix_beg].t1_count++;

   877                 StatArray[ix_beg].t1_space += (unsigned short)beg_space;

   878                 StatArray[ix_beg].t1_age    = StatArray[ix_beg].t1_age < compile_id ? compile_id : StatArray[ix_beg].t1_age;

   879 

   880                 StatArray[ix_end].t1_count++;

   881                 StatArray[ix_end].t1_space += (unsigned short)end_space;

   882                 StatArray[ix_end].t1_age    = StatArray[ix_end].t1_age < compile_id ? compile_id : StatArray[ix_end].t1_age;

   883               } else {

   884                 nBlocks_t2++;

   885                 t2Space   += hb_bytelen;

   886                 StatArray[ix_beg].t2_count++;

   887                 StatArray[ix_beg].t2_space += (unsigned short)beg_space;

   888                 StatArray[ix_beg].t2_age    = StatArray[ix_beg].t2_age < compile_id ? compile_id : StatArray[ix_beg].t2_age;

   889 

   890                 StatArray[ix_end].t2_count++;

   891                 StatArray[ix_end].t2_space += (unsigned short)end_space;

   892                 StatArray[ix_end].t2_age    = StatArray[ix_end].t2_age < compile_id ? compile_id : StatArray[ix_end].t2_age;

   893               }

   894               StatArray[ix_beg].level     = comp_lvl;

   895               StatArray[ix_beg].compiler  = cType;

   896               StatArray[ix_end].level     = comp_lvl;

   897               StatArray[ix_end].compiler  = cType;

   898               break;

   899             case nMethod_alive:

   900               StatArray[ix_beg].tx_count++;

   901               StatArray[ix_beg].tx_space += (unsigned short)beg_space;

   902               StatArray[ix_beg].tx_age    = StatArray[ix_beg].tx_age < compile_id ? compile_id : StatArray[ix_beg].tx_age;

   903 

   904               StatArray[ix_end].tx_count++;

   905               StatArray[ix_end].tx_space += (unsigned short)end_space;

   906               StatArray[ix_end].tx_age    = StatArray[ix_end].tx_age < compile_id ? compile_id : StatArray[ix_end].tx_age;

   907 

   908               StatArray[ix_beg].level     = comp_lvl;

   909               StatArray[ix_beg].compiler  = cType;

   910               StatArray[ix_end].level     = comp_lvl;

   911               StatArray[ix_end].compiler  = cType;

   912               break;

   913             case nMethod_dead:

   914             case nMethod_unloaded:

   915               StatArray[ix_beg].dead_count++;

   916               StatArray[ix_beg].dead_space += (unsigned short)beg_space;

   917               StatArray[ix_end].dead_count++;

   918               StatArray[ix_end].dead_space += (unsigned short)end_space;

   919               break;

   920             default:

   921               // must be a stub, if it's not a dead or alive nMethod

   922               nBlocks_stub++;

   923               stubSpace   += hb_bytelen;

   924               StatArray[ix_beg].stub_count++;

   925               StatArray[ix_beg].stub_space += (unsigned short)beg_space;

   926               StatArray[ix_end].stub_count++;

   927               StatArray[ix_end].stub_space += (unsigned short)end_space;

   928               break;

   929           }

   930           for (unsigned int ix = ix_beg+1; ix < ix_end; ix++) {

   931             StatArray[ix].type = cbType;

   932             switch (cbType) {

   933               case nMethod_inuse:

   934                 if (comp_lvl < CompLevel_full_optimization) {

   935                   StatArray[ix].t1_count++;

   936                   StatArray[ix].t1_space += (unsigned short)(granule_size>>log2_seg_size);

   937                   StatArray[ix].t1_age    = StatArray[ix].t1_age < compile_id ? compile_id : StatArray[ix].t1_age;

   938                 } else {

   939                   StatArray[ix].t2_count++;

   940                   StatArray[ix].t2_space += (unsigned short)(granule_size>>log2_seg_size);

   941                   StatArray[ix].t2_age    = StatArray[ix].t2_age < compile_id ? compile_id : StatArray[ix].t2_age;

   942                 }

   943                 StatArray[ix].level     = comp_lvl;

   944                 StatArray[ix].compiler  = cType;

   945                 break;

   946               case nMethod_alive:

   947                 StatArray[ix].tx_count++;

   948                 StatArray[ix].tx_space += (unsigned short)(granule_size>>log2_seg_size);

   949                 StatArray[ix].tx_age    = StatArray[ix].tx_age < compile_id ? compile_id : StatArray[ix].tx_age;

   950                 StatArray[ix].level     = comp_lvl;

   951                 StatArray[ix].compiler  = cType;

   952                 break;

   953               case nMethod_dead:

   954               case nMethod_unloaded:

   955                 StatArray[ix].dead_count++;

   956                 StatArray[ix].dead_space += (unsigned short)(granule_size>>log2_seg_size);

   957                 break;

   958               default:

   959                 // must be a stub, if it's not a dead or alive nMethod

   960                 StatArray[ix].stub_count++;

   961                 StatArray[ix].stub_space += (unsigned short)(granule_size>>log2_seg_size);

   962                 break;

   963             }

   964           }

   965         }

   966       }

   967     }

   968     if (n_methods > 0) {

   969       avgTemp = hotnessAccumulator/n_methods;

   970     } else {

   971       avgTemp = 0;

   972     }

   973     done = true;

   974 

   975     if (!insane) {

   976       // There is a risk for this block (because it contains many print statements) to get

   977       // interspersed with print data from other threads. We take this risk intentionally.

   978       // Getting stalled waiting for tty_lock while holding the CodeCache_lock is not desirable.

   979       printBox(ast, '-', "Global CodeHeap statistics for segment ", heapName);

   980       ast->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);

   981       ast->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);

   982       ast->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);

   983       ast->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);

   984       ast->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);

   985       ast->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);

   986       ast->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);

   987       ast->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);

   988       ast->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);

   989       ast->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);

   990       ast->print_cr("ZombieBlocks     = %8d. These are HeapBlocks which could not be identified as CodeBlobs.", nBlocks_zomb);

   991       ast->print_cr("latest allocated compilation id = %d", latest_compilation_id);

   992       ast->print_cr("highest observed compilation id = %d", highest_compilation_id);

   993       ast->print_cr("Building TopSizeList iterations = %ld", total_iterations);

   994       ast->cr();

   995 

   996       int             reset_val = NMethodSweeper::hotness_counter_reset_val();

   997       double reverse_free_ratio = (res_size > size) ? (double)res_size/(double)(res_size-size) : (double)res_size;

   998       printBox(ast, '-', "Method hotness information at time of this analysis", NULL);

   999       ast->print_cr("Highest possible method temperature:          %12d", reset_val);

  1000       ast->print_cr("Threshold for method to be considered 'cold': %12.3f", -reset_val + reverse_free_ratio * NmethodSweepActivity);

  1001       ast->print_cr("min. hotness = %6d", minTemp);

  1002       ast->print_cr("avg. hotness = %6d", avgTemp);

  1003       ast->print_cr("max. hotness = %6d", maxTemp);

  1004       STRINGSTREAM_FLUSH("\n")

  1005 

  1006       // This loop is intentionally printing directly to "out".

  1007       out->print("Verifying collected data...");

  1008       size_t granule_segs = granule_size>>log2_seg_size;

  1009       for (unsigned int ix = 0; ix < granules; ix++) {

  1010         if (StatArray[ix].t1_count   > granule_segs) {

  1011           out->print_cr("t1_count[%d]   = %d", ix, StatArray[ix].t1_count);

  1012         }

  1013         if (StatArray[ix].t2_count   > granule_segs) {

  1014           out->print_cr("t2_count[%d]   = %d", ix, StatArray[ix].t2_count);

  1015         }

  1016         if (StatArray[ix].stub_count > granule_segs) {

  1017           out->print_cr("stub_count[%d] = %d", ix, StatArray[ix].stub_count);

  1018         }

  1019         if (StatArray[ix].dead_count > granule_segs) {

  1020           out->print_cr("dead_count[%d] = %d", ix, StatArray[ix].dead_count);

  1021         }

  1022         if (StatArray[ix].t1_space   > granule_segs) {

  1023           out->print_cr("t1_space[%d]   = %d", ix, StatArray[ix].t1_space);

  1024         }

  1025         if (StatArray[ix].t2_space   > granule_segs) {

  1026           out->print_cr("t2_space[%d]   = %d", ix, StatArray[ix].t2_space);

  1027         }

  1028         if (StatArray[ix].stub_space > granule_segs) {

  1029           out->print_cr("stub_space[%d] = %d", ix, StatArray[ix].stub_space);

  1030         }

  1031         if (StatArray[ix].dead_space > granule_segs) {

  1032           out->print_cr("dead_space[%d] = %d", ix, StatArray[ix].dead_space);

  1033         }

  1034         //   this cast is awful! I need it because NT/Intel reports a signed/unsigned mismatch.

  1035         if ((size_t)(StatArray[ix].t1_count+StatArray[ix].t2_count+StatArray[ix].stub_count+StatArray[ix].dead_count) > granule_segs) {

  1036           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);

  1037         }

  1038         if ((size_t)(StatArray[ix].t1_space+StatArray[ix].t2_space+StatArray[ix].stub_space+StatArray[ix].dead_space) > granule_segs) {

  1039           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);

  1040         }

  1041       }

  1042 

  1043       // This loop is intentionally printing directly to "out".

  1044       if (used_topSizeBlocks > 0) {

  1045         unsigned int j = 0;

  1046         if (TopSizeArray[0].len != currMax) {

  1047           out->print_cr("currMax(%d) differs from TopSizeArray[0].len(%d)", currMax, TopSizeArray[0].len);

  1048         }

  1049         for (unsigned int i = 0; (TopSizeArray[i].index != tsbStopper) && (j++ < alloc_topSizeBlocks); i = TopSizeArray[i].index) {

  1050           if (TopSizeArray[i].len < TopSizeArray[TopSizeArray[i].index].len) {

  1051             out->print_cr("sort error at index %d: %d !>= %d", i, TopSizeArray[i].len, TopSizeArray[TopSizeArray[i].index].len);

  1052           }

  1053         }

  1054         if (j >= alloc_topSizeBlocks) {

  1055           out->print_cr("Possible loop in TopSizeArray chaining!\n  allocBlocks = %d, usedBlocks = %d", alloc_topSizeBlocks, used_topSizeBlocks);

  1056           for (unsigned int i = 0; i < alloc_topSizeBlocks; i++) {

  1057             out->print_cr("  TopSizeArray[%d].index = %d, len = %d", i, TopSizeArray[i].index, TopSizeArray[i].len);

  1058           }

  1059         }

  1060       }

  1061       out->print_cr("...done\n\n");

  1062     } else {

  1063       // insane heap state detected. Analysis data incomplete. Just throw it away.

  1064       discard_StatArray(out);

  1065       discard_TopSizeArray(out);

  1066     }

  1067   }

  1068 

  1069 

  1070   done        = false;

  1071   while (!done && (nBlocks_free > 0)) {

  1072 

  1073     printBox(ast, '=', "C O D E   H E A P   A N A L Y S I S   (free blocks) for segment ", heapName);

  1074     ast->print_cr("   The aggregate step collects information about all free blocks in CodeHeap.\n"

  1075                   "   Subsequent print functions create their output based on this snapshot.\n");

  1076     ast->print_cr("   Free space in %s is distributed over %d free blocks.", heapName, nBlocks_free);

  1077     ast->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);

  1078     STRINGSTREAM_FLUSH("\n")

  1079 

  1080     //----------------------------------------

  1081     //--  Prepare the FreeArray of FreeBlks --

  1082     //----------------------------------------

  1083 

  1084     //---< discard old array if size does not match  >---

  1085     if (nBlocks_free != alloc_freeBlocks) {

  1086       discard_FreeArray(out);

  1087     }

  1088 

  1089     prepare_FreeArray(out, nBlocks_free, heapName);

  1090     if (FreeArray == NULL) {

  1091       done = true;

  1092       continue;

  1093     }

  1094 

  1095     //----------------------------------------

  1096     //--  Collect all FreeBlks in FreeArray --

  1097     //----------------------------------------

  1098 

  1099     unsigned int ix = 0;

  1100     FreeBlock* cur  = heap->freelist();

  1101 

  1102     while (cur != NULL) {

  1103       if (ix < alloc_freeBlocks) { // don't index out of bounds if _freelist has more blocks than anticipated

  1104         FreeArray[ix].start = cur;

  1105         FreeArray[ix].len   = (unsigned int)(cur->length()<<log2_seg_size);

  1106         FreeArray[ix].index = ix;

  1107       }

  1108       cur  = cur->link();

  1109       ix++;

  1110     }

  1111     if (ix != alloc_freeBlocks) {

  1112       ast->print_cr("Free block count mismatch. Expected %d free blocks, but found %d.", alloc_freeBlocks, ix);

  1113       ast->print_cr("I will update the counter and retry data collection");

  1114       STRINGSTREAM_FLUSH("\n")

  1115       nBlocks_free = ix;

  1116       continue;

  1117     }

  1118     done = true;

  1119   }

  1120 

  1121   if (!done || (nBlocks_free == 0)) {

  1122     if (nBlocks_free == 0) {

  1123       printBox(ast, '-', "no free blocks found in", heapName);

  1124     } else if (!done) {

  1125       ast->print_cr("Free block count mismatch could not be resolved.");

  1126       ast->print_cr("Try to run \"aggregate\" function to update counters");

  1127     }

  1128     STRINGSTREAM_FLUSH("")

  1129 

  1130     //---< discard old array and update global values  >---

  1131     discard_FreeArray(out);

  1132     set_HeapStatGlobals(out, heapName);

  1133     return;

  1134   }

  1135