src/hotspot/share/gc/z/zServiceability.cpp - toolchain/jdk/jdk21 - Git at Google

 /*
  * Copyright (c) 2017, 2023, 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/shared/generationCounters.hpp"
 #include "gc/shared/hSpaceCounters.hpp"
 #include "gc/z/zCollectedHeap.hpp"
 #include "gc/z/zDriver.hpp"
 #include "gc/z/zHeap.inline.hpp"
 #include "gc/z/zServiceability.hpp"
 #include "memory/metaspaceCounters.hpp"
 #include "runtime/perfData.hpp"

 struct ZMemoryUsageInfo {
   size_t _young_used;
   size_t _young_capacity;
   size_t _old_used;
   size_t _old_capacity;
 };

 static ZMemoryUsageInfo compute_memory_usage_info() {
   const size_t capacity = ZHeap::heap()->capacity();
   const size_t old_used = ZHeap::heap()->used_old();
   const size_t young_used = ZHeap::heap()->used_young();

   ZMemoryUsageInfo info;
   info._old_used = MIN2(old_used, capacity);
   info._old_capacity = info._old_used;
   info._young_capacity = capacity - info._old_capacity;
   info._young_used = MIN2(young_used, info._young_capacity);
   return info;
 }

 class ZGenerationCounters : public GenerationCounters {
 public:
   ZGenerationCounters(const char* name,
                       int ordinal,
                       int spaces,
                       size_t min_capacity,
                       size_t max_capacity,
                       size_t curr_capacity)
     : GenerationCounters(name,
                          ordinal,
                          spaces,
                          min_capacity,
                          max_capacity,
                          curr_capacity) {}

   void update_capacity(size_t capacity) {
     _current_size->set_value(capacity);
   }
 };

 // Class to expose perf counters used by jstat.
 class ZServiceabilityCounters : public CHeapObj<mtGC> {
 private:
   ZGenerationCounters _generation_young_counters;
   ZGenerationCounters _generation_old_counters;
   HSpaceCounters      _space_young_counters;
   HSpaceCounters      _space_old_counters;
   CollectorCounters   _minor_collection_counters;
   CollectorCounters   _major_collection_counters;

 public:
   ZServiceabilityCounters(size_t initial_capacity, size_t min_capacity, size_t max_capacity);

   CollectorCounters* collector_counters(bool minor);

   void update_sizes();
 };

 ZServiceabilityCounters::ZServiceabilityCounters(size_t initial_capacity, size_t min_capacity, size_t max_capacity)
   : // generation.0
     _generation_young_counters(
         "young"          /* name */,
         0                /* ordinal */,
         1                /* spaces */,
         min_capacity     /* min_capacity */,
         max_capacity     /* max_capacity */,
         initial_capacity /* curr_capacity */),
     // generation.1
     _generation_old_counters(
         "old"        /* name */,
         1            /* ordinal */,
         1            /* spaces */,
         0            /* min_capacity */,
         max_capacity /* max_capacity */,
         0            /* curr_capacity */),
     // generation.0.space.0
     _space_young_counters(
         _generation_young_counters.name_space(),
         "space"          /* name */,
         0                /* ordinal */,
         max_capacity     /* max_capacity */,
         initial_capacity /* init_capacity */),
     // generation.1.space.0
     _space_old_counters(
         _generation_old_counters.name_space(),
         "space"      /* name */,
         0            /* ordinal */,
         max_capacity /* max_capacity */,
         0            /* init_capacity */),
     // gc.collector.0
     _minor_collection_counters(
         "ZGC minor collection pauses" /* name */,
         0                             /* ordinal */),
     // gc.collector.2
     _major_collection_counters(
         "ZGC major collection pauses" /* name */,
         2                             /* ordinal */) {}

 CollectorCounters* ZServiceabilityCounters::collector_counters(bool minor) {
   return minor
       ? &_minor_collection_counters
       : &_major_collection_counters;
 }

 void ZServiceabilityCounters::update_sizes() {
   if (UsePerfData) {
     const ZMemoryUsageInfo info = compute_memory_usage_info();
     _generation_young_counters.update_capacity(info._young_capacity);
     _generation_old_counters.update_capacity(info._old_capacity);
     _space_young_counters.update_capacity(info._young_capacity);
     _space_young_counters.update_used(info._young_used);
     _space_old_counters.update_capacity(info._old_capacity);
     _space_old_counters.update_used(info._old_used);

     MetaspaceCounters::update_performance_counters();
   }
 }

 ZServiceabilityMemoryPool::ZServiceabilityMemoryPool(const char* name, ZGenerationId id, size_t min_capacity, size_t max_capacity)
   : CollectedMemoryPool(name,
                         min_capacity,
                         max_capacity,
                         id == ZGenerationId::old /* support_usage_threshold */),
     _generation_id(id) {}

 size_t ZServiceabilityMemoryPool::used_in_bytes() {
   return ZHeap::heap()->used_generation(_generation_id);
 }

 MemoryUsage ZServiceabilityMemoryPool::get_memory_usage() {
   const ZMemoryUsageInfo info = compute_memory_usage_info();

   if (_generation_id == ZGenerationId::young) {
     return MemoryUsage(initial_size(), info._young_used, info._young_capacity, max_size());
   } else {
     return MemoryUsage(initial_size(), info._old_used, info._old_capacity, max_size());
   }
 }

 ZServiceabilityMemoryManager::ZServiceabilityMemoryManager(const char* name,
                                                            MemoryPool* young_memory_pool,
                                                            MemoryPool* old_memory_pool)
   : GCMemoryManager(name) {
   add_pool(young_memory_pool);
   add_pool(old_memory_pool);
 }

 ZServiceability::ZServiceability(size_t initial_capacity,
                                  size_t min_capacity,
                                  size_t max_capacity)
   : _initial_capacity(initial_capacity),
     _min_capacity(min_capacity),
     _max_capacity(max_capacity),
     _young_memory_pool("ZGC Young Generation", ZGenerationId::young, _min_capacity, _max_capacity),
     _old_memory_pool("ZGC Old Generation", ZGenerationId::old, 0, _max_capacity),
     _minor_cycle_memory_manager("ZGC Minor Cycles", &_young_memory_pool, &_old_memory_pool),
     _major_cycle_memory_manager("ZGC Major Cycles", &_young_memory_pool, &_old_memory_pool),
     _minor_pause_memory_manager("ZGC Minor Pauses", &_young_memory_pool, &_old_memory_pool),
     _major_pause_memory_manager("ZGC Major Pauses", &_young_memory_pool, &_old_memory_pool),
     _counters(nullptr) {}

 void ZServiceability::initialize() {
   _counters = new ZServiceabilityCounters(_initial_capacity, _min_capacity, _max_capacity);
 }

 MemoryPool* ZServiceability::memory_pool(ZGenerationId id) {
   return id == ZGenerationId::young
       ? &_young_memory_pool
       : &_old_memory_pool;
 }

 GCMemoryManager* ZServiceability::cycle_memory_manager(bool minor) {
   return minor
       ? &_minor_cycle_memory_manager
       : &_major_cycle_memory_manager;
 }

 GCMemoryManager* ZServiceability::pause_memory_manager(bool minor) {
   return minor
       ? &_minor_pause_memory_manager
       : &_major_pause_memory_manager;
 }

 ZServiceabilityCounters* ZServiceability::counters() {
   return _counters;
 }

 bool ZServiceabilityCycleTracer::_minor_is_active;

 ZServiceabilityCycleTracer::ZServiceabilityCycleTracer(bool minor)
   : _memory_manager_stats(ZHeap::heap()->serviceability_cycle_memory_manager(minor),
                           minor ? ZDriver::minor()->gc_cause() : ZDriver::major()->gc_cause(),
                           "end of GC cycle",
                           true /* allMemoryPoolsAffected */,
                           true /* recordGCBeginTime */,
                           true /* recordPreGCUsage */,
                           true /* recordPeakUsage */,
                           true /* recordPostGCUsage */,
                           true /* recordAccumulatedGCTime */,
                           true /* recordGCEndTime */,
                           true /* countCollection */) {
   _minor_is_active = minor;
 }

 ZServiceabilityCycleTracer::~ZServiceabilityCycleTracer() {
   _minor_is_active = false;
 }

 bool ZServiceabilityCycleTracer::minor_is_active() {
   return _minor_is_active;
 }

 bool ZServiceabilityPauseTracer::minor_is_active() const {
   // We report pauses at the minor/major collection level instead
   // of the young/old level. At the call-site where ZServiceabilityPauseTracer
   // is used, we don't have that information readily available, so
   // we let ZServiceabilityCycleTracer keep track of that.
   return ZServiceabilityCycleTracer::minor_is_active();
 }

 ZServiceabilityPauseTracer::ZServiceabilityPauseTracer()
   : _svc_gc_marker(SvcGCMarker::CONCURRENT),
     _counters_stats(ZHeap::heap()->serviceability_counters()->collector_counters(minor_is_active())),
     _memory_manager_stats(ZHeap::heap()->serviceability_pause_memory_manager(minor_is_active()),
                           minor_is_active() ? ZDriver::minor()->gc_cause() : ZDriver::major()->gc_cause(),
                           "end of GC pause",
                           true  /* allMemoryPoolsAffected */,
                           true  /* recordGCBeginTime */,
                           false /* recordPreGCUsage */,
                           false /* recordPeakUsage */,
                           false /* recordPostGCUsage */,
                           true  /* recordAccumulatedGCTime */,
                           true  /* recordGCEndTime */,
                           true  /* countCollection */) {}

 ZServiceabilityPauseTracer::~ZServiceabilityPauseTracer()  {
   ZHeap::heap()->serviceability_counters()->update_sizes();
   MemoryService::track_memory_usage();
 }
	/*
	* Copyright (c) 2017, 2023, 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/shared/generationCounters.hpp"
	#include "gc/shared/hSpaceCounters.hpp"
	#include "gc/z/zCollectedHeap.hpp"
	#include "gc/z/zDriver.hpp"
	#include "gc/z/zHeap.inline.hpp"
	#include "gc/z/zServiceability.hpp"
	#include "memory/metaspaceCounters.hpp"
	#include "runtime/perfData.hpp"

	struct ZMemoryUsageInfo {
	size_t _young_used;
	size_t _young_capacity;
	size_t _old_used;
	size_t _old_capacity;
	};

	static ZMemoryUsageInfo compute_memory_usage_info() {
	const size_t capacity = ZHeap::heap()->capacity();
	const size_t old_used = ZHeap::heap()->used_old();
	const size_t young_used = ZHeap::heap()->used_young();

	ZMemoryUsageInfo info;
	info._old_used = MIN2(old_used, capacity);
	info._old_capacity = info._old_used;
	info._young_capacity = capacity - info._old_capacity;
	info._young_used = MIN2(young_used, info._young_capacity);
	return info;
	}

	class ZGenerationCounters : public GenerationCounters {
	public:
	ZGenerationCounters(const char* name,
	int ordinal,
	int spaces,
	size_t min_capacity,
	size_t max_capacity,
	size_t curr_capacity)
	: GenerationCounters(name,
	ordinal,
	spaces,
	min_capacity,
	max_capacity,
	curr_capacity) {}

	void update_capacity(size_t capacity) {
	_current_size->set_value(capacity);
	}
	};

	// Class to expose perf counters used by jstat.
	class ZServiceabilityCounters : public CHeapObj<mtGC> {
	private:
	ZGenerationCounters _generation_young_counters;
	ZGenerationCounters _generation_old_counters;
	HSpaceCounters _space_young_counters;
	HSpaceCounters _space_old_counters;
	CollectorCounters _minor_collection_counters;
	CollectorCounters _major_collection_counters;

	public:
	ZServiceabilityCounters(size_t initial_capacity, size_t min_capacity, size_t max_capacity);

	CollectorCounters* collector_counters(bool minor);

	void update_sizes();
	};

	ZServiceabilityCounters::ZServiceabilityCounters(size_t initial_capacity, size_t min_capacity, size_t max_capacity)
	: // generation.0
	_generation_young_counters(
	"young" /* name */,
	0 /* ordinal */,
	1 /* spaces */,
	min_capacity /* min_capacity */,
	max_capacity /* max_capacity */,
	initial_capacity /* curr_capacity */),
	// generation.1
	_generation_old_counters(
	"old" /* name */,
	1 /* ordinal */,
	1 /* spaces */,
	0 /* min_capacity */,
	max_capacity /* max_capacity */,
	0 /* curr_capacity */),
	// generation.0.space.0
	_space_young_counters(
	_generation_young_counters.name_space(),
	"space" /* name */,
	0 /* ordinal */,
	max_capacity /* max_capacity */,
	initial_capacity /* init_capacity */),
	// generation.1.space.0
	_space_old_counters(
	_generation_old_counters.name_space(),
	"space" /* name */,
	0 /* ordinal */,
	max_capacity /* max_capacity */,
	0 /* init_capacity */),
	// gc.collector.0
	_minor_collection_counters(
	"ZGC minor collection pauses" /* name */,
	0 /* ordinal */),
	// gc.collector.2
	_major_collection_counters(
	"ZGC major collection pauses" /* name */,
	2 /* ordinal */) {}

	CollectorCounters* ZServiceabilityCounters::collector_counters(bool minor) {
	return minor
	? &_minor_collection_counters
	: &_major_collection_counters;
	}

	void ZServiceabilityCounters::update_sizes() {
	if (UsePerfData) {
	const ZMemoryUsageInfo info = compute_memory_usage_info();
	_generation_young_counters.update_capacity(info._young_capacity);
	_generation_old_counters.update_capacity(info._old_capacity);
	_space_young_counters.update_capacity(info._young_capacity);
	_space_young_counters.update_used(info._young_used);
	_space_old_counters.update_capacity(info._old_capacity);
	_space_old_counters.update_used(info._old_used);

	MetaspaceCounters::update_performance_counters();
	}
	}

	ZServiceabilityMemoryPool::ZServiceabilityMemoryPool(const char* name, ZGenerationId id, size_t min_capacity, size_t max_capacity)
	: CollectedMemoryPool(name,
	min_capacity,
	max_capacity,
	id == ZGenerationId::old /* support_usage_threshold */),
	_generation_id(id) {}

	size_t ZServiceabilityMemoryPool::used_in_bytes() {
	return ZHeap::heap()->used_generation(_generation_id);
	}

	MemoryUsage ZServiceabilityMemoryPool::get_memory_usage() {
	const ZMemoryUsageInfo info = compute_memory_usage_info();

	if (_generation_id == ZGenerationId::young) {
	return MemoryUsage(initial_size(), info._young_used, info._young_capacity, max_size());
	} else {
	return MemoryUsage(initial_size(), info._old_used, info._old_capacity, max_size());
	}
	}

	ZServiceabilityMemoryManager::ZServiceabilityMemoryManager(const char* name,
	MemoryPool* young_memory_pool,
	MemoryPool* old_memory_pool)
	: GCMemoryManager(name) {
	add_pool(young_memory_pool);
	add_pool(old_memory_pool);
	}

	ZServiceability::ZServiceability(size_t initial_capacity,
	size_t min_capacity,
	size_t max_capacity)
	: _initial_capacity(initial_capacity),
	_min_capacity(min_capacity),
	_max_capacity(max_capacity),
	_young_memory_pool("ZGC Young Generation", ZGenerationId::young, _min_capacity, _max_capacity),
	_old_memory_pool("ZGC Old Generation", ZGenerationId::old, 0, _max_capacity),
	_minor_cycle_memory_manager("ZGC Minor Cycles", &_young_memory_pool, &_old_memory_pool),
	_major_cycle_memory_manager("ZGC Major Cycles", &_young_memory_pool, &_old_memory_pool),
	_minor_pause_memory_manager("ZGC Minor Pauses", &_young_memory_pool, &_old_memory_pool),
	_major_pause_memory_manager("ZGC Major Pauses", &_young_memory_pool, &_old_memory_pool),
	_counters(nullptr) {}

	void ZServiceability::initialize() {
	_counters = new ZServiceabilityCounters(_initial_capacity, _min_capacity, _max_capacity);
	}

	MemoryPool* ZServiceability::memory_pool(ZGenerationId id) {
	return id == ZGenerationId::young
	? &_young_memory_pool
	: &_old_memory_pool;
	}

	GCMemoryManager* ZServiceability::cycle_memory_manager(bool minor) {
	return minor
	? &_minor_cycle_memory_manager
	: &_major_cycle_memory_manager;
	}

	GCMemoryManager* ZServiceability::pause_memory_manager(bool minor) {
	return minor
	? &_minor_pause_memory_manager
	: &_major_pause_memory_manager;
	}

	ZServiceabilityCounters* ZServiceability::counters() {
	return _counters;
	}

	bool ZServiceabilityCycleTracer::_minor_is_active;

	ZServiceabilityCycleTracer::ZServiceabilityCycleTracer(bool minor)
	: _memory_manager_stats(ZHeap::heap()->serviceability_cycle_memory_manager(minor),
	minor ? ZDriver::minor()->gc_cause() : ZDriver::major()->gc_cause(),
	"end of GC cycle",
	true /* allMemoryPoolsAffected */,
	true /* recordGCBeginTime */,
	true /* recordPreGCUsage */,
	true /* recordPeakUsage */,
	true /* recordPostGCUsage */,
	true /* recordAccumulatedGCTime */,
	true /* recordGCEndTime */,
	true /* countCollection */) {
	_minor_is_active = minor;
	}

	ZServiceabilityCycleTracer::~ZServiceabilityCycleTracer() {
	_minor_is_active = false;
	}

	bool ZServiceabilityCycleTracer::minor_is_active() {
	return _minor_is_active;
	}

	bool ZServiceabilityPauseTracer::minor_is_active() const {
	// We report pauses at the minor/major collection level instead
	// of the young/old level. At the call-site where ZServiceabilityPauseTracer
	// is used, we don't have that information readily available, so
	// we let ZServiceabilityCycleTracer keep track of that.
	return ZServiceabilityCycleTracer::minor_is_active();
	}

	ZServiceabilityPauseTracer::ZServiceabilityPauseTracer()
	: _svc_gc_marker(SvcGCMarker::CONCURRENT),
	_counters_stats(ZHeap::heap()->serviceability_counters()->collector_counters(minor_is_active())),
	_memory_manager_stats(ZHeap::heap()->serviceability_pause_memory_manager(minor_is_active()),
	minor_is_active() ? ZDriver::minor()->gc_cause() : ZDriver::major()->gc_cause(),
	"end of GC pause",
	true /* allMemoryPoolsAffected */,
	true /* recordGCBeginTime */,
	false /* recordPreGCUsage */,
	false /* recordPeakUsage */,
	false /* recordPostGCUsage */,
	true /* recordAccumulatedGCTime */,
	true /* recordGCEndTime */,
	true /* countCollection */) {}

	ZServiceabilityPauseTracer::~ZServiceabilityPauseTracer() {
	ZHeap::heap()->serviceability_counters()->update_sizes();
	MemoryService::track_memory_usage();
	}