--- a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp Wed Aug 22 20:37:07 2018 +0200
+++ b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp Wed Aug 22 20:37:07 2018 +0200
@@ -4800,7 +4800,7 @@
_hr_printer.retire(alloc_region);
// We update the eden sizes here, when the region is retired,
// instead of when it's allocated, since this is the point that its
- // used space has been recored in _summary_bytes_used.
+ // used space has been recorded in _summary_bytes_used.
g1mm()->update_eden_size();
}
--- a/src/hotspot/share/gc/g1/g1MemoryPool.cpp Wed Aug 22 20:37:07 2018 +0200
+++ b/src/hotspot/share/gc/g1/g1MemoryPool.cpp Wed Aug 22 20:37:07 2018 +0200
@@ -40,50 +40,41 @@
assert(UseG1GC, "sanity");
}
-G1EdenPool::G1EdenPool(G1CollectedHeap* g1h) :
+G1EdenPool::G1EdenPool(G1CollectedHeap* g1h, size_t initial_size) :
G1MemoryPoolSuper(g1h,
"G1 Eden Space",
- g1h->g1mm()->eden_space_committed(), /* init_size */
- _undefined_max,
+ initial_size,
+ MemoryUsage::undefined_size(),
false /* support_usage_threshold */) { }
MemoryUsage G1EdenPool::get_memory_usage() {
- size_t initial_sz = initial_size();
- size_t max_sz = max_size();
- size_t used = used_in_bytes();
size_t committed = _g1mm->eden_space_committed();
- return MemoryUsage(initial_sz, used, committed, max_sz);
+ return MemoryUsage(initial_size(), used_in_bytes(), committed, max_size());
}
-G1SurvivorPool::G1SurvivorPool(G1CollectedHeap* g1h) :
+G1SurvivorPool::G1SurvivorPool(G1CollectedHeap* g1h, size_t initial_size) :
G1MemoryPoolSuper(g1h,
"G1 Survivor Space",
- g1h->g1mm()->survivor_space_committed(), /* init_size */
- _undefined_max,
+ initial_size,
+ MemoryUsage::undefined_size(),
false /* support_usage_threshold */) { }
MemoryUsage G1SurvivorPool::get_memory_usage() {
- size_t initial_sz = initial_size();
- size_t max_sz = max_size();
- size_t used = used_in_bytes();
size_t committed = _g1mm->survivor_space_committed();
- return MemoryUsage(initial_sz, used, committed, max_sz);
+ return MemoryUsage(initial_size(), used_in_bytes(), committed, max_size());
}
-G1OldGenPool::G1OldGenPool(G1CollectedHeap* g1h) :
+G1OldGenPool::G1OldGenPool(G1CollectedHeap* g1h, size_t initial_size, size_t max_size) :
G1MemoryPoolSuper(g1h,
"G1 Old Gen",
- g1h->g1mm()->old_space_committed(), /* init_size */
- g1h->g1mm()->old_gen_max(),
+ initial_size,
+ max_size,
true /* support_usage_threshold */) { }
MemoryUsage G1OldGenPool::get_memory_usage() {
- size_t initial_sz = initial_size();
- size_t max_sz = max_size();
- size_t used = used_in_bytes();
- size_t committed = _g1mm->old_space_committed();
+ size_t committed = _g1mm->old_gen_committed();
- return MemoryUsage(initial_sz, used, committed, max_sz);
+ return MemoryUsage(initial_size(), used_in_bytes(), committed, max_size());
}
--- a/src/hotspot/share/gc/g1/g1MemoryPool.hpp Wed Aug 22 20:37:07 2018 +0200
+++ b/src/hotspot/share/gc/g1/g1MemoryPool.hpp Wed Aug 22 20:37:07 2018 +0200
@@ -53,7 +53,6 @@
// (G1EdenPool, G1SurvivorPool, G1OldGenPool).
class G1MemoryPoolSuper : public CollectedMemoryPool {
protected:
- const static size_t _undefined_max = (size_t) -1;
G1MonitoringSupport* _g1mm;
// Would only be called from subclasses.
@@ -67,42 +66,30 @@
// Memory pool that represents the G1 eden.
class G1EdenPool : public G1MemoryPoolSuper {
public:
- G1EdenPool(G1CollectedHeap* g1h);
+ G1EdenPool(G1CollectedHeap* g1h, size_t initial_size);
- size_t used_in_bytes() {
- return _g1mm->eden_space_used();
- }
- size_t max_size() const {
- return _undefined_max;
- }
+ size_t used_in_bytes() { return _g1mm->eden_space_used(); }
+
MemoryUsage get_memory_usage();
};
// Memory pool that represents the G1 survivor.
class G1SurvivorPool : public G1MemoryPoolSuper {
public:
- G1SurvivorPool(G1CollectedHeap* g1h);
+ G1SurvivorPool(G1CollectedHeap* g1h, size_t initial_size);
- size_t used_in_bytes() {
- return _g1mm->survivor_space_used();
- }
- size_t max_size() const {
- return _undefined_max;
- }
+ size_t used_in_bytes() { return _g1mm->survivor_space_used(); }
+
MemoryUsage get_memory_usage();
};
// Memory pool that represents the G1 old gen.
class G1OldGenPool : public G1MemoryPoolSuper {
public:
- G1OldGenPool(G1CollectedHeap* g1h);
+ G1OldGenPool(G1CollectedHeap* g1h, size_t initial_size, size_t max_size);
- size_t used_in_bytes() {
- return _g1mm->old_space_used();
- }
- size_t max_size() const {
- return _g1mm->old_gen_max();
- }
+ size_t used_in_bytes() { return _g1mm->old_gen_used(); }
+
MemoryUsage get_memory_usage();
};
--- a/src/hotspot/share/gc/g1/g1MonitoringSupport.cpp Wed Aug 22 20:37:07 2018 +0200
+++ b/src/hotspot/share/gc/g1/g1MonitoringSupport.cpp Wed Aug 22 20:37:07 2018 +0200
@@ -31,84 +31,90 @@
#include "memory/metaspaceCounters.hpp"
#include "services/memoryPool.hpp"
-G1GenerationCounters::G1GenerationCounters(G1MonitoringSupport* g1mm,
- const char* name,
- int ordinal, int spaces,
- size_t min_capacity,
- size_t max_capacity,
- size_t curr_capacity)
+class G1GenerationCounters : public GenerationCounters {
+protected:
+ G1MonitoringSupport* _g1mm;
+
+public:
+ G1GenerationCounters(G1MonitoringSupport* g1mm,
+ 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), _g1mm(g1mm) { }
+};
-// We pad the capacity three times given that the young generation
-// contains three spaces (eden and two survivors).
-G1YoungGenerationCounters::G1YoungGenerationCounters(G1MonitoringSupport* g1mm,
- const char* name)
+class G1YoungGenerationCounters : public G1GenerationCounters {
+public:
+ // We pad the capacity three times given that the young generation
+ // contains three spaces (eden and two survivors).
+ G1YoungGenerationCounters(G1MonitoringSupport* g1mm, const char* name, size_t max_size)
: G1GenerationCounters(g1mm, name, 0 /* ordinal */, 3 /* spaces */,
- G1MonitoringSupport::pad_capacity(0, 3) /* min_capacity */,
- G1MonitoringSupport::pad_capacity(g1mm->young_gen_max(), 3),
- G1MonitoringSupport::pad_capacity(0, 3) /* curr_capacity */) {
- if (UsePerfData) {
- update_all();
+ G1MonitoringSupport::pad_capacity(0, 3) /* min_capacity */,
+ G1MonitoringSupport::pad_capacity(max_size, 3),
+ G1MonitoringSupport::pad_capacity(0, 3) /* curr_capacity */) {
+ if (UsePerfData) {
+ update_all();
+ }
}
-}
-G1OldGenerationCounters::G1OldGenerationCounters(G1MonitoringSupport* g1mm,
- const char* name)
+ virtual void update_all() {
+ size_t committed =
+ G1MonitoringSupport::pad_capacity(_g1mm->young_gen_committed(), 3);
+ _current_size->set_value(committed);
+ }
+};
+
+class G1OldGenerationCounters : public G1GenerationCounters {
+public:
+ G1OldGenerationCounters(G1MonitoringSupport* g1mm, const char* name, size_t max_size)
: G1GenerationCounters(g1mm, name, 1 /* ordinal */, 1 /* spaces */,
- G1MonitoringSupport::pad_capacity(0) /* min_capacity */,
- G1MonitoringSupport::pad_capacity(g1mm->old_gen_max()),
- G1MonitoringSupport::pad_capacity(0) /* curr_capacity */) {
- if (UsePerfData) {
- update_all();
+ G1MonitoringSupport::pad_capacity(0) /* min_capacity */,
+ G1MonitoringSupport::pad_capacity(max_size),
+ G1MonitoringSupport::pad_capacity(0) /* curr_capacity */) {
+ if (UsePerfData) {
+ update_all();
+ }
}
-}
-void G1YoungGenerationCounters::update_all() {
- size_t committed =
- G1MonitoringSupport::pad_capacity(_g1mm->young_gen_committed(), 3);
- _current_size->set_value(committed);
-}
-
-void G1OldGenerationCounters::update_all() {
- size_t committed =
- G1MonitoringSupport::pad_capacity(_g1mm->old_gen_committed());
- _current_size->set_value(committed);
-}
+ virtual void update_all() {
+ size_t committed =
+ G1MonitoringSupport::pad_capacity(_g1mm->old_gen_committed());
+ _current_size->set_value(committed);
+ }
+};
G1MonitoringSupport::G1MonitoringSupport(G1CollectedHeap* g1h) :
_g1h(g1h),
- _memory_manager("G1 Young Generation", "end of minor GC"),
+ _incremental_memory_manager("G1 Young Generation", "end of minor GC"),
_full_gc_memory_manager("G1 Old Generation", "end of major GC"),
- _eden_pool(NULL),
- _survivor_pool(NULL),
- _old_pool(NULL),
+ _eden_space_pool(NULL),
+ _survivor_space_pool(NULL),
+ _old_gen_pool(NULL),
_incremental_collection_counters(NULL),
_full_collection_counters(NULL),
_conc_collection_counters(NULL),
- _young_collection_counters(NULL),
- _old_collection_counters(NULL),
+ _young_gen_counters(NULL),
+ _old_gen_counters(NULL),
_old_space_counters(NULL),
- _eden_counters(NULL),
- _from_counters(NULL),
- _to_counters(NULL),
+ _eden_space_counters(NULL),
+ _from_space_counters(NULL),
+ _to_space_counters(NULL),
- _overall_reserved(0),
_overall_committed(0),
_overall_used(0),
- _young_region_num(0),
_young_gen_committed(0),
- _eden_committed(0),
- _eden_used(0),
- _survivor_committed(0),
- _survivor_used(0),
- _old_committed(0),
- _old_used(0) {
+ _old_gen_committed(0),
- _overall_reserved = g1h->max_capacity();
+ _eden_space_committed(0),
+ _eden_space_used(0),
+ _survivor_space_committed(0),
+ _survivor_space_used(0),
+ _old_gen_used(0) {
+
recalculate_sizes();
- // Counters for GC collections
+ // Counters for garbage collections
//
// name "collector.0". In a generational collector this would be the
// young generation collection.
@@ -123,112 +129,96 @@
_conc_collection_counters =
new CollectorCounters("G1 stop-the-world phases", 2);
- // timer sampling for all counters supporting sampling only update the
- // used value. See the take_sample() method. G1 requires both used and
- // capacity updated so sampling is not currently used. It might
- // be sufficient to update all counters in take_sample() even though
- // take_sample() only returns "used". When sampling was used, there
- // were some anomolous values emitted which may have been the consequence
- // of not updating all values simultaneously (i.e., see the calculation done
- // in eden_space_used(), is it possible that the values used to
- // calculate either eden_used or survivor_used are being updated by
- // the collector when the sample is being done?).
- const bool sampled = false;
-
// "Generation" and "Space" counters.
//
// name "generation.1" This is logically the old generation in
// generational GC terms. The "1, 1" parameters are for
// the n-th generation (=1) with 1 space.
// Counters are created from minCapacity, maxCapacity, and capacity
- _old_collection_counters = new G1OldGenerationCounters(this, "old");
+ _old_gen_counters = new G1OldGenerationCounters(this, "old", _g1h->max_capacity());
// name "generation.1.space.0"
// Counters are created from maxCapacity, capacity, initCapacity,
// and used.
- _old_space_counters = new HSpaceCounters(_old_collection_counters->name_space(),
+ _old_space_counters = new HSpaceCounters(_old_gen_counters->name_space(),
"space", 0 /* ordinal */,
- pad_capacity(overall_reserved()) /* max_capacity */,
- pad_capacity(old_space_committed()) /* init_capacity */);
+ pad_capacity(g1h->max_capacity()) /* max_capacity */,
+ pad_capacity(_old_gen_committed) /* init_capacity */);
// Young collection set
// name "generation.0". This is logically the young generation.
// The "0, 3" are parameters for the n-th generation (=0) with 3 spaces.
// See _old_collection_counters for additional counters
- _young_collection_counters = new G1YoungGenerationCounters(this, "young");
+ _young_gen_counters = new G1YoungGenerationCounters(this, "young", _g1h->max_capacity());
- const char* young_collection_name_space = _young_collection_counters->name_space();
+ const char* young_collection_name_space = _young_gen_counters->name_space();
// name "generation.0.space.0"
// See _old_space_counters for additional counters
- _eden_counters = new HSpaceCounters(young_collection_name_space,
+ _eden_space_counters = new HSpaceCounters(young_collection_name_space,
"eden", 0 /* ordinal */,
- pad_capacity(overall_reserved()) /* max_capacity */,
- pad_capacity(eden_space_committed()) /* init_capacity */);
+ pad_capacity(g1h->max_capacity()) /* max_capacity */,
+ pad_capacity(_eden_space_committed) /* init_capacity */);
// name "generation.0.space.1"
// See _old_space_counters for additional counters
// Set the arguments to indicate that this survivor space is not used.
- _from_counters = new HSpaceCounters(young_collection_name_space,
+ _from_space_counters = new HSpaceCounters(young_collection_name_space,
"s0", 1 /* ordinal */,
pad_capacity(0) /* max_capacity */,
pad_capacity(0) /* init_capacity */);
+ // Given that this survivor space is not used, we update it here
+ // once to reflect that its used space is 0 so that we don't have to
+ // worry about updating it again later.
+ _from_space_counters->update_used(0);
// name "generation.0.space.2"
// See _old_space_counters for additional counters
- _to_counters = new HSpaceCounters(young_collection_name_space,
+ _to_space_counters = new HSpaceCounters(young_collection_name_space,
"s1", 2 /* ordinal */,
- pad_capacity(overall_reserved()) /* max_capacity */,
- pad_capacity(survivor_space_committed()) /* init_capacity */);
-
- if (UsePerfData) {
- // Given that this survivor space is not used, we update it here
- // once to reflect that its used space is 0 so that we don't have to
- // worry about updating it again later.
- _from_counters->update_used(0);
- }
+ pad_capacity(g1h->max_capacity()) /* max_capacity */,
+ pad_capacity(_survivor_space_committed) /* init_capacity */);
}
G1MonitoringSupport::~G1MonitoringSupport() {
- delete _eden_pool;
- delete _survivor_pool;
- delete _old_pool;
+ delete _eden_space_pool;
+ delete _survivor_space_pool;
+ delete _old_gen_pool;
}
void G1MonitoringSupport::initialize_serviceability() {
- _eden_pool = new G1EdenPool(_g1h);
- _survivor_pool = new G1SurvivorPool(_g1h);
- _old_pool = new G1OldGenPool(_g1h);
+ _eden_space_pool = new G1EdenPool(_g1h, _eden_space_committed);
+ _survivor_space_pool = new G1SurvivorPool(_g1h, _survivor_space_committed);
+ _old_gen_pool = new G1OldGenPool(_g1h, _old_gen_committed, _g1h->max_capacity());
- _full_gc_memory_manager.add_pool(_eden_pool);
- _full_gc_memory_manager.add_pool(_survivor_pool);
- _full_gc_memory_manager.add_pool(_old_pool);
+ _full_gc_memory_manager.add_pool(_eden_space_pool);
+ _full_gc_memory_manager.add_pool(_survivor_space_pool);
+ _full_gc_memory_manager.add_pool(_old_gen_pool);
- _memory_manager.add_pool(_eden_pool);
- _memory_manager.add_pool(_survivor_pool);
- _memory_manager.add_pool(_old_pool, false /* always_affected_by_gc */);
+ _incremental_memory_manager.add_pool(_eden_space_pool);
+ _incremental_memory_manager.add_pool(_survivor_space_pool);
+ _incremental_memory_manager.add_pool(_old_gen_pool, false /* always_affected_by_gc */);
}
GrowableArray<GCMemoryManager*> G1MonitoringSupport::memory_managers() {
GrowableArray<GCMemoryManager*> memory_managers(2);
- memory_managers.append(&_memory_manager);
+ memory_managers.append(&_incremental_memory_manager);
memory_managers.append(&_full_gc_memory_manager);
return memory_managers;
}
GrowableArray<MemoryPool*> G1MonitoringSupport::memory_pools() {
GrowableArray<MemoryPool*> memory_pools(3);
- memory_pools.append(_eden_pool);
- memory_pools.append(_survivor_pool);
- memory_pools.append(_old_pool);
+ memory_pools.append(_eden_space_pool);
+ memory_pools.append(_survivor_space_pool);
+ memory_pools.append(_old_gen_pool);
return memory_pools;
}
void G1MonitoringSupport::recalculate_sizes() {
- // Recalculate all the sizes from scratch. We assume that this is
- // called at a point where no concurrent updates to the various
- // values we read here are possible (i.e., at a STW phase at the end
- // of a GC).
+ assert_heap_locked_or_at_safepoint(true);
+
+ // Recalculate all the sizes from scratch.
uint young_list_length = _g1h->young_regions_count();
uint survivor_list_length = _g1h->survivor_regions_count();
@@ -241,14 +231,13 @@
uint eden_list_max_length = young_list_max_length - survivor_list_length;
_overall_used = _g1h->used_unlocked();
- _eden_used = (size_t) eden_list_length * HeapRegion::GrainBytes;
- _survivor_used = (size_t) survivor_list_length * HeapRegion::GrainBytes;
- _young_region_num = young_list_length;
- _old_used = subtract_up_to_zero(_overall_used, _eden_used + _survivor_used);
+ _eden_space_used = (size_t) eden_list_length * HeapRegion::GrainBytes;
+ _survivor_space_used = (size_t) survivor_list_length * HeapRegion::GrainBytes;
+ _old_gen_used = subtract_up_to_zero(_overall_used, _eden_space_used + _survivor_space_used);
// First calculate the committed sizes that can be calculated independently.
- _survivor_committed = _survivor_used;
- _old_committed = HeapRegion::align_up_to_region_byte_size(_old_used);
+ _survivor_space_committed = _survivor_space_used;
+ _old_gen_committed = HeapRegion::align_up_to_region_byte_size(_old_gen_used);
// Next, start with the overall committed size.
_overall_committed = _g1h->capacity();
@@ -256,76 +245,64 @@
// Remove the committed size we have calculated so far (for the
// survivor and old space).
- assert(committed >= (_survivor_committed + _old_committed), "sanity");
- committed -= _survivor_committed + _old_committed;
+ assert(committed >= (_survivor_space_committed + _old_gen_committed), "sanity");
+ committed -= _survivor_space_committed + _old_gen_committed;
// Next, calculate and remove the committed size for the eden.
- _eden_committed = (size_t) eden_list_max_length * HeapRegion::GrainBytes;
+ _eden_space_committed = (size_t) eden_list_max_length * HeapRegion::GrainBytes;
// Somewhat defensive: be robust in case there are inaccuracies in
// the calculations
- _eden_committed = MIN2(_eden_committed, committed);
- committed -= _eden_committed;
+ _eden_space_committed = MIN2(_eden_space_committed, committed);
+ committed -= _eden_space_committed;
// Finally, give the rest to the old space...
- _old_committed += committed;
+ _old_gen_committed += committed;
// ..and calculate the young gen committed.
- _young_gen_committed = _eden_committed + _survivor_committed;
+ _young_gen_committed = _eden_space_committed + _survivor_space_committed;
assert(_overall_committed ==
- (_eden_committed + _survivor_committed + _old_committed),
+ (_eden_space_committed + _survivor_space_committed + _old_gen_committed),
"the committed sizes should add up");
// Somewhat defensive: cap the eden used size to make sure it
// never exceeds the committed size.
- _eden_used = MIN2(_eden_used, _eden_committed);
+ _eden_space_used = MIN2(_eden_space_used, _eden_space_committed);
// _survivor_committed and _old_committed are calculated in terms of
// the corresponding _*_used value, so the next two conditions
// should hold.
- assert(_survivor_used <= _survivor_committed, "post-condition");
- assert(_old_used <= _old_committed, "post-condition");
-}
-
-void G1MonitoringSupport::recalculate_eden_size() {
- // When a new eden region is allocated, only the eden_used size is
- // affected (since we have recalculated everything else at the last GC).
-
- uint young_region_num = _g1h->young_regions_count();
- if (young_region_num > _young_region_num) {
- uint diff = young_region_num - _young_region_num;
- _eden_used += (size_t) diff * HeapRegion::GrainBytes;
- // Somewhat defensive: cap the eden used size to make sure it
- // never exceeds the committed size.
- _eden_used = MIN2(_eden_used, _eden_committed);
- _young_region_num = young_region_num;
- }
+ assert(_survivor_space_used <= _survivor_space_committed, "post-condition");
+ assert(_old_gen_used <= _old_gen_committed, "post-condition");
}
void G1MonitoringSupport::update_sizes() {
recalculate_sizes();
if (UsePerfData) {
- _eden_counters->update_capacity(pad_capacity(eden_space_committed()));
- _eden_counters->update_used(eden_space_used());
- // only the "to" survivor space is active, so we don't need to
+ _eden_space_counters->update_capacity(pad_capacity(_eden_space_committed));
+ _eden_space_counters->update_used(_eden_space_used);
+ // only the "to" survivor space is active, so we don't need to
// update the counters for the "from" survivor space
- _to_counters->update_capacity(pad_capacity(survivor_space_committed()));
- _to_counters->update_used(survivor_space_used());
- _old_space_counters->update_capacity(pad_capacity(old_space_committed()));
- _old_space_counters->update_used(old_space_used());
- _old_collection_counters->update_all();
- _young_collection_counters->update_all();
+ _to_space_counters->update_capacity(pad_capacity(_survivor_space_committed));
+ _to_space_counters->update_used(_survivor_space_used);
+ _old_space_counters->update_capacity(pad_capacity(_old_gen_committed));
+ _old_space_counters->update_used(_old_gen_used);
+
+ _young_gen_counters->update_all();
+ _old_gen_counters->update_all();
+
MetaspaceCounters::update_performance_counters();
CompressedClassSpaceCounters::update_performance_counters();
}
}
void G1MonitoringSupport::update_eden_size() {
- recalculate_eden_size();
+ // Recalculate everything - this is fast enough.
+ recalculate_sizes();
if (UsePerfData) {
- _eden_counters->update_used(eden_space_used());
+ _eden_space_counters->update_used(_eden_space_used);
}
}
G1MonitoringScope::G1MonitoringScope(G1MonitoringSupport* g1mm, bool full_gc, bool all_memory_pools_affected) :
_tcs(full_gc ? g1mm->_full_collection_counters : g1mm->_incremental_collection_counters),
- _tms(full_gc ? &g1mm->_full_gc_memory_manager : &g1mm->_memory_manager,
+ _tms(full_gc ? &g1mm->_full_gc_memory_manager : &g1mm->_incremental_memory_manager,
G1CollectedHeap::heap()->gc_cause(), all_memory_pools_affected) {
}
--- a/src/hotspot/share/gc/g1/g1MonitoringSupport.hpp Wed Aug 22 20:37:07 2018 +0200
+++ b/src/hotspot/share/gc/g1/g1MonitoringSupport.hpp Wed Aug 22 20:37:07 2018 +0200
@@ -125,12 +125,12 @@
G1CollectedHeap* _g1h;
// java.lang.management MemoryManager and MemoryPool support
- GCMemoryManager _memory_manager;
+ GCMemoryManager _incremental_memory_manager;
GCMemoryManager _full_gc_memory_manager;
- MemoryPool* _eden_pool;
- MemoryPool* _survivor_pool;
- MemoryPool* _old_pool;
+ MemoryPool* _eden_space_pool;
+ MemoryPool* _survivor_space_pool;
+ MemoryPool* _old_gen_pool;
// jstat performance counters
// incremental collections both young and mixed
@@ -142,37 +142,36 @@
// young collection set counters. The _eden_counters,
// _from_counters, and _to_counters are associated with
// this "generational" counter.
- GenerationCounters* _young_collection_counters;
+ GenerationCounters* _young_gen_counters;
// old collection set counters. The _old_space_counters
// below are associated with this "generational" counter.
- GenerationCounters* _old_collection_counters;
+ GenerationCounters* _old_gen_counters;
// Counters for the capacity and used for
// the whole heap
HSpaceCounters* _old_space_counters;
// the young collection
- HSpaceCounters* _eden_counters;
+ HSpaceCounters* _eden_space_counters;
// the survivor collection (only one, _to_counters, is actively used)
- HSpaceCounters* _from_counters;
- HSpaceCounters* _to_counters;
+ HSpaceCounters* _from_space_counters;
+ HSpaceCounters* _to_space_counters;
// When it's appropriate to recalculate the various sizes (at the
// end of a GC, when a new eden region is allocated, etc.) we store
// them here so that we can easily report them when needed and not
// have to recalculate them every time.
- size_t _overall_reserved;
size_t _overall_committed;
size_t _overall_used;
- uint _young_region_num;
size_t _young_gen_committed;
- size_t _eden_committed;
- size_t _eden_used;
- size_t _survivor_committed;
- size_t _survivor_used;
+ size_t _old_gen_committed;
- size_t _old_committed;
- size_t _old_used;
+ size_t _eden_space_committed;
+ size_t _eden_space_used;
+ size_t _survivor_space_committed;
+ size_t _survivor_space_used;
+
+ size_t _old_gen_used;
// It returns x - y if x > y, 0 otherwise.
// As described in the comment above, some of the inputs to the
@@ -191,10 +190,10 @@
// Recalculate all the sizes.
void recalculate_sizes();
- // Recalculate only what's necessary when a new eden region is allocated.
+
void recalculate_eden_size();
- public:
+public:
G1MonitoringSupport(G1CollectedHeap* g1h);
~G1MonitoringSupport();
@@ -220,8 +219,7 @@
// Recalculate all the sizes from scratch and update all the jstat
// counters accordingly.
void update_sizes();
- // Recalculate only what's necessary when a new eden region is
- // allocated and update any jstat counters that need to be updated.
+
void update_eden_size();
CollectorCounters* conc_collection_counters() {
@@ -233,21 +231,15 @@
// jstat counters
// Tracing
- size_t overall_reserved() { return _overall_reserved; }
- size_t overall_committed() { return _overall_committed; }
- size_t overall_used() { return _overall_used; }
+ size_t young_gen_committed() { return _young_gen_committed; }
- size_t young_gen_committed() { return _young_gen_committed; }
- size_t young_gen_max() { return overall_reserved(); }
- size_t eden_space_committed() { return _eden_committed; }
- size_t eden_space_used() { return _eden_used; }
- size_t survivor_space_committed() { return _survivor_committed; }
- size_t survivor_space_used() { return _survivor_used; }
+ size_t eden_space_committed() { return _eden_space_committed; }
+ size_t eden_space_used() { return _eden_space_used; }
+ size_t survivor_space_committed() { return _survivor_space_committed; }
+ size_t survivor_space_used() { return _survivor_space_used; }
- size_t old_gen_committed() { return old_space_committed(); }
- size_t old_gen_max() { return overall_reserved(); }
- size_t old_space_committed() { return _old_committed; }
- size_t old_space_used() { return _old_used; }
+ size_t old_gen_committed() { return _old_gen_committed; }
+ size_t old_gen_used() { return _old_gen_used; }
};
// Scope object for java.lang.management support.
@@ -258,27 +250,4 @@
G1MonitoringScope(G1MonitoringSupport* g1mm, bool full_gc, bool all_memory_pools_affected);
};
-class G1GenerationCounters: public GenerationCounters {
-protected:
- G1MonitoringSupport* _g1mm;
-
-public:
- G1GenerationCounters(G1MonitoringSupport* g1mm,
- const char* name, int ordinal, int spaces,
- size_t min_capacity, size_t max_capacity,
- size_t curr_capacity);
-};
-
-class G1YoungGenerationCounters: public G1GenerationCounters {
-public:
- G1YoungGenerationCounters(G1MonitoringSupport* g1mm, const char* name);
- virtual void update_all();
-};
-
-class G1OldGenerationCounters: public G1GenerationCounters {
-public:
- G1OldGenerationCounters(G1MonitoringSupport* g1mm, const char* name);
- virtual void update_all();
-};
-
#endif // SHARE_VM_GC_G1_G1MONITORINGSUPPORT_HPP
--- a/src/hotspot/share/gc/g1/vmStructs_g1.hpp Wed Aug 22 20:37:07 2018 +0200
+++ b/src/hotspot/share/gc/g1/vmStructs_g1.hpp Wed Aug 22 20:37:07 2018 +0200
@@ -59,12 +59,12 @@
nonstatic_field(G1CollectedHeap, _archive_set, HeapRegionSetBase) \
nonstatic_field(G1CollectedHeap, _humongous_set, HeapRegionSetBase) \
\
- nonstatic_field(G1MonitoringSupport, _eden_committed, size_t) \
- nonstatic_field(G1MonitoringSupport, _eden_used, size_t) \
- nonstatic_field(G1MonitoringSupport, _survivor_committed, size_t) \
- nonstatic_field(G1MonitoringSupport, _survivor_used, size_t) \
- nonstatic_field(G1MonitoringSupport, _old_committed, size_t) \
- nonstatic_field(G1MonitoringSupport, _old_used, size_t) \
+ nonstatic_field(G1MonitoringSupport, _eden_space_committed, size_t) \
+ nonstatic_field(G1MonitoringSupport, _eden_space_used, size_t) \
+ nonstatic_field(G1MonitoringSupport, _survivor_space_committed, size_t) \
+ nonstatic_field(G1MonitoringSupport, _survivor_space_used, size_t) \
+ nonstatic_field(G1MonitoringSupport, _old_gen_committed, size_t) \
+ nonstatic_field(G1MonitoringSupport, _old_gen_used, size_t) \
\
nonstatic_field(HeapRegionSetBase, _length, uint) \
\
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/g1/G1MonitoringSupport.java Wed Aug 22 20:37:07 2018 +0200
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/g1/G1MonitoringSupport.java Wed Aug 22 20:37:07 2018 +0200
@@ -37,18 +37,18 @@
// Mirror class for G1MonitoringSupport.
public class G1MonitoringSupport extends VMObject {
- // size_t _eden_committed;
- static private CIntegerField edenCommittedField;
- // size_t _eden_used;
- static private CIntegerField edenUsedField;
- // size_t _survivor_committed;
- static private CIntegerField survivorCommittedField;
- // size_t _survivor_used;
- static private CIntegerField survivorUsedField;
- // size_t _old_committed;
- static private CIntegerField oldCommittedField;
- // size_t _old_used;
- static private CIntegerField oldUsedField;
+ // size_t _eden_space_committed;
+ static private CIntegerField edenSpaceCommittedField;
+ // size_t _eden_space_used;
+ static private CIntegerField edenSpaceUsedField;
+ // size_t _survivor_space_committed;
+ static private CIntegerField survivorSpaceCommittedField;
+ // size_t _survivor_space_used;
+ static private CIntegerField survivorSpaceUsedField;
+ // size_t _old_gen_committed;
+ static private CIntegerField oldGenCommittedField;
+ // size_t _old_gen_used;
+ static private CIntegerField oldGenUsedField;
static {
VM.registerVMInitializedObserver(new Observer() {
@@ -61,44 +61,44 @@
static private synchronized void initialize(TypeDataBase db) {
Type type = db.lookupType("G1MonitoringSupport");
- edenCommittedField = type.getCIntegerField("_eden_committed");
- edenUsedField = type.getCIntegerField("_eden_used");
- survivorCommittedField = type.getCIntegerField("_survivor_committed");
- survivorUsedField = type.getCIntegerField("_survivor_used");
- oldCommittedField = type.getCIntegerField("_old_committed");
- oldUsedField = type.getCIntegerField("_old_used");
+ edenSpaceCommittedField = type.getCIntegerField("_eden_space_committed");
+ edenSpaceUsedField = type.getCIntegerField("_eden_space_used");
+ survivorSpaceCommittedField = type.getCIntegerField("_survivor_space_committed");
+ survivorSpaceUsedField = type.getCIntegerField("_survivor_space_used");
+ oldGenCommittedField = type.getCIntegerField("_old_gen_committed");
+ oldGenUsedField = type.getCIntegerField("_old_gen_used");
}
- public long edenCommitted() {
- return edenCommittedField.getValue(addr);
+ public long edenSpaceCommitted() {
+ return edenSpaceCommittedField.getValue(addr);
}
- public long edenUsed() {
- return edenUsedField.getValue(addr);
+ public long edenSpaceUsed() {
+ return edenSpaceUsedField.getValue(addr);
}
- public long edenRegionNum() {
- return edenUsed() / HeapRegion.grainBytes();
+ public long edenSpaceRegionNum() {
+ return edenSpaceUsed() / HeapRegion.grainBytes();
}
- public long survivorCommitted() {
- return survivorCommittedField.getValue(addr);
+ public long survivorSpaceCommitted() {
+ return survivorSpaceCommittedField.getValue(addr);
}
- public long survivorUsed() {
- return survivorUsedField.getValue(addr);
+ public long survivorSpaceUsed() {
+ return survivorSpaceUsedField.getValue(addr);
}
- public long survivorRegionNum() {
- return survivorUsed() / HeapRegion.grainBytes();
+ public long survivorSpaceRegionNum() {
+ return survivorSpaceUsed() / HeapRegion.grainBytes();
}
- public long oldCommitted() {
- return oldCommittedField.getValue(addr);
+ public long oldGenCommitted() {
+ return oldGenCommittedField.getValue(addr);
}
- public long oldUsed() {
- return oldUsedField.getValue(addr);
+ public long oldGenUsed() {
+ return oldGenUsedField.getValue(addr);
}
public G1MonitoringSupport(Address addr) {
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/tools/HeapSummary.java Wed Aug 22 20:37:07 2018 +0200
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/tools/HeapSummary.java Wed Aug 22 20:37:07 2018 +0200
@@ -225,21 +225,21 @@
public void printG1HeapSummary(G1CollectedHeap g1h) {
G1MonitoringSupport g1mm = g1h.g1mm();
- long edenRegionNum = g1mm.edenRegionNum();
- long survivorRegionNum = g1mm.survivorRegionNum();
+ long edenSpaceRegionNum = g1mm.edenSpaceRegionNum();
+ long survivorSpaceRegionNum = g1mm.survivorSpaceRegionNum();
HeapRegionSetBase oldSet = g1h.oldSet();
HeapRegionSetBase archiveSet = g1h.archiveSet();
HeapRegionSetBase humongousSet = g1h.humongousSet();
- long oldRegionNum = oldSet.length() + archiveSet.length() + humongousSet.length();
+ long oldGenRegionNum = oldSet.length() + archiveSet.length() + humongousSet.length();
printG1Space("G1 Heap:", g1h.n_regions(),
g1h.used(), g1h.capacity());
System.out.println("G1 Young Generation:");
- printG1Space("Eden Space:", edenRegionNum,
- g1mm.edenUsed(), g1mm.edenCommitted());
- printG1Space("Survivor Space:", survivorRegionNum,
- g1mm.survivorUsed(), g1mm.survivorCommitted());
- printG1Space("G1 Old Generation:", oldRegionNum,
- g1mm.oldUsed(), g1mm.oldCommitted());
+ printG1Space("Eden Space:", edenSpaceRegionNum,
+ g1mm.edenSpaceUsed(), g1mm.edenSpaceCommitted());
+ printG1Space("Survivor Space:", survivorSpaceRegionNum,
+ g1mm.survivorSpaceUsed(), g1mm.survivorSpaceCommitted());
+ printG1Space("G1 Old Generation:", oldGenRegionNum,
+ g1mm.oldGenUsed(), g1mm.oldGenCommitted());
}
private void printG1Space(String spaceName, long regionNum,