--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Wed Jan 19 13:04:37 2011 -0800
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Wed Jan 19 19:30:42 2011 -0500
@@ -23,7 +23,6 @@
*/
#include "precompiled.hpp"
-#include "gc_implementation/g1/concurrentZFThread.hpp"
#include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp"
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/g1/g1OopClosures.inline.hpp"
@@ -348,22 +347,20 @@
}
void HeapRegion::hr_clear(bool par, bool clear_space) {
- _humongous_type = NotHumongous;
- _humongous_start_region = NULL;
+ assert(_humongous_type == NotHumongous,
+ "we should have already filtered out humongous regions");
+ assert(_humongous_start_region == NULL,
+ "we should have already filtered out humongous regions");
+ assert(_end == _orig_end,
+ "we should have already filtered out humongous regions");
+
_in_collection_set = false;
_is_gc_alloc_region = false;
- // Age stuff (if parallel, this will be done separately, since it needs
- // to be sequential).
- G1CollectedHeap* g1h = G1CollectedHeap::heap();
-
set_young_index_in_cset(-1);
uninstall_surv_rate_group();
set_young_type(NotYoung);
- // In case it had been the start of a humongous sequence, reset its end.
- set_end(_orig_end);
-
if (!par) {
// If this is parallel, this will be done later.
HeapRegionRemSet* hrrs = rem_set();
@@ -387,6 +384,7 @@
// </PREDICTION>
void HeapRegion::set_startsHumongous(HeapWord* new_top, HeapWord* new_end) {
+ assert(!isHumongous(), "sanity / pre-condition");
assert(end() == _orig_end,
"Should be normal before the humongous object allocation");
assert(top() == bottom(), "should be empty");
@@ -400,6 +398,7 @@
}
void HeapRegion::set_continuesHumongous(HeapRegion* first_hr) {
+ assert(!isHumongous(), "sanity / pre-condition");
assert(end() == _orig_end,
"Should be normal before the humongous object allocation");
assert(top() == bottom(), "should be empty");
@@ -409,6 +408,26 @@
_humongous_start_region = first_hr;
}
+void HeapRegion::set_notHumongous() {
+ assert(isHumongous(), "pre-condition");
+
+ if (startsHumongous()) {
+ assert(top() <= end(), "pre-condition");
+ set_end(_orig_end);
+ if (top() > end()) {
+ // at least one "continues humongous" region after it
+ set_top(end());
+ }
+ } else {
+ // continues humongous
+ assert(end() == _orig_end, "sanity");
+ }
+
+ assert(capacity() == (size_t) HeapRegion::GrainBytes, "pre-condition");
+ _humongous_type = NotHumongous;
+ _humongous_start_region = NULL;
+}
+
bool HeapRegion::claimHeapRegion(jint claimValue) {
jint current = _claimed;
if (current != claimValue) {
@@ -443,15 +462,6 @@
return low;
}
-void HeapRegion::set_next_on_unclean_list(HeapRegion* r) {
- assert(r == NULL || r->is_on_unclean_list(), "Malformed unclean list.");
- _next_in_special_set = r;
-}
-
-void HeapRegion::set_on_unclean_list(bool b) {
- _is_on_unclean_list = b;
-}
-
void HeapRegion::initialize(MemRegion mr, bool clear_space, bool mangle_space) {
G1OffsetTableContigSpace::initialize(mr, false, mangle_space);
hr_clear(false/*par*/, clear_space);
@@ -469,15 +479,16 @@
_hrs_index(-1),
_humongous_type(NotHumongous), _humongous_start_region(NULL),
_in_collection_set(false), _is_gc_alloc_region(false),
- _is_on_free_list(false), _is_on_unclean_list(false),
_next_in_special_set(NULL), _orig_end(NULL),
_claimed(InitialClaimValue), _evacuation_failed(false),
_prev_marked_bytes(0), _next_marked_bytes(0), _sort_index(-1),
_young_type(NotYoung), _next_young_region(NULL),
- _next_dirty_cards_region(NULL),
- _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1),
- _rem_set(NULL), _zfs(NotZeroFilled),
- _recorded_rs_length(0), _predicted_elapsed_time_ms(0),
+ _next_dirty_cards_region(NULL), _next(NULL), _pending_removal(false),
+#ifdef ASSERT
+ _containing_set(NULL),
+#endif // ASSERT
+ _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1),
+ _rem_set(NULL), _recorded_rs_length(0), _predicted_elapsed_time_ms(0),
_predicted_bytes_to_copy(0)
{
_orig_end = mr.end();
@@ -552,86 +563,6 @@
oops_in_mr_iterate(MemRegion(bottom(), saved_mark_word()), cl);
}
-#ifdef DEBUG
-HeapWord* HeapRegion::allocate(size_t size) {
- jint state = zero_fill_state();
- assert(!G1CollectedHeap::heap()->allocs_are_zero_filled() ||
- zero_fill_is_allocated(),
- "When ZF is on, only alloc in ZF'd regions");
- return G1OffsetTableContigSpace::allocate(size);
-}
-#endif
-
-void HeapRegion::set_zero_fill_state_work(ZeroFillState zfs) {
- assert(ZF_mon->owned_by_self() ||
- Universe::heap()->is_gc_active(),
- "Must hold the lock or be a full GC to modify.");
-#ifdef ASSERT
- if (top() != bottom() && zfs != Allocated) {
- ResourceMark rm;
- stringStream region_str;
- print_on(®ion_str);
- assert(top() == bottom() || zfs == Allocated,
- err_msg("Region must be empty, or we must be setting it to allocated. "
- "_zfs=%d, zfs=%d, region: %s", _zfs, zfs, region_str.as_string()));
- }
-#endif
- _zfs = zfs;
-}
-
-void HeapRegion::set_zero_fill_complete() {
- set_zero_fill_state_work(ZeroFilled);
- if (ZF_mon->owned_by_self()) {
- ZF_mon->notify_all();
- }
-}
-
-
-void HeapRegion::ensure_zero_filled() {
- MutexLockerEx x(ZF_mon, Mutex::_no_safepoint_check_flag);
- ensure_zero_filled_locked();
-}
-
-void HeapRegion::ensure_zero_filled_locked() {
- assert(ZF_mon->owned_by_self(), "Precondition");
- bool should_ignore_zf = SafepointSynchronize::is_at_safepoint();
- assert(should_ignore_zf || Heap_lock->is_locked(),
- "Either we're in a GC or we're allocating a region.");
- switch (zero_fill_state()) {
- case HeapRegion::NotZeroFilled:
- set_zero_fill_in_progress(Thread::current());
- {
- ZF_mon->unlock();
- Copy::fill_to_words(bottom(), capacity()/HeapWordSize);
- ZF_mon->lock_without_safepoint_check();
- }
- // A trap.
- guarantee(zero_fill_state() == HeapRegion::ZeroFilling
- && zero_filler() == Thread::current(),
- "AHA! Tell Dave D if you see this...");
- set_zero_fill_complete();
- // gclog_or_tty->print_cr("Did sync ZF.");
- ConcurrentZFThread::note_sync_zfs();
- break;
- case HeapRegion::ZeroFilling:
- if (should_ignore_zf) {
- // We can "break" the lock and take over the work.
- Copy::fill_to_words(bottom(), capacity()/HeapWordSize);
- set_zero_fill_complete();
- ConcurrentZFThread::note_sync_zfs();
- break;
- } else {
- ConcurrentZFThread::wait_for_ZF_completed(this);
- }
- case HeapRegion::ZeroFilled:
- // Nothing to do.
- break;
- case HeapRegion::Allocated:
- guarantee(false, "Should not call on allocated regions.");
- }
- assert(zero_fill_state() == HeapRegion::ZeroFilled, "Post");
-}
-
HeapWord*
HeapRegion::object_iterate_mem_careful(MemRegion mr,
ObjectClosure* cl) {
@@ -1010,67 +941,3 @@
_offsets.set_space(this);
initialize(mr, !is_zeroed, SpaceDecorator::Mangle);
}
-
-size_t RegionList::length() {
- size_t len = 0;
- HeapRegion* cur = hd();
- DEBUG_ONLY(HeapRegion* last = NULL);
- while (cur != NULL) {
- len++;
- DEBUG_ONLY(last = cur);
- cur = get_next(cur);
- }
- assert(last == tl(), "Invariant");
- return len;
-}
-
-void RegionList::insert_before_head(HeapRegion* r) {
- assert(well_formed(), "Inv");
- set_next(r, hd());
- _hd = r;
- _sz++;
- if (tl() == NULL) _tl = r;
- assert(well_formed(), "Inv");
-}
-
-void RegionList::prepend_list(RegionList* new_list) {
- assert(well_formed(), "Precondition");
- assert(new_list->well_formed(), "Precondition");
- HeapRegion* new_tl = new_list->tl();
- if (new_tl != NULL) {
- set_next(new_tl, hd());
- _hd = new_list->hd();
- _sz += new_list->sz();
- if (tl() == NULL) _tl = new_list->tl();
- } else {
- assert(new_list->hd() == NULL && new_list->sz() == 0, "Inv");
- }
- assert(well_formed(), "Inv");
-}
-
-void RegionList::delete_after(HeapRegion* r) {
- assert(well_formed(), "Precondition");
- HeapRegion* next = get_next(r);
- assert(r != NULL, "Precondition");
- HeapRegion* next_tl = get_next(next);
- set_next(r, next_tl);
- dec_sz();
- if (next == tl()) {
- assert(next_tl == NULL, "Inv");
- _tl = r;
- }
- assert(well_formed(), "Inv");
-}
-
-HeapRegion* RegionList::pop() {
- assert(well_formed(), "Inv");
- HeapRegion* res = hd();
- if (res != NULL) {
- _hd = get_next(res);
- _sz--;
- set_next(res, NULL);
- if (sz() == 0) _tl = NULL;
- }
- assert(well_formed(), "Inv");
- return res;
-}