/*

 * 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.

 *

 */

#include "precompiled.hpp"

#include "code/codeHeapState.hpp"

#include "compiler/compileBroker.hpp"

#include "runtime/sweeper.hpp"

// -------------------------

// |  General Description  |

// -------------------------

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

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

// information that is believed useful/important.

//

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

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

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

// internal sttructure sizes in check.

//

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

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

// against concurrent aggregations. That keeps the impact on

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

//

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

// prints the previously collected information with emphasis on

// various aspects.

//

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

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

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

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

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

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

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

// structures allocated.

//

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

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

//

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

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

//   -Xlog:codecache=Trace

//

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

// VM with the

//   -Xlog:codecache=Debug

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

// condition is recognized.

//

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

//   jcmd <pid> Compiler.CodeHeap_Analytics all 4096

// ---------------------------------------------------------------------------------

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

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

//  - buffered output into a bufferedStream with subsequent flush

//    of the filled buffer to the outputStream.

#define USE_STRINGSTREAM

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

//

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

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

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

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

#if defined(USE_STRINGSTREAM)

#define STRINGSTREAM_DECL(_anyst, _outst)                 \

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

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

    ResourceMark rm;                                      \

    bufferedStream   _sstobj = bufferedStream(4*K);       \

    bufferedStream*  _sstbuf = &_sstobj;                  \

    outputStream*    _outbuf = _outst;                    \

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

#define STRINGSTREAM_FLUSH(termString)                    \

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

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

    _sstbuf->reset();

#define STRINGSTREAM_FLUSH_LOCKED(termString)             \

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

      STRINGSTREAM_FLUSH(termString)                      \

    }

#else

#define STRINGSTREAM_DECL(_anyst, _outst)                 \

    outputStream*  _outbuf = _outst;                      \

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

#define STRINGSTREAM_FLUSH(termString)                    \

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

#define STRINGSTREAM_FLUSH_LOCKED(termString)             \

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

#endif

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

const char* blobTypeName[] = {"noType"

                             ,     "nMethod (under construction)"

                             ,          "nMethod (active)"

                             ,               "nMethod (inactive)"

                             ,                    "nMethod (deopt)"

                             ,                         "nMethod (zombie)"

                             ,                              "nMethod (unloaded)"

                             ,                                   "runtime stub"

                             ,                                        "ricochet stub"

                             ,                                             "deopt stub"

                             ,                                                  "uncommon trap stub"

                             ,                                                       "exception stub"

                             ,                                                            "safepoint stub"

                             ,                                                                 "adapter blob"

                             ,                                                                      "MH adapter blob"

                             ,                                                                           "buffer blob"

                             ,                                                                                "lastType"

                             };

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

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

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

const  unsigned int        maxTopSizeBlocks  = 50;

const  unsigned int        tsbStopper        = 2 * maxTopSizeBlocks;

const  unsigned int        maxHeaps          = 10;

static unsigned int        nHeaps            = 0;

static struct CodeHeapStat CodeHeapStatArray[maxHeaps];

// static struct StatElement *StatArray      = NULL;

static StatElement* StatArray             = NULL;

static int          log2_seg_size         = 0;

static size_t       seg_size              = 0;

static size_t       alloc_granules        = 0;

static size_t       granule_size          = 0;

static bool         segment_granules      = false;

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

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

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

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

static unsigned int nBlocks_inconstr      = 0;  // counting "inconstruction" nmethods only. This is a transient state.

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

static unsigned int nBlocks_stub          = 0;

static struct FreeBlk*          FreeArray = NULL;

static unsigned int      alloc_freeBlocks = 0;

static struct TopSizeBlk*    TopSizeArray = NULL;

static unsigned int   alloc_topSizeBlocks = 0;

static unsigned int    used_topSizeBlocks = 0;

static struct SizeDistributionElement*  SizeDistributionArray = NULL;

// nMethod temperature (hotness) indicators.

static int                     avgTemp    = 0;

static int                     maxTemp    = 0;

static int                     minTemp    = 0;

static unsigned int  latest_compilation_id   = 0;

static volatile bool initialization_complete = false;

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

  if (SegmentedCodeCache) {

    return heap->name();

  } else {

    return "CodeHeap";

  }

}

