truffle: src/share/vm/gc_implementation/g1/heapRegion.cpp comparison

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	33df1aeaebbf a2f7274eb6ef
children	c38f13903fdf

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1,
 HeapRegion* hr, OopClosure* cl,
 CardTableModRefBS::PrecisionStyle precision,
 FilterKind fk) :
 ContiguousSpaceDCTOC(hr, cl, precision, NULL),
-_hr(hr), _fk(fk), _g1(g1)
+_hr(hr), _fk(fk), _g1(g1) { }
-{ }
 FilterOutOfRegionClosure::FilterOutOfRegionClosure(HeapRegion* r,
 OopClosure* oc) :
-_r_bottom(r->bottom()), _r_end(r->end()),
+_r_bottom(r->bottom()), _r_end(r->end()), _oc(oc) { }
-_oc(oc), _out_of_region(0)
-{}
 class VerifyLiveClosure: public OopClosure {
 private:
 G1CollectedHeap* _g1h;
 CardTableModRefBS* _bs;
 // MIN_REGION_SIZE and MAX_REGION_SIZE.
 GrainBytes = (size_t)region_size;
 guarantee(GrainWords == 0, "we should only set it once");
 GrainWords = GrainBytes >> LogHeapWordSize;
-guarantee((size_t)(1 << LogOfHRGrainWords) == GrainWords, "sanity");
+guarantee((size_t) 1 << LogOfHRGrainWords == GrainWords, "sanity");
 guarantee(CardsPerRegion == 0, "we should only set it once");
 CardsPerRegion = GrainBytes >> CardTableModRefBS::card_shift;
 }
 HeapRegionRemSet* hrrs = rem_set();
 if (hrrs != NULL) hrrs->clear();
 _claimed = InitialClaimValue;
 }
 zero_marked_bytes();
-set_sort_index(-1);
 _offsets.resize(HeapRegion::GrainWords);
 init_top_at_mark_start();
 if (clear_space) clear(SpaceDecorator::Mangle);
 }
 #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::HeapRegion(uint hrs_index,
-HeapRegion(size_t hrs_index, G1BlockOffsetSharedArray* sharedOffsetArray,
+G1BlockOffsetSharedArray* sharedOffsetArray,
-MemRegion mr, bool is_zeroed)
+MemRegion mr, bool is_zeroed) :
-: G1OffsetTableContigSpace(sharedOffsetArray, mr, is_zeroed),
+G1OffsetTableContigSpace(sharedOffsetArray, mr, is_zeroed),
 _hrs_index(hrs_index),
 _humongous_type(NotHumongous), _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), _sort_index(-1),
+_prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
-_gc_efficiency(0.0),
 _young_type(NotYoung), _next_young_region(NULL),
 _next_dirty_cards_region(NULL), _next(NULL), _pending_removal(false),
 #ifdef ASSERT
 _containing_set(NULL),
 #endif // ASSERT
 set_saved_mark();
 _rem_set =  new HeapRegionRemSet(sharedOffsetArray, this);
 assert(HeapRegionRemSet::num_par_rem_sets() > 0, "Invariant.");
-// In case the region is allocated during a pause, note the top.
+}
-// We haven't done any counting on a brand new region.
-_top_at_conc_mark_count = bottom();
-}
-class NextCompactionHeapRegionClosure: public HeapRegionClosure {
-const HeapRegion* _target;
-bool _target_seen;
-HeapRegion* _last;
-CompactibleSpace* _res;
-public:
-NextCompactionHeapRegionClosure(const HeapRegion* target) :
-_target(target), _target_seen(false), _res(NULL) {}
-bool doHeapRegion(HeapRegion* cur) {
-if (_target_seen) {
-if (!cur->isHumongous()) {
-_res = cur;
-return true;
-}
-} else if (cur == _target) {
-_target_seen = true;
-}
-return false;
-}
-CompactibleSpace* result() { return _res; }
-};
 CompactibleSpace* HeapRegion::next_compaction_space() const {
+// We're not using an iterator given that it will wrap around when
+// it reaches the last region and this is not what we want here.
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
-// cast away const-ness
+uint index = hrs_index() + 1;
-HeapRegion* r = (HeapRegion*) this;
+while (index < g1h->n_regions()) {
-NextCompactionHeapRegionClosure blk(r);
+HeapRegion* hr = g1h->region_at(index);
-g1h->heap_region_iterate_from(r, &blk);
+if (!hr->isHumongous()) {
-return blk.result();
+return hr;
+}
+index += 1;
+}
+return NULL;
 }
 void HeapRegion::save_marks() {
 set_saved_mark();
 }
 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
 // objects need to be below NTAMS.
 _next_top_at_mark_start = top();
-set_top_at_conc_mark_count(bottom());
 _next_marked_bytes = 0;
 } else if (during_conc_mark) {
 // During concurrent mark, all objects in the CSet (including
 // the ones we find to be self-forwarded) are implicitly live.
 // So all objects need to be above NTAMS.
 _next_top_at_mark_start = bottom();
-set_top_at_conc_mark_count(bottom());
 _next_marked_bytes = 0;
 }
 }
 void HeapRegion::note_self_forwarding_removal_end(bool during_initial_mark,
 st->print(" PTAMS "PTR_FORMAT" NTAMS "PTR_FORMAT,
 prev_top_at_mark_start(), next_top_at_mark_start());
 G1OffsetTableContigSpace::print_on(st);
 }
-void HeapRegion::verify(bool allow_dirty) const {
+void HeapRegion::verify() const {
 bool dummy = false;
-verify(allow_dirty, VerifyOption_G1UsePrevMarking, /* failures */ &dummy);
+verify(VerifyOption_G1UsePrevMarking, /* failures */ &dummy);
 }
 // 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(bool allow_dirty,
+void HeapRegion::verify(VerifyOption vo,
-VerifyOption vo,
 bool* failures) const {
 G1CollectedHeap* g1 = G1CollectedHeap::heap();
 *failures = false;
 HeapWord* p = bottom();
 HeapWord* prev_p = NULL;

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/heapRegion.cpp @ 6275:957c266d8bc5