stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8189737: Make HeapRegion not derive from Space

Browse Source 
Reviewed-by: sjohanss, kbarrett
This commit is contained in:
Thomas Schatzl 2019-11-08 10:01:13 +01:00
parent f225f7cd0b
commit c4b3dcf8c1
32 changed files with 304 additions and 286 deletions

1
src/hotspot/share/aot/aotCodeHeap.cpp

@ -34,6 +34,7 @@
#include "interpreter/abstractInterpreter.hpp"
#include "jvmci/compilerRuntime.hpp"
#include "jvmci/jvmciRuntime.hpp"
#include "logging/log.hpp"
#include "memory/allocation.inline.hpp"
#include "memory/universe.hpp"
#include "oops/compressedOops.hpp"

2
src/hotspot/share/gc/cms/compactibleFreeListSpace.cpp

@ -32,7 +32,7 @@
#include "gc/shared/collectedHeap.inline.hpp"
#include "gc/shared/genOopClosures.inline.hpp"
#include "gc/shared/space.inline.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "logging/log.hpp"
#include "logging/logStream.hpp"
#include "memory/allocation.inline.hpp"

2
src/hotspot/share/gc/cms/parNewGeneration.cpp

@ -44,7 +44,7 @@
#include "gc/shared/referencePolicy.hpp"
#include "gc/shared/referenceProcessorPhaseTimes.hpp"
#include "gc/shared/space.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "gc/shared/strongRootsScope.hpp"
#include "gc/shared/taskqueue.inline.hpp"
#include "gc/shared/weakProcessor.hpp"

44
src/hotspot/share/gc/g1/g1BlockOffsetTable.cpp

