< prev index next >
src/hotspot/share/gc/g1/g1MonitoringSupport.hpp
Print this page
*** 44,67 ****
//
// * eden : regions that have been allocated since the last GC
// * survivors : regions with objects that survived the last few GCs
// * old : long-lived non-humongous regions
// * humongous : humongous regions
// * free : free regions
//
// The combination of eden and survivor regions form the equivalent of
! // the young generation in the other GCs. The combination of old and
! // humongous regions form the equivalent of the old generation in the
! // other GCs. Free regions do not have a good equivalent in the other
! // GCs given that they can be allocated as any of the other region types.
! //
! // The monitoring tools expect the heap to contain a number of
! // generations (young, old, perm) and each generation to contain a
! // number of spaces (young: eden, survivors, old). Given that G1 does
! // not maintain those spaces physically (e.g., the set of
! // non-contiguous eden regions can be considered as a "logical"
! // space), we'll provide the illusion that those generations and
// spaces exist. In reality, each generation and space refers to a set
// of heap regions that are potentially non-contiguous.
//
// This class provides interfaces to access the min, current, and max
// capacity and current occupancy for each of G1's logical spaces and
--- 44,70 ----
//
// * eden : regions that have been allocated since the last GC
// * survivors : regions with objects that survived the last few GCs
// * old : long-lived non-humongous regions
// * humongous : humongous regions
+ // * archive : archive regions
// * free : free regions
//
// The combination of eden and survivor regions form the equivalent of
! // the young generation in the other GCs. The combination of old,
! // humongous, and archive regions form the equivalent of the old
! // generation in the other GCs. Archive regions are permanently
! // allocated during heap initialization, e.g., for CDS. Free regions
! // do not have a good equivalent in the other GCs, given that they can
! // be allocated as any of the other region types.
! //
! // The monitoring tools expect the heap to contain one or more
! // generations (young, old) and each generation to contain one or
! // more spaces (young has eden and survivor, old has old, humongous and
! // archive). Given that G1 does not maintain those spaces physically
! // (e.g., the set of non-contiguous eden regions can be considered as
! // a "logical" space), we provide the illusion that those generations and
// spaces exist. In reality, each generation and space refers to a set
// of heap regions that are potentially non-contiguous.
//
// This class provides interfaces to access the min, current, and max
// capacity and current occupancy for each of G1's logical spaces and
*** 76,100 ****
// - heap_capacity = current heap capacity (e.g., current committed size)
// - young_gen_capacity = current max young gen target capacity
// (i.e., young gen target capacity + max allowed expansion capacity)
// - survivor_capacity = current survivor region capacity
// - eden_capacity = young_gen_capacity - survivor_capacity
// - old_capacity = heap_capacity - young_gen_capacity
//
// What we do in the above is to distribute the free regions among
// eden_capacity and old_capacity.
//
// * Occupancy
//
! // - young_gen_used = current young region capacity
// - survivor_used = survivor_capacity
// - eden_used = young_gen_used - survivor_used
// - old_used = overall_used - young_gen_used
! //
! // Unfortunately, we currently only keep track of the number of
! // currently allocated young and survivor regions + the overall used
! // bytes in the heap, so the above can be a little inaccurate.
//
// * Min Capacity
//
// We set this to 0 for all spaces.
//
--- 79,111 ----
// - heap_capacity = current heap capacity (e.g., current committed size)
// - young_gen_capacity = current max young gen target capacity
// (i.e., young gen target capacity + max allowed expansion capacity)
// - survivor_capacity = current survivor region capacity
// - eden_capacity = young_gen_capacity - survivor_capacity
+ // In legacy mode:
// - old_capacity = heap_capacity - young_gen_capacity
+ // Otherwise:
+ // - humongous_capacity = sum of humongous regions allocated
+ // - archive_capacity = sum of archive regions allocated
+ // - old_capacity = heap_capacity - young_gen_capacity -
+ // humongous_capacity - archive_capacity
//
// What we do in the above is to distribute the free regions among
// eden_capacity and old_capacity.
//
// * Occupancy
//
! // - young_gen_committed = current young region capacity
// - survivor_used = survivor_capacity
// - eden_used = young_gen_used - survivor_used
+ // In legacy mode:
// - old_used = overall_used - young_gen_used
! // Otherwise:
! // - humongous_used = sum of humongous regions allocated
! // - archive_used = sum of archive regions allocated
! // - old_used = overall_used - young_gen_used -
! // humongous_used - archive_used
//
// * Min Capacity
//
// We set this to 0 for all spaces.
//
*** 102,139 ****
//
// For jstat, we set the max capacity of all spaces to heap_capacity,
// given that we don't always have a reasonable upper bound on how big
// each space can grow. For the memory pools, we make the max
// capacity undefined with the exception of the old memory pool for
! // which we make the max capacity same as the max heap capacity.
! //
! // If we had more accurate occupancy / capacity information per
! // region set the above calculations would be greatly simplified and
! // be made more accurate.
//
// We update all the above synchronously and we store the results in
! // fields so that we just read said fields when needed. A subtle point
! // is that all the above sizes need to be recalculated when the old
// gen changes capacity (after a GC or after a humongous allocation)
// but only the eden occupancy changes when a new eden region is
// allocated. So, in the latter case we have minimal recalculation to
! // do which is important as we want to keep the eden region allocation
! // path as low-overhead as possible.
class G1MonitoringSupport : public CHeapObj<mtGC> {
friend class VMStructs;
friend class G1MonitoringScope;
G1CollectedHeap* _g1h;
// java.lang.management MemoryManager and MemoryPool support
GCMemoryManager _incremental_memory_manager;
! GCMemoryManager _full_gc_memory_manager;
MemoryPool* _eden_space_pool;
MemoryPool* _survivor_space_pool;
! MemoryPool* _old_gen_pool;
// jstat performance counters
// incremental collections both young and mixed
CollectorCounters* _incremental_collection_counters;
// full stop-the-world collections
--- 113,158 ----
//
// For jstat, we set the max capacity of all spaces to heap_capacity,
// given that we don't always have a reasonable upper bound on how big
// each space can grow. For the memory pools, we make the max
// capacity undefined with the exception of the old memory pool for
! // which we make the max capacity same as the max heap capacity. This
! // allows users to sum memory pool max capacities to get something
! // reasonable.
//
// We update all the above synchronously and we store the results in
! // this singleton class so we can just read them out when needed. A subtle
! // point is that all the above sizes must be recalculated when the old
// gen changes capacity (after a GC or after a humongous allocation)
// but only the eden occupancy changes when a new eden region is
// allocated. So, in the latter case we have minimal recalculation to
! // do, but we don't both special-casing it because doing the full
! // recalculation is quite fast.
class G1MonitoringSupport : public CHeapObj<mtGC> {
friend class VMStructs;
friend class G1MonitoringScope;
G1CollectedHeap* _g1h;
// java.lang.management MemoryManager and MemoryPool support
+
+ bool _use_legacy_monitoring; // For vmStructs and hsdb
+
+ GCMemoryManager _full_memory_manager;
+ // Legacy monitoring
GCMemoryManager _incremental_memory_manager;
! // Default monitoring
! GCMemoryManager _young_memory_manager;
! GCMemoryManager _mixed_memory_manager;
! GCMemoryManager _conc_memory_manager;
MemoryPool* _eden_space_pool;
MemoryPool* _survivor_space_pool;
! MemoryPool* _old_space_pool;
! MemoryPool* _archive_space_pool;
! MemoryPool* _humongous_space_pool;
// jstat performance counters
// incremental collections both young and mixed
CollectorCounters* _incremental_collection_counters;
// full stop-the-world collections
*** 163,180 ****
size_t _overall_committed;
size_t _overall_used;
size_t _young_gen_committed;
- size_t _old_gen_committed;
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
// calculations we have to do are obtained concurrently and hence
// may be inconsistent with each other. So, this provides a
--- 182,204 ----
size_t _overall_committed;
size_t _overall_used;
size_t _young_gen_committed;
size_t _eden_space_committed;
size_t _eden_space_used;
size_t _survivor_space_committed;
size_t _survivor_space_used;
! size_t _old_space_committed;
! size_t _old_space_used;
! size_t _archive_space_committed;
! size_t _archive_space_used;
!
! size_t _humongous_space_committed;
! size_t _humongous_space_used;
// It returns x - y if x > y, 0 otherwise.
// As described in the comment above, some of the inputs to the
// calculations we have to do are obtained concurrently and hence
// may be inconsistent with each other. So, this provides a
*** 187,211 ****
} else {
return 0;
}
}
! // Recalculate all the sizes.
void recalculate_sizes();
- void recalculate_eden_size();
-
public:
G1MonitoringSupport(G1CollectedHeap* g1h);
~G1MonitoringSupport();
void initialize_serviceability();
- MemoryUsage memory_usage();
GrowableArray<GCMemoryManager*> memory_managers();
GrowableArray<MemoryPool*> memory_pools();
// Unfortunately, the jstat tool assumes that no space has 0
// capacity. In our case, given that each space is logical, it's
// possible that no regions will be allocated to it, hence to have 0
// capacity (e.g., if there are no survivor regions, the survivor
// space has 0 capacity). The way we deal with this is to always pad
--- 211,235 ----
} else {
return 0;
}
}
! // Recalculate all the space sizes.
void recalculate_sizes();
public:
G1MonitoringSupport(G1CollectedHeap* g1h);
~G1MonitoringSupport();
void initialize_serviceability();
GrowableArray<GCMemoryManager*> memory_managers();
GrowableArray<MemoryPool*> memory_pools();
+ bool use_legacy_monitoring() { return _use_legacy_monitoring; }
+ GCMemoryManager* conc_memory_manager() { return &_conc_memory_manager; }
+
// Unfortunately, the jstat tool assumes that no space has 0
// capacity. In our case, given that each space is logical, it's
// possible that no regions will be allocated to it, hence to have 0
// capacity (e.g., if there are no survivor regions, the survivor
// space has 0 capacity). The way we deal with this is to always pad
*** 217,230 ****
// padding multiple times so that the capacities add up correctly.
static size_t pad_capacity(size_t size_bytes, size_t mult = 1) {
return size_bytes + MinObjAlignmentInBytes * mult;
}
! // Recalculate all the sizes from scratch and update all the jstat
! // counters accordingly.
void update_sizes();
!
void update_eden_size();
CollectorCounters* conc_collection_counters() {
return _conc_collection_counters;
}
--- 241,255 ----
// padding multiple times so that the capacities add up correctly.
static size_t pad_capacity(size_t size_bytes, size_t mult = 1) {
return size_bytes + MinObjAlignmentInBytes * mult;
}
! // Recalculate all the space sizes from scratch and update
! // all jstat counters accordingly.
void update_sizes();
! // Recalculate all the space sizes from scratch, but update
! // just the eden size and jstat counters.
void update_eden_size();
CollectorCounters* conc_collection_counters() {
return _conc_collection_counters;
}
*** 238,262 ****
size_t young_gen_committed() { return _young_gen_committed; }
size_t eden_space_used() { return _eden_space_used; }
size_t survivor_space_used() { return _survivor_space_used; }
! size_t old_gen_committed() { return _old_gen_committed; }
! size_t old_gen_used() { return _old_gen_used; }
// Monitoring support for MemoryPools. Values in the returned MemoryUsage are
// guaranteed to be consistent with each other.
MemoryUsage eden_space_memory_usage(size_t initial_size, size_t max_size);
MemoryUsage survivor_space_memory_usage(size_t initial_size, size_t max_size);
! MemoryUsage old_gen_memory_usage(size_t initial_size, size_t max_size);
};
// Scope object for java.lang.management support.
class G1MonitoringScope : public StackObj {
TraceCollectorStats _tcs;
TraceMemoryManagerStats _tms;
public:
! G1MonitoringScope(G1MonitoringSupport* g1mm, bool full_gc, bool all_memory_pools_affected);
};
#endif // SHARE_VM_GC_G1_G1MONITORINGSUPPORT_HPP
--- 263,307 ----
size_t young_gen_committed() { return _young_gen_committed; }
size_t eden_space_used() { return _eden_space_used; }
size_t survivor_space_used() { return _survivor_space_used; }
! size_t old_gen_committed();
! size_t old_gen_used();
!
! size_t old_space_committed() { return _old_space_committed; }
! size_t old_space_used() { return _old_space_used; }
! size_t archive_space_used() { return _archive_space_used; }
!
! size_t humongous_space_used() { return _humongous_space_used; }
// Monitoring support for MemoryPools. Values in the returned MemoryUsage are
// guaranteed to be consistent with each other.
+ MemoryUsage memory_usage();
MemoryUsage eden_space_memory_usage(size_t initial_size, size_t max_size);
MemoryUsage survivor_space_memory_usage(size_t initial_size, size_t max_size);
+ MemoryUsage old_space_memory_usage(size_t initial_size, size_t max_size);
+ MemoryUsage archive_space_memory_usage(size_t initial_size, size_t max_size);
+ MemoryUsage humongous_space_memory_usage(size_t initial_size, size_t max_size);
+ };
! // TraceMemoryManagerStats for concurrent cycle.
! class TraceConcMemoryManagerStats : public TraceMemoryManagerStats {
! public:
! enum Stage {
! CycleStart,
! Remark,
! Cleanup,
! CycleEnd
! };
! TraceConcMemoryManagerStats(Stage stage, GCCause::Cause cause);
};
// Scope object for java.lang.management support.
class G1MonitoringScope : public StackObj {
TraceCollectorStats _tcs;
TraceMemoryManagerStats _tms;
public:
! G1MonitoringScope(G1MonitoringSupport* g1mm, bool full_gc, bool mixed_gc);
};
#endif // SHARE_VM_GC_G1_G1MONITORINGSUPPORT_HPP
< prev index next >