/*

 * Copyright (c) 2015, 2018, Oracle and/or its affiliates. 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 "gc/z/zCollectedHeap.hpp"

#include "gc/z/zCPU.hpp"

#include "gc/z/zGlobals.hpp"

#include "gc/z/zHeap.inline.hpp"

#include "gc/z/zLargePages.inline.hpp"

#include "gc/z/zNMethodTable.hpp"

#include "gc/z/zNUMA.hpp"

#include "gc/z/zStat.hpp"

#include "gc/z/zTracer.inline.hpp"

#include "gc/z/zUtils.hpp"

#include "memory/resourceArea.hpp"

#include "runtime/atomic.hpp"

#include "runtime/os.hpp"

#include "runtime/timer.hpp"

#include "utilities/align.hpp"

#include "utilities/compilerWarnings.hpp"

#include "utilities/debug.hpp"

#include "utilities/ticks.hpp"

//

// Stat sampler/counter data

//

struct ZStatSamplerData {

  uint64_t _nsamples;

  uint64_t _sum;

  uint64_t _max;

  ZStatSamplerData() :

    _nsamples(0),

    _sum(0),

    _max(0) {}

  void add(const ZStatSamplerData& new_sample) {

    _nsamples += new_sample._nsamples;

    _sum += new_sample._nsamples;

    _max = MAX2(_max, new_sample._max);

  }

};

struct ZStatCounterData {

  uint64_t _counter;

  ZStatCounterData() :

    _counter(0) {}

};

//

// Stat sampler history

//

template <size_t size>

class ZStatSamplerHistoryInterval {

private:

  size_t           _next;

  ZStatSamplerData _samples[size];

  ZStatSamplerData _accumulated;

  ZStatSamplerData _total;

public:

  ZStatSamplerHistoryInterval() :

      _next(0),

      _samples(),

      _accumulated(),

      _total() {}

  bool add(const ZStatSamplerData& new_sample) {

    // Insert sample

    const ZStatSamplerData old_sample = _samples[_next];

    _samples[_next] = new_sample;

    // Adjust accumulated

    _accumulated._nsamples += new_sample._nsamples;

    _accumulated._sum += new_sample._sum;

    _accumulated._max = MAX2(_accumulated._max, new_sample._max);

    // Adjust total

    _total._nsamples -= old_sample._nsamples;

    _total._sum -= old_sample._sum;

    _total._nsamples += new_sample._nsamples;

    _total._sum += new_sample._sum;

    if (_total._max < new_sample._max) {

      // Found new max

      _total._max = new_sample._max;

    } else if (_total._max == old_sample._max) {

      // Removed old max, reset and find new max

      _total._max = 0;

      for (size_t i = 0; i < size; i++) {

        if (_total._max < _samples[i]._max) {

          _total._max = _samples[i]._max;

        }

      }

    }

    // Adjust next

    if (++_next == size) {

      _next = 0;

      // Clear accumulated

      const ZStatSamplerData zero;

      _accumulated = zero;

      // Became full

      return true;

    }

    // Not yet full

    return false;

  }

  const ZStatSamplerData& total() const {

    return _total;

  }

  const ZStatSamplerData& accumulated() const {

    return _accumulated;

  }

};

class ZStatSamplerHistory : public CHeapObj<mtGC> {

private:

  ZStatSamplerHistoryInterval<10> _10seconds;

  ZStatSamplerHistoryInterval<60> _10minutes;

  ZStatSamplerHistoryInterval<60> _10hours;

  ZStatSamplerData                _total;

  uint64_t avg(uint64_t sum, uint64_t nsamples) const {

    return (nsamples > 0) ? sum / nsamples : 0;

  }

public:

  ZStatSamplerHistory() :

      _10seconds(),

      _10minutes(),

      _10hours(),

      _total() {}

  void add(const ZStatSamplerData& new_sample) {

    if (_10seconds.add(new_sample)) {

      if (_10minutes.add(_10seconds.total())) {

        if (_10hours.add(_10minutes.total())) {

          _total.add(_10hours.total());

        }

      }

    }

  }

  uint64_t avg_10_seconds() const {

    const uint64_t sum      = _10seconds.total()._sum;

    const uint64_t nsamples = _10seconds.total()._nsamples;

    return avg(sum, nsamples);

  }

  uint64_t avg_10_minutes() const {

    const uint64_t sum      = _10seconds.accumulated()._sum +

                              _10minutes.total()._sum;

    const uint64_t nsamples = _10seconds.accumulated()._nsamples +

                              _10minutes.total()._nsamples;

    return avg(sum, nsamples);

  }

  uint64_t avg_10_hours() const {

    const uint64_t sum      = _10seconds.accumulated()._sum +

                              _10minutes.accumulated()._sum +

                              _10hours.total()._sum;

    const uint64_t nsamples = _10seconds.accumulated()._nsamples +

                              _10minutes.accumulated()._nsamples +

                              _10hours.total()._nsamples;

    return avg(sum, nsamples);

  }

  uint64_t avg_total() const {

    const uint64_t sum      = _10seconds.accumulated()._sum +

                              _10minutes.accumulated()._sum +

                              _10hours.accumulated()._sum +

                              _total._sum;

    const uint64_t nsamples = _10seconds.accumulated()._nsamples +

                              _10minutes.accumulated()._nsamples +

                              _10hours.accumulated()._nsamples +

                              _total._nsamples;

    return avg(sum, nsamples);

  }

  uint64_t max_10_seconds() const {

    return _10seconds.total()._max;

  }

  uint64_t max_10_minutes() const {

    return MAX2(_10seconds.accumulated()._max,

                _10minutes.total()._max);

  }

  uint64_t max_10_hours() const {

    return MAX3(_10seconds.accumulated()._max,

                _10minutes.accumulated()._max,

                _10hours.total()._max);

  }

  uint64_t max_total() const {

    return MAX4(_10seconds.accumulated()._max,

                _10minutes.accumulated()._max,

                _10hours.accumulated()._max,

                _total._max);

  }

};

//

// Stat unit printers

//

void ZStatUnitTime(LogTargetHandle log, const ZStatSampler& sampler, const ZStatSamplerHistory& history) {

  log.print(" %10s: %-40s  "

            "%9.3f / %-9.3f "

            "%9.3f / %-9.3f "

            "%9.3f / %-9.3f "

            "%9.3f / %-9.3f   ms",

            sampler.group(),

            sampler.name(),

            TimeHelper::counter_to_millis(history.avg_10_seconds()),

            TimeHelper::counter_to_millis(history.max_10_seconds()),

            TimeHelper::counter_to_millis(history.avg_10_minutes()),

            TimeHelper::counter_to_millis(history.max_10_minutes()),

            TimeHelper::counter_to_millis(history.avg_10_hours()),

            TimeHelper::counter_to_millis(history.max_10_hours()),

            TimeHelper::counter_to_millis(history.avg_total()),

            TimeHelper::counter_to_millis(history.max_total()));

}

void ZStatUnitBytes(LogTargetHandle log, const ZStatSampler& sampler, const ZStatSamplerHistory& history) {

  log.print(" %10s: %-40s  "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) "   MB",

            sampler.group(),

            sampler.name(),

            history.avg_10_seconds() / M,

            history.max_10_seconds() / M,

            history.avg_10_minutes() / M,

            history.max_10_minutes() / M,

            history.avg_10_hours() / M,

            history.max_10_hours() / M,

            history.avg_total() / M,

            history.max_total() / M);

}

void ZStatUnitThreads(LogTargetHandle log, const ZStatSampler& sampler, const ZStatSamplerHistory& history) {

  log.print(" %10s: %-40s  "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) "   threads",

            sampler.group(),

            sampler.name(),

            history.avg_10_seconds(),

            history.max_10_seconds(),

            history.avg_10_minutes(),

            history.max_10_minutes(),

            history.avg_10_hours(),

            history.max_10_hours(),

            history.avg_total(),

            history.max_total());

}

void ZStatUnitBytesPerSecond(LogTargetHandle log, const ZStatSampler& sampler, const ZStatSamplerHistory& history) {

  log.print(" %10s: %-40s  "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) "   MB/s",

            sampler.group(),

            sampler.name(),

            history.avg_10_seconds() / M,

            history.max_10_seconds() / M,

            history.avg_10_minutes() / M,

            history.max_10_minutes() / M,

            history.avg_10_hours() / M,

            history.max_10_hours() / M,

            history.avg_total() / M,

            history.max_total() / M);

}

void ZStatUnitOpsPerSecond(LogTargetHandle log, const ZStatSampler& sampler, const ZStatSamplerHistory& history) {

  log.print(" %10s: %-40s  "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) " "

            UINT64_FORMAT_W(9) " / " UINT64_FORMAT_W(-9) "   ops/s",

            sampler.group(),

            sampler.name(),

            history.avg_10_seconds(),

            history.max_10_seconds(),

            history.avg_10_minutes(),

            history.max_10_minutes(),

            history.avg_10_hours(),

            history.max_10_hours(),

            history.avg_total(),

            history.max_total());

}

//

// Stat value

//

uintptr_t ZStatValue::_base = 0;

uint32_t  ZStatValue::_cpu_offset = 0;

ZStatValue::ZStatValue(const char* group,

                          const char* name,

                          uint32_t id,

                          uint32_t size) :

    _group(group),

    _name(name),

    _id(id),

    _offset(_cpu_offset) {

  assert(_base == 0, "Already initialized");

  _cpu_offset += size;

}

template <typename T>

T* ZStatValue::get_cpu_local(uint32_t cpu) const {

  assert(_base != 0, "Not initialized");

  const uintptr_t cpu_base = _base + (_cpu_offset * cpu);

  const uintptr_t value_addr = cpu_base + _offset;

  return (T*)value_addr;

}

void ZStatValue::initialize() {

  // Finalize and align CPU offset

  _cpu_offset = align_up(_cpu_offset, ZCacheLineSize);

  // Allocation aligned memory

  const size_t size = _cpu_offset * ZCPU::count();

  _base = ZUtils::alloc_aligned(ZCacheLineSize, size);

  memset((void*)_base, 0, size);

}

const char* ZStatValue::group() const {

  return _group;

}

const char* ZStatValue::name() const {

  return _name;

}

uint32_t ZStatValue::id() const {

  return _id;

}

//

// Stat iterable value

//

template <typename T> uint32_t ZStatIterableValue<T>::_count = 0;

template <typename T> T*       ZStatIterableValue<T>::_first = NULL;

template <typename T>

ZStatIterableValue<T>::ZStatIterableValue(const char* group,

                                          const char* name,

                                          uint32_t size) :

    ZStatValue(group, name, _count++, size),

    _next(insert()) {}

template <typename T>

T* ZStatIterableValue<T>::insert() const {

  T** current = &_first;

  while (*current != NULL) {

    // First sort by group, then by name

    const int group_cmp = strcmp((*current)->group(), group());

    const int name_cmp = strcmp((*current)->name(), name());

    if ((group_cmp > 0) || (group_cmp == 0 && name_cmp > 0)) {

      break;

    }

    current = &(*current)->_next;

  }

  T* const next = *current;

  *current = (T*)this;

  return next;

}

//

// Stat sampler

//

ZStatSampler::ZStatSampler(const char* group, const char* name, ZStatUnitPrinter printer) :

    ZStatIterableValue<ZStatSampler>(group, name, sizeof(ZStatSamplerData)),

    _printer(printer) {}

ZStatSamplerData* ZStatSampler::get() const {

  return get_cpu_local<ZStatSamplerData>(ZCPU::id());

}

ZStatSamplerData ZStatSampler::collect_and_reset() const {

  ZStatSamplerData all;

  const uint32_t ncpus = ZCPU::count();

  for (uint32_t i = 0; i < ncpus; i++) {

    ZStatSamplerData* const cpu_data = get_cpu_local<ZStatSamplerData>(i);

    if (cpu_data->_nsamples > 0) {

      const uint64_t nsamples = Atomic::xchg((uint64_t)0, &cpu_data->_nsamples);

      const uint64_t sum = Atomic::xchg((uint64_t)0, &cpu_data->_sum);

      const uint64_t max = Atomic::xchg((uint64_t)0, &cpu_data->_max);

      all._nsamples += nsamples;

      all._sum += sum;

      if (all._max < max) {

        all._max = max;

      }

    }

  }

  return all;

}

ZStatUnitPrinter ZStatSampler::printer() const {

  return _printer;

}

//

// Stat counter

//

ZStatCounter::ZStatCounter(const char* group, const char* name, ZStatUnitPrinter printer) :

    ZStatIterableValue<ZStatCounter>(group, name, sizeof(ZStatCounterData)),

    _sampler(group, name, printer) {}

ZStatCounterData* ZStatCounter::get() const {

  return get_cpu_local<ZStatCounterData>(ZCPU::id());

}

void ZStatCounter::sample_and_reset() const {

  uint64_t counter = 0;

  const uint32_t ncpus = ZCPU::count();

  for (uint32_t i = 0; i < ncpus; i++) {

    ZStatCounterData* const cpu_data = get_cpu_local<ZStatCounterData>(i);

    counter += Atomic::xchg((uint64_t)0, &cpu_data->_counter);

  }

  ZStatSample(_sampler, counter);

}

//

// Stat unsampled counter

//

ZStatUnsampledCounter::ZStatUnsampledCounter(const char* name) :

    ZStatIterableValue<ZStatUnsampledCounter>("Unsampled", name, sizeof(ZStatCounterData)) {}

ZStatCounterData* ZStatUnsampledCounter::get() const {

  return get_cpu_local<ZStatCounterData>(ZCPU::id());

}

ZStatCounterData ZStatUnsampledCounter::collect_and_reset() const {

  ZStatCounterData all;

  const uint32_t ncpus = ZCPU::count();

  for (uint32_t i = 0; i < ncpus; i++) {

    ZStatCounterData* const cpu_data = get_cpu_local<ZStatCounterData>(i);

    all._counter += Atomic::xchg((uint64_t)0, &cpu_data->_counter);

  }

  return all;

}

//

// Stat MMU (Minimum Mutator Utilization)

//

ZStatMMUPause::ZStatMMUPause() :

    _start(0.0),

    _end(0.0) {}

ZStatMMUPause::ZStatMMUPause(const Ticks& start, const Ticks& end) :

    _start(TimeHelper::counter_to_millis(start.value())),

    _end(TimeHelper::counter_to_millis(end.value())) {}

double ZStatMMUPause::end() const {

  return _end;

}

double ZStatMMUPause::overlap(double start, double end) const {

  const double start_max = MAX2(start, _start);

  const double end_min = MIN2(end, _end);

  if (end_min > start_max) {

    // Overlap found

    return end_min - start_max;

  }

  // No overlap

  return 0.0;

}

size_t ZStatMMU::_next = 0;

size_t ZStatMMU::_npauses = 0;

ZStatMMUPause ZStatMMU::_pauses[200];

double ZStatMMU::_mmu_2ms = 100.0;

double ZStatMMU::_mmu_5ms = 100.0;

double ZStatMMU::_mmu_10ms = 100.0;

double ZStatMMU::_mmu_20ms = 100.0;

double ZStatMMU::_mmu_50ms = 100.0;

double ZStatMMU::_mmu_100ms = 100.0;

const ZStatMMUPause& ZStatMMU::pause(size_t index) {

  return _pauses[(_next - index - 1) % ARRAY_SIZE(_pauses)];

}

double ZStatMMU::calculate_mmu(double time_slice) {

  const double end = pause(0).end();