| /* |
| * Copyright (c) 2015, 2019, 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.inline.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" |
| |
| #define ZSIZE_FMT SIZE_FORMAT "M(%.0f%%)" |
| #define ZSIZE_ARGS(size) ((size) / M), (percent_of(size, ZStatHeap::max_capacity())) |
| |
| #define ZTABLE_ARGS_NA "%9s", "-" |
| #define ZTABLE_ARGS(size) SIZE_FORMAT_W(8) "M (%.0f%%)", \ |
| ((size) / M), (percent_of(size, ZStatHeap::max_capacity())) |
| |
| // |
| // 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._sum; |
| _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: %-41s " |
| "%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: %-41s " |
| 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: %-41s " |
| 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: %-41s " |
| 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: %-41s " |
| 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, (uint32_t)ZCacheLineSize); |
| |
| // Allocation aligned memory |
| const size_t size = _cpu_offset * ZCPU::count(); |
| _base = ZUtils::alloc_aligned(ZCacheLineSize, 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(&cpu_data->_nsamples, (uint64_t)0); |
| const uint64_t sum = Atomic::xchg(&cpu_data->_sum, (uint64_t)0); |
| const uint64_t max = Atomic::xchg(&cpu_data->_max, (uint64_t)0); |
| 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(&cpu_data->_counter, (uint64_t)0); |
| } |
| |
| 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(&cpu_data->_counter, (uint64_t)0); |
| } |
| |
| 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(); |
| const double start = end - time_slice; |
| double time_paused = 0.0; |
| |
| // Find all overlapping pauses |
| for (size_t i = 0; i < _npauses; i++) { |
| const double overlap = pause(i).overlap(start, end); |
| if (overlap == 0.0) { |
| // No overlap |
| break; |
| } |
| |
| time_paused += overlap; |
| } |
| |
| // Calculate MMU |
| const double time_mutator = time_slice - time_paused; |
| return percent_of(time_mutator, time_slice); |
| } |
| |
| void ZStatMMU::register_pause(const Ticks& start, const Ticks& end) { |
| // Add pause |
| const size_t index = _next++ % ARRAY_SIZE(_pauses); |
| _pauses[index] = ZStatMMUPause(start, end); |
| _npauses = MIN2(_npauses + 1, ARRAY_SIZE(_pauses)); |
| |
| // Recalculate MMUs |
| _mmu_2ms = MIN2(_mmu_2ms, calculate_mmu(2)); |
| _mmu_5ms = MIN2(_mmu_5ms, calculate_mmu(5)); |
| _mmu_10ms = MIN2(_mmu_10ms, calculate_mmu(10)); |
| _mmu_20ms = MIN2(_mmu_20ms, calculate_mmu(20)); |
| _mmu_50ms = MIN2(_mmu_50ms, calculate_mmu(50)); |
| _mmu_100ms = MIN2(_mmu_100ms, calculate_mmu(100)); |
| } |
| |
| void ZStatMMU::print() { |
| log_info(gc, mmu)("MMU: 2ms/%.1f%%, 5ms/%.1f%%, 10ms/%.1f%%, 20ms/%.1f%%, 50ms/%.1f%%, 100ms/%.1f%%", |
| _mmu_2ms, _mmu_5ms, _mmu_10ms, _mmu_20ms, _mmu_50ms, _mmu_100ms); |
| } |
| |
| // |
| // Stat phases |
| // |
| ConcurrentGCTimer ZStatPhase::_timer; |
| |
| ZStatPhase::ZStatPhase(const char* group, const char* name) : |
| _sampler(group, name, ZStatUnitTime) {} |
| |
| void ZStatPhase::log_start(LogTargetHandle log, bool thread) const { |
| if (!log.is_enabled()) { |
| return; |
| } |
| |
| if (thread) { |
| ResourceMark rm; |
| log.print("%s (%s)", name(), Thread::current()->name()); |
| } else { |
| log.print("%s", name()); |
| } |
| } |
| |
| void ZStatPhase::log_end(LogTargetHandle log, const Tickspan& duration, bool thread) const { |
| if (!log.is_enabled()) { |
| return; |
| } |
| |
| if (thread) { |
| ResourceMark rm; |
| log.print("%s (%s) %.3fms", name(), Thread::current()->name(), TimeHelper::counter_to_millis(duration.value())); |
| } else { |
| log.print("%s %.3fms", name(), TimeHelper::counter_to_millis(duration.value())); |
| } |
| } |
| |
| ConcurrentGCTimer* ZStatPhase::timer() { |
| return &_timer; |
| } |
| |
| const char* ZStatPhase::name() const { |
| return _sampler.name(); |
| } |
| |
| ZStatPhaseCycle::ZStatPhaseCycle(const char* name) : |
| ZStatPhase("Collector", name) {} |
| |
| void ZStatPhaseCycle::register_start(const Ticks& start) const { |
| timer()->register_gc_start(start); |
| |
| ZTracer::tracer()->report_gc_start(ZCollectedHeap::heap()->gc_cause(), start); |
| |
| ZCollectedHeap::heap()->print_heap_before_gc(); |
| ZCollectedHeap::heap()->trace_heap_before_gc(ZTracer::tracer()); |
| |
| log_info(gc, start)("Garbage Collection (%s)", |
| GCCause::to_string(ZCollectedHeap::heap()->gc_cause())); |
| } |
| |
| void ZStatPhaseCycle::register_end(const Ticks& start, const Ticks& end) const { |
| timer()->register_gc_end(end); |
| |
| ZCollectedHeap::heap()->print_heap_after_gc(); |
| ZCollectedHeap::heap()->trace_heap_after_gc(ZTracer::tracer()); |
| |
| ZTracer::tracer()->report_gc_end(end, timer()->time_partitions()); |
| |
| const Tickspan duration = end - start; |
| ZStatSample(_sampler, duration.value()); |
| |
| ZStatLoad::print(); |
| ZStatMMU::print(); |
| ZStatMark::print(); |
| ZStatRelocation::print(); |
| ZStatNMethods::print(); |
| ZStatMetaspace::print(); |
| ZStatReferences::print(); |
| ZStatHeap::print(); |
| |
| log_info(gc)("Garbage Collection (%s) " ZSIZE_FMT "->" ZSIZE_FMT, |
| GCCause::to_string(ZCollectedHeap::heap()->gc_cause()), |
| ZSIZE_ARGS(ZStatHeap::used_at_mark_start()), |
| ZSIZE_ARGS(ZStatHeap::used_at_relocate_end())); |
| } |
| |
| Tickspan ZStatPhasePause::_max; |
| |
| ZStatPhasePause::ZStatPhasePause(const char* name) : |
| ZStatPhase("Phase", name) {} |
| |
| const Tickspan& ZStatPhasePause::max() { |
| return _max; |
| } |
| |
| void ZStatPhasePause::register_start(const Ticks& start) const { |
| timer()->register_gc_pause_start(name(), start); |
| |
| LogTarget(Debug, gc, phases, start) log; |
| log_start(log); |
| } |
| |
| void ZStatPhasePause::register_end(const Ticks& start, const Ticks& end) const { |
| timer()->register_gc_pause_end(end); |
| |
| const Tickspan duration = end - start; |
| ZStatSample(_sampler, duration.value()); |
| |
| // Track max pause time |
| if (_max < duration) { |
| _max = duration; |
| } |
| |
| // Track minimum mutator utilization |
| ZStatMMU::register_pause(start, end); |
| |
| LogTarget(Info, gc, phases) log; |
| log_end(log, duration); |
| } |
| |
| ZStatPhaseConcurrent::ZStatPhaseConcurrent(const char* name) : |
| ZStatPhase("Phase", name) {} |
| |
| void ZStatPhaseConcurrent::register_start(const Ticks& start) const { |
| timer()->register_gc_concurrent_start(name(), start); |
| |
| LogTarget(Debug, gc, phases, start) log; |
| log_start(log); |
| } |
| |
| void ZStatPhaseConcurrent::register_end(const Ticks& start, const Ticks& end) const { |
| timer()->register_gc_concurrent_end(end); |
| |
| const Tickspan duration = end - start; |
| ZStatSample(_sampler, duration.value()); |
| |
| LogTarget(Info, gc, phases) log; |
| log_end(log, duration); |
| } |
| |
| ZStatSubPhase::ZStatSubPhase(const char* name) : |
| ZStatPhase("Subphase", name) {} |
| |
| void ZStatSubPhase::register_start(const Ticks& start) const { |
| LogTarget(Debug, gc, phases, start) log; |
| log_start(log, true /* thread */); |
| } |
| |
| void ZStatSubPhase::register_end(const Ticks& start, const Ticks& end) const { |
| ZTracer::tracer()->report_thread_phase(name(), start, end); |
| |
| const Tickspan duration = end - start; |
| ZStatSample(_sampler, duration.value()); |
| |
| LogTarget(Debug, gc, phases) log; |
| log_end(log, duration, true /* thread */); |
| } |
| |
| ZStatCriticalPhase::ZStatCriticalPhase(const char* name, bool verbose) : |
| ZStatPhase("Critical", name), |
| _counter("Critical", name, ZStatUnitOpsPerSecond), |
| _verbose(verbose) {} |
| |
| void ZStatCriticalPhase::register_start(const Ticks& start) const { |
| LogTarget(Debug, gc, start) log; |
| log_start(log, true /* thread */); |
| } |
| |
| void ZStatCriticalPhase::register_end(const Ticks& start, const Ticks& end) const { |
| ZTracer::tracer()->report_thread_phase(name(), start, end); |
| |
| const Tickspan duration = end - start; |
| ZStatSample(_sampler, duration.value()); |
| ZStatInc(_counter); |
| |
| if (_verbose) { |
| LogTarget(Info, gc) log; |
| log_end(log, duration, true /* thread */); |
| } else { |
| LogTarget(Debug, gc) log; |
| log_end(log, duration, true /* thread */); |
| } |
| } |
| |
| // |
| // Stat timer |
| // |
| THREAD_LOCAL uint32_t ZStatTimerDisable::_active = 0; |
| |
| // |
| // Stat sample/inc |
| // |
| void ZStatSample(const ZStatSampler& sampler, uint64_t value) { |
| ZStatSamplerData* const cpu_data = sampler.get(); |
| Atomic::add(&cpu_data->_nsamples, 1u); |
| Atomic::add(&cpu_data->_sum, value); |
| |
| uint64_t max = cpu_data->_max; |
| for (;;) { |
| if (max >= value) { |
| // Not max |
| break; |
| } |
| |
| const uint64_t new_max = value; |
| const uint64_t prev_max = Atomic::cmpxchg(new_max, &cpu_data->_max, max); |
| if (prev_max == max) { |
| // Success |
| break; |
| } |
| |
| // Retry |
| max = prev_max; |
| } |
| |
| ZTracer::tracer()->report_stat_sampler(sampler, value); |
| } |
| |
| void ZStatInc(const ZStatCounter& counter, uint64_t increment) { |
| ZStatCounterData* const cpu_data = counter.get(); |
| const uint64_t value = Atomic::add(&cpu_data->_counter, increment); |
| |
| ZTracer::tracer()->report_stat_counter(counter, increment, value); |
| } |
| |
| void ZStatInc(const ZStatUnsampledCounter& counter, uint64_t increment) { |
| ZStatCounterData* const cpu_data = counter.get(); |
| Atomic::add(&cpu_data->_counter, increment); |
| } |
| |
| // |
| // Stat allocation rate |
| // |
| const ZStatUnsampledCounter ZStatAllocRate::_counter("Allocation Rate"); |
| TruncatedSeq ZStatAllocRate::_rate(ZStatAllocRate::sample_window_sec * ZStatAllocRate::sample_hz); |
| TruncatedSeq ZStatAllocRate::_rate_avg(ZStatAllocRate::sample_window_sec * ZStatAllocRate::sample_hz); |
| |
| const ZStatUnsampledCounter& ZStatAllocRate::counter() { |
| return _counter; |
| } |
| |
| uint64_t ZStatAllocRate::sample_and_reset() { |
| const ZStatCounterData bytes_per_sample = _counter.collect_and_reset(); |
| const uint64_t bytes_per_second = bytes_per_sample._counter * sample_hz; |
| |
| _rate.add(bytes_per_second); |
| _rate_avg.add(_rate.avg()); |
| |
| return bytes_per_second; |
| } |
| |
| double ZStatAllocRate::avg() { |
| return _rate.avg(); |
| } |
| |
| double ZStatAllocRate::avg_sd() { |
| return _rate_avg.sd(); |
| } |
| |
| // |
| // Stat thread |
| // |
| ZStat::ZStat() : |
| _metronome(sample_hz) { |
| set_name("ZStat"); |
| create_and_start(); |
| } |
| |
| void ZStat::sample_and_collect(ZStatSamplerHistory* history) const { |
| // Sample counters |
| for (const ZStatCounter* counter = ZStatCounter::first(); counter != NULL; counter = counter->next()) { |
| counter->sample_and_reset(); |
| } |
| |
| // Collect samples |
| for (const ZStatSampler* sampler = ZStatSampler::first(); sampler != NULL; sampler = sampler->next()) { |
| ZStatSamplerHistory& sampler_history = history[sampler->id()]; |
| sampler_history.add(sampler->collect_and_reset()); |
| } |
| } |
| |
| bool ZStat::should_print(LogTargetHandle log) const { |
| static uint64_t print_at = ZStatisticsInterval; |
| const uint64_t now = os::elapsedTime(); |
| |
| if (now < print_at) { |
| return false; |
| } |
| |
| print_at = ((now / ZStatisticsInterval) * ZStatisticsInterval) + ZStatisticsInterval; |
| |
| return log.is_enabled(); |
| } |
| |
| void ZStat::print(LogTargetHandle log, const ZStatSamplerHistory* history) const { |
| // Print |
| log.print("=== Garbage Collection Statistics ======================================================================================================================="); |
| log.print(" Last 10s Last 10m Last 10h Total"); |
| log.print(" Avg / Max Avg / Max Avg / Max Avg / Max"); |
| |
| for (const ZStatSampler* sampler = ZStatSampler::first(); sampler != NULL; sampler = sampler->next()) { |
| const ZStatSamplerHistory& sampler_history = history[sampler->id()]; |
| const ZStatUnitPrinter printer = sampler->printer(); |
| printer(log, *sampler, sampler_history); |
| } |
| |
| log.print("========================================================================================================================================================="); |
| } |
| |
| void ZStat::run_service() { |
| ZStatSamplerHistory* const history = new ZStatSamplerHistory[ZStatSampler::count()]; |
| LogTarget(Info, gc, stats) log; |
| |
| // Main loop |
| while (_metronome.wait_for_tick()) { |
| sample_and_collect(history); |
| if (should_print(log)) { |
| print(log, history); |
| } |
| } |
| |
| delete [] history; |
| } |
| |
| void ZStat::stop_service() { |
| _metronome.stop(); |
| } |
| |
| // |
| // Stat table |
| // |
| class ZStatTablePrinter { |
| private: |
| static const size_t _buffer_size = 256; |
| |
| const size_t _column0_width; |
| const size_t _columnN_width; |
| char _buffer[_buffer_size]; |
| |
| public: |
| class ZColumn { |
| private: |
| char* const _buffer; |
| const size_t _position; |
| const size_t _width; |
| const size_t _width_next; |
| |
| ZColumn next() const { |
| // Insert space between columns |
| _buffer[_position + _width] = ' '; |
| return ZColumn(_buffer, _position + _width + 1, _width_next, _width_next); |
| } |
| |
| size_t print(size_t position, const char* fmt, va_list va) { |
| const int res = jio_vsnprintf(_buffer + position, _buffer_size - position, fmt, va); |
| if (res < 0) { |
| return 0; |
| } |
| |
| return (size_t)res; |
| } |
| |
| public: |
| ZColumn(char* buffer, size_t position, size_t width, size_t width_next) : |
| _buffer(buffer), |
| _position(position), |
| _width(width), |
| _width_next(width_next) {} |
| |
| ZColumn left(const char* fmt, ...) ATTRIBUTE_PRINTF(2, 3) { |
| va_list va; |
| |
| va_start(va, fmt); |
| const size_t written = print(_position, fmt, va); |
| va_end(va); |
| |
| if (written < _width) { |
| // Fill empty space |
| memset(_buffer + _position + written, ' ', _width - written); |
| } |
| |
| return next(); |
| } |
| |
| ZColumn right(const char* fmt, ...) ATTRIBUTE_PRINTF(2, 3) { |
| va_list va; |
| |
| va_start(va, fmt); |
| const size_t written = print(_position, fmt, va); |
| va_end(va); |
| |
| if (written > _width) { |
| // Line too long |
| return fill('?'); |
| } |
| |
| if (written < _width) { |
| // Short line, move all to right |
| memmove(_buffer + _position + _width - written, _buffer + _position, written); |
| |
| // Fill empty space |
| memset(_buffer + _position, ' ', _width - written); |
| } |
| |
| return next(); |
| } |
| |
| ZColumn center(const char* fmt, ...) ATTRIBUTE_PRINTF(2, 3) { |
| va_list va; |
| |
| va_start(va, fmt); |
| const size_t written = print(_position, fmt, va); |
| va_end(va); |
| |
| if (written > _width) { |
| // Line too long |
| return fill('?'); |
| } |
| |
| if (written < _width) { |
| // Short line, move all to center |
| const size_t start_space = (_width - written) / 2; |
| const size_t end_space = _width - written - start_space; |
| memmove(_buffer + _position + start_space, _buffer + _position, written); |
| |
| // Fill empty spaces |
| memset(_buffer + _position, ' ', start_space); |
| memset(_buffer + _position + start_space + written, ' ', end_space); |
| } |
| |
| return next(); |
| } |
| |
| ZColumn fill(char filler = ' ') { |
| memset(_buffer + _position, filler, _width); |
| return next(); |
| } |
| |
| const char* end() { |
| _buffer[_position] = '\0'; |
| return _buffer; |
| } |
| }; |
| |
| public: |
| ZStatTablePrinter(size_t column0_width, size_t columnN_width) : |
| _column0_width(column0_width), |
| _columnN_width(columnN_width) {} |
| |
| ZColumn operator()() { |
| return ZColumn(_buffer, 0, _column0_width, _columnN_width); |
| } |
| }; |
| |
| // |
| // Stat cycle |
| // |
| uint64_t ZStatCycle::_nwarmup_cycles = 0; |
| Ticks ZStatCycle::_start_of_last; |
| Ticks ZStatCycle::_end_of_last; |
| NumberSeq ZStatCycle::_normalized_duration(0.3 /* alpha */); |
| |
| void ZStatCycle::at_start() { |
| _start_of_last = Ticks::now(); |
| } |
| |
| void ZStatCycle::at_end(GCCause::Cause cause, double boost_factor) { |
| _end_of_last = Ticks::now(); |
| |
| if (cause == GCCause::_z_warmup) { |
| _nwarmup_cycles++; |
| } |
| |
| // Calculate normalized cycle duration. The measured duration is |
| // normalized using the boost factor to avoid artificial deflation |
| // of the duration when boost mode is enabled. |
| const double duration = (_end_of_last - _start_of_last).seconds(); |
| const double normalized_duration = duration * boost_factor; |
| _normalized_duration.add(normalized_duration); |
| } |
| |
| bool ZStatCycle::is_warm() { |
| return _nwarmup_cycles >= 3; |
| } |
| |
| uint64_t ZStatCycle::nwarmup_cycles() { |
| return _nwarmup_cycles; |
| } |
| |
| bool ZStatCycle::is_normalized_duration_trustable() { |
| // The normalized duration is considered trustable if we have |
| // completed at least one warmup cycle |
| return _nwarmup_cycles > 0; |
| } |
| |
| const AbsSeq& ZStatCycle::normalized_duration() { |
| return _normalized_duration; |
| } |
| |
| double ZStatCycle::time_since_last() { |
| if (_end_of_last.value() == 0) { |
| // No end recorded yet, return time since VM start |
| return os::elapsedTime(); |
| } |
| |
| const Ticks now = Ticks::now(); |
| const Tickspan time_since_last = now - _end_of_last; |
| return time_since_last.seconds(); |
| } |
| |
| // |
| // Stat load |
| // |
| void ZStatLoad::print() { |
| double loadavg[3] = {}; |
| os::loadavg(loadavg, ARRAY_SIZE(loadavg)); |
| log_info(gc, load)("Load: %.2f/%.2f/%.2f", loadavg[0], loadavg[1], loadavg[2]); |
| } |
| |
| // |
| // Stat mark |
| // |
| size_t ZStatMark::_nstripes; |
| size_t ZStatMark::_nproactiveflush; |
| size_t ZStatMark::_nterminateflush; |
| size_t ZStatMark::_ntrycomplete; |
| size_t ZStatMark::_ncontinue; |
| |
| void ZStatMark::set_at_mark_start(size_t nstripes) { |
| _nstripes = nstripes; |
| } |
| |
| void ZStatMark::set_at_mark_end(size_t nproactiveflush, |
| size_t nterminateflush, |
| size_t ntrycomplete, |
| size_t ncontinue) { |
| _nproactiveflush = nproactiveflush; |
| _nterminateflush = nterminateflush; |
| _ntrycomplete = ntrycomplete; |
| _ncontinue = ncontinue; |
| } |
| |
| void ZStatMark::print() { |
| log_info(gc, marking)("Mark: " |
| SIZE_FORMAT " stripe(s), " |
| SIZE_FORMAT " proactive flush(es), " |
| SIZE_FORMAT " terminate flush(es), " |
| SIZE_FORMAT " completion(s), " |
| SIZE_FORMAT " continuation(s) ", |
| _nstripes, |
| _nproactiveflush, |
| _nterminateflush, |
| _ntrycomplete, |
| _ncontinue); |
| } |
| |
| // |
| // Stat relocation |
| // |
| size_t ZStatRelocation::_relocating; |
| bool ZStatRelocation::_success; |
| |
| void ZStatRelocation::set_at_select_relocation_set(size_t relocating) { |
| _relocating = relocating; |
| } |
| |
| void ZStatRelocation::set_at_relocate_end(bool success) { |
| _success = success; |
| } |
| |
| void ZStatRelocation::print() { |
| if (_success) { |
| log_info(gc, reloc)("Relocation: Successful, " SIZE_FORMAT "M relocated", _relocating / M); |
| } else { |
| log_info(gc, reloc)("Relocation: Incomplete"); |
| } |
| } |
| |
| // |
| // Stat nmethods |
| // |
| void ZStatNMethods::print() { |
| log_info(gc, nmethod)("NMethods: " SIZE_FORMAT " registered, " SIZE_FORMAT " unregistered", |
| ZNMethodTable::registered_nmethods(), |
| ZNMethodTable::unregistered_nmethods()); |
| } |
| |
| // |
| // Stat metaspace |
| // |
| void ZStatMetaspace::print() { |
| log_info(gc, metaspace)("Metaspace: " |
| SIZE_FORMAT "M used, " SIZE_FORMAT "M capacity, " |
| SIZE_FORMAT "M committed, " SIZE_FORMAT "M reserved", |
| MetaspaceUtils::used_bytes() / M, |
| MetaspaceUtils::capacity_bytes() / M, |
| MetaspaceUtils::committed_bytes() / M, |
| MetaspaceUtils::reserved_bytes() / M); |
| } |
| |
| // |
| // Stat references |
| // |
| ZStatReferences::ZCount ZStatReferences::_soft; |
| ZStatReferences::ZCount ZStatReferences::_weak; |
| ZStatReferences::ZCount ZStatReferences::_final; |
| ZStatReferences::ZCount ZStatReferences::_phantom; |
| |
| void ZStatReferences::set(ZCount* count, size_t encountered, size_t discovered, size_t enqueued) { |
| count->encountered = encountered; |
| count->discovered = discovered; |
| count->enqueued = enqueued; |
| } |
| |
| void ZStatReferences::set_soft(size_t encountered, size_t discovered, size_t enqueued) { |
| set(&_soft, encountered, discovered, enqueued); |
| } |
| |
| void ZStatReferences::set_weak(size_t encountered, size_t discovered, size_t enqueued) { |
| set(&_weak, encountered, discovered, enqueued); |
| } |
| |
| void ZStatReferences::set_final(size_t encountered, size_t discovered, size_t enqueued) { |
| set(&_final, encountered, discovered, enqueued); |
| } |
| |
| void ZStatReferences::set_phantom(size_t encountered, size_t discovered, size_t enqueued) { |
| set(&_phantom, encountered, discovered, enqueued); |
| } |
| |
| void ZStatReferences::print(const char* name, const ZStatReferences::ZCount& ref) { |
| log_info(gc, ref)("%s: " |
| SIZE_FORMAT " encountered, " |
| SIZE_FORMAT " discovered, " |
| SIZE_FORMAT " enqueued", |
| name, |
| ref.encountered, |
| ref.discovered, |
| ref.enqueued); |
| } |
| |
| void ZStatReferences::print() { |
| print("Soft", _soft); |
| print("Weak", _weak); |
| print("Final", _final); |
| print("Phantom", _phantom); |
| } |
| |
| // |
| // Stat heap |
| // |
| ZStatHeap::ZAtInitialize ZStatHeap::_at_initialize; |
| ZStatHeap::ZAtMarkStart ZStatHeap::_at_mark_start; |
| ZStatHeap::ZAtMarkEnd ZStatHeap::_at_mark_end; |
| ZStatHeap::ZAtRelocateStart ZStatHeap::_at_relocate_start; |
| ZStatHeap::ZAtRelocateEnd ZStatHeap::_at_relocate_end; |
| |
| size_t ZStatHeap::capacity_high() { |
| return MAX4(_at_mark_start.capacity, |
| _at_mark_end.capacity, |
| _at_relocate_start.capacity, |
| _at_relocate_end.capacity); |
| } |
| |
| size_t ZStatHeap::capacity_low() { |
| return MIN4(_at_mark_start.capacity, |
| _at_mark_end.capacity, |
| _at_relocate_start.capacity, |
| _at_relocate_end.capacity); |
| } |
| |
| size_t ZStatHeap::available(size_t used) { |
| return _at_initialize.max_capacity - used; |
| } |
| |
| size_t ZStatHeap::reserve(size_t used) { |
| return MIN2(_at_initialize.max_reserve, available(used)); |
| } |
| |
| size_t ZStatHeap::free(size_t used) { |
| return available(used) - reserve(used); |
| } |
| |
| void ZStatHeap::set_at_initialize(size_t min_capacity, |
| size_t max_capacity, |
| size_t max_reserve) { |
| _at_initialize.min_capacity = min_capacity; |
| _at_initialize.max_capacity = max_capacity; |
| _at_initialize.max_reserve = max_reserve; |
| } |
| |
| void ZStatHeap::set_at_mark_start(size_t soft_max_capacity, |
| size_t capacity, |
| size_t used) { |
| _at_mark_start.soft_max_capacity = soft_max_capacity; |
| _at_mark_start.capacity = capacity; |
| _at_mark_start.reserve = reserve(used); |
| _at_mark_start.used = used; |
| _at_mark_start.free = free(used); |
| } |
| |
| void ZStatHeap::set_at_mark_end(size_t capacity, |
| size_t allocated, |
| size_t used) { |
| _at_mark_end.capacity = capacity; |
| _at_mark_end.reserve = reserve(used); |
| _at_mark_end.allocated = allocated; |
| _at_mark_end.used = used; |
| _at_mark_end.free = free(used); |
| } |
| |
| void ZStatHeap::set_at_select_relocation_set(size_t live, |
| size_t garbage, |
| size_t reclaimed) { |
| _at_mark_end.live = live; |
| _at_mark_end.garbage = garbage; |
| |
| _at_relocate_start.garbage = garbage - reclaimed; |
| _at_relocate_start.reclaimed = reclaimed; |
| } |
| |
| void ZStatHeap::set_at_relocate_start(size_t capacity, |
| size_t allocated, |
| size_t used) { |
| _at_relocate_start.capacity = capacity; |
| _at_relocate_start.reserve = reserve(used); |
| _at_relocate_start.allocated = allocated; |
| _at_relocate_start.used = used; |
| _at_relocate_start.free = free(used); |
| } |
| |
| void ZStatHeap::set_at_relocate_end(size_t capacity, |
| size_t allocated, |
| size_t reclaimed, |
| size_t used, |
| size_t used_high, |
| size_t used_low) { |
| _at_relocate_end.capacity = capacity; |
| _at_relocate_end.capacity_high = capacity_high(); |
| _at_relocate_end.capacity_low = capacity_low(); |
| _at_relocate_end.reserve = reserve(used); |
| _at_relocate_end.reserve_high = reserve(used_low); |
| _at_relocate_end.reserve_low = reserve(used_high); |
| _at_relocate_end.garbage = _at_mark_end.garbage - reclaimed; |
| _at_relocate_end.allocated = allocated; |
| _at_relocate_end.reclaimed = reclaimed; |
| _at_relocate_end.used = used; |
| _at_relocate_end.used_high = used_high; |
| _at_relocate_end.used_low = used_low; |
| _at_relocate_end.free = free(used); |
| _at_relocate_end.free_high = free(used_low); |
| _at_relocate_end.free_low = free(used_high); |
| } |
| |
| size_t ZStatHeap::max_capacity() { |
| return _at_initialize.max_capacity; |
| } |
| |
| size_t ZStatHeap::used_at_mark_start() { |
| return _at_mark_start.used; |
| } |
| |
| size_t ZStatHeap::used_at_relocate_end() { |
| return _at_relocate_end.used; |
| } |
| |
| void ZStatHeap::print() { |
| log_info(gc, heap)("Min Capacity: " |
| ZSIZE_FMT, ZSIZE_ARGS(_at_initialize.min_capacity)); |
| log_info(gc, heap)("Max Capacity: " |
| ZSIZE_FMT, ZSIZE_ARGS(_at_initialize.max_capacity)); |
| log_info(gc, heap)("Soft Max Capacity: " |
| ZSIZE_FMT, ZSIZE_ARGS(_at_mark_start.soft_max_capacity)); |
| |
| ZStatTablePrinter table(10, 18); |
| log_info(gc, heap)("%s", table() |
| .fill() |
| .center("Mark Start") |
| .center("Mark End") |
| .center("Relocate Start") |
| .center("Relocate End") |
| .center("High") |
| .center("Low") |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Capacity:") |
| .left(ZTABLE_ARGS(_at_mark_start.capacity)) |
| .left(ZTABLE_ARGS(_at_mark_end.capacity)) |
| .left(ZTABLE_ARGS(_at_relocate_start.capacity)) |
| .left(ZTABLE_ARGS(_at_relocate_end.capacity)) |
| .left(ZTABLE_ARGS(_at_relocate_end.capacity_high)) |
| .left(ZTABLE_ARGS(_at_relocate_end.capacity_low)) |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Reserve:") |
| .left(ZTABLE_ARGS(_at_mark_start.reserve)) |
| .left(ZTABLE_ARGS(_at_mark_end.reserve)) |
| .left(ZTABLE_ARGS(_at_relocate_start.reserve)) |
| .left(ZTABLE_ARGS(_at_relocate_end.reserve)) |
| .left(ZTABLE_ARGS(_at_relocate_end.reserve_high)) |
| .left(ZTABLE_ARGS(_at_relocate_end.reserve_low)) |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Free:") |
| .left(ZTABLE_ARGS(_at_mark_start.free)) |
| .left(ZTABLE_ARGS(_at_mark_end.free)) |
| .left(ZTABLE_ARGS(_at_relocate_start.free)) |
| .left(ZTABLE_ARGS(_at_relocate_end.free)) |
| .left(ZTABLE_ARGS(_at_relocate_end.free_high)) |
| .left(ZTABLE_ARGS(_at_relocate_end.free_low)) |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Used:") |
| .left(ZTABLE_ARGS(_at_mark_start.used)) |
| .left(ZTABLE_ARGS(_at_mark_end.used)) |
| .left(ZTABLE_ARGS(_at_relocate_start.used)) |
| .left(ZTABLE_ARGS(_at_relocate_end.used)) |
| .left(ZTABLE_ARGS(_at_relocate_end.used_high)) |
| .left(ZTABLE_ARGS(_at_relocate_end.used_low)) |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Live:") |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS(_at_mark_end.live)) |
| .left(ZTABLE_ARGS(_at_mark_end.live /* Same as at mark end */)) |
| .left(ZTABLE_ARGS(_at_mark_end.live /* Same as at mark end */)) |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS_NA) |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Allocated:") |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS(_at_mark_end.allocated)) |
| .left(ZTABLE_ARGS(_at_relocate_start.allocated)) |
| .left(ZTABLE_ARGS(_at_relocate_end.allocated)) |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS_NA) |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Garbage:") |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS(_at_mark_end.garbage)) |
| .left(ZTABLE_ARGS(_at_relocate_start.garbage)) |
| .left(ZTABLE_ARGS(_at_relocate_end.garbage)) |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS_NA) |
| .end()); |
| log_info(gc, heap)("%s", table() |
| .right("Reclaimed:") |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS(_at_relocate_start.reclaimed)) |
| .left(ZTABLE_ARGS(_at_relocate_end.reclaimed)) |
| .left(ZTABLE_ARGS_NA) |
| .left(ZTABLE_ARGS_NA) |
| .end()); |
| } |
