graal-jvmci-8: src/share/vm/gc_implementation/g1/heapRegion.cpp comparison

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 e8bf410d5e23
children	dd9cc155639c

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "code/nmethod.hpp"
 #include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
 #include "gc_implementation/g1/heapRegion.inline.hpp"
+#include "gc_implementation/g1/heapRegionBounds.inline.hpp"
 #include "gc_implementation/g1/heapRegionRemSet.hpp"
-#include "gc_implementation/g1/heapRegionSeq.inline.hpp"
+#include "gc_implementation/g1/heapRegionManager.inline.hpp"
+#include "gc_implementation/shared/liveRange.hpp"
 #include "memory/genOopClosures.inline.hpp"
 #include "memory/iterator.hpp"
+#include "memory/space.inline.hpp"
 #include "oops/oop.inline.hpp"
+#include "runtime/orderAccess.inline.hpp"
 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 int    HeapRegion::LogOfHRGrainBytes = 0;
 int    HeapRegion::LogOfHRGrainWords = 0;
 HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1,
 HeapRegion* hr, ExtendedOopClosure* cl,
 CardTableModRefBS::PrecisionStyle precision,
 FilterKind fk) :
-ContiguousSpaceDCTOC(hr, cl, precision, NULL),
+DirtyCardToOopClosure(hr, cl, precision, NULL),
 _hr(hr), _fk(fk), _g1(g1) { }
 FilterOutOfRegionClosure::FilterOutOfRegionClosure(HeapRegion* r,
 OopClosure* oc) :
 _r_bottom(r->bottom()), _r_end(r->end()), _oc(oc) { }
 template<class ClosureType>
 HeapWord* walk_mem_region_loop(ClosureType* cl, G1CollectedHeap* g1h,
 HeapRegion* hr,
 HeapWord* cur, HeapWord* top) {
 oop cur_oop = oop(cur);
-int oop_size = cur_oop->size();
+size_t oop_size = hr->block_size(cur);
 HeapWord* next_obj = cur + oop_size;
 while (next_obj < top) {
 // Keep filtering the remembered set.
 if (!g1h->is_obj_dead(cur_oop, hr)) {
 // Bottom lies entirely below top, so we can call the
 // non-memRegion version of oop_iterate below.
 cur_oop->oop_iterate(cl);
 }
 cur = next_obj;
 cur_oop = oop(cur);
-oop_size = cur_oop->size();
+oop_size = hr->block_size(cur);
 next_obj = cur + oop_size;
 }
 return cur;
 }
-void HeapRegionDCTOC::walk_mem_region_with_cl(MemRegion mr,
+void HeapRegionDCTOC::walk_mem_region(MemRegion mr,
 HeapWord* bottom,
-HeapWord* top,
+HeapWord* top) {
-ExtendedOopClosure* cl) {
 G1CollectedHeap* g1h = _g1;
-int oop_size;
+size_t oop_size;
 ExtendedOopClosure* cl2 = NULL;
-FilterIntoCSClosure intoCSFilt(this, g1h, cl);
+FilterIntoCSClosure intoCSFilt(this, g1h, _cl);
-FilterOutOfRegionClosure outOfRegionFilt(_hr, cl);
+FilterOutOfRegionClosure outOfRegionFilt(_hr, _cl);
 switch (_fk) {
-case NoFilterKind:          cl2 = cl; break;
+case NoFilterKind:          cl2 = _cl; break;
 case IntoCSFilterKind:      cl2 = &intoCSFilt; break;
 case OutOfRegionFilterKind: cl2 = &outOfRegionFilt; break;
 default:                    ShouldNotReachHere();
 }
 // or it was allocated after marking finished, then we add it. Otherwise
 // we can safely ignore the object.
 if (!g1h->is_obj_dead(oop(bottom), _hr)) {
 oop_size = oop(bottom)->oop_iterate(cl2, mr);
 } else {
-oop_size = oop(bottom)->size();
+oop_size = _hr->block_size(bottom);
 }
 bottom += oop_size;
 if (bottom < top) {
 // We replicate the loop below for several kinds of possible filters.
 switch (_fk) {
 case NoFilterKind:
-bottom = walk_mem_region_loop(cl, g1h, _hr, bottom, top);
+bottom = walk_mem_region_loop(_cl, g1h, _hr, bottom, top);
 break;
 case IntoCSFilterKind: {
-FilterIntoCSClosure filt(this, g1h, cl);
+FilterIntoCSClosure filt(this, g1h, _cl);
 bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top);
 break;
 }
 case OutOfRegionFilterKind: {
-FilterOutOfRegionClosure filt(_hr, cl);
+FilterOutOfRegionClosure filt(_hr, _cl);
 bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top);
 break;
 }
 default:
 oop(bottom)->oop_iterate(cl2, mr);
 }
 }
 }