// returns the index for the heap being processed.

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

  if (heapName == NULL) {

    return maxHeaps;

  }

  if (SegmentedCodeCache) {

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

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

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

        return i;

      }

    }

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

    if (nHeaps == maxHeaps) {

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

      return maxHeaps;

    }

    // allocate new slot in StatArray.

    CodeHeapStatArray[nHeaps].heapName = heapName;

    return nHeaps++;

  } else {

    nHeaps = 1;

    CodeHeapStatArray[0].heapName = heapName;

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

  }

}

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

  unsigned int ix = findHeapIndex(out, heapName);

  if (ix < maxHeaps) {

    StatArray             = CodeHeapStatArray[ix].StatArray;

    seg_size              = CodeHeapStatArray[ix].segment_size;

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

    alloc_granules        = CodeHeapStatArray[ix].alloc_granules;

    granule_size          = CodeHeapStatArray[ix].granule_size;

    segment_granules      = CodeHeapStatArray[ix].segment_granules;

    nBlocks_t1            = CodeHeapStatArray[ix].nBlocks_t1;

    nBlocks_t2            = CodeHeapStatArray[ix].nBlocks_t2;

    nBlocks_alive         = CodeHeapStatArray[ix].nBlocks_alive;

    nBlocks_dead          = CodeHeapStatArray[ix].nBlocks_dead;

    nBlocks_inconstr      = CodeHeapStatArray[ix].nBlocks_inconstr;

    nBlocks_unloaded      = CodeHeapStatArray[ix].nBlocks_unloaded;

    nBlocks_stub          = CodeHeapStatArray[ix].nBlocks_stub;

    FreeArray             = CodeHeapStatArray[ix].FreeArray;

    alloc_freeBlocks      = CodeHeapStatArray[ix].alloc_freeBlocks;

    TopSizeArray          = CodeHeapStatArray[ix].TopSizeArray;

    alloc_topSizeBlocks   = CodeHeapStatArray[ix].alloc_topSizeBlocks;

    used_topSizeBlocks    = CodeHeapStatArray[ix].used_topSizeBlocks;

    SizeDistributionArray = CodeHeapStatArray[ix].SizeDistributionArray;

    avgTemp               = CodeHeapStatArray[ix].avgTemp;

    maxTemp               = CodeHeapStatArray[ix].maxTemp;

    minTemp               = CodeHeapStatArray[ix].minTemp;

  } else {

    StatArray             = NULL;

    seg_size              = 0;

    log2_seg_size         = 0;

    alloc_granules        = 0;

    granule_size          = 0;

    segment_granules      = false;

    nBlocks_t1            = 0;

    nBlocks_t2            = 0;

    nBlocks_alive         = 0;

    nBlocks_dead          = 0;

    nBlocks_inconstr      = 0;

    nBlocks_unloaded      = 0;

    nBlocks_stub          = 0;

    FreeArray             = NULL;

    alloc_freeBlocks      = 0;

    TopSizeArray          = NULL;

    alloc_topSizeBlocks   = 0;

    used_topSizeBlocks    = 0;

    SizeDistributionArray = NULL;

    avgTemp               = 0;

    maxTemp               = 0;

    minTemp               = 0;

  }

}

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

  unsigned int ix = findHeapIndex(out, heapName);

  if (ix < maxHeaps) {

    CodeHeapStatArray[ix].StatArray             = StatArray;

    CodeHeapStatArray[ix].segment_size          = seg_size;

    CodeHeapStatArray[ix].alloc_granules        = alloc_granules;

    CodeHeapStatArray[ix].granule_size          = granule_size;

    CodeHeapStatArray[ix].segment_granules      = segment_granules;

    CodeHeapStatArray[ix].nBlocks_t1            = nBlocks_t1;

    CodeHeapStatArray[ix].nBlocks_t2            = nBlocks_t2;

    CodeHeapStatArray[ix].nBlocks_alive         = nBlocks_alive;

    CodeHeapStatArray[ix].nBlocks_dead          = nBlocks_dead;

    CodeHeapStatArray[ix].nBlocks_inconstr      = nBlocks_inconstr;

    CodeHeapStatArray[ix].nBlocks_unloaded      = nBlocks_unloaded;

    CodeHeapStatArray[ix].nBlocks_stub          = nBlocks_stub;

    CodeHeapStatArray[ix].FreeArray             = FreeArray;

    CodeHeapStatArray[ix].alloc_freeBlocks      = alloc_freeBlocks;

    CodeHeapStatArray[ix].TopSizeArray          = TopSizeArray;

    CodeHeapStatArray[ix].alloc_topSizeBlocks   = alloc_topSizeBlocks;

    CodeHeapStatArray[ix].used_topSizeBlocks    = used_topSizeBlocks;

    CodeHeapStatArray[ix].SizeDistributionArray = SizeDistributionArray;

    CodeHeapStatArray[ix].avgTemp               = avgTemp;

    CodeHeapStatArray[ix].maxTemp               = maxTemp;

    CodeHeapStatArray[ix].minTemp               = minTemp;

  }

}

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

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

  if (StatArray == NULL) {

    StatArray      = new StatElement[nElem];

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

    alloc_granules = nElem;

    granule_size   = granularity;

  }

  if (StatArray == NULL) {

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

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

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

    alloc_granules = 0;

    granule_size   = 0;

  } else {

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

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

  }

}

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

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

  if (FreeArray == NULL) {

    FreeArray      = new FreeBlk[nElem];

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

    alloc_freeBlocks = nElem;

  }

  if (FreeArray == NULL) {

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

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

    alloc_freeBlocks = 0;

  } else {

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

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

  }

}

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

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

  if (TopSizeArray == NULL) {

    TopSizeArray   = new TopSizeBlk[nElem];

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

    alloc_topSizeBlocks = nElem;

    used_topSizeBlocks  = 0;

  }

  if (TopSizeArray == NULL) {

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

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

    alloc_topSizeBlocks = 0;

  } else {

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

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

    used_topSizeBlocks  = 0;

  }

}

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

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

  if (SizeDistributionArray == NULL) {

    SizeDistributionArray = new SizeDistributionElement[nElem];

  }

  if (SizeDistributionArray == NULL) {

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

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

  } else {

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

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

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

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

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

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

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

    }

  }

}

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

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

  if (SizeDistributionArray != NULL) {

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

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

        SizeDistributionArray[i].lenSum += len;

        SizeDistributionArray[i].count++;

        break;

      }

    }

  }

}