@ -25,8 +25,7 @@
#include "precompiled.hpp"
#include "gc/g1/g1BlockOffsetTable.inline.hpp"
#include "gc/g1/g1CollectedHeap.inline.hpp"
#include "gc/g1/heapRegion.hpp"
#include "gc/shared/space.hpp"
#include "gc/g1/heapRegion.inline.hpp"
#include "logging/log.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/java.hpp"
@ -74,12 +73,12 @@ void G1BlockOffsetTable::check_index(size_t index, const char* msg) const {
// G1BlockOffsetTablePart
//////////////////////////////////////////////////////////////////////
G1BlockOffsetTablePart::G1BlockOffsetTablePart(G1BlockOffsetTable* array, G1ContiguousSpace* gsp) :
G1BlockOffsetTablePart::G1BlockOffsetTablePart(G1BlockOffsetTable* array, HeapRegion* hr) :
_next_offset_threshold(NULL),
_next_offset_index(0),
DEBUG_ONLY(_object_can_span(false) COMMA)
_bot(array),
_space(gsp)
_hr(hr)
{
}
@ -141,7 +140,7 @@ void G1BlockOffsetTablePart::set_remainder_to_point_to_start_incl(size_t start_c
if (start_card > end_card) {
return;
}
assert(start_card > _bot->index_for(_space->bottom()), "Cannot be first card");
assert(start_card > _bot->index_for(_hr->bottom()), "Cannot be first card");
assert(_bot->offset_array(start_card-1) <= BOTConstants::N_words,
"Offset card has an unexpected value");
size_t start_card_for_region = start_card;
@ -224,7 +223,7 @@ HeapWord* G1BlockOffsetTablePart::forward_to_block_containing_addr_slow(HeapWord
"next_boundary is beyond the end of the covered region "
" next_boundary " PTR_FORMAT " _array->_end " PTR_FORMAT,
p2i(next_boundary), p2i(_bot->_reserved.end()));
if (addr >= _space->top()) return _space->top();
if (addr >= _hr->top()) return _hr->top();
while (next_boundary < addr) {
while (n <= next_boundary) {
q = n;
@ -326,9 +325,9 @@ void G1BlockOffsetTablePart::alloc_block_work(HeapWord** threshold_, size_t* ind
}
void G1BlockOffsetTablePart::verify() const {
assert(_space->bottom() < _space->top(), "Only non-empty regions should be verified.");
size_t start_card = _bot->index_for(_space->bottom());
size_t end_card = _bot->index_for(_space->top() - 1);
assert(_hr->bottom() < _hr->top(), "Only non-empty regions should be verified.");
size_t start_card = _bot->index_for(_hr->bottom());
size_t end_card = _bot->index_for(_hr->top() - 1);
for (size_t current_card = start_card; current_card < end_card; current_card++) {
u_char entry = _bot->offset_array(current_card);
@ -342,9 +341,9 @@ void G1BlockOffsetTablePart::verify() const {
HeapWord* obj = obj_end;
size_t obj_size = block_size(obj);
obj_end = obj + obj_size;
guarantee(obj_end > obj && obj_end <= _space->top(),
guarantee(obj_end > obj && obj_end <= _hr->top(),
"Invalid object end. obj: " PTR_FORMAT " obj_size: " SIZE_FORMAT " obj_end: " PTR_FORMAT " top: " PTR_FORMAT,
p2i(obj), obj_size, p2i(obj_end), p2i(_space->top()));
p2i(obj), obj_size, p2i(obj_end), p2i(_hr->top()));
}
} else {
// Because we refine the BOT based on which cards are dirty there is not much we can verify here.
@ -359,9 +358,9 @@ void G1BlockOffsetTablePart::verify() const {
start_card, current_card, backskip);
HeapWord* backskip_address = _bot->address_for_index(current_card - backskip);
guarantee(backskip_address >= _space->bottom(),
guarantee(backskip_address >= _hr->bottom(),
"Going backwards beyond bottom of the region: bottom: " PTR_FORMAT ", backskip_address: " PTR_FORMAT,
p2i(_space->bottom()), p2i(backskip_address));
p2i(_hr->bottom()), p2i(backskip_address));
}
}
}
@ -373,13 +372,12 @@ void G1BlockOffsetTablePart::set_object_can_span(bool can_span) {
#endif
#ifndef PRODUCT
void
G1BlockOffsetTablePart::print_on(outputStream* out) {
size_t from_index = _bot->index_for(_space->bottom());
size_t to_index = _bot->index_for(_space->end());
void G1BlockOffsetTablePart::print_on(outputStream* out) {
size_t from_index = _bot->index_for(_hr->bottom());
size_t to_index = _bot->index_for(_hr->end());
out->print_cr(">> BOT for area [" PTR_FORMAT "," PTR_FORMAT ") "
"cards [" SIZE_FORMAT "," SIZE_FORMAT ")",
p2i(_space->bottom()), p2i(_space->end()), from_index, to_index);
p2i(_hr->bottom()), p2i(_hr->end()), from_index, to_index);
for (size_t i = from_index; i < to_index; ++i) {
out->print_cr(" entry " SIZE_FORMAT_W(8) " | " PTR_FORMAT " : %3u",
i, p2i(_bot->address_for_index(i)),
@ -391,7 +389,7 @@ G1BlockOffsetTablePart::print_on(outputStream* out) {
#endif // !PRODUCT
HeapWord* G1BlockOffsetTablePart::initialize_threshold_raw() {
_next_offset_index = _bot->index_for_raw(_space->bottom());
_next_offset_index = _bot->index_for_raw(_hr->bottom());
_next_offset_index++;
_next_offset_threshold =
_bot->address_for_index_raw(_next_offset_index);
@ -399,14 +397,14 @@ HeapWord* G1BlockOffsetTablePart::initialize_threshold_raw() {
}
void G1BlockOffsetTablePart::zero_bottom_entry_raw() {
size_t bottom_index = _bot->index_for_raw(_space->bottom());
assert(_bot->address_for_index_raw(bottom_index) == _space->bottom(),
size_t bottom_index = _bot->index_for_raw(_hr->bottom());
assert(_bot->address_for_index_raw(bottom_index) == _hr->bottom(),
"Precondition of call");
_bot->set_offset_array_raw(bottom_index, 0);
}
HeapWord* G1BlockOffsetTablePart::initialize_threshold() {
_next_offset_index = _bot->index_for(_space->bottom());
_next_offset_index = _bot->index_for(_hr->bottom());
_next_offset_index++;
_next_offset_threshold =
_bot->address_for_index(_next_offset_index);
@ -416,7 +414,7 @@ HeapWord* G1BlockOffsetTablePart::initialize_threshold() {
void G1BlockOffsetTablePart::set_for_starts_humongous(HeapWord* obj_top, size_t fill_size) {
// The first BOT entry should have offset 0.
reset_bot();
alloc_block(_space->bottom(), obj_top);
alloc_block(_hr->bottom(), obj_top);
if (fill_size > 0) {
alloc_block(obj_top, fill_size);
}

10
src/hotspot/share/gc/g1/g1BlockOffsetTable.hpp

@ -33,14 +33,14 @@
// Forward declarations
class G1BlockOffsetTable;
class G1ContiguousSpace;
class HeapRegion;
// This implementation of "G1BlockOffsetTable" divides the covered region
// into "N"-word subregions (where "N" = 2^"LogN". An array with an entry
// for each such subregion indicates how far back one must go to find the
// start of the chunk that includes the first word of the subregion.
//
// Each G1BlockOffsetTablePart is owned by a G1ContiguousSpace.
// Each G1BlockOffsetTablePart is owned by a HeapRegion.
class G1BlockOffsetTable: public CHeapObj<mtGC> {
friend class G1BlockOffsetTablePart;
@ -120,8 +120,8 @@ private:
// This is the global BlockOffsetTable.
G1BlockOffsetTable* _bot;
// The space that owns this subregion.
G1ContiguousSpace* _space;
// The region that owns this subregion.
HeapRegion* _hr;
// Sets the entries
// corresponding to the cards starting at "start" and ending at "end"
@ -183,7 +183,7 @@ private:
public:
// The elements of the array are initialized to zero.
G1BlockOffsetTablePart(G1BlockOffsetTable* array, G1ContiguousSpace* gsp);
G1BlockOffsetTablePart(G1BlockOffsetTable* array, HeapRegion* hr);
void verify() const;

13
src/hotspot/share/gc/g1/g1BlockOffsetTable.inline.hpp

@ -28,11 +28,10 @@
#include "gc/g1/g1BlockOffsetTable.hpp"
#include "gc/g1/heapRegion.hpp"
#include "gc/shared/memset_with_concurrent_readers.hpp"
#include "gc/shared/space.hpp"
#include "runtime/atomic.hpp"
inline HeapWord* G1BlockOffsetTablePart::block_start(const void* addr) {
if (addr >= _space->bottom() && addr < _space->end()) {
if (addr >= _hr->bottom() && addr < _hr->end()) {
HeapWord* q = block_at_or_preceding(addr, true, _next_offset_index-1);
return forward_to_block_containing_addr(q, addr);
} else {
@ -41,7 +40,7 @@ inline HeapWord* G1BlockOffsetTablePart::block_start(const void* addr) {
}
inline HeapWord* G1BlockOffsetTablePart::block_start_const(const void* addr) const {
if (addr >= _space->bottom() && addr < _space->end()) {
if (addr >= _hr->bottom() && addr < _hr->end()) {
HeapWord* q = block_at_or_preceding(addr, true, _next_offset_index-1);
HeapWord* n = q + block_size(q);
return forward_to_block_containing_addr_const(q, n, addr);
@ -107,15 +106,15 @@ inline HeapWord* G1BlockOffsetTable::address_for_index(size_t index) const {
}
inline size_t G1BlockOffsetTablePart::block_size(const HeapWord* p) const {
return _space->block_size(p);
return _hr->block_size(p);
}
inline HeapWord* G1BlockOffsetTablePart::block_at_or_preceding(const void* addr,
bool has_max_index,
size_t max_index) const {
assert(_object_can_span || _bot->offset_array(_bot->index_for(_space->bottom())) == 0,
assert(_object_can_span || _bot->offset_array(_bot->index_for(_hr->bottom())) == 0,
"Object crossed region boundary, found offset %u instead of 0",
(uint) _bot->offset_array(_bot->index_for(_space->bottom())));
(uint) _bot->offset_array(_bot->index_for(_hr->bottom())));
size_t index = _bot->index_for(addr);
// We must make sure that the offset table entry we use is valid. If
// "addr" is past the end, start at the last known one and go forward.
@ -140,7 +139,7 @@ inline HeapWord* G1BlockOffsetTablePart::block_at_or_preceding(const void* addr,
inline HeapWord* G1BlockOffsetTablePart::forward_to_block_containing_addr_const(HeapWord* q, HeapWord* n,
const void* addr) const {
if (addr >= _space->top()) return _space->top();
if (addr >= _hr->top()) return _hr->top();
while (n <= addr) {
q = n;
oop obj = oop(q);

4
src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@ -664,8 +664,6 @@ bool G1CollectedHeap::alloc_archive_regions(MemRegion* ranges,
next_region = NULL;
}
curr_region->set_top(top);
curr_region->set_first_dead(top);
curr_region->set_end_of_live(top);
curr_region = next_region;
}
@ -3978,7 +3976,7 @@ private:
}
if (!r->evacuation_failed()) {
assert(r->not_empty(), "Region %u is an empty region in the collection set.", r->hrm_index());
assert(!r->is_empty(), "Region %u is an empty region in the collection set.", r->hrm_index());
_before_used_bytes += r->used();
g1h->free_region(r,
&_local_free_list,

1
src/hotspot/share/gc/g1/g1ConcurrentMark.hpp

@ -32,6 +32,7 @@
#include "gc/g1/heapRegionSet.hpp"
#include "gc/shared/taskqueue.hpp"
#include "gc/shared/verifyOption.hpp"
#include "gc/shared/workgroup.hpp"
#include "memory/allocation.hpp"
#include "utilities/compilerWarnings.hpp"

1
src/hotspot/share/gc/g1/g1YoungGenSizer.cpp

@ -28,6 +28,7 @@
#include "gc/g1/g1YoungGenSizer.hpp"
#include "gc/g1/heapRegion.hpp"
#include "logging/log.hpp"
#include "runtime/globals_extension.hpp"
G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults),
_use_adaptive_sizing(true), _min_desired_young_length(0), _max_desired_young_length(0) {

108
src/hotspot/share/gc/g1/heapRegion.cpp

@ -35,7 +35,6 @@
#include "gc/g1/heapRegionRemSet.hpp"
#include "gc/g1/heapRegionTracer.hpp"
#include "gc/shared/genOopClosures.inline.hpp"
#include "gc/shared/space.inline.hpp"
#include "logging/log.hpp"
#include "logging/logStream.hpp"
#include "memory/iterator.inline.hpp"
@ -45,7 +44,6 @@
#include "oops/oop.inline.hpp"
#include "runtime/atomic.hpp"
#include "runtime/orderAccess.hpp"
#include "utilities/growableArray.hpp"
int HeapRegion::LogOfHRGrainBytes = 0;
int HeapRegion::LogOfHRGrainWords = 0;
@ -234,21 +232,27 @@ void HeapRegion::clear_humongous() {
HeapRegion::HeapRegion(uint hrm_index,
G1BlockOffsetTable* bot,
MemRegion mr) :
G1ContiguousSpace(bot),
_rem_set(NULL),
_hrm_index(hrm_index),
_type(),
_humongous_start_region(NULL),
_evacuation_failed(false),
_next(NULL), _prev(NULL),
_bottom(NULL),
_end(NULL),
_top(NULL),
_compaction_top(NULL),
_bot_part(bot, this),
_par_alloc_lock(Mutex::leaf, "HeapRegion par alloc lock", true),
_pre_dummy_top(NULL),
_rem_set(NULL),
_hrm_index(hrm_index),
_type(),
_humongous_start_region(NULL),
_evacuation_failed(false),
_next(NULL), _prev(NULL),
#ifdef ASSERT
_containing_set(NULL),
_containing_set(NULL),
#endif
_prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
_index_in_opt_cset(InvalidCSetIndex), _young_index_in_cset(-1),
_surv_rate_group(NULL), _age_index(-1),
_prev_top_at_mark_start(NULL), _next_top_at_mark_start(NULL),
_recorded_rs_length(0), _predicted_elapsed_time_ms(0)
_prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
_index_in_opt_cset(InvalidCSetIndex), _young_index_in_cset(-1),
_surv_rate_group(NULL), _age_index(-1),
_prev_top_at_mark_start(NULL), _next_top_at_mark_start(NULL),
_recorded_rs_length(0), _predicted_elapsed_time_ms(0)
{
_rem_set = new HeapRegionRemSet(bot, this);
@ -258,10 +262,20 @@ HeapRegion::HeapRegion(uint hrm_index,
void HeapRegion::initialize(MemRegion mr, bool clear_space, bool mangle_space) {
assert(_rem_set->is_empty(), "Remembered set must be empty");
G1ContiguousSpace::initialize(mr, clear_space, mangle_space);
assert(Universe::on_page_boundary(mr.start()) && Universe::on_page_boundary(mr.end()),
"invalid space boundaries");
set_bottom(mr.start());
set_end(mr.end());
if (clear_space) {
clear(mangle_space);
}
set_top(bottom());
set_compaction_top(bottom());
reset_bot();
hr_clear(false /*par*/, false /*clear_space*/);
set_top(bottom());
}
void HeapRegion::report_region_type_change(G1HeapRegionTraceType::Type to) {
@ -444,6 +458,7 @@ void HeapRegion::verify_strong_code_roots(VerifyOption vo, bool* failures) const
}
void HeapRegion::print() const { print_on(tty); }
void HeapRegion::print_on(outputStream* st) const {
st->print("|%4u", this->_hrm_index);
st->print("|" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT,
@ -636,9 +651,6 @@ public:
debug_only(virtual bool should_verify_oops() { return false; })
};
// This really ought to be commoned up into OffsetTableContigSpace somehow.
// We would need a mechanism to make that code skip dead objects.
void HeapRegion::verify(VerifyOption vo,
bool* failures) const {
G1CollectedHeap* g1h = G1CollectedHeap::heap();
@ -828,51 +840,32 @@ void HeapRegion::verify_rem_set() const {
guarantee(!failures, "HeapRegion RemSet verification failed");
}
void HeapRegion::prepare_for_compaction(CompactPoint* cp) {
// Not used for G1 anymore, but pure virtual in Space.
ShouldNotReachHere();
}
// G1OffsetTableContigSpace code; copied from space.cpp. Hope this can go
// away eventually.
void G1ContiguousSpace::clear(bool mangle_space) {
void HeapRegion::clear(bool mangle_space) {
set_top(bottom());
CompactibleSpace::clear(mangle_space);
set_compaction_top(bottom());
if (ZapUnusedHeapArea && mangle_space) {
mangle_unused_area();
}
reset_bot();
}
#ifndef PRODUCT
void G1ContiguousSpace::mangle_unused_area() {
mangle_unused_area_complete();
}
void G1ContiguousSpace::mangle_unused_area_complete() {
#ifndef PRODUCT
void HeapRegion::mangle_unused_area() {
SpaceMangler::mangle_region(MemRegion(top(), end()));
}
#endif
void G1ContiguousSpace::print() const {
print_short();
tty->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", "
INTPTR_FORMAT ", " INTPTR_FORMAT ")",
p2i(bottom()), p2i(top()), p2i(_bot_part.threshold()), p2i(end()));
}
HeapWord* G1ContiguousSpace::initialize_threshold() {
HeapWord* HeapRegion::initialize_threshold() {
return _bot_part.initialize_threshold();
}
HeapWord* G1ContiguousSpace::cross_threshold(HeapWord* start,
HeapWord* end) {
HeapWord* HeapRegion::cross_threshold(HeapWord* start, HeapWord* end) {
_bot_part.alloc_block(start, end);
return _bot_part.threshold();
}
void G1ContiguousSpace::safe_object_iterate(ObjectClosure* blk) {
object_iterate(blk);
}
void G1ContiguousSpace::object_iterate(ObjectClosure* blk) {
void HeapRegion::object_iterate(ObjectClosure* blk) {
HeapWord* p = bottom();
while (p < top()) {
if (block_is_obj(p)) {
@ -881,18 +874,3 @@ void G1ContiguousSpace::object_iterate(ObjectClosure* blk) {
p += block_size(p);
}
}
G1ContiguousSpace::G1ContiguousSpace(G1BlockOffsetTable* bot) :
_top(NULL),
_bot_part(bot, this),
_par_alloc_lock(Mutex::leaf, "OffsetTableContigSpace par alloc lock", true),
_pre_dummy_top(NULL)
{
}
void G1ContiguousSpace::initialize(MemRegion mr, bool clear_space, bool mangle_space) {
CompactibleSpace::initialize(mr, clear_space, mangle_space);
_top = bottom();
set_saved_mark_word(NULL);
reset_bot();
}

182
src/hotspot/share/gc/g1/heapRegion.hpp

@ -31,34 +31,13 @@
#include "gc/g1/heapRegionType.hpp"
#include "gc/g1/survRateGroup.hpp"
#include "gc/shared/ageTable.hpp"
#include "gc/shared/cardTable.hpp"
#include "gc/shared/verifyOption.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/verifyOption.hpp"
#include "runtime/mutex.hpp"
#include "utilities/macros.hpp"
// A HeapRegion is the smallest piece of a G1CollectedHeap that
// can be collected independently.
// NOTE: Although a HeapRegion is a Space, its
// Space::initDirtyCardClosure method must not be called.
// The problem is that the existence of this method breaks
// the independence of barrier sets from remembered sets.
// The solution is to remove this method from the definition
// of a Space.
// Each heap region is self contained. top() and end() can never
// be set beyond the end of the region. For humongous objects,
// the first region is a StartsHumongous region. If the humongous
// object is larger than a heap region, the following regions will
// be of type ContinuesHumongous. In this case the top() of the
// StartHumongous region and all ContinuesHumongous regions except
// the last will point to their own end. The last ContinuesHumongous
// region may have top() equal the end of object if there isn't
// room for filler objects to pad out to the end of the region.
class G1CollectedHeap;
class G1CMBitMap;
class G1IsAliveAndApplyClosure;
class HeapRegionRemSet;
class HeapRegion;
class HeapRegionSetBase;
@ -73,31 +52,27 @@ class nmethod;
// sentinel value for hrm_index
#define G1_NO_HRM_INDEX ((uint) -1)
// The complicating factor is that BlockOffsetTable diverged
// significantly, and we need functionality that is only in the G1 version.
// So I copied that code, which led to an alternate G1 version of
// OffsetTableContigSpace. If the two versions of BlockOffsetTable could
// be reconciled, then G1OffsetTableContigSpace could go away.
// A HeapRegion is the smallest piece of a G1CollectedHeap that
// can be collected independently.
// The idea behind time stamps is the following. We want to keep track of
// the highest address where it's safe to scan objects for each region.
// This is only relevant for current GC alloc regions so we keep a time stamp
// per region to determine if the region has been allocated during the current
// GC or not. If the time stamp is current we report a scan_top value which
// was saved at the end of the previous GC for retained alloc regions and which is
// equal to the bottom for all other regions.
// There is a race between card scanners and allocating gc workers where we must ensure
// that card scanners do not read the memory allocated by the gc workers.
// In order to enforce that, we must not return a value of _top which is more recent than the
// time stamp. This is due to the fact that a region may become a gc alloc region at
// some point after we've read the timestamp value as being < the current time stamp.
// The time stamps are re-initialized to zero at cleanup and at Full GCs.
// The current scheme that uses sequential unsigned ints will fail only if we have 4b
// evacuation pauses between two cleanups, which is _highly_ unlikely.
class G1ContiguousSpace: public CompactibleSpace {
// Each heap region is self contained. top() and end() can never
// be set beyond the end of the region. For humongous objects,
// the first region is a StartsHumongous region. If the humongous
// object is larger than a heap region, the following regions will
// be of type ContinuesHumongous. In this case the top() of the
// StartHumongous region and all ContinuesHumongous regions except
// the last will point to their own end. The last ContinuesHumongous
// region may have top() equal the end of object if there isn't
// room for filler objects to pad out to the end of the region.
class HeapRegion : public CHeapObj<mtGC> {
friend class VMStructs;
HeapWord* _bottom;
HeapWord* _end;
HeapWord* volatile _top;
protected:
HeapWord* _compaction_top;
G1BlockOffsetTablePart _bot_part;
Mutex _par_alloc_lock;
// When we need to retire an allocation region, while other threads
@ -108,43 +83,57 @@ class G1ContiguousSpace: public CompactibleSpace {
// into the region was and this is what this keeps track.
HeapWord* _pre_dummy_top;
public:
G1ContiguousSpace(G1BlockOffsetTable* bot);
public:
void set_bottom(HeapWord* value) { _bottom = value; }
HeapWord* bottom() const { return _bottom; }
void set_end(HeapWord* value) { _end = value; }
HeapWord* end() const { return _end; }
void set_compaction_top(HeapWord* compaction_top) { _compaction_top = compaction_top; }
HeapWord* compaction_top() const { return _compaction_top; }
void set_top(HeapWord* value) { _top = value; }
HeapWord* top() const { return _top; }
protected:
// Reset the G1ContiguousSpace.
virtual void initialize(MemRegion mr, bool clear_space, bool mangle_space);
// Returns true iff the given the heap region contains the
// given address as part of an allocated object. This may
// be a potentially, so we restrict its use to assertion checks only.
bool is_in(const void* p) const {
return is_in_reserved(p);
}
bool is_in(oop obj) const {
return is_in((void*)obj);
}
// Returns true iff the given reserved memory of the space contains the
// given address.
bool is_in_reserved(const void* p) const { return _bottom <= p && p < _end; }
HeapWord* volatile* top_addr() { return &_top; }
// Try to allocate at least min_word_size and up to desired_size from this Space.
size_t capacity() const { return byte_size(bottom(), end()); }
size_t used() const { return byte_size(bottom(), top()); }
size_t free() const { return byte_size(top(), end()); }
bool is_empty() const { return used() == 0; }
private:
void reset_after_compaction() { set_top(compaction_top()); }
// Try to allocate at least min_word_size and up to desired_size from this region.
// Returns NULL if not possible, otherwise sets actual_word_size to the amount of
// space allocated.
// This version assumes that all allocation requests to this Space are properly
// This version assumes that all allocation requests to this HeapRegion are properly
// synchronized.
inline HeapWord* allocate_impl(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
// Try to allocate at least min_word_size and up to desired_size from this Space.
// Try to allocate at least min_word_size and up to desired_size from this HeapRegion.
// Returns NULL if not possible, otherwise sets actual_word_size to the amount of
// space allocated.
// This version synchronizes with other calls to par_allocate_impl().
inline HeapWord* par_allocate_impl(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
public:
void reset_after_compaction() { set_top(compaction_top()); }
size_t used() const { return byte_size(bottom(), top()); }
size_t free() const { return byte_size(top(), end()); }
bool is_free_block(const HeapWord* p) const { return p >= top(); }
MemRegion used_region() const { return MemRegion(bottom(), top()); }
void object_iterate(ObjectClosure* blk);
void safe_object_iterate(ObjectClosure* blk);
void mangle_unused_area() PRODUCT_RETURN;
void mangle_unused_area_complete() PRODUCT_RETURN;
public:
void object_iterate(ObjectClosure* blk);
// See the comment above in the declaration of _pre_dummy_top for an
// explanation of what it is.
@ -152,32 +141,31 @@ class G1ContiguousSpace: public CompactibleSpace {
assert(is_in(pre_dummy_top) && pre_dummy_top <= top(), "pre-condition");
_pre_dummy_top = pre_dummy_top;
}
HeapWord* pre_dummy_top() {
return (_pre_dummy_top == NULL) ? top() : _pre_dummy_top;
}
void reset_pre_dummy_top() { _pre_dummy_top = NULL; }
virtual void clear(bool mangle_space);
void clear(bool mangle_space);
HeapWord* block_start(const void* p);
HeapWord* block_start_const(const void* p) const;
// Allocation (return NULL if full). Assumes the caller has established
// mutually exclusive access to the space.
// mutually exclusive access to the HeapRegion.
HeapWord* allocate(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
// Allocation (return NULL if full). Enforces mutual exclusion internally.
HeapWord* par_allocate(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
virtual HeapWord* allocate(size_t word_size);
virtual HeapWord* par_allocate(size_t word_size);
HeapWord* allocate(size_t word_size);
HeapWord* par_allocate(size_t word_size);
HeapWord* saved_mark_word() const { ShouldNotReachHere(); return NULL; }
// MarkSweep support phase3
virtual HeapWord* initialize_threshold();
virtual HeapWord* cross_threshold(HeapWord* start, HeapWord* end);
virtual void print() const;
HeapWord* initialize_threshold();
HeapWord* cross_threshold(HeapWord* start, HeapWord* end);
void reset_bot() {
_bot_part.reset_bot();
@ -186,34 +174,11 @@ class G1ContiguousSpace: public CompactibleSpace {
void print_bot_on(outputStream* out) {
_bot_part.print_on(out);
}
};
class HeapRegion: public G1ContiguousSpace {
friend class VMStructs;
// Allow scan_and_forward to call (private) overrides for auxiliary functions on this class
template <typename SpaceType>
friend void CompactibleSpace::scan_and_forward(SpaceType* space, CompactPoint* cp);
private:
private:
// The remembered set for this region.
// (Might want to make this "inline" later, to avoid some alloc failure
// issues.)
HeapRegionRemSet* _rem_set;
// Auxiliary functions for scan_and_forward support.
// See comments for CompactibleSpace for more information.
inline HeapWord* scan_limit() const {
return top();
}
inline bool scanned_block_is_obj(const HeapWord* addr) const {
return true; // Always true, since scan_limit is top
}
inline size_t scanned_block_size(const HeapWord* addr) const {
return HeapRegion::block_size(addr); // Avoid virtual call
}
void report_region_type_change(G1HeapRegionTraceType::Type to);
// Returns whether the given object address refers to a dead object, and either the
@ -223,7 +188,6 @@ class HeapRegion: public G1ContiguousSpace {
// - not called on humongous objects or archive regions
inline bool is_obj_dead_with_size(const oop obj, const G1CMBitMap* const prev_bitmap, size_t* size) const;
protected:
// The index of this region in the heap region sequence.
uint _hrm_index;
@ -269,8 +233,6 @@ class HeapRegion: public G1ContiguousSpace {
// "next" is the top at the start of the in-progress marking (if any.)
HeapWord* _prev_top_at_mark_start;
HeapWord* _next_top_at_mark_start;
// If a collection pause is in progress, this is the top at the start
// of that pause.
void init_top_at_mark_start() {
assert(_prev_marked_bytes == 0 &&
@ -306,16 +268,14 @@ class HeapRegion: public G1ContiguousSpace {
// Returns the block size of the given (dead, potentially having its class unloaded) object
// starting at p extending to at most the prev TAMS using the given mark bitmap.
inline size_t block_size_using_bitmap(const HeapWord* p, const G1CMBitMap* const prev_bitmap) const;
public:
HeapRegion(uint hrm_index,
G1BlockOffsetTable* bot,
MemRegion mr);
public:
HeapRegion(uint hrm_index, G1BlockOffsetTable* bot, MemRegion mr);
// Initializing the HeapRegion not only resets the data structure, but also
// resets the BOT for that heap region.
// The default values for clear_space means that we will do the clearing if
// there's clearing to be done ourselves. We also always mangle the space.
virtual void initialize(MemRegion mr, bool clear_space = false, bool mangle_space = SpaceDecorator::Mangle);
void initialize(MemRegion mr, bool clear_space = false, bool mangle_space = SpaceDecorator::Mangle);
static int LogOfHRGrainBytes;
static int LogOfHRGrainWords;
@ -364,8 +324,6 @@ class HeapRegion: public G1ContiguousSpace {
// objects to call size_t ApplyToMarkedClosure::apply(oop) for.
template<typename ApplyToMarkedClosure>
inline void apply_to_marked_objects(G1CMBitMap* bitmap, ApplyToMarkedClosure* closure);
// Override for scan_and_forward support.
void prepare_for_compaction(CompactPoint* cp);
// Update heap region to be consistent after compaction.
void complete_compaction();
@ -707,8 +665,8 @@ class HeapRegion: public G1ContiguousSpace {
// full GC.
void verify(VerifyOption vo, bool *failures) const;
// Override; it uses the "prev" marking information
virtual void verify() const;
// Verify using the "prev" marking information
void verify() const;
void verify_rem_set(VerifyOption vo, bool *failures) const;
void verify_rem_set() const;
@ -724,7 +682,7 @@ class HeapRegionClosure : public StackObj {
bool _is_complete;
void set_incomplete() { _is_complete = false; }
public:
public:
HeapRegionClosure(): _is_complete(true) {}
// Typically called on each region until it returns true.

48
src/hotspot/share/gc/g1/heapRegion.inline.hpp

@ -29,22 +29,22 @@
#include "gc/g1/g1CollectedHeap.inline.hpp"
#include "gc/g1/g1ConcurrentMarkBitMap.inline.hpp"
#include "gc/g1/heapRegion.hpp"
#include "gc/shared/space.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/atomic.hpp"
#include "runtime/prefetch.inline.hpp"
#include "utilities/align.hpp"
#include "utilities/globalDefinitions.hpp"
inline HeapWord* G1ContiguousSpace::allocate_impl(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
inline HeapWord* HeapRegion::allocate_impl(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
HeapWord* obj = top();
size_t available = pointer_delta(end(), obj);
size_t want_to_allocate = MIN2(available, desired_word_size);
if (want_to_allocate >= min_word_size) {
HeapWord* new_top = obj + want_to_allocate;
set_top(new_top);
assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
assert(is_object_aligned(obj) && is_object_aligned(new_top), "checking alignment");
*actual_size = want_to_allocate;
return obj;
} else {
@ -52,21 +52,21 @@ inline HeapWord* G1ContiguousSpace::allocate_impl(size_t min_word_size,
}
}
inline HeapWord* G1ContiguousSpace::par_allocate_impl(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
inline HeapWord* HeapRegion::par_allocate_impl(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
do {
HeapWord* obj = top();
size_t available = pointer_delta(end(), obj);
size_t want_to_allocate = MIN2(available, desired_word_size);
if (want_to_allocate >= min_word_size) {
HeapWord* new_top = obj + want_to_allocate;
HeapWord* result = Atomic::cmpxchg(new_top, top_addr(), obj);
HeapWord* result = Atomic::cmpxchg(new_top, &_top, obj);
// result can be one of two:
// the old top value: the exchange succeeded
// otherwise: the new value of the top is returned.
if (result == obj) {
assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
assert(is_object_aligned(obj) && is_object_aligned(new_top), "checking alignment");
*actual_size = want_to_allocate;
return obj;
}
@ -76,9 +76,9 @@ inline HeapWord* G1ContiguousSpace::par_allocate_impl(size_t min_word_size,
} while (true);
}
inline HeapWord* G1ContiguousSpace::allocate(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
inline HeapWord* HeapRegion::allocate(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
HeapWord* res = allocate_impl(min_word_size, desired_word_size, actual_size);
if (res != NULL) {
_bot_part.alloc_block(res, *actual_size);
@ -86,12 +86,12 @@ inline HeapWord* G1ContiguousSpace::allocate(size_t min_word_size,
return res;
}
inline HeapWord* G1ContiguousSpace::allocate(size_t word_size) {
inline HeapWord* HeapRegion::allocate(size_t word_size) {
size_t temp;
return allocate(word_size, word_size, &temp);
}
inline HeapWord* G1ContiguousSpace::par_allocate(size_t word_size) {
inline HeapWord* HeapRegion::par_allocate(size_t word_size) {
size_t temp;
return par_allocate(word_size, word_size, &temp);
}
@ -99,19 +99,18 @@ inline HeapWord* G1ContiguousSpace::par_allocate(size_t word_size) {
// Because of the requirement of keeping "_offsets" up to date with the
// allocations, we sequentialize these with a lock. Therefore, best if
// this is used for larger LAB allocations only.
inline HeapWord* G1ContiguousSpace::par_allocate(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
inline HeapWord* HeapRegion::par_allocate(size_t min_word_size,
size_t desired_word_size,
size_t* actual_size) {
MutexLocker x(&_par_alloc_lock);
return allocate(min_word_size, desired_word_size, actual_size);
}
inline HeapWord* G1ContiguousSpace::block_start(const void* p) {
inline HeapWord* HeapRegion::block_start(const void* p) {
return _bot_part.block_start(p);
}
inline HeapWord*
G1ContiguousSpace::block_start_const(const void* p) const {
inline HeapWord* HeapRegion::block_start_const(const void* p) const {
return _bot_part.block_start_const(p);
}
@ -134,8 +133,7 @@ inline bool HeapRegion::is_obj_dead_with_size(const oop obj, const G1CMBitMap* c
return obj_is_dead;
}
inline bool
HeapRegion::block_is_obj(const HeapWord* p) const {
inline bool HeapRegion::block_is_obj(const HeapWord* p) const {
G1CollectedHeap* g1h = G1CollectedHeap::heap();
if (!this->is_in(p)) {
@ -185,7 +183,7 @@ inline size_t HeapRegion::block_size(const HeapWord *addr) const {
inline void HeapRegion::complete_compaction() {
// Reset space and bot after compaction is complete if needed.
reset_after_compaction();
if (used_region().is_empty()) {
if (is_empty()) {
reset_bot();
}
@ -202,7 +200,7 @@ inline void HeapRegion::complete_compaction() {
template<typename ApplyToMarkedClosure>
inline void HeapRegion::apply_to_marked_objects(G1CMBitMap* bitmap, ApplyToMarkedClosure* closure) {
HeapWord* limit = scan_limit();
HeapWord* limit = top();
HeapWord* next_addr = bottom();
while (next_addr < limit) {

10
src/hotspot/share/gc/g1/vmStructs_g1.hpp

@ -37,11 +37,14 @@
static_field(HeapRegion, GrainBytes, size_t) \
static_field(HeapRegion, LogOfHRGrainBytes, int) \
\
nonstatic_field(HeapRegion, _type, HeapRegionType) \
nonstatic_field(HeapRegion, _type, HeapRegionType) \
nonstatic_field(HeapRegion, _bottom, HeapWord*) \
nonstatic_field(HeapRegion, _top, HeapWord* volatile) \
nonstatic_field(HeapRegion, _end, HeapWord*) \
nonstatic_field(HeapRegion, _compaction_top, HeapWord*) \
\
nonstatic_field(HeapRegionType, _tag, HeapRegionType::Tag volatile) \
\
nonstatic_field(G1ContiguousSpace, _top, HeapWord* volatile) \
\
nonstatic_field(G1HeapRegionTable, _base, address) \
nonstatic_field(G1HeapRegionTable, _length, size_t) \
@ -94,8 +97,7 @@
\
declare_type(G1CollectedHeap, CollectedHeap) \
\
declare_type(G1ContiguousSpace, CompactibleSpace) \
declare_type(HeapRegion, G1ContiguousSpace) \
declare_toplevel_type(HeapRegion) \
declare_toplevel_type(HeapRegionManager) \
declare_toplevel_type(HeapRegionSetBase) \
declare_toplevel_type(G1MonitoringSupport) \

2
src/hotspot/share/gc/parallel/asPSYoungGen.cpp

@ -30,7 +30,7 @@
#include "gc/parallel/psYoungGen.hpp"
#include "gc/shared/gcUtil.hpp"
#include "gc/shared/genArguments.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/java.hpp"
#include "utilities/align.hpp"

2
src/hotspot/share/gc/parallel/mutableSpace.cpp

@ -24,7 +24,7 @@
#include "precompiled.hpp"
#include "gc/parallel/mutableSpace.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "memory/iterator.inline.hpp"
#include "memory/universe.hpp"
#include "oops/oop.inline.hpp"

2
src/hotspot/share/gc/parallel/psMarkSweep.cpp

@ -48,7 +48,7 @@
#include "gc/shared/referencePolicy.hpp"
#include "gc/shared/referenceProcessor.hpp"
#include "gc/shared/referenceProcessorPhaseTimes.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "gc/shared/weakProcessor.hpp"
#include "memory/universe.hpp"
#include "logging/log.hpp"

2
src/hotspot/share/gc/parallel/psMarkSweepDecorator.cpp

@ -31,7 +31,7 @@
#include "gc/parallel/psMarkSweepDecorator.hpp"
#include "gc/parallel/psParallelCompact.inline.hpp"
#include "gc/serial/markSweep.inline.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "memory/iterator.inline.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/prefetch.inline.hpp"

2
src/hotspot/share/gc/parallel/psOldGen.cpp

@ -33,7 +33,7 @@
#include "gc/parallel/psOldGen.hpp"
#include "gc/shared/cardTableBarrierSet.hpp"
#include "gc/shared/gcLocker.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "logging/log.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/java.hpp"

2
src/hotspot/share/gc/parallel/psParallelCompact.cpp

@ -52,7 +52,7 @@
#include "gc/shared/referencePolicy.hpp"
#include "gc/shared/referenceProcessor.hpp"
#include "gc/shared/referenceProcessorPhaseTimes.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "gc/shared/weakProcessor.hpp"
#include "gc/shared/workerPolicy.hpp"
#include "gc/shared/workgroup.hpp"

2
src/hotspot/share/gc/parallel/psScavenge.cpp

@ -48,7 +48,7 @@
#include "gc/shared/referenceProcessor.hpp"
#include "gc/shared/referenceProcessorPhaseTimes.hpp"
#include "gc/shared/scavengableNMethods.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "gc/shared/weakProcessor.hpp"
#include "gc/shared/workerPolicy.hpp"
#include "gc/shared/workgroup.hpp"

2
src/hotspot/share/gc/parallel/psYoungGen.cpp

@ -30,7 +30,7 @@
#include "gc/parallel/psYoungGen.hpp"
#include "gc/shared/gcUtil.hpp"
#include "gc/shared/genArguments.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "logging/log.hpp"
#include "oops/oop.inline.hpp"
#include "runtime/java.hpp"

2
src/hotspot/share/gc/serial/defNewGeneration.cpp

@ -43,7 +43,7 @@
#include "gc/shared/referencePolicy.hpp"
#include "gc/shared/referenceProcessorPhaseTimes.hpp"
#include "gc/shared/space.inline.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "gc/shared/strongRootsScope.hpp"
#include "gc/shared/weakProcessor.hpp"
#include "logging/log.hpp"

2
src/hotspot/share/gc/shared/generation.cpp

@ -35,7 +35,7 @@
#include "gc/shared/generation.hpp"
#include "gc/shared/generationSpec.hpp"
#include "gc/shared/space.inline.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "logging/log.hpp"
#include "memory/allocation.inline.hpp"
#include "oops/oop.inline.hpp"

2
src/hotspot/share/gc/shared/space.cpp

@ -31,7 +31,7 @@
#include "gc/shared/genOopClosures.inline.hpp"
#include "gc/shared/space.hpp"
#include "gc/shared/space.inline.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "memory/iterator.inline.hpp"
#include "memory/universe.hpp"
#include "oops/oop.inline.hpp"

3
src/hotspot/share/gc/shared/spaceDecorator.cpp

@ -23,8 +23,9 @@
*/
#include "precompiled.hpp"
#include "gc/parallel/mutableSpace.hpp"
#include "gc/shared/space.inline.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/spaceDecorator.inline.hpp"
#include "logging/log.hpp"
#include "utilities/copy.hpp"

13
src/hotspot/share/gc/shared/spaceDecorator.hpp

@ -25,8 +25,8 @@
#ifndef SHARE_GC_SHARED_SPACEDECORATOR_HPP
#define SHARE_GC_SHARED_SPACEDECORATOR_HPP
#include "gc/parallel/mutableSpace.hpp"
#include "gc/shared/space.hpp"
#include "memory/allocation.hpp"
#include "memory/memRegion.hpp"
#include "utilities/globalDefinitions.hpp"
class SpaceDecorator: public AllStatic {
@ -120,6 +120,7 @@ class SpaceMangler: public CHeapObj<mtGC> {
};
class ContiguousSpace;
class MutableSpace;
// For use with GenCollectedHeap's
class GenSpaceMangler: public SpaceMangler {
@ -127,8 +128,8 @@ class GenSpaceMangler: public SpaceMangler {
ContiguousSpace* sp() { return _sp; }
HeapWord* top() const { return _sp->top(); }
HeapWord* end() const { return _sp->end(); }
HeapWord* top() const;
HeapWord* end() const;
public:
GenSpaceMangler(ContiguousSpace* sp) : SpaceMangler(), _sp(sp) {}
@ -140,8 +141,8 @@ class MutableSpaceMangler: public SpaceMangler {
MutableSpace* sp() { return _sp; }
HeapWord* top() const { return _sp->top(); }
HeapWord* end() const { return _sp->end(); }
HeapWord* top() const;
HeapWord* end() const;
public:
MutableSpaceMangler(MutableSpace* sp) : SpaceMangler(), _sp(sp) {}

39
src/hotspot/share/gc/shared/spaceDecorator.inline.hpp Normal file

@ -0,0 +1,39 @@
/*
* Copyright (c) 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.
*
*/
#ifndef SHARE_GC_SHARED_SPACEDECORATOR_INLINE_HPP
#define SHARE_GC_SHARED_SPACEDECORATOR_INLINE_HPP
#include "gc/parallel/mutableSpace.hpp"
#include "gc/shared/space.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "utilities/globalDefinitions.hpp"
inline HeapWord* GenSpaceMangler::top() const { return _sp->top(); }
inline HeapWord* GenSpaceMangler::end() const { return _sp->end(); }
inline HeapWord* MutableSpaceMangler::top() const { return _sp->top(); }
inline HeapWord* MutableSpaceMangler::end() const { return _sp->end(); }
#endif // SHARE_GC_SHARED_SPACEDECORATOR_INLINE_HPP

8
src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/g1/G1CollectedHeap.java

@ -30,11 +30,11 @@ import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.Address;
import sun.jvm.hotspot.gc.g1.HeapRegionClosure;
import sun.jvm.hotspot.gc.g1.PrintRegionClosure;
import sun.jvm.hotspot.gc.shared.CollectedHeap;
import sun.jvm.hotspot.gc.shared.CollectedHeapName;
import sun.jvm.hotspot.gc.shared.LiveRegionsClosure;
import sun.jvm.hotspot.gc.shared.PrintRegionClosure;
import sun.jvm.hotspot.gc.shared.SpaceClosure;
import sun.jvm.hotspot.memory.MemRegion;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.runtime.VMObjectFactory;
@ -126,11 +126,11 @@ public class G1CollectedHeap extends CollectedHeap {
return hrm().heapRegionIterator();
}
public void heapRegionIterate(SpaceClosure scl) {
public void heapRegionIterate(HeapRegionClosure hrcl) {
Iterator<HeapRegion> iter = heapRegionIterator();
while (iter.hasNext()) {
HeapRegion hr = iter.next();
scl.doSpace(hr);
hrcl.doHeapRegion(hr);
}
}

29
src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/g1/HeapRegion.java

@ -45,9 +45,12 @@ import sun.jvm.hotspot.types.TypeDataBase;
// any of its fields but only iterate over it.
public class HeapRegion extends CompactibleSpace implements LiveRegionsProvider {
// static int GrainBytes;
static private CIntegerField grainBytesField;
private static AddressField bottomField;
static private AddressField topField;
private static AddressField endField;
private static AddressField compactionTopField;
static private CIntegerField grainBytesField;
private static long typeFieldOffset;
private static long pointerSize;
@ -64,8 +67,12 @@ public class HeapRegion extends CompactibleSpace implements LiveRegionsProvider
static private synchronized void initialize(TypeDataBase db) {
Type type = db.lookupType("HeapRegion");
grainBytesField = type.getCIntegerField("GrainBytes");
bottomField = type.getAddressField("_bottom");
topField = type.getAddressField("_top");
endField = type.getAddressField("_end");
compactionTopField = type.getAddressField("_compaction_top");
grainBytesField = type.getCIntegerField("GrainBytes");
typeFieldOffset = type.getField("_type").getOffset();
pointerSize = db.lookupType("HeapRegion*").getSize();
@ -82,9 +89,11 @@ public class HeapRegion extends CompactibleSpace implements LiveRegionsProvider
type = (HeapRegionType)VMObjectFactory.newObject(HeapRegionType.class, typeAddr);
}
public Address top() {
return topField.getValue(addr);
}
public Address bottom() { return bottomField.getValue(addr); }
public Address top() { return topField.getValue(addr); }
public Address end() { return endField.getValue(addr); }
public Address compactionTop() { return compactionTopField.getValue(addr); }
@Override
public List<MemRegion> getLiveRegions() {
@ -93,12 +102,16 @@ public class HeapRegion extends CompactibleSpace implements LiveRegionsProvider
return res;
}
@Override
/** Returns a subregion of the space containing all the objects in
the space. */
public MemRegion usedRegion() {
return new MemRegion(bottom(), end());
}
public long used() {
return top().minus(bottom());
}
@Override
public long free() {
return end().minus(top());
}

29
src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/g1/HeapRegionClosure.java Normal file

@ -0,0 +1,29 @@
/*
* Copyright (c) 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.
*
*/
package sun.jvm.hotspot.gc.g1;
public interface HeapRegionClosure {
public void doHeapRegion(HeapRegion hr);
}

20
src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/shared/PrintRegionClosure.java → src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/g1/PrintRegionClosure.java

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018, 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
@ -22,19 +22,19 @@
*
*/
package sun.jvm.hotspot.gc.shared;
package sun.jvm.hotspot.gc.g1;
import java.io.PrintStream;
import sun.jvm.hotspot.gc.g1.HeapRegion;
public class PrintRegionClosure implements SpaceClosure {
private PrintStream tty;
public class PrintRegionClosure implements HeapRegionClosure {
private PrintStream tty;
public PrintRegionClosure(PrintStream tty) {
this.tty = tty;
}
public PrintRegionClosure(PrintStream tty) {
this.tty = tty;
}
public void doSpace(Space hr) {
((HeapRegion)hr).printOn(tty);
}
public void doHeapRegion(HeapRegion hr) {
hr.printOn(tty);
}
}

1
test/hotspot/gtest/gc/g1/test_g1HeapVerifier.cpp

@ -26,6 +26,7 @@
#include "gc/g1/g1Arguments.hpp"
#include "gc/g1/g1HeapVerifier.hpp"
#include "logging/logConfiguration.hpp"
#include "logging/logTag.hpp"
#include "logging/logTestFixture.hpp"
#include "unittest.hpp"