-// Minimum region size; we won't go lower than that.
-// We might want to decrease this in the future, to deal with small
-// heaps a bit more efficiently.
-#define MIN_REGION_SIZE  (      1024 * 1024 )
-// Maximum region size; we don't go higher than that. There's a good
-// reason for having an upper bound. We don't want regions to get too
-// large, otherwise cleanup's effectiveness would decrease as there
-// will be fewer opportunities to find totally empty regions after
-// marking.
-#define MAX_REGION_SIZE  ( 32 * 1024 * 1024 )
-// The automatic region size calculation will try to have around this
-// many regions in the heap (based on the min heap size).
-#define TARGET_REGION_NUMBER          2048
 size_t HeapRegion::max_region_size() {
-return (size_t)MAX_REGION_SIZE;
+return HeapRegionBounds::max_size();
 }
 void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {
 uintx region_size = G1HeapRegionSize;
 if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
 size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
-region_size = MAX2(average_heap_size / TARGET_REGION_NUMBER,
+region_size = MAX2(average_heap_size / HeapRegionBounds::target_number(),
-(uintx) MIN_REGION_SIZE);
+(uintx) HeapRegionBounds::min_size());
 }
 int region_size_log = log2_long((jlong) region_size);
 // Recalculate the region size to make sure it's a power of
 // 2. This means that region_size is the largest power of 2 that's
 // <= what we've calculated so far.
 region_size = ((uintx)1 << region_size_log);
 // Now make sure that we don't go over or under our limits.
-if (region_size < MIN_REGION_SIZE) {
+if (region_size < HeapRegionBounds::min_size()) {
-region_size = MIN_REGION_SIZE;
+region_size = HeapRegionBounds::min_size();
-} else if (region_size > MAX_REGION_SIZE) {
+} else if (region_size > HeapRegionBounds::max_size()) {
-region_size = MAX_REGION_SIZE;
+region_size = HeapRegionBounds::max_size();
 }
 // And recalculate the log.
 region_size_log = log2_long((jlong) region_size);
 zero_marked_bytes();
 init_top_at_mark_start();
 }
 void HeapRegion::hr_clear(bool par, bool clear_space, bool locked) {
-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;
+set_allocation_context(AllocationContext::system());
 set_young_index_in_cset(-1);
 uninstall_surv_rate_group();
-set_young_type(NotYoung);
+set_free();
 reset_pre_dummy_top();
 if (!par) {
 // If this is parallel, this will be done later.
 HeapRegionRemSet* hrrs = rem_set();
 assert(end() == _orig_end,
 "Should be normal before the humongous object allocation");
 assert(top() == bottom(), "should be empty");
 assert(bottom() <= new_top && new_top <= new_end, "pre-condition");
-_humongous_type = StartsHumongous;
+_type.set_starts_humongous();
 _humongous_start_region = this;
 set_end(new_end);
 _offsets.set_for_starts_humongous(new_top);
 }
 assert(end() == _orig_end,
 "Should be normal before the humongous object allocation");
 assert(top() == bottom(), "should be empty");
 assert(first_hr->startsHumongous(), "pre-condition");
-_humongous_type = ContinuesHumongous;
+_type.set_continues_humongous();
 _humongous_start_region = first_hr;
 }
-void HeapRegion::set_notHumongous() {
+void HeapRegion::clear_humongous() {
 assert(isHumongous(), "pre-condition");
 if (startsHumongous()) {
 assert(top() <= end(), "pre-condition");
 set_end(_orig_end);
 // continues humongous
 assert(end() == _orig_end, "sanity");
 }
 assert(capacity() == HeapRegion::GrainBytes, "pre-condition");
-_humongous_type = NotHumongous;
 _humongous_start_region = NULL;
 }
 bool HeapRegion::claimHeapRegion(jint claimValue) {
 jint current = _claimed;
 }
 }
 return false;
 }