void CodeHeapState::discard_StatArray(outputStream* out) {

  if (StatArray != NULL) {

    delete StatArray;

    StatArray        = NULL;

    alloc_granules   = 0;

    granule_size     = 0;

  }

}

void CodeHeapState::discard_FreeArray(outputStream* out) {

  if (FreeArray != NULL) {

    delete[] FreeArray;

    FreeArray        = NULL;

    alloc_freeBlocks = 0;

  }

}

void CodeHeapState::discard_TopSizeArray(outputStream* out) {

  if (TopSizeArray != NULL) {

    delete[] TopSizeArray;

    TopSizeArray        = NULL;

    alloc_topSizeBlocks = 0;

    used_topSizeBlocks  = 0;

  }

}

void CodeHeapState::discard_SizeDistArray(outputStream* out) {

  if (SizeDistributionArray != NULL) {

    delete[] SizeDistributionArray;

    SizeDistributionArray = NULL;

  }

}

// Discard all allocated internal data structures.

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

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

  if (!initialization_complete) {

    return;

  }

  if (nHeaps > 0) {

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

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

      discard_StatArray(out);

      discard_FreeArray(out);

      discard_TopSizeArray(out);

      discard_SizeDistArray(out);

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

      CodeHeapStatArray[ix].heapName = NULL;

    }

    nHeaps = 0;

  }

}

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

  unsigned int nBlocks_free    = 0;

  unsigned int nBlocks_used    = 0;

  unsigned int nBlocks_zomb    = 0;

  unsigned int nBlocks_disconn = 0;

  unsigned int nBlocks_notentr = 0;

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

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

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

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

  unsigned int  currMax          = 0;

  unsigned int  currMin          = 0;

  unsigned int  currMin_ix       = 0;

  unsigned long total_iterations = 0;

  bool  done             = false;

  const int min_granules = 256;

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

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

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

  const char* heapName   = get_heapName(heap);

  STRINGSTREAM_DECL(ast, out)

  if (!initialization_complete) {

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

    initialization_complete = true;

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

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

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

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

                  "   code is stored.\n"

                  "   \n"

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

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

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

                  "   \n");

    STRINGSTREAM_FLUSH("")

  }

  get_HeapStatGlobals(out, heapName);

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

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

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

  char*  low_bound     = heap->low_boundary();

  size_t size          = heap->capacity();

  size_t res_size      = heap->max_capacity();

  seg_size             = heap->segment_size();

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

  if (seg_size == 0) {

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

    STRINGSTREAM_FLUSH("")

    return;

  }

  // Calculate granularity of analysis (and output).

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

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

  //

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

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

  //

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

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

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

  //

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

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

  //   keep the amount of allocated storage in check.

  //

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

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

  //

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

  if (granularity > size) {

    granularity = size;

  }

  if (size/granularity < min_granules) {

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

  }

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