< prev index next >
src/share/vm/gc/shenandoah/shenandoahHeap.cpp
Print this page
rev 12551 : Refactor/consolidate/cleanup
*** 153,166 ****
_ordered_regions = new ShenandoahHeapRegionSet(_max_regions);
_sorted_regions = new ShenandoahHeapRegionSet(_max_regions);
_collection_set = new ShenandoahCollectionSet(_max_regions);
_free_regions = new ShenandoahFreeSet(_max_regions);
size_t i = 0;
for (i = 0; i < _num_regions; i++) {
ShenandoahHeapRegion* current = new ShenandoahHeapRegion();
! current->initialize_heap_region((HeapWord*) pgc_rs.base() +
regionSizeWords * i, regionSizeWords, i);
_free_regions->add_region(current);
_ordered_regions->add_region(current);
_sorted_regions->add_region(current);
}
--- 153,190 ----
_ordered_regions = new ShenandoahHeapRegionSet(_max_regions);
_sorted_regions = new ShenandoahHeapRegionSet(_max_regions);
_collection_set = new ShenandoahCollectionSet(_max_regions);
_free_regions = new ShenandoahFreeSet(_max_regions);
+ // Initialize fast collection set test structure.
+ _in_cset_fast_test_length = _max_regions;
+ _in_cset_fast_test_base =
+ NEW_C_HEAP_ARRAY(bool, _in_cset_fast_test_length, mtGC);
+ _in_cset_fast_test = _in_cset_fast_test_base -
+ ((uintx) pgc_rs.base() >> ShenandoahHeapRegion::RegionSizeShift);
+
+ _next_top_at_mark_starts_base =
+ NEW_C_HEAP_ARRAY(HeapWord*, _max_regions, mtGC);
+ _next_top_at_mark_starts = _next_top_at_mark_starts_base -
+ ((uintx) pgc_rs.base() >> ShenandoahHeapRegion::RegionSizeShift);
+
+ _complete_top_at_mark_starts_base =
+ NEW_C_HEAP_ARRAY(HeapWord*, _max_regions, mtGC);
+ _complete_top_at_mark_starts = _complete_top_at_mark_starts_base -
+ ((uintx) pgc_rs.base() >> ShenandoahHeapRegion::RegionSizeShift);
+
size_t i = 0;
for (i = 0; i < _num_regions; i++) {
+ _in_cset_fast_test_base[i] = false; // Not in cset
+ HeapWord* bottom = (HeapWord*) pgc_rs.base() + regionSizeWords * i;
+ _complete_top_at_mark_starts_base[i] = bottom;
+ _next_top_at_mark_starts_base[i] = bottom;
+ }
+
+ for (i = 0; i < _num_regions; i++) {
ShenandoahHeapRegion* current = new ShenandoahHeapRegion();
! current->initialize_heap_region(this, (HeapWord*) pgc_rs.base() +
regionSizeWords * i, regionSizeWords, i);
_free_regions->add_region(current);
_ordered_regions->add_region(current);
_sorted_regions->add_region(current);
}
*** 198,234 ****
ReservedSpace bitmap0(bitmap_size, page_size);
os::commit_memory_or_exit(bitmap0.base(), bitmap0.size(), false, "couldn't allocate mark bitmap");
MemTracker::record_virtual_memory_type(bitmap0.base(), mtGC);
MemRegion bitmap_region0 = MemRegion((HeapWord*) bitmap0.base(), bitmap0.size() / HeapWordSize);
_mark_bit_map0.initialize(heap_region, bitmap_region0);
! _prev_mark_bit_map = &_mark_bit_map0;
ReservedSpace bitmap1(bitmap_size, page_size);
os::commit_memory_or_exit(bitmap1.base(), bitmap1.size(), false, "couldn't allocate mark bitmap");
MemTracker::record_virtual_memory_type(bitmap1.base(), mtGC);
MemRegion bitmap_region1 = MemRegion((HeapWord*) bitmap1.base(), bitmap1.size() / HeapWordSize);
_mark_bit_map1.initialize(heap_region, bitmap_region1);
_next_mark_bit_map = &_mark_bit_map1;
- // Initialize fast collection set test structure.
- _in_cset_fast_test_length = _max_regions;
- _in_cset_fast_test_base =
- NEW_C_HEAP_ARRAY(bool, _in_cset_fast_test_length, mtGC);
- _in_cset_fast_test = _in_cset_fast_test_base -
- ((uintx) pgc_rs.base() >> ShenandoahHeapRegion::RegionSizeShift);
- clear_cset_fast_test();
-
- _top_at_mark_starts_base =
- NEW_C_HEAP_ARRAY(HeapWord*, _max_regions, mtGC);
- _top_at_mark_starts = _top_at_mark_starts_base -
- ((uintx) pgc_rs.base() >> ShenandoahHeapRegion::RegionSizeShift);
-
- for (i = 0; i < _num_regions; i++) {
- _in_cset_fast_test_base[i] = false; // Not in cset
- _top_at_mark_starts_base[i] = _ordered_regions->get(i)->bottom();
- }
-
_monitoring_support = new ShenandoahMonitoringSupport(this);
_concurrent_gc_thread = new ShenandoahConcurrentThread();
ShenandoahMarkCompact::initialize();
--- 222,240 ----
ReservedSpace bitmap0(bitmap_size, page_size);
os::commit_memory_or_exit(bitmap0.base(), bitmap0.size(), false, "couldn't allocate mark bitmap");
MemTracker::record_virtual_memory_type(bitmap0.base(), mtGC);
MemRegion bitmap_region0 = MemRegion((HeapWord*) bitmap0.base(), bitmap0.size() / HeapWordSize);
_mark_bit_map0.initialize(heap_region, bitmap_region0);
! _complete_mark_bit_map = &_mark_bit_map0;
ReservedSpace bitmap1(bitmap_size, page_size);
os::commit_memory_or_exit(bitmap1.base(), bitmap1.size(), false, "couldn't allocate mark bitmap");
MemTracker::record_virtual_memory_type(bitmap1.base(), mtGC);
MemRegion bitmap_region1 = MemRegion((HeapWord*) bitmap1.base(), bitmap1.size() / HeapWordSize);
_mark_bit_map1.initialize(heap_region, bitmap_region1);
_next_mark_bit_map = &_mark_bit_map1;
_monitoring_support = new ShenandoahMonitoringSupport(this);
_concurrent_gc_thread = new ShenandoahConcurrentThread();
ShenandoahMarkCompact::initialize();
*** 252,263 ****
_max_conc_workers((int) MAX2((uint) ConcGCThreads, 1U)),
_max_parallel_workers((int) MAX2((uint) ParallelGCThreads, 1U)),
_ref_processor(NULL),
_in_cset_fast_test(NULL),
_in_cset_fast_test_base(NULL),
! _top_at_mark_starts(NULL),
! _top_at_mark_starts_base(NULL),
_mark_bit_map0(),
_mark_bit_map1(),
_cancelled_concgc(false),
_need_update_refs(false),
_need_reset_bitmaps(false),
--- 258,271 ----
_max_conc_workers((int) MAX2((uint) ConcGCThreads, 1U)),
_max_parallel_workers((int) MAX2((uint) ParallelGCThreads, 1U)),
_ref_processor(NULL),
_in_cset_fast_test(NULL),
_in_cset_fast_test_base(NULL),
! _next_top_at_mark_starts(NULL),
! _next_top_at_mark_starts_base(NULL),
! _complete_top_at_mark_starts(NULL),
! _complete_top_at_mark_starts_base(NULL),
_mark_bit_map0(),
_mark_bit_map1(),
_cancelled_concgc(false),
_need_update_refs(false),
_need_reset_bitmaps(false),
*** 286,374 ****
_workers->initialize_workers();
_conc_workers->initialize_workers();
}
}
! class ResetBitmapTask : public AbstractGangTask {
private:
ShenandoahHeapRegionSet* _regions;
public:
! ResetBitmapTask(ShenandoahHeapRegionSet* regions) :
AbstractGangTask("Parallel Reset Bitmap Task"),
_regions(regions) {
_regions->clear_current_index();
}
void work(uint worker_id) {
ShenandoahHeapRegion* region = _regions->claim_next();
ShenandoahHeap* heap = ShenandoahHeap::heap();
while (region != NULL) {
HeapWord* bottom = region->bottom();
! HeapWord* top = region->top_prev_mark_bitmap();
! region->set_top_prev_mark_bitmap(region->top_at_prev_mark_start());
if (top > bottom) {
! heap->reset_mark_bitmap_range(bottom, top);
}
region = _regions->claim_next();
}
}
};
! class ResetPrevBitmapTask : public AbstractGangTask {
private:
ShenandoahHeapRegionSet* _regions;
public:
! ResetPrevBitmapTask(ShenandoahHeapRegionSet* regions) :
! AbstractGangTask("Parallel Reset Prev Bitmap Task"),
_regions(regions) {
_regions->clear_current_index();
}
void work(uint worker_id) {
ShenandoahHeapRegion* region = _regions->claim_next();
ShenandoahHeap* heap = ShenandoahHeap::heap();
while (region != NULL) {
HeapWord* bottom = region->bottom();
! HeapWord* top = region->top_prev_mark_bitmap();
if (top > bottom) {
! heap->reset_prev_mark_bitmap_range(bottom, top);
}
region = _regions->claim_next();
}
}
};
! void ShenandoahHeap::reset_mark_bitmap(WorkGang* workers) {
GCTraceTime(Info, gc, phases) time("Concurrent reset bitmaps", gc_timer(), GCCause::_no_gc);
! ResetBitmapTask task = ResetBitmapTask(_ordered_regions);
workers->run_task(&task);
}
! void ShenandoahHeap::reset_prev_mark_bitmap(WorkGang* workers) {
! GCTraceTime(Info, gc, phases) time("Concurrent reset prev bitmaps", gc_timer(), GCCause::_no_gc);
!
! ResetPrevBitmapTask task = ResetPrevBitmapTask(_ordered_regions);
! workers->run_task(&task);
! }
!
! void ShenandoahHeap::reset_mark_bitmap_range(HeapWord* from, HeapWord* to) {
! _next_mark_bit_map->clear_range(MemRegion(from, to));
! }
!
! void ShenandoahHeap::reset_prev_mark_bitmap_range(HeapWord* from, HeapWord* to) {
! _prev_mark_bit_map->clear_range(MemRegion(from, to));
! }
!
! bool ShenandoahHeap::is_bitmap_clear() {
HeapWord* start = _ordered_regions->bottom();
HeapWord* end = _ordered_regions->end();
return _next_mark_bit_map->getNextMarkedWordAddress(start, end) == end;
}
void ShenandoahHeap::print_on(outputStream* st) const {
st->print("Shenandoah Heap");
st->print(" total = " SIZE_FORMAT " K, used " SIZE_FORMAT " K ", capacity()/ K, used() /K);
st->print("Region size = " SIZE_FORMAT "K ", ShenandoahHeapRegion::RegionSizeBytes / K);
if (_concurrent_mark_in_progress) {
--- 294,377 ----
_workers->initialize_workers();
_conc_workers->initialize_workers();
}
}
! class ResetNextBitmapTask : public AbstractGangTask {
private:
ShenandoahHeapRegionSet* _regions;
public:
! ResetNextBitmapTask(ShenandoahHeapRegionSet* regions) :
AbstractGangTask("Parallel Reset Bitmap Task"),
_regions(regions) {
_regions->clear_current_index();
}
void work(uint worker_id) {
ShenandoahHeapRegion* region = _regions->claim_next();
ShenandoahHeap* heap = ShenandoahHeap::heap();
while (region != NULL) {
HeapWord* bottom = region->bottom();
! HeapWord* top = heap->next_top_at_mark_start(region->bottom());
if (top > bottom) {
! heap->next_mark_bit_map()->clear_range(MemRegion(bottom, top));
}
region = _regions->claim_next();
}
}
};
! void ShenandoahHeap::reset_next_mark_bitmap(WorkGang* workers) {
! GCTraceTime(Info, gc, phases) time("Concurrent reset bitmaps", gc_timer(), GCCause::_no_gc);
!
! ResetNextBitmapTask task = ResetNextBitmapTask(_ordered_regions);
! workers->run_task(&task);
! }
!
! class ResetCompleteBitmapTask : public AbstractGangTask {
private:
ShenandoahHeapRegionSet* _regions;
public:
! ResetCompleteBitmapTask(ShenandoahHeapRegionSet* regions) :
! AbstractGangTask("Parallel Reset Bitmap Task"),
_regions(regions) {
_regions->clear_current_index();
}
void work(uint worker_id) {
ShenandoahHeapRegion* region = _regions->claim_next();
ShenandoahHeap* heap = ShenandoahHeap::heap();
while (region != NULL) {
HeapWord* bottom = region->bottom();
! HeapWord* top = heap->complete_top_at_mark_start(region->bottom());
if (top > bottom) {
! heap->complete_mark_bit_map()->clear_range(MemRegion(bottom, top));
}
region = _regions->claim_next();
}
}
};
! void ShenandoahHeap::reset_complete_mark_bitmap(WorkGang* workers) {
GCTraceTime(Info, gc, phases) time("Concurrent reset bitmaps", gc_timer(), GCCause::_no_gc);
! ResetCompleteBitmapTask task = ResetCompleteBitmapTask(_ordered_regions);
workers->run_task(&task);
}
! bool ShenandoahHeap::is_next_bitmap_clear() {
HeapWord* start = _ordered_regions->bottom();
HeapWord* end = _ordered_regions->end();
return _next_mark_bit_map->getNextMarkedWordAddress(start, end) == end;
}
+ bool ShenandoahHeap::is_complete_bitmap_clear_range(HeapWord* start, HeapWord* end) {
+ return _complete_mark_bit_map->getNextMarkedWordAddress(start, end) == end;
+ }
+
void ShenandoahHeap::print_on(outputStream* st) const {
st->print("Shenandoah Heap");
st->print(" total = " SIZE_FORMAT " K, used " SIZE_FORMAT " K ", capacity()/ K, used() /K);
st->print("Region size = " SIZE_FORMAT "K ", ShenandoahHeapRegion::RegionSizeBytes / K);
if (_concurrent_mark_in_progress) {
*** 482,492 ****
}
bool ShenandoahHeap::is_in(const void* p) const {
HeapWord* first_region_bottom = _first_region->bottom();
HeapWord* last_region_end = first_region_bottom + (ShenandoahHeapRegion::RegionSizeBytes / HeapWordSize) * _num_regions;
! return p > _first_region_bottom && p < last_region_end;
}
bool ShenandoahHeap::is_scavengable(const void* p) {
return true;
}
--- 485,495 ----
}
bool ShenandoahHeap::is_in(const void* p) const {
HeapWord* first_region_bottom = _first_region->bottom();
HeapWord* last_region_end = first_region_bottom + (ShenandoahHeapRegion::RegionSizeBytes / HeapWordSize) * _num_regions;
! return p >= _first_region_bottom && p < last_region_end;
}
bool ShenandoahHeap::is_scavengable(const void* p) {
return true;
}
*** 542,552 ****
HeapWord* ShenandoahHeap::allocate_new_tlab(size_t word_size, bool evacuating) {
HeapWord* result = allocate_memory(word_size, evacuating);
if (result != NULL) {
! assert(! heap_region_containing(result)->is_in_collection_set(), "Never allocate in dirty region");
_bytes_allocated_since_cm += word_size * HeapWordSize;
log_develop_trace(gc, tlab)("allocating new tlab of size "SIZE_FORMAT" at addr "PTR_FORMAT, word_size, p2i(result));
}
--- 545,555 ----
HeapWord* ShenandoahHeap::allocate_new_tlab(size_t word_size, bool evacuating) {
HeapWord* result = allocate_memory(word_size, evacuating);
if (result != NULL) {
! assert(! in_collection_set(result), "Never allocate in dirty region");
_bytes_allocated_since_cm += word_size * HeapWordSize;
log_develop_trace(gc, tlab)("allocating new tlab of size "SIZE_FORMAT" at addr "PTR_FORMAT, word_size, p2i(result));
}
*** 644,658 ****
return NULL; // No more room to make a new region. OOM.
}
assert(my_current_region != NULL, "should have a region at this point");
#ifdef ASSERT
! if (my_current_region->is_in_collection_set()) {
print_heap_regions();
}
#endif
! assert(! my_current_region->is_in_collection_set(), "never get targetted regions in free-lists");
assert(! my_current_region->is_humongous(), "never attempt to allocate from humongous object regions");
HeapWord* result = my_current_region->par_allocate(word_size);
while (result == NULL) {
--- 647,661 ----
return NULL; // No more room to make a new region. OOM.
}
assert(my_current_region != NULL, "should have a region at this point");
#ifdef ASSERT
! if (in_collection_set(my_current_region)) {
print_heap_regions();
}
#endif
! assert(! in_collection_set(my_current_region), "never get targetted regions in free-lists");
assert(! my_current_region->is_humongous(), "never attempt to allocate from humongous object regions");
HeapWord* result = my_current_region->par_allocate(word_size);
while (result == NULL) {
*** 663,673 ****
if (my_current_region == NULL) {
return NULL; // No more room to make a new region. OOM.
}
// _free_regions->increase_used(remaining);
assert(my_current_region != NULL, "should have a region at this point");
! assert(! my_current_region->is_in_collection_set(), "never get targetted regions in free-lists");
assert(! my_current_region->is_humongous(), "never attempt to allocate from humongous object regions");
result = my_current_region->par_allocate(word_size);
}
my_current_region->increase_live_data(word_size * HeapWordSize);
--- 666,676 ----
if (my_current_region == NULL) {
return NULL; // No more room to make a new region. OOM.
}
// _free_regions->increase_used(remaining);
assert(my_current_region != NULL, "should have a region at this point");
! assert(! in_collection_set(my_current_region), "never get targetted regions in free-lists");
assert(! my_current_region->is_humongous(), "never attempt to allocate from humongous object regions");
result = my_current_region->par_allocate(word_size);
}
my_current_region->increase_live_data(word_size * HeapWordSize);
*** 713,723 ****
HeapWord* result = filler + BrooksPointer::word_size();
if (filler != NULL) {
BrooksPointer::initialize(oop(result));
_bytes_allocated_since_cm += size * HeapWordSize;
! assert(! heap_region_containing(result)->is_in_collection_set(), "never allocate in targetted region");
return result;
} else {
/*
tty->print_cr("Out of memory. Requested number of words: "SIZE_FORMAT" used heap: "INT64_FORMAT", bytes allocated since last CM: "INT64_FORMAT, size, used(), _bytes_allocated_since_cm);
{
--- 716,726 ----
HeapWord* result = filler + BrooksPointer::word_size();
if (filler != NULL) {
BrooksPointer::initialize(oop(result));
_bytes_allocated_since_cm += size * HeapWordSize;
! assert(! in_collection_set(result), "never allocate in targetted region");
return result;
} else {
/*
tty->print_cr("Out of memory. Requested number of words: "SIZE_FORMAT" used heap: "INT64_FORMAT", bytes allocated since last CM: "INT64_FORMAT, size, used(), _bytes_allocated_since_cm);
{
*** 741,751 ****
void do_object(oop p) {
log_develop_trace(gc, compaction)("Calling ParallelEvacuateRegionObjectClosure on "PTR_FORMAT" of size %d\n", p2i((HeapWord*) p), p->size());
! assert(_heap->is_marked_prev(p), "expect only marked objects");
if (oopDesc::unsafe_equals(p, ShenandoahBarrierSet::resolve_oop_static_not_null(p))) {
_heap->evacuate_object(p, _thread);
}
}
};
--- 744,754 ----
void do_object(oop p) {
log_develop_trace(gc, compaction)("Calling ParallelEvacuateRegionObjectClosure on "PTR_FORMAT" of size %d\n", p2i((HeapWord*) p), p->size());
! assert(_heap->is_marked_complete(p), "expect only marked objects");
if (oopDesc::unsafe_equals(p, ShenandoahBarrierSet::resolve_oop_static_not_null(p))) {
_heap->evacuate_object(p, _thread);
}
}
};
*** 754,764 ****
class VerifyEvacuatedObjectClosure : public ObjectClosure {
public:
void do_object(oop p) {
! if (ShenandoahHeap::heap()->is_marked_prev(p)) {
oop p_prime = oopDesc::bs()->read_barrier(p);
assert(! oopDesc::unsafe_equals(p, p_prime), "Should point to evacuated copy");
if (p->klass() != p_prime->klass()) {
tty->print_cr("copy has different class than original:");
p->klass()->print_on(tty);
--- 757,767 ----
class VerifyEvacuatedObjectClosure : public ObjectClosure {
public:
void do_object(oop p) {
! if (ShenandoahHeap::heap()->is_marked_complete(p)) {
oop p_prime = oopDesc::bs()->read_barrier(p);
assert(! oopDesc::unsafe_equals(p, p_prime), "Should point to evacuated copy");
if (p->klass() != p_prime->klass()) {
tty->print_cr("copy has different class than original:");
p->klass()->print_on(tty);
*** 772,792 ****
}
};
void ShenandoahHeap::verify_evacuated_region(ShenandoahHeapRegion* from_region) {
VerifyEvacuatedObjectClosure verify_evacuation;
! marked_next_object_iterate(from_region, &verify_evacuation);
}
#endif
void ShenandoahHeap::parallel_evacuate_region(ShenandoahHeapRegion* from_region) {
assert(from_region->get_live_data() > 0, "all-garbage regions are reclaimed earlier");
ParallelEvacuateRegionObjectClosure evacuate_region(this);
! marked_prev_object_iterate(from_region, &evacuate_region);
#ifdef ASSERT
if (ShenandoahVerify && ! cancelled_concgc()) {
verify_evacuated_region(from_region);
}
--- 775,795 ----
}
};
void ShenandoahHeap::verify_evacuated_region(ShenandoahHeapRegion* from_region) {
VerifyEvacuatedObjectClosure verify_evacuation;
! marked_object_iterate(from_region, &verify_evacuation);
}
#endif
void ShenandoahHeap::parallel_evacuate_region(ShenandoahHeapRegion* from_region) {
assert(from_region->get_live_data() > 0, "all-garbage regions are reclaimed earlier");
ParallelEvacuateRegionObjectClosure evacuate_region(this);
! marked_object_iterate(from_region, &evacuate_region);
#ifdef ASSERT
if (ShenandoahVerify && ! cancelled_concgc()) {
verify_evacuated_region(from_region);
}
*** 833,857 ****
public:
RecycleDirtyRegionsClosure() : _heap(ShenandoahHeap::heap()) {}
bool doHeapRegion(ShenandoahHeapRegion* r) {
! if (_heap->cancelled_concgc()) {
! // The aborted marking bitmap needs to be cleared at the end of cycle.
! // Setup the top-marker for this.
! r->set_top_prev_mark_bitmap(r->top_at_mark_start());
! return false;
! }
!
! r->swap_top_at_mark_start();
!
! if (r->is_in_collection_set()) {
log_develop_trace(gc, region)("Recycling region " SIZE_FORMAT ":", r->region_number());
_heap->decrease_used(r->used());
_bytes_reclaimed += r->used();
r->recycle();
_heap->free_regions()->add_region(r);
}
return false;
}
--- 836,857 ----
public:
RecycleDirtyRegionsClosure() : _heap(ShenandoahHeap::heap()) {}
bool doHeapRegion(ShenandoahHeapRegion* r) {
! assert (! _heap->cancelled_concgc(), "no recycling after cancelled marking");
! if (_heap->in_collection_set(r)) {
log_develop_trace(gc, region)("Recycling region " SIZE_FORMAT ":", r->region_number());
_heap->decrease_used(r->used());
_bytes_reclaimed += r->used();
r->recycle();
+ // Reset C-TAMS pointer to ensure size-based iteration, everything
+ // in that regions is going to be new objects.
+ _heap->set_complete_top_at_mark_start(r->bottom(), r->bottom());
+ // We can only safely reset the C-TAMS pointer if the bitmap is clear for that region.
+ assert(_heap->is_complete_bitmap_clear_range(r->bottom(), r->end()), "must be clear");
_heap->free_regions()->add_region(r);
}
return false;
}
*** 891,901 ****
template <class T>
inline void do_oop_work(T* p) {
oop o = oopDesc::load_decode_heap_oop(p);
if (o != NULL) {
if (ShenandoahHeap::heap()->is_in(o) && o->is_oop()) {
! tty->print_cr("%s "INT32_FORMAT" ("PTR_FORMAT")-> "PTR_FORMAT" (marked: %s) (%s "PTR_FORMAT")", _prefix, _index, p2i(p), p2i((HeapWord*) o), BOOL_TO_STR(ShenandoahHeap::heap()->is_marked_current(o)), o->klass()->internal_name(), p2i(o->klass()));
} else {
// tty->print_cr("%s "INT32_FORMAT" ("PTR_FORMAT" dirty: %s) -> "PTR_FORMAT" (not in heap, possibly corrupted or dirty (%s))", _prefix, _index, p2i(p), BOOL_TO_STR(ShenandoahHeap::heap()->heap_region_containing(p)->is_in_collection_set()), p2i((HeapWord*) o), BOOL_TO_STR(ShenandoahHeap::heap()->heap_region_containing(o)->is_in_collection_set()));
tty->print_cr("%s "INT32_FORMAT" ("PTR_FORMAT" dirty -> "PTR_FORMAT" (not in heap, possibly corrupted or dirty)", _prefix, _index, p2i(p), p2i((HeapWord*) o));
}
} else {
--- 891,901 ----
template <class T>
inline void do_oop_work(T* p) {
oop o = oopDesc::load_decode_heap_oop(p);
if (o != NULL) {
if (ShenandoahHeap::heap()->is_in(o) && o->is_oop()) {
! tty->print_cr("%s "INT32_FORMAT" ("PTR_FORMAT")-> "PTR_FORMAT" (marked: %s) (%s "PTR_FORMAT")", _prefix, _index, p2i(p), p2i((HeapWord*) o), BOOL_TO_STR(ShenandoahHeap::heap()->is_marked_complete(o)), o->klass()->internal_name(), p2i(o->klass()));
} else {
// tty->print_cr("%s "INT32_FORMAT" ("PTR_FORMAT" dirty: %s) -> "PTR_FORMAT" (not in heap, possibly corrupted or dirty (%s))", _prefix, _index, p2i(p), BOOL_TO_STR(ShenandoahHeap::heap()->heap_region_containing(p)->is_in_collection_set()), p2i((HeapWord*) o), BOOL_TO_STR(ShenandoahHeap::heap()->heap_region_containing(o)->is_in_collection_set()));
tty->print_cr("%s "INT32_FORMAT" ("PTR_FORMAT" dirty -> "PTR_FORMAT" (not in heap, possibly corrupted or dirty)", _prefix, _index, p2i(p), p2i((HeapWord*) o));
}
} else {
*** 921,931 ****
public:
PrintAllRefsObjectClosure(const char* prefix) : _prefix(prefix) {}
void do_object(oop p) {
if (ShenandoahHeap::heap()->is_in(p)) {
! tty->print_cr("%s object "PTR_FORMAT" (marked: %s) (%s "PTR_FORMAT") refers to:", _prefix, p2i((HeapWord*) p), BOOL_TO_STR(ShenandoahHeap::heap()->is_marked_current(p)), p->klass()->internal_name(), p2i(p->klass()));
PrintAllRefsOopClosure cl(_prefix);
p->oop_iterate(&cl);
}
}
};
--- 921,931 ----
public:
PrintAllRefsObjectClosure(const char* prefix) : _prefix(prefix) {}
void do_object(oop p) {
if (ShenandoahHeap::heap()->is_in(p)) {
! tty->print_cr("%s object "PTR_FORMAT" (marked: %s) (%s "PTR_FORMAT") refers to:", _prefix, p2i((HeapWord*) p), BOOL_TO_STR(ShenandoahHeap::heap()->is_marked_complete(p)), p->klass()->internal_name(), p2i(p->klass()));
PrintAllRefsOopClosure cl(_prefix);
p->oop_iterate(&cl);
}
}
};
*** 955,969 ****
private:
template <class T>
inline void do_oop_work(T* p) {
oop o = oopDesc::load_decode_heap_oop(p);
if (o != NULL) {
! if (! _heap->is_marked_prev(o)) {
_heap->print_heap_regions();
_heap->print_all_refs("post-mark");
tty->print_cr("oop not marked, although referrer is marked: "PTR_FORMAT": in_heap: %s, is_marked: %s",
! p2i((HeapWord*) o), BOOL_TO_STR(_heap->is_in(o)), BOOL_TO_STR(_heap->is_marked_prev(o)));
_heap->print_heap_locations((HeapWord*) o, (HeapWord*) o + o->size());
tty->print_cr("oop class: %s", o->klass()->internal_name());
if (_heap->is_in(p)) {
oop referrer = oop(_heap->heap_region_containing(p)->block_start_const(p));
--- 955,969 ----
private:
template <class T>
inline void do_oop_work(T* p) {
oop o = oopDesc::load_decode_heap_oop(p);
if (o != NULL) {
! if (! _heap->is_marked_complete(o)) {
_heap->print_heap_regions();
_heap->print_all_refs("post-mark");
tty->print_cr("oop not marked, although referrer is marked: "PTR_FORMAT": in_heap: %s, is_marked: %s",
! p2i((HeapWord*) o), BOOL_TO_STR(_heap->is_in(o)), BOOL_TO_STR(_heap->is_marked_complete(o)));
_heap->print_heap_locations((HeapWord*) o, (HeapWord*) o + o->size());
tty->print_cr("oop class: %s", o->klass()->internal_name());
if (_heap->is_in(p)) {
oop referrer = oop(_heap->heap_region_containing(p)->block_start_const(p));
*** 979,994 ****
_heap->heap_region_containing(oopDesc::bs()->read_barrier(o))->print();
}
assert(o->is_oop(), "oop must be an oop");
assert(Metaspace::contains(o->klass()), "klass pointer must go to metaspace");
if (! oopDesc::unsafe_equals(o, oopDesc::bs()->read_barrier(o))) {
! tty->print_cr("oops has forwardee: p: "PTR_FORMAT" (%s), o = "PTR_FORMAT" (%s), new-o: "PTR_FORMAT" (%s)", p2i(p), BOOL_TO_STR(_heap->heap_region_containing(p)->is_in_collection_set()), p2i((HeapWord*) o), BOOL_TO_STR(_heap->heap_region_containing(o)->is_in_collection_set()), p2i((HeapWord*) oopDesc::bs()->read_barrier(o)), BOOL_TO_STR(_heap->heap_region_containing(oopDesc::bs()->read_barrier(o))->is_in_collection_set()));
tty->print_cr("oop class: %s", o->klass()->internal_name());
}
assert(oopDesc::unsafe_equals(o, oopDesc::bs()->read_barrier(o)), "oops must not be forwarded");
! assert(! _heap->heap_region_containing(o)->is_in_collection_set(), "references must not point to dirty heap regions");
! assert(_heap->is_marked_prev(o), "live oops must be marked current");
}
}
public:
void do_oop(oop* p) {
--- 979,994 ----
_heap->heap_region_containing(oopDesc::bs()->read_barrier(o))->print();
}
assert(o->is_oop(), "oop must be an oop");
assert(Metaspace::contains(o->klass()), "klass pointer must go to metaspace");
if (! oopDesc::unsafe_equals(o, oopDesc::bs()->read_barrier(o))) {
! tty->print_cr("oops has forwardee: p: "PTR_FORMAT" (%s), o = "PTR_FORMAT" (%s), new-o: "PTR_FORMAT" (%s)", p2i(p), BOOL_TO_STR(_heap->in_collection_set(p)), p2i((HeapWord*) o), BOOL_TO_STR(_heap->in_collection_set(o)), p2i((HeapWord*) oopDesc::bs()->read_barrier(o)), BOOL_TO_STR(_heap->in_collection_set(oopDesc::bs()->read_barrier(o))));
tty->print_cr("oop class: %s", o->klass()->internal_name());
}
assert(oopDesc::unsafe_equals(o, oopDesc::bs()->read_barrier(o)), "oops must not be forwarded");
! assert(! _heap->in_collection_set(o), "references must not point to dirty heap regions");
! assert(_heap->is_marked_complete(o), "live oops must be marked current");
}
}
public:
void do_oop(oop* p) {
*** 999,1035 ****
do_oop_work(p);
}
};
- class IterateMarkedCurrentObjectsClosure: public ObjectClosure {
- private:
- ShenandoahHeap* _heap;
- ExtendedOopClosure* _cl;
- public:
- IterateMarkedCurrentObjectsClosure(ExtendedOopClosure* cl) :
- _heap(ShenandoahHeap::heap()), _cl(cl) {};
-
- void do_object(oop p) {
- if (_heap->is_marked_current(p)) {
- p->oop_iterate(_cl);
- }
- }
-
- };
-
void ShenandoahHeap::verify_heap_after_marking() {
verify_heap_size_consistency();
log_trace(gc)("verifying heap after marking");
VerifyAfterMarkingOopClosure cl;
roots_iterate(&cl);
!
! IterateMarkedCurrentObjectsClosure marked_oops(&cl);
! object_iterate(&marked_oops);
}
void ShenandoahHeap::reclaim_humongous_region_at(ShenandoahHeapRegion* r) {
assert(r->is_humongous_start(), "reclaim regions starting with the first one");
--- 999,1018 ----
do_oop_work(p);
}
};
void ShenandoahHeap::verify_heap_after_marking() {
verify_heap_size_consistency();
log_trace(gc)("verifying heap after marking");
VerifyAfterMarkingOopClosure cl;
roots_iterate(&cl);
! ObjectToOopClosure objs(&cl);
! object_iterate(&objs);
}
void ShenandoahHeap::reclaim_humongous_region_at(ShenandoahHeapRegion* r) {
assert(r->is_humongous_start(), "reclaim regions starting with the first one");
*** 1054,1064 ****
ResourceMark rm;
outputStream* out = Log(gc, humongous)::debug_stream();
region->print_on(out);
}
! region->reset();
ShenandoahHeap::heap()->decrease_used(ShenandoahHeapRegion::RegionSizeBytes);
}
}
class ShenandoahReclaimHumongousRegionsClosure : public ShenandoahHeapRegionClosure {
--- 1037,1047 ----
ResourceMark rm;
outputStream* out = Log(gc, humongous)::debug_stream();
region->print_on(out);
}
! region->recycle();
ShenandoahHeap::heap()->decrease_used(ShenandoahHeapRegion::RegionSizeBytes);
}
}
class ShenandoahReclaimHumongousRegionsClosure : public ShenandoahHeapRegionClosure {
*** 1066,1076 ****
bool doHeapRegion(ShenandoahHeapRegion* r) {
ShenandoahHeap* heap = ShenandoahHeap::heap();
if (r->is_humongous_start()) {
oop humongous_obj = oop(r->bottom() + BrooksPointer::word_size());
! if (! heap->is_marked_prev(humongous_obj)) {
heap->reclaim_humongous_region_at(r);
}
}
return false;
--- 1049,1059 ----
bool doHeapRegion(ShenandoahHeapRegion* r) {
ShenandoahHeap* heap = ShenandoahHeap::heap();
if (r->is_humongous_start()) {
oop humongous_obj = oop(r->bottom() + BrooksPointer::word_size());
! if (! heap->is_marked_complete(humongous_obj)) {
heap->reclaim_humongous_region_at(r);
}
}
return false;
*** 1078,1088 ****
};
#ifdef ASSERT
class CheckCollectionSetClosure: public ShenandoahHeapRegionClosure {
bool doHeapRegion(ShenandoahHeapRegion* r) {
! assert(!r->is_in_collection_set(), "Should have been cleared by now");
return false;
}
};
#endif
--- 1061,1071 ----
};
#ifdef ASSERT
class CheckCollectionSetClosure: public ShenandoahHeapRegionClosure {
bool doHeapRegion(ShenandoahHeapRegion* r) {
! assert(! ShenandoahHeap::heap()->in_collection_set(r), "Should have been cleared by now");
return false;
}
};
#endif
*** 1181,1202 ****
assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
T o = oopDesc::load_heap_oop(p);
if (! oopDesc::is_null(o)) {
oop obj = oopDesc::decode_heap_oop_not_null(o);
! if (_heap->in_cset_fast_test((HeapWord*) obj)) {
! assert(_heap->is_marked_prev(obj), "only evacuate marked objects %d %d", _heap->is_marked_prev(obj), _heap->is_marked_prev(ShenandoahBarrierSet::resolve_oop_static_not_null(obj)));
oop resolved = ShenandoahBarrierSet::resolve_oop_static_not_null(obj);
if (oopDesc::unsafe_equals(resolved, obj)) {
resolved = _heap->evacuate_object(obj, _thread);
}
oopDesc::encode_store_heap_oop(p, resolved);
}
}
#ifdef ASSERT
else {
! // tty->print_cr("not updating root at: "PTR_FORMAT" with object: "PTR_FORMAT", is_in_heap: %s, is_in_cset: %s, is_marked: %s", p2i(p), p2i((HeapWord*) obj), BOOL_TO_STR(_heap->is_in(obj)), BOOL_TO_STR(_heap->in_cset_fast_test(obj)), BOOL_TO_STR(_heap->is_marked_current(obj)));
}
#endif
}
public:
--- 1164,1185 ----
assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
T o = oopDesc::load_heap_oop(p);
if (! oopDesc::is_null(o)) {
oop obj = oopDesc::decode_heap_oop_not_null(o);
! if (_heap->in_collection_set(obj)) {
! assert(_heap->is_marked_complete(obj), "only evacuate marked objects %d %d", _heap->is_marked_complete(obj), _heap->is_marked_complete(ShenandoahBarrierSet::resolve_oop_static_not_null(obj)));
oop resolved = ShenandoahBarrierSet::resolve_oop_static_not_null(obj);
if (oopDesc::unsafe_equals(resolved, obj)) {
resolved = _heap->evacuate_object(obj, _thread);
}
oopDesc::encode_store_heap_oop(p, resolved);
}
}
#ifdef ASSERT
else {
! // tty->print_cr("not updating root at: "PTR_FORMAT" with object: "PTR_FORMAT", is_in_heap: %s, is_in_cset: %s, is_marked: %s", p2i(p), p2i((HeapWord*) obj), BOOL_TO_STR(_heap->is_in(obj)), BOOL_TO_STR(_heap->in_cset_fast_test(obj)), BOOL_TO_STR(_heap->is_marked_complete(obj)));
}
#endif
}
public:
*** 1605,1617 ****
ShenandoahVerifyHeapClosure heapCl(rootsCl);
object_iterate(&heapCl);
// TODO: Implement rest of it.
- #ifdef ASSERT_DISABLED
- verify_live();
- #endif
} else {
tty->print("(SKIPPING roots, heapRegions, remset) ");
}
}
size_t ShenandoahHeap::tlab_capacity(Thread *thr) const {
--- 1588,1597 ----
*** 1621,1631 ****
class ShenandoahIterateObjectClosureRegionClosure: public ShenandoahHeapRegionClosure {
ObjectClosure* _cl;
public:
ShenandoahIterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {}
bool doHeapRegion(ShenandoahHeapRegion* r) {
! ShenandoahHeap::heap()->marked_prev_object_iterate(r, _cl);
return false;
}
};
void ShenandoahHeap::object_iterate(ObjectClosure* cl) {
--- 1601,1611 ----
class ShenandoahIterateObjectClosureRegionClosure: public ShenandoahHeapRegionClosure {
ObjectClosure* _cl;
public:
ShenandoahIterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {}
bool doHeapRegion(ShenandoahHeapRegion* r) {
! ShenandoahHeap::heap()->marked_object_iterate(r, _cl);
return false;
}
};
void ShenandoahHeap::object_iterate(ObjectClosure* cl) {
*** 1643,1653 ****
for (size_t i = 0; i < _num_regions; i++) {
ShenandoahHeapRegion* current = _ordered_regions->get(i);
if (skip_humongous_continuation && current->is_humongous_continuation()) {
continue;
}
! if (skip_dirty_regions && current->is_in_collection_set()) {
continue;
}
if (blk->doHeapRegion(current)) {
return;
}
--- 1623,1633 ----
for (size_t i = 0; i < _num_regions; i++) {
ShenandoahHeapRegion* current = _ordered_regions->get(i);
if (skip_humongous_continuation && current->is_humongous_continuation()) {
continue;
}
! if (skip_dirty_regions && in_collection_set(current)) {
continue;
}
if (blk->doHeapRegion(current)) {
return;
}
*** 1659,1669 ****
public:
ClearLivenessClosure(ShenandoahHeap* heap) : sh(heap) { }
bool doHeapRegion(ShenandoahHeapRegion* r) {
r->clear_live_data();
! r->init_top_at_mark_start();
return false;
}
};
--- 1639,1649 ----
public:
ClearLivenessClosure(ShenandoahHeap* heap) : sh(heap) { }
bool doHeapRegion(ShenandoahHeapRegion* r) {
r->clear_live_data();
! sh->set_next_top_at_mark_start(r->bottom(), r->top());
return false;
}
};
*** 1708,1761 ****
shenandoahPolicy()->record_phase_end(ShenandoahCollectorPolicy::scan_roots);
// print_all_refs("pre-mark2");
}
-
- class VerifyLivenessClosure : public ExtendedOopClosure {
-
- ShenandoahHeap* _sh;
-
- public:
- VerifyLivenessClosure() : _sh ( ShenandoahHeap::heap() ) {}
-
- template<class T> void do_oop_nv(T* p) {
- T heap_oop = oopDesc::load_heap_oop(p);
- if (!oopDesc::is_null(heap_oop)) {
- oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
- guarantee(_sh->heap_region_containing(obj)->is_in_collection_set() == (! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj))),
- "forwarded objects can only exist in dirty (from-space) regions is_dirty: %s, is_forwarded: %s",
- BOOL_TO_STR(_sh->heap_region_containing(obj)->is_in_collection_set()),
- BOOL_TO_STR(! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj)))
- );
- obj = oopDesc::bs()->read_barrier(obj);
- guarantee(! _sh->heap_region_containing(obj)->is_in_collection_set(), "forwarded oops must not point to dirty regions");
- guarantee(obj->is_oop(), "is_oop");
- ShenandoahHeap* sh = (ShenandoahHeap*) Universe::heap();
- if (! sh->is_marked_current(obj)) {
- sh->print_on(tty);
- }
- assert(sh->is_marked_current(obj), "Referenced Objects should be marked obj: "PTR_FORMAT", marked: %s, is_in_heap: %s",
- p2i((HeapWord*) obj), BOOL_TO_STR(sh->is_marked_current(obj)), BOOL_TO_STR(sh->is_in(obj)));
- }
- }
-
- void do_oop(oop* p) { do_oop_nv(p); }
- void do_oop(narrowOop* p) { do_oop_nv(p); }
-
- };
-
- void ShenandoahHeap::verify_live() {
-
- VerifyLivenessClosure cl;
- roots_iterate(&cl);
-
- IterateMarkedCurrentObjectsClosure marked_oops(&cl);
- object_iterate(&marked_oops);
-
- }
-
class VerifyAfterEvacuationClosure : public ExtendedOopClosure {
ShenandoahHeap* _sh;
public:
--- 1688,1697 ----
*** 1763,1807 ****
template<class T> void do_oop_nv(T* p) {
T heap_oop = oopDesc::load_heap_oop(p);
if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
! guarantee(_sh->heap_region_containing(obj)->is_in_collection_set() == (! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj))),
"forwarded objects can only exist in dirty (from-space) regions is_dirty: %s, is_forwarded: %s obj-klass: %s, marked: %s",
! BOOL_TO_STR(_sh->heap_region_containing(obj)->is_in_collection_set()),
! BOOL_TO_STR(! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj))), obj->klass()->external_name(), BOOL_TO_STR(_sh->is_marked_current(obj))
);
obj = oopDesc::bs()->read_barrier(obj);
! guarantee(! _sh->heap_region_containing(obj)->is_in_collection_set(), "forwarded oops must not point to dirty regions");
! guarantee(obj->is_oop(), "is_oop");
! guarantee(Metaspace::contains(obj->klass()), "klass pointer must go to metaspace");
! }
! }
!
! void do_oop(oop* p) { do_oop_nv(p); }
! void do_oop(narrowOop* p) { do_oop_nv(p); }
!
! };
!
! class VerifyAfterUpdateRefsClosure : public ExtendedOopClosure {
!
! ShenandoahHeap* _sh;
!
! public:
! VerifyAfterUpdateRefsClosure() : _sh ( ShenandoahHeap::heap() ) {}
!
! template<class T> void do_oop_nv(T* p) {
! T heap_oop = oopDesc::load_heap_oop(p);
! if (!oopDesc::is_null(heap_oop)) {
! oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
! guarantee((! _sh->heap_region_containing(obj)->is_in_collection_set()),
! "no live reference must point to from-space, is_marked: %s",
! BOOL_TO_STR(_sh->is_marked_current(obj)));
! if (! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj)) && _sh->is_in(p)) {
! tty->print_cr("top-limit: "PTR_FORMAT", p: "PTR_FORMAT, p2i(_sh->heap_region_containing(p)->concurrent_iteration_safe_limit()), p2i(p));
! }
! guarantee(oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj)), "no live reference must point to forwarded object");
guarantee(obj->is_oop(), "is_oop");
guarantee(Metaspace::contains(obj->klass()), "klass pointer must go to metaspace");
}
}
--- 1699,1715 ----
template<class T> void do_oop_nv(T* p) {
T heap_oop = oopDesc::load_heap_oop(p);
if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
! guarantee(_sh->in_collection_set(obj) == (! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj))),
"forwarded objects can only exist in dirty (from-space) regions is_dirty: %s, is_forwarded: %s obj-klass: %s, marked: %s",
! BOOL_TO_STR(_sh->in_collection_set(obj)),
! BOOL_TO_STR(! oopDesc::unsafe_equals(obj, oopDesc::bs()->read_barrier(obj))), obj->klass()->external_name(), BOOL_TO_STR(_sh->is_marked_complete(obj))
);
obj = oopDesc::bs()->read_barrier(obj);
! guarantee(! _sh->in_collection_set(obj), "forwarded oops must not point to dirty regions");
guarantee(obj->is_oop(), "is_oop");
guarantee(Metaspace::contains(obj->klass()), "klass pointer must go to metaspace");
}
}
*** 1817,1844 ****
ensure_parsability(false);
VerifyAfterEvacuationClosure cl;
roots_iterate(&cl);
! IterateMarkedCurrentObjectsClosure marked_oops(&cl);
! object_iterate(&marked_oops);
}
class VerifyRegionsAfterUpdateRefsClosure : public ShenandoahHeapRegionClosure {
public:
bool doHeapRegion(ShenandoahHeapRegion* r) {
! assert(! r->is_in_collection_set(), "no region must be in collection set");
! assert(! ShenandoahHeap::heap()->in_cset_fast_test(r->bottom()), "no region must be in collection set");
return false;
}
};
void ShenandoahHeap::swap_mark_bitmaps() {
! CMBitMap* tmp = _prev_mark_bit_map;
! _prev_mark_bit_map = _next_mark_bit_map;
! _next_mark_bit_map = tmp;
}
void ShenandoahHeap::stop_concurrent_marking() {
assert(concurrent_mark_in_progress(), "How else could we get here?");
if (! cancelled_concgc()) {
--- 1725,1761 ----
ensure_parsability(false);
VerifyAfterEvacuationClosure cl;
roots_iterate(&cl);
! ObjectToOopClosure objs(&cl);
! object_iterate(&objs);
}
class VerifyRegionsAfterUpdateRefsClosure : public ShenandoahHeapRegionClosure {
public:
bool doHeapRegion(ShenandoahHeapRegion* r) {
! assert(! ShenandoahHeap::heap()->in_collection_set(r), "no region must be in collection set");
return false;
}
};
void ShenandoahHeap::swap_mark_bitmaps() {
! // Swap bitmaps.
! CMBitMap* tmp1 = _complete_mark_bit_map;
! _complete_mark_bit_map = _next_mark_bit_map;
! _next_mark_bit_map = tmp1;
!
! // Swap top-at-mark-start pointers
! HeapWord** tmp2 = _complete_top_at_mark_starts;
! _complete_top_at_mark_starts = _next_top_at_mark_starts;
! _next_top_at_mark_starts = tmp2;
!
! HeapWord** tmp3 = _complete_top_at_mark_starts_base;
! _complete_top_at_mark_starts_base = _next_top_at_mark_starts_base;
! _next_top_at_mark_starts_base = tmp3;
}
void ShenandoahHeap::stop_concurrent_marking() {
assert(concurrent_mark_in_progress(), "How else could we get here?");
if (! cancelled_concgc()) {
*** 1917,1927 ****
ShenandoahHeapRegion* regions[num_regions];
for (size_t i = 0; i < num_regions; i++) {
ShenandoahHeapRegion* new_region = new ShenandoahHeapRegion();
size_t new_region_index = i + base;
HeapWord* start = _first_region_bottom + (ShenandoahHeapRegion::RegionSizeBytes / HeapWordSize) * new_region_index;
! new_region->initialize_heap_region(start, ShenandoahHeapRegion::RegionSizeBytes / HeapWordSize, new_region_index);
if (log_is_enabled(Trace, gc, region)) {
ResourceMark rm;
outputStream* out = Log(gc, region)::trace_stream();
out->print_cr("allocating new region at index: "SIZE_FORMAT, new_region_index);
--- 1834,1844 ----
ShenandoahHeapRegion* regions[num_regions];
for (size_t i = 0; i < num_regions; i++) {
ShenandoahHeapRegion* new_region = new ShenandoahHeapRegion();
size_t new_region_index = i + base;
HeapWord* start = _first_region_bottom + (ShenandoahHeapRegion::RegionSizeBytes / HeapWordSize) * new_region_index;
! new_region->initialize_heap_region(this, start, ShenandoahHeapRegion::RegionSizeBytes / HeapWordSize, new_region_index);
if (log_is_enabled(Trace, gc, region)) {
ResourceMark rm;
outputStream* out = Log(gc, region)::trace_stream();
out->print_cr("allocating new region at index: "SIZE_FORMAT, new_region_index);
*** 1930,1940 ****
assert(_ordered_regions->active_regions() == new_region->region_number(), "must match");
_ordered_regions->add_region(new_region);
_sorted_regions->add_region(new_region);
_in_cset_fast_test_base[new_region_index] = false; // Not in cset
! _top_at_mark_starts_base[new_region_index] = new_region->bottom();
regions[i] = new_region;
}
_free_regions->par_add_regions(regions, 0, num_regions, num_regions);
}
--- 1847,1858 ----
assert(_ordered_regions->active_regions() == new_region->region_number(), "must match");
_ordered_regions->add_region(new_region);
_sorted_regions->add_region(new_region);
_in_cset_fast_test_base[new_region_index] = false; // Not in cset
! _next_top_at_mark_starts_base[new_region_index] = new_region->bottom();
! _complete_top_at_mark_starts_base[new_region_index] = new_region->bottom();
regions[i] = new_region;
}
_free_regions->par_add_regions(regions, 0, num_regions, num_regions);
}
*** 1952,1981 ****
_num_regions = new_num_regions;
}
- ShenandoahIsAliveClosure::ShenandoahIsAliveClosure() :
- _heap(ShenandoahHeap::heap_no_check()) {
- }
-
- void ShenandoahIsAliveClosure::init(ShenandoahHeap* heap) {
- _heap = heap;
- }
-
- bool ShenandoahIsAliveClosure::do_object_b(oop obj) {
-
- assert(_heap != NULL, "sanity");
- #ifdef ASSERT
- if (_heap->concurrent_mark_in_progress()) {
- assert(oopDesc::unsafe_equals(obj, ShenandoahBarrierSet::resolve_oop_static_not_null(obj)), "only query to-space");
- }
- #endif
- assert(!oopDesc::is_null(obj), "null");
- return _heap->is_marked_current(obj);
- }
-
ShenandoahForwardedIsAliveClosure::ShenandoahForwardedIsAliveClosure() :
_heap(ShenandoahHeap::heap_no_check()) {
}
void ShenandoahForwardedIsAliveClosure::init(ShenandoahHeap* heap) {
--- 1870,1879 ----
*** 1990,2000 ****
if (_heap->concurrent_mark_in_progress()) {
assert(oopDesc::unsafe_equals(obj, ShenandoahBarrierSet::resolve_oop_static_not_null(obj)), "only query to-space");
}
#endif
assert(!oopDesc::is_null(obj), "null");
! return _heap->is_marked_current(obj);
}
void ShenandoahHeap::ref_processing_init() {
MemRegion mr = reserved_region();
--- 1888,1898 ----
if (_heap->concurrent_mark_in_progress()) {
assert(oopDesc::unsafe_equals(obj, ShenandoahBarrierSet::resolve_oop_static_not_null(obj)), "only query to-space");
}
#endif
assert(!oopDesc::is_null(obj), "null");
! return _heap->is_marked_next(obj);
}
void ShenandoahHeap::ref_processing_init() {
MemRegion mr = reserved_region();
*** 2018,2028 ****
#ifdef ASSERT
void ShenandoahHeap::set_from_region_protection(bool protect) {
for (uint i = 0; i < _num_regions; i++) {
ShenandoahHeapRegion* region = _ordered_regions->get(i);
! if (region != NULL && region->is_in_collection_set()) {
if (protect) {
region->memProtectionOn();
} else {
region->memProtectionOff();
}
--- 1916,1926 ----
#ifdef ASSERT
void ShenandoahHeap::set_from_region_protection(bool protect) {
for (uint i = 0; i < _num_regions; i++) {
ShenandoahHeapRegion* region = _ordered_regions->get(i);
! if (region != NULL && in_collection_set(region)) {
if (protect) {
region->memProtectionOn();
} else {
region->memProtectionOff();
}
*** 2105,2128 ****
guarantee(next->region_number() == region_idx, "region number must match");
}
return next;
}
! bool ShenandoahHeap::is_in_collection_set(const void* p) {
! return heap_region_containing(p)->is_in_collection_set();
}
ShenandoahMonitoringSupport* ShenandoahHeap::monitoring_support() {
return _monitoring_support;
}
! bool ShenandoahHeap::is_obj_dead(const oop obj, const ShenandoahHeapRegion* r) const {
! return ! r->allocated_after_prev_mark_start((HeapWord*) obj) &&
! ! is_marked_prev(obj, r);
! }
! CMBitMap* ShenandoahHeap::prev_mark_bit_map() {
! return _prev_mark_bit_map;
}
CMBitMap* ShenandoahHeap::next_mark_bit_map() {
return _next_mark_bit_map;
}
--- 2003,2022 ----
guarantee(next->region_number() == region_idx, "region number must match");
}
return next;
}
! void ShenandoahHeap::set_region_in_collection_set(size_t region_index, bool b) {
! _in_cset_fast_test_base[region_index] = b;
}
ShenandoahMonitoringSupport* ShenandoahHeap::monitoring_support() {
return _monitoring_support;
}
! CMBitMap* ShenandoahHeap::complete_mark_bit_map() {
! return _complete_mark_bit_map;
}
CMBitMap* ShenandoahHeap::next_mark_bit_map() {
return _next_mark_bit_map;
}
*** 2133,2151 ****
void ShenandoahHeap::clear_free_regions() {
_free_regions->clear();
}
- void ShenandoahHeap::register_region_with_in_cset_fast_test(ShenandoahHeapRegion* r) {
- assert(_in_cset_fast_test_base != NULL, "sanity");
- assert(r->is_in_collection_set(), "invariant");
- size_t index = r->region_number();
- assert(index < _in_cset_fast_test_length, "invariant");
- assert(!_in_cset_fast_test_base[index], "invariant");
- _in_cset_fast_test_base[index] = true;
- }
-
address ShenandoahHeap::in_cset_fast_test_addr() {
return (address) (ShenandoahHeap::heap()->_in_cset_fast_test);
}
address ShenandoahHeap::cancelled_concgc_addr() {
--- 2027,2036 ----
*** 2172,2184 ****
size_t ShenandoahHeap::max_allocated_gc() {
return _max_allocated_gc;
}
! void ShenandoahHeap::set_top_at_mark_start(HeapWord* region_base, HeapWord* addr) {
uintx index = ((uintx) region_base) >> ShenandoahHeapRegion::RegionSizeShift;
! _top_at_mark_starts[index] = addr;
}
void ShenandoahHeap::set_full_gc_in_progress(bool in_progress) {
_full_gc_in_progress = in_progress;
}
--- 2057,2084 ----
size_t ShenandoahHeap::max_allocated_gc() {
return _max_allocated_gc;
}
! void ShenandoahHeap::set_next_top_at_mark_start(HeapWord* region_base, HeapWord* addr) {
! uintx index = ((uintx) region_base) >> ShenandoahHeapRegion::RegionSizeShift;
! _next_top_at_mark_starts[index] = addr;
! }
!
! HeapWord* ShenandoahHeap::next_top_at_mark_start(HeapWord* region_base) {
! uintx index = ((uintx) region_base) >> ShenandoahHeapRegion::RegionSizeShift;
! return _next_top_at_mark_starts[index];
! }
!
! void ShenandoahHeap::set_complete_top_at_mark_start(HeapWord* region_base, HeapWord* addr) {
! uintx index = ((uintx) region_base) >> ShenandoahHeapRegion::RegionSizeShift;
! _complete_top_at_mark_starts[index] = addr;
! }
!
! HeapWord* ShenandoahHeap::complete_top_at_mark_start(HeapWord* region_base) {
uintx index = ((uintx) region_base) >> ShenandoahHeapRegion::RegionSizeShift;
! return _complete_top_at_mark_starts[index];
}
void ShenandoahHeap::set_full_gc_in_progress(bool in_progress) {
_full_gc_in_progress = in_progress;
}
< prev index next >