/*

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

 * Copyright (c) 2018, SAP SE.

 *

 * 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 "gc/shared/collectedHeap.hpp"

#include "classfile/classLoaderDataGraph.inline.hpp"

#include "code/codeCache.hpp"

#include "memory/allocation.hpp"

#include "memory/universe.hpp"

#include "runtime/thread.hpp"

#include "services/memTracker.hpp"

#include "services/stathist.hpp"

#include "services/stathist_internals.hpp"

#include "utilities/debug.hpp"

#include "utilities/globalDefinitions.hpp"

#include "utilities/ostream.hpp"

#include <locale.h>

#include <time.h>

// Define this switch to limit sampling to those values which can be obtained without locking.

#undef NEVER_LOCK_WHEN_SAMPLING

namespace StatisticsHistory {

namespace counters {

// These are counters for the statistics history. Ideally, they would live

// inside their thematical homes, e.g. thread.cpp or classLoaderDataGraph.cpp,

// however since this is unlikely ever to be brought upstream we keep them separate

// from central coding to ease maintenance.

static volatile size_t g_classes_loaded = 0;

static volatile size_t g_classes_unloaded = 0;

static volatile size_t g_threads_created = 0;

void inc_classes_loaded(size_t count) {

  Atomic::add(count, &g_classes_loaded);

}

void inc_classes_unloaded(size_t count) {

  Atomic::add(count, &g_classes_unloaded);

}

void inc_threads_created(size_t count) {

  Atomic::add(count, &g_threads_created);

}

} // namespace counters

// helper function for the missing outputStream::put(int c, int repeat)

static void ostream_put_n(outputStream* st, int c, int repeat) {

  for (int i = 0; i < repeat; i ++) {

    st->put(c);

  }

}

static size_t record_size_in_bytes() {

  const int num_columns = ColumnList::the_list()->num_columns();

  return sizeof(record_t) + sizeof(value_t) * (num_columns - 1);

}

static void print_text_with_dashes(outputStream* st, const char* text, int width) {

  assert(width > 0, "Sanity");

  // Print the name centered within the width like this

  // ----- system ------

  int extra_space = width - (int)strlen(text);

  if (extra_space > 0) {

    int left_space = extra_space / 2;

    int right_space = extra_space - left_space;

    ostream_put_n(st, '-', left_space);

    st->print_raw(text);

    ostream_put_n(st, '-', right_space);

  } else {

    ostream_put_n(st, '-', width);

  }

}

// Helper function for printing:

// Print to ostream, but only if ostream is given. In any case return number ofcat_process = 10,

// characters printed (or which would have been printed).

static

ATTRIBUTE_PRINTF(2, 3)

int printf_helper(outputStream* st, const char *fmt, ...) {

  // We only print numbers, so a small buffer is fine.

  char buf[64];

  va_list args;

  int len = 0;

  va_start(args, fmt);

  len = jio_vsnprintf(buf, sizeof(buf), fmt, args);

  va_end(args);

  assert((size_t)len < sizeof(buf), "Truncation. Increase bufsize.");

  if (st != NULL) {

    st->print_raw(buf);

  }

  return len;

}

// length of time stamp

#define TIMESTAMP_LEN 19

// number of spaces after time stamp

#define TIMESTAMP_DIVIDER_LEN 3

static void print_timestamp(outputStream* st, time_t t) {

  struct tm _tm;

  if (os::localtime_pd(&t, &_tm) == &_tm) {

    char buf[32];

    ::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &_tm);

    st->print("%*s", TIMESTAMP_LEN, buf);

  }

}

// A little RAII class to temporarily change locale to "C"

class CLocaleMark {

  const char* _orig;

public:

  CLocaleMark() {

    _orig = ::setlocale(LC_NUMERIC, NULL);

    ::setlocale(LC_NUMERIC, "C");

  }

  ~CLocaleMark() {

    ::setlocale(LC_NUMERIC, _orig);

  }

};

////// class ColumnList methods ////

ColumnList* ColumnList::_the_list = NULL;

bool ColumnList::initialize() {

  _the_list = new ColumnList();

  return _the_list != NULL;

}

void ColumnList::add_column(Column* c) {

  assert(c->index() == -1, "Do not add twice.");

  Column* c_last = _last;

  if (_last != NULL) {

    _last->_next = c;

    _last = c;

  } else {

    _first = _last = c;

  }

  // fix indices (describe position of column within table/category/header

  c->_idx = c->_idx_cat = c->_idx_hdr = 0;

  if (c_last != NULL) {

    c->_idx = c_last->_idx + 1;

    if (::strcmp(c->category(), c_last->category()) == 0) { // same category as last column?

      c->_idx_cat = c_last->_idx_cat + 1;

    }

    if (c->header() != NULL && c_last->header() != NULL &&

        ::strcmp(c_last->header(), c->header()) == 0) { // have header and same as last column?

      c->_idx_hdr = c_last->_idx_hdr + 1;

    }

  }

  _num_columns ++;

}

////////////////////

// At various places we need a scratch buffer of ints with one element per column; since

// after initialization the number of columns is fixed, we pre-create this.

static int* g_widths = NULL;

bool initialize_widths_buffer() {

  assert(ColumnList::the_list() != NULL && g_widths == NULL, "Initialization order problem.");

  g_widths = (int*)os::malloc(sizeof(int) * ColumnList::the_list()->num_columns(), mtInternal);

  return g_widths != NULL;

}

// pre-allocated space for a single record used to take current values when printing via dcmd.

static record_t* g_record_now = NULL;

bool initialize_space_for_now_record() {

  assert(ColumnList::the_list() != NULL && g_record_now == NULL, "Initialization order problem.");

  g_record_now = (record_t*) os::malloc(record_size_in_bytes(), mtInternal);

  return g_record_now != NULL;

}

////////////////////

static void print_category_line(outputStream* st, int widths[], const print_info_t* pi) {

  assert(pi->cvs == false, "Not in cvs mode");

  ostream_put_n(st, ' ', TIMESTAMP_LEN + TIMESTAMP_DIVIDER_LEN);

  const Column* c = ColumnList::the_list()->first();

  assert(c != NULL, "no columns?");

  const char* last_category_text = NULL;

  int width = 0;

  while(c != NULL) {

    if (c->index_within_category_section() == 0) {

      if (width > 0) {

        // Print category label centered over the last n columns, surrounded by dashes.

        print_text_with_dashes(st, last_category_text, width - 1);

        st->put(' ');

      }

      width = 0;

    }

    width += widths[c->index()];

    width += 1; // divider between columns

    last_category_text = c->category();

    c = c->next();

  }

  print_text_with_dashes(st, last_category_text, width - 1);

  st->cr();

}

static void print_header_line(outputStream* st, int widths[], const print_info_t* pi) {

  assert(pi->cvs == false, "Not in cvs mode");

  ostream_put_n(st, ' ', TIMESTAMP_LEN + TIMESTAMP_DIVIDER_LEN);

  const Column* c = ColumnList::the_list()->first();

  assert(c != NULL, "no columns?");

  const char* last_header_text = NULL;

  int width = 0;

  while(c != NULL) {

    if (c->index_within_header_section() == 0) { // First in header section

      if (width > 0) {

        if (last_header_text != NULL) {

          // Print header label centered over the last n columns, surrounded by dashes.

          print_text_with_dashes(st, last_header_text, width - 1);

          st->put(' '); // divider

        } else {

          // the last n columns had no header. Just fill with blanks.

          ostream_put_n(st, ' ', width);

        }

      }

      width = 0;

    }

    width += widths[c->index()];

    width += 1; // divider between columns

    last_header_text = c->header();

    c = c->next();

  }

  if (width > 0 && last_header_text != NULL) {

    print_text_with_dashes(st, last_header_text, width - 1);

  }

  st->cr();

}

static void print_column_names(outputStream* st, int widths[], const print_info_t* pi) {

  // Leave space for timestamp column

  if (pi->cvs == false) {

    ostream_put_n(st, ' ', TIMESTAMP_LEN + TIMESTAMP_DIVIDER_LEN);

  } else {

    st->put(',');

  }

  const Column* c = ColumnList::the_list()->first();

  const Column* previous = NULL;

  while (c != NULL) {

    if (pi->cvs == false) {

      st->print("%-*s ", widths[c->index()], c->name());

    } else { // cvs mode

      // cvs: use comma as delimiter, don't pad, and precede name with header if there is one.

      if (c->header() != NULL) {

        st->print("%s-", c->header());

      }

      st->print("%s,", c->name());

    }

    previous = c;

    c = c->next();

  }

  st->cr();

}

static void print_legend(outputStream* st, const print_info_t* pi) {

  const Column* c = ColumnList::the_list()->first();

  const Column* c_prev = NULL;

  while (c != NULL) {

    // Print category label.

    if (c->index_within_category_section() == 0) {

      print_text_with_dashes(st, c->category(), 30);

      st->cr();

    }

    // print column name and description

    const int min_width_column_label = 16;

    char buf[32];

    if (c->header() != NULL) {

      jio_snprintf(buf, sizeof(buf), "%s-%s", c->header(), c->name());

    } else {

      jio_snprintf(buf, sizeof(buf), "%s", c->name());

    }

    st->print("%*s: %s", min_width_column_label, buf, c->description());

    // If memory units are not dynamic (otion scale), print out the unit as well.

    if (c->is_memory_size() && pi->scale != 0) {

      st->print_raw(" [mem]");

    }

    // If column is a delta value, indicate so

    if (c->is_delta()) {

      st->print_raw(" [delta]");

    }

    st->cr();

    c_prev = c;

    c = c->next();

  }

  st->cr();

  st->print_cr("[delta] values refer to the previous measurement.");

  if (pi->scale != 0) {

    const char* display_unit = NULL;

    switch (pi->scale) {

      case K: display_unit = "KB"; break;

      case M: display_unit = "MB"; break;

      case G: display_unit = "GB"; break;

      default: ShouldNotReachHere();

    }

    st->print_cr("[mem] values are in %s.", display_unit);

  }

}

// Print a human readable size.

// byte_size: size, in bytes, to be printed.

// scale: K,M,G or 0 (dynamic)

// width: printing width.

static int print_memory_size(outputStream* st, size_t byte_size, size_t scale)  {

  bool print_unit = false;

  if (scale == 0) {

    print_unit = true;

    // Dynamic mode. Choose scale for this value.

    if (byte_size == 0) {

      scale = K;

    } else {

      if (byte_size >= G) {

        scale = G;

      } else if (byte_size >= M) {

        scale = M;

      } else {

        scale = K;

      }

    }

  }

  const char* display_unit = "";

  if (print_unit) {

    switch(scale) {

      case K: display_unit = "k"; break;

      case M: display_unit = "m"; break;

      case G: display_unit = "g"; break;

      default:

        ShouldNotReachHere();

    }

  }

  int l = 0;

  float display_value = (float) byte_size / scale;

  // Values smaller than 1M are shown are rounded up to whole numbers to de-clutter

  // the display. Who cares for half kbytes.

  int precision = scale < G ? 0 : 1;

  if (byte_size > 0 && byte_size < K) {

    // Prevent values smaller than one K but not 0 showing up as .

    l = printf_helper(st, "<1%s", display_unit);

  } else {

    l = printf_helper(st, "%.*f%s", precision, display_value, display_unit);

  }

  return l;

}

///////// class Column and childs ///////////

Column::Column(const char* category, const char* header, const char* name, const char* description)

  : _category(category),

    _header(header), // may be NULL

    _name(name),

    _description(description),

    _next(NULL), _idx(-1),

    _idx_cat(-1), _idx_hdr(-1)

{

  ColumnList::the_list()->add_column(this);

}

void Column::print_value(outputStream* st, value_t value, value_t last_value,

    int last_value_age, int min_width, const print_info_t* pi) const {

#ifdef ASSERT

  if (pi->raw) {

    printf_helper(st, UINT64_FORMAT, value);

    return;

  }

#endif

  // We print all values right aligned.

  int needed = calc_print_size(value, last_value, last_value_age, pi);

  if (pi->cvs == false && min_width > needed) {

    // In ascii (non cvs) mode, pad to minimum width

    ostream_put_n(st, ' ', min_width - needed);

  }

  do_print(st, value, last_value, last_value_age, pi);

}

// Returns the number of characters this value needs to be printed.

int Column::calc_print_size(value_t value, value_t last_value,

    int last_value_age, const print_info_t* pi) const {

  return do_print(NULL, value, last_value, last_value_age, pi);

}

int PlainValueColumn::do_print(outputStream* st, value_t value,

    value_t last_value, int last_value_age, const print_info_t* pi) const

{

  int l = 0;

  if (value != INVALID_VALUE) {

    l = printf_helper(st, UINT64_FORMAT, value);

  }

  return l;

}

int DeltaValueColumn::do_print(outputStream* st, value_t value,

    value_t last_value, int last_value_age, const print_info_t* pi) const {

  if (_show_only_positive && last_value > value) {

    // we assume the underlying value to be monotonically raising, and that

    // any negative delta would be just a fluke (e.g. counter overflows)

    // we do not want to show

    return 0;

  }

  int l = 0;

  if (value != INVALID_VALUE && last_value != INVALID_VALUE) {

    l = printf_helper(st, INT64_FORMAT, (int64_t)(value - last_value));

  }

  return l;

}

int MemorySizeColumn::do_print(outputStream* st, value_t value,

    value_t last_value, int last_value_age, const print_info_t* pi) const {

  int l = 0;

  if (value != INVALID_VALUE) {

    l = print_memory_size(st, value, pi->scale);

  }

  return l;

}

int DeltaMemorySizeColumn::do_print(outputStream* st, value_t value,

    value_t last_value, int last_value_age, const print_info_t* pi) const {

  int l = 0;

  if (value != INVALID_VALUE && last_value != INVALID_VALUE) {

    l = print_memory_size(st, value - last_value, pi->scale);

  }

  return l;

}

////////////// Record printing ///////////////////////////

// Print one record.

static void print_one_record(outputStream* st, const record_t* record,

    const record_t* last_record, const int widths[], const print_info_t* pi) {

  // Print timestamp and divider

  if (record->timestamp == 0) {

    st->print("%*s", TIMESTAMP_LEN, "Now");

  } else {

    print_timestamp(st, record->timestamp);

  }

  if (pi->cvs == false) {

    ostream_put_n(st, ' ', TIMESTAMP_DIVIDER_LEN);

  } else {

    st->put(',');

  }

  const Column* c = ColumnList::the_list()->first();

  while (c != NULL) {

    const int idx = c->index();

    const value_t v = record->values[idx];

    value_t v2 = INVALID_VALUE;

    int age = -1;

    if (last_record != NULL) {

      v2 = last_record->values[idx];

      age = record->timestamp - last_record->timestamp;

    }

    const int min_width = widths[idx];

    c->print_value(st, v, v2, age, min_width, pi);

    st->put(pi->cvs ? ',' : ' ');

    c = c->next();

  }

  st->cr();

}

// For each value in record, update the width in the widths array if it is smaller than

// the value printing width

static void update_widths_from_one_record(const record_t* record, const record_t* last_record, int widths[],

    const print_info_t* pi) {

  const Column* c = ColumnList::the_list()->first();

  while (c != NULL) {

    const int idx = c->index();

    const value_t v = record->values[idx];

    value_t v2 = INVALID_VALUE;

    int age = -1;

    if (last_record != NULL) {

      v2 = last_record->values[idx];

      age = record->timestamp - last_record->timestamp;

    }

    int needed = c->calc_print_size(v, v2, age, pi);

    if (widths[idx] < needed) {

      widths[idx] = needed;

    }