-HeapWord* HeapRegion::next_block_start_careful(HeapWord* addr) {
+HeapRegion::HeapRegion(uint hrm_index,
-HeapWord* low = addr;
-HeapWord* high = end();
-while (low < high) {
-size_t diff = pointer_delta(high, low);
-// Must add one below to bias toward the high amount.  Otherwise, if
-// "high" were at the desired value, and "low" were one less, we
-// would not converge on "high".  This is not symmetric, because
-// we set "high" to a block start, which might be the right one,
-// which we don't do for "low".
-HeapWord* middle = low + (diff+1)/2;
-if (middle == high) return high;
-HeapWord* mid_bs = block_start_careful(middle);
-if (mid_bs < addr) {
-low = middle;
-} else {
-high = mid_bs;
-}
-}
-assert(low == high && low >= addr, "Didn't work.");
-return low;
-}
-#ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
-#pragma warning( disable:4355 ) // 'this' : used in base member initializer list
-#endif // _MSC_VER
-HeapRegion::HeapRegion(uint hrs_index,
 G1BlockOffsetSharedArray* sharedOffsetArray,
 MemRegion mr) :
 G1OffsetTableContigSpace(sharedOffsetArray, mr),
-_hrs_index(hrs_index),
+_hrm_index(hrm_index),
-_humongous_type(NotHumongous), _humongous_start_region(NULL),
+_allocation_context(AllocationContext::system()),
+_humongous_start_region(NULL),
 _in_collection_set(false),
 _next_in_special_set(NULL), _orig_end(NULL),
 _claimed(InitialClaimValue), _evacuation_failed(false),
 _prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
-_young_type(NotYoung), _next_young_region(NULL),
+_next_young_region(NULL),
-_next_dirty_cards_region(NULL), _next(NULL), _prev(NULL), _pending_removal(false),
+_next_dirty_cards_region(NULL), _next(NULL), _prev(NULL),
 #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)
 {
 _rem_set = new HeapRegionRemSet(sharedOffsetArray, this);
+assert(HeapRegionRemSet::num_par_rem_sets() > 0, "Invariant.");
+initialize(mr);
+}
+void HeapRegion::initialize(MemRegion mr, bool clear_space, bool mangle_space) {
+assert(_rem_set->is_empty(), "Remembered set must be empty");
+G1OffsetTableContigSpace::initialize(mr, clear_space, mangle_space);
 _orig_end = mr.end();
-// Note that initialize() will set the start of the unmarked area of the
-// region.
 hr_clear(false /*par*/, false /*clear_space*/);
 set_top(bottom());
-set_saved_mark();
+record_top_and_timestamp();
-assert(HeapRegionRemSet::num_par_rem_sets() > 0, "Invariant.");
 }
 CompactibleSpace* HeapRegion::next_compaction_space() const {
-// We're not using an iterator given that it will wrap around when
+return G1CollectedHeap::heap()->next_compaction_region(this);
-// it reaches the last region and this is not what we want here.
-G1CollectedHeap* g1h = G1CollectedHeap::heap();
-uint index = hrs_index() + 1;
-while (index < g1h->n_regions()) {
-HeapRegion* hr = g1h->region_at(index);
-if (!hr->isHumongous()) {
-return hr;
-}
-index += 1;
-}
-return NULL;
-}
-void HeapRegion::save_marks() {
-set_saved_mark();
-}
-void HeapRegion::oops_in_mr_iterate(MemRegion mr, ExtendedOopClosure* cl) {
-HeapWord* p = mr.start();
-HeapWord* e = mr.end();
-oop obj;
-while (p < e) {
-obj = oop(p);
-p += obj->oop_iterate(cl);
-}
-assert(p == e, "bad memregion: doesn't end on obj boundary");
-}
-#define HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \
-void HeapRegion::oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \
-ContiguousSpace::oop_since_save_marks_iterate##nv_suffix(cl);              \
-}
-SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN)
-void HeapRegion::oop_before_save_marks_iterate(ExtendedOopClosure* cl) {
-oops_in_mr_iterate(MemRegion(bottom(), saved_mark_word()), cl);
 }
 void HeapRegion::note_self_forwarding_removal_start(bool during_initial_mark,
 bool during_conc_mark) {
 // We always recreate the prev marking info and we'll explicitly
 // mark all objects we find to be self-forwarded on the prev
 // bitmap. So all objects need to be below PTAMS.
-_prev_top_at_mark_start = top();
 _prev_marked_bytes = 0;
 if (during_initial_mark) {
 // During initial-mark, we'll also explicitly mark all objects
 // we find to be self-forwarded on the next bitmap. So all
 bool during_conc_mark,
 size_t marked_bytes) {
 assert(0 <= marked_bytes && marked_bytes <= used(),
 err_msg("marked: "SIZE_FORMAT" used: "SIZE_FORMAT,
 marked_bytes, used()));
+_prev_top_at_mark_start = top();
 _prev_marked_bytes = marked_bytes;
 }
 HeapWord*
 HeapRegion::object_iterate_mem_careful(MemRegion mr,
 cl->do_object(obj);
 }
 if (cl->abort()) return cur;
 // The check above must occur before the operation below, since an
 // abort might invalidate the "size" operation.
-cur += obj->size();
+cur += block_size(cur);
 }
 return NULL;
 }
 HeapWord*
 if (obj->klass_or_null() == NULL) {
 // Ran into an unparseable point.
 return cur;
 }
 // Otherwise...
