/*

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

 * Copyright (c) 2018, 2019 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 structure sizes in check.

//

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

// prints the previously collected information with emphasis on

// various aspects.

//

// The CodeHeap is a living thing. Therefore, protection against concurrent

// modification (by acquiring the CodeCache_lock) is necessary. It has

// to be provided by the caller of the analysis functions.

// If the CodeCache_lock is not held, the analysis functions may print

// less detailed information or may just do nothing. It is by intention

// that an unprotected invocation is not abnormally terminated.

//

// 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

//   -XX:+PrintCodeHeapAnalytics

// It will cause a full analysis to be written to tty. In addition, a full

// analysis will be written the first time a "CodeCache full" condition is

// detected.

//

// The command line option produces 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_BUFFEREDSTREAM

// There are instances when composing an output line or a small set of

// output lines out of many tty->print() calls creates significant overhead.

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

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

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

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

//

// Conversion of existing code is easy and straightforward, if the code already

// uses a parameterized output destination, e.g. "outputStream st".

//  - rename the formal parameter to any other name, e.g. out_st.

//  - at a suitable place in your code, insert

//      BUFFEREDSTEAM_DECL(buf_st, out_st)

// This will provide all the declarations necessary. After that, all

// buf_st->print() (and the like) calls will be directed to a bufferedStream object.

// Once a block of output (a line or a small set of lines) is composed, insert

//      BUFFEREDSTREAM_FLUSH(termstring)

// to flush the bufferedStream to the final destination out_st. termstring is just

// an arbitrary string (e.g. "\n") which is appended to the bufferedStream before

// being written to out_st. Be aware that the last character written MUST be a '\n'.

// Otherwise, buf_st->position() does not correspond to out_st->position() any longer.

//      BUFFEREDSTREAM_FLUSH_LOCKED(termstring)

// does the same thing, protected by the ttyLocker lock.

//      BUFFEREDSTREAM_FLUSH_IF(termstring, remSize)

// does a flush only if the remaining buffer space is less than remSize.

//

// To activate, #define USE_BUFFERED_STREAM before including this header.

// If not activated, output will directly go to the originally used outputStream

// with no additional overhead.

//

#if defined(USE_BUFFEREDSTREAM)

// All necessary declarations to print via a bufferedStream

// This macro must be placed before any other BUFFEREDSTREAM*

// macro in the function.

#define BUFFEREDSTREAM_DECL_SIZE(_anyst, _outst, _capa)       \

    ResourceMark         _rm;                                 \

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

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

    /* _capa   allocated capacity of stream buffer    */      \

    size_t           _nflush = 0;                             \

    size_t     _nforcedflush = 0;                             \

    size_t      _nsavedflush = 0;                             \

    size_t     _nlockedflush = 0;                             \

    size_t     _nflush_bytes = 0;                             \

    size_t         _capacity = _capa;                         \

    bufferedStream   _sstobj(_capa);                          \

    bufferedStream*  _sstbuf = &_sstobj;                      \

    outputStream*    _outbuf = _outst;                        \

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

// Same as above, but with fixed buffer size.

#define BUFFEREDSTREAM_DECL(_anyst, _outst)                   \

    BUFFEREDSTREAM_DECL_SIZE(_anyst, _outst, 4*K);

// Flush the buffer contents unconditionally.

// No action if the buffer is empty.

#define BUFFEREDSTREAM_FLUSH(_termString)                     \

    if (((_termString) != NULL) && (strlen(_termString) > 0)){\

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

    }                                                         \

    if (_sstbuf != _outbuf) {                                 \

      if (_sstbuf->size() != 0) {                             \

        _nforcedflush++; _nflush_bytes += _sstbuf->size();    \

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

        _sstbuf->reset();                                     \

      }                                                       \

    }

// Flush the buffer contents if the remaining capacity is

// less than the given threshold.

#define BUFFEREDSTREAM_FLUSH_IF(_termString, _remSize)        \

    if (((_termString) != NULL) && (strlen(_termString) > 0)){\

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

    }                                                         \

    if (_sstbuf != _outbuf) {                                 \

      if ((_capacity - _sstbuf->size()) < (size_t)(_remSize)){\

        _nflush++; _nforcedflush--;                           \

        BUFFEREDSTREAM_FLUSH("")                              \

      } else {                                                \

        _nsavedflush++;                                       \

      }                                                       \

    }

// Flush the buffer contents if the remaining capacity is less

// than the calculated threshold (256 bytes + capacity/16)

// That should suffice for all reasonably sized output lines.

#define BUFFEREDSTREAM_FLUSH_AUTO(_termString)                \

    BUFFEREDSTREAM_FLUSH_IF(_termString, 256+(_capacity>>4))

#define BUFFEREDSTREAM_FLUSH_LOCKED(_termString)              \

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

      _nlockedflush++;                                        \

      BUFFEREDSTREAM_FLUSH(_termString)                       \

    }

// #define BUFFEREDSTREAM_FLUSH_STAT()                           \

//     if (_sstbuf != _outbuf) {                                 \

//       _outbuf->print_cr("%ld flushes (buffer full), %ld forced, %ld locked, %ld bytes total, %ld flushes saved", _nflush, _nforcedflush, _nlockedflush, _nflush_bytes, _nsavedflush); \

//    }

#define BUFFEREDSTREAM_FLUSH_STAT()

#else

#define BUFFEREDSTREAM_DECL_SIZE(_anyst, _outst, _capa)       \

    size_t       _capacity = _capa;                           \

    outputStream*  _outbuf = _outst;                          \

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

#define BUFFEREDSTREAM_DECL(_anyst, _outst)                   \

    BUFFEREDSTREAM_DECL_SIZE(_anyst, _outst, 4*K)

#define BUFFEREDSTREAM_FLUSH(_termString)                     \

    if (((_termString) != NULL) && (strlen(_termString) > 0)){\

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

    }

#define BUFFEREDSTREAM_FLUSH_IF(_termString, _remSize)        \

    BUFFEREDSTREAM_FLUSH(_termString)

#define BUFFEREDSTREAM_FLUSH_AUTO(_termString)                \

    BUFFEREDSTREAM_FLUSH(_termString)

#define BUFFEREDSTREAM_FLUSH_LOCKED(_termString)              \

    BUFFEREDSTREAM_FLUSH(_termString)

#define BUFFEREDSTREAM_FLUSH_STAT()

#endif

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

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) {