-next = (cur + obj->size());
+next = cur + block_size(cur);
 }
 // If we finish the above loop...We have a parseable object that
 // begins on or before the start of the memory region, and ends
 // inside or spans the entire region.
 assert(obj == oop(cur), "sanity");
-assert(cur <= start &&
+assert(cur <= start, "Loop postcondition");
-obj->klass_or_null() != NULL &&
+assert(obj->klass_or_null() != NULL, "Loop postcondition");
-(cur + obj->size()) > start,
+assert((cur + block_size(cur)) > start, "Loop postcondition");
-"Loop postcondition");
 if (!g1h->is_obj_dead(obj)) {
 obj->oop_iterate(cl, mr);
 }
 // Ran into an unparseable point.
 return cur;
 };
 // Otherwise:
-next = (cur + obj->size());
+next = cur + block_size(cur);
 if (!g1h->is_obj_dead(obj)) {
 if (next < end || !obj->is_objArray()) {
 // This object either does not span the MemRegion
 // boundary, or if it does it's not an array.
 void HeapRegion::add_strong_code_root(nmethod* nm) {
 HeapRegionRemSet* hrrs = rem_set();
 hrrs->add_strong_code_root(nm);
 }
+void HeapRegion::add_strong_code_root_locked(nmethod* nm) {
+assert_locked_or_safepoint(CodeCache_lock);
+HeapRegionRemSet* hrrs = rem_set();
+hrrs->add_strong_code_root_locked(nm);
+}
 void HeapRegion::remove_strong_code_root(nmethod* nm) {
 HeapRegionRemSet* hrrs = rem_set();
 hrrs->remove_strong_code_root(nm);
-}
-void HeapRegion::migrate_strong_code_roots() {
-assert(in_collection_set(), "only collection set regions");
-assert(!isHumongous(),
-err_msg("humongous region "HR_FORMAT" should not have been added to collection set",
-HR_FORMAT_PARAMS(this)));
-HeapRegionRemSet* hrrs = rem_set();
-hrrs->migrate_strong_code_roots();
 }
 void HeapRegion::strong_code_roots_do(CodeBlobClosure* blk) const {
 HeapRegionRemSet* hrrs = rem_set();
 hrrs->strong_code_roots_do(blk);
 }
 }
 void HeapRegion::print() const { print_on(gclog_or_tty); }
 void HeapRegion::print_on(outputStream* st) const {
-if (isHumongous()) {
+st->print("AC%4u", allocation_context());
-if (startsHumongous())
+st->print(" %2s", get_short_type_str());
-st->print(" HS");
-else
-st->print(" HC");
-} else {
-st->print("   ");
-}
 if (in_collection_set())
 st->print(" CS");
 else
 st->print("   ");
-if (is_young())
-st->print(is_survivor() ? " SU" : " Y ");
-else
-st->print("   ");
-if (is_empty())
-st->print(" F");
-else
-st->print("  ");
 st->print(" TS %5d", _gc_time_stamp);
 st->print(" PTAMS "PTR_FORMAT" NTAMS "PTR_FORMAT,
 prev_top_at_mark_start(), next_top_at_mark_start());
 G1OffsetTableContigSpace::print_on(st);
 }
 bool is_humongous = isHumongous();
 bool do_bot_verify = !is_young();
 size_t object_num = 0;
 while (p < top()) {
 oop obj = oop(p);
-size_t obj_size = obj->size();
+size_t obj_size = block_size(p);
 object_num += 1;
-if (is_humongous != g1->isHumongous(obj_size)) {
+if (is_humongous != g1->isHumongous(obj_size) &&
+!g1->is_obj_dead(obj, this)) { // Dead objects may have bigger block_size since they span several objects.
 gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size ("
 SIZE_FORMAT" words) in a %shumongous region",
 p, g1->isHumongous(obj_size) ? "" : "non-",
 obj_size, is_humongous ? "" : "non-");
 *failures = true;
 return;
 }
 // If it returns false, verify_for_object() will output the
-// appropriate messasge.
+// appropriate message.
-if (do_bot_verify && !_offsets.verify_for_object(p, obj_size)) {
+if (do_bot_verify &&
+!g1->is_obj_dead(obj, this) &&
+!_offsets.verify_for_object(p, obj_size)) {
 *failures = true;
 return;
 }
 if (!g1->is_obj_dead_cond(obj, this, vo)) {
 if (obj->is_oop()) {
 Klass* klass = obj->klass();
-if (!klass->is_metaspace_object()) {
+bool is_metaspace_object = Metaspace::contains(klass) ||
+(vo == VerifyOption_G1UsePrevMarking &&
+ClassLoaderDataGraph::unload_list_contains(klass));
+if (!is_metaspace_object) {
 gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" "
 "not metadata", klass, (void *)obj);
 *failures = true;
 return;
 } else if (!klass->is_klass()) {
 // G1OffsetTableContigSpace code; copied from space.cpp.  Hope this can go
 // away eventually.
 void G1OffsetTableContigSpace::clear(bool mangle_space) {
-ContiguousSpace::clear(mangle_space);
+set_top(bottom());
-_offsets.zero_bottom_entry();
+set_saved_mark_word(bottom());
-_offsets.initialize_threshold();
+CompactibleSpace::clear(mangle_space);
+reset_bot();
 }
 void G1OffsetTableContigSpace::set_bottom(HeapWord* new_bottom) {
 Space::set_bottom(new_bottom);
 _offsets.set_bottom(new_bottom);
 }
 HeapWord* G1OffsetTableContigSpace::saved_mark_word() const {
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
 assert( _gc_time_stamp <= g1h->get_gc_time_stamp(), "invariant" );
-if (_gc_time_stamp < g1h->get_gc_time_stamp())
+HeapWord* local_top = top();
-return top();
+OrderAccess::loadload();
-else
+if (_gc_time_stamp < g1h->get_gc_time_stamp()) {
-return ContiguousSpace::saved_mark_word();
+return local_top;
-}
+} else {
+return Space::saved_mark_word();
-void G1OffsetTableContigSpace::set_saved_mark() {
+}
+}
+void G1OffsetTableContigSpace::record_top_and_timestamp() {
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
 unsigned curr_gc_time_stamp = g1h->get_gc_time_stamp();
 if (_gc_time_stamp < curr_gc_time_stamp) {
 // The order of these is important, as another thread might be
 // set_saved_mark and before _gc_time_stamp = ..., then the latter
 // will be false, and it will pick up top() as the high water mark
 // of region. If it does so after _gc_time_stamp = ..., then it
 // will pick up the right saved_mark_word() as the high water mark
 // of the region. Either way, the behaviour will be correct.
-ContiguousSpace::set_saved_mark();
+Space::set_saved_mark_word(top());
 OrderAccess::storestore();
 _gc_time_stamp = curr_gc_time_stamp;
 // No need to do another barrier to flush the writes above. If
 // this is called in parallel with other threads trying to
 // allocate into the region, the caller should call this while
 // holding a lock and when the lock is released the writes will be
 // flushed.
 }
 }
+void G1OffsetTableContigSpace::safe_object_iterate(ObjectClosure* blk) {
+object_iterate(blk);
+}
+void G1OffsetTableContigSpace::object_iterate(ObjectClosure* blk) {
+HeapWord* p = bottom();
+while (p < top()) {
+if (block_is_obj(p)) {
+blk->do_object(oop(p));
+}
+p += block_size(p);
+}
+}
+#define block_is_always_obj(q) true
+void G1OffsetTableContigSpace::prepare_for_compaction(CompactPoint* cp) {
+SCAN_AND_FORWARD(cp, top, block_is_always_obj, block_size);
+}
+#undef block_is_always_obj
 G1OffsetTableContigSpace::
 G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray,
 MemRegion mr) :
 _offsets(sharedOffsetArray, mr),
 _par_alloc_lock(Mutex::leaf, "OffsetTableContigSpace par alloc lock", true),
 _gc_time_stamp(0)
 {
 _offsets.set_space(this);
-// false ==> we'll do the clearing if there's clearing to be done.
+}
-ContiguousSpace::initialize(mr, false, SpaceDecorator::Mangle);
-_offsets.zero_bottom_entry();
+void G1OffsetTableContigSpace::initialize(MemRegion mr, bool clear_space, bool mangle_space) {
-_offsets.initialize_threshold();
+CompactibleSpace::initialize(mr, clear_space, mangle_space);
-}
+_top = bottom();
+reset_bot();
+}

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 20804:7848fc12602b