graal-compiler: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 12352:798522662fcd

Merge

author	jcoomes
date	Fri, 04 Oct 2013 13:37:25 -0700
parents	a5ac0873476c 9de9169ddde6
children	cefad50507d8 aa6f2ea19d8f

comparison

equal deleted inserted replaced

-:100614790c1e
+:798522662fcd
 G1CollectedHeap* _g1h;
 CardTableModRefBS* _ctbs;
 int _histo[256];
 public:
 ClearLoggedCardTableEntryClosure() :
-_calls(0)
+_calls(0), _g1h(G1CollectedHeap::heap()), _ctbs(_g1h->g1_barrier_set())
 {
-_g1h = G1CollectedHeap::heap();
-_ctbs = (CardTableModRefBS*)_g1h->barrier_set();
 for (int i = 0; i < 256; i++) _histo[i] = 0;
 }
 bool do_card_ptr(jbyte* card_ptr, int worker_i) {
 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) {
 _calls++;
 int _calls;
 G1CollectedHeap* _g1h;
 CardTableModRefBS* _ctbs;
 public:
 RedirtyLoggedCardTableEntryClosure() :
-_calls(0)
+_calls(0), _g1h(G1CollectedHeap::heap()), _ctbs(_g1h->g1_barrier_set()) {}
-{
-_g1h = G1CollectedHeap::heap();
-_ctbs = (CardTableModRefBS*)_g1h->barrier_set();
-}
 bool do_card_ptr(jbyte* card_ptr, int worker_i) {
 if (_g1h->is_in_reserved(_ctbs->addr_for(card_ptr))) {
 _calls++;
 *card_ptr = 0;
 }
 }
 }
 void G1CollectedHeap::check_ct_logs_at_safepoint() {
 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
-CardTableModRefBS* ct_bs = (CardTableModRefBS*)barrier_set();
+CardTableModRefBS* ct_bs = g1_barrier_set();
 // Count the dirty cards at the start.
 CountNonCleanMemRegionClosure count1(this);
 ct_bs->mod_card_iterate(&count1);
 int orig_count = count1.n();
 return false;
 }
 };
 void G1CollectedHeap::clear_rsets_post_compaction() {
-PostMCRemSetClearClosure rs_clear(this, mr_bs());
+PostMCRemSetClearClosure rs_clear(this, g1_barrier_set());
 heap_region_iterate(&rs_clear);
 }
 class RebuildRSOutOfRegionClosure: public HeapRegionClosure {
 G1CollectedHeap*   _g1h;
 // Tell the hot card cache about the update
 _cg1r->hot_card_cache()->resize_card_counts(capacity());
 }
 bool G1CollectedHeap::expand(size_t expand_bytes) {
-size_t old_mem_size = _g1_storage.committed_size();
 size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes);
 aligned_expand_bytes = align_size_up(aligned_expand_bytes,
 HeapRegion::GrainBytes);
 ergo_verbose2(ErgoHeapSizing,
 "expand the heap",
 ergo_format_byte("requested expansion amount")
 ergo_format_byte("attempted expansion amount"),
 expand_bytes, aligned_expand_bytes);
+if (_g1_storage.uncommitted_size() == 0) {
+ergo_verbose0(ErgoHeapSizing,
+"did not expand the heap",
+ergo_format_reason("heap already fully expanded"));
+return false;
+}
 // First commit the memory.
 HeapWord* old_end = (HeapWord*) _g1_storage.high();
 bool successful = _g1_storage.expand_by(aligned_expand_bytes);
 if (successful) {
 }
 return successful;
 }
 void G1CollectedHeap::shrink_helper(size_t shrink_bytes) {
-size_t old_mem_size = _g1_storage.committed_size();
 size_t aligned_shrink_bytes =
 ReservedSpace::page_align_size_down(shrink_bytes);
 aligned_shrink_bytes = align_size_down(aligned_shrink_bytes,
 HeapRegion::GrainBytes);
 uint num_regions_to_remove = (uint)(shrink_bytes / HeapRegion::GrainBytes);
 _expansion_regions = (uint) (max_byte_size / HeapRegion::GrainBytes);
 // Create the gen rem set (and barrier set) for the entire reserved region.
 _rem_set = collector_policy()->create_rem_set(_reserved, 2);
 set_barrier_set(rem_set()->bs());
-if (barrier_set()->is_a(BarrierSet::ModRef)) {
+if (!barrier_set()->is_a(BarrierSet::G1SATBCTLogging)) {
-_mr_bs = (ModRefBarrierSet*)_barrier_set;
+vm_exit_during_initialization("G1 requires a G1SATBLoggingCardTableModRefBS");
-} else {
-vm_exit_during_initialization("G1 requires a mod ref bs.");
 return JNI_ENOMEM;
 }
 // Also create a G1 rem set.
-if (mr_bs()->is_a(BarrierSet::CardTableModRef)) {
+_g1_rem_set = new G1RemSet(this, g1_barrier_set());
-_g1_rem_set = new G1RemSet(this, (CardTableModRefBS*)mr_bs());
-} else {
-vm_exit_during_initialization("G1 requires a cardtable mod ref bs.");
-return JNI_ENOMEM;
-}
 // Carve out the G1 part of the heap.
 ReservedSpace g1_rs   = heap_rs.first_part(max_byte_size);
 _g1_reserved = MemRegion((HeapWord*)g1_rs.base(),
 void G1CollectedHeap::gc_prologue(bool full /* Ignored */) {
 // always_do_update_barrier = false;
 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer");
 // Fill TLAB's and such
 ensure_parsability(true);
+if (G1SummarizeRSetStats && (G1SummarizeRSetStatsPeriod > 0) &&
+(total_collections() % G1SummarizeRSetStatsPeriod == 0)) {
+g1_rem_set()->print_periodic_summary_info("Before GC RS summary");
+}
 }
 void G1CollectedHeap::gc_epilogue(bool full /* Ignored */) {
 if (G1SummarizeRSetStats &&
 (G1SummarizeRSetStatsPeriod > 0) &&
 // we are at the end of the GC. Total collections has already been increased.
 ((total_collections() - 1) % G1SummarizeRSetStatsPeriod == 0)) {
-g1_rem_set()->print_periodic_summary_info();
+g1_rem_set()->print_periodic_summary_info("After GC RS summary");
 }
 // FIXME: what is this about?
 // I'm ignoring the "fill_newgen()" call if "alloc_event_enabled"
 // is set.
 G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num)
 : _g1h(g1h),
 _refs(g1h->task_queue(queue_num)),
 _dcq(&g1h->dirty_card_queue_set()),
-_ct_bs((CardTableModRefBS*)_g1h->barrier_set()),
+_ct_bs(g1h->g1_barrier_set()),
 _g1_rem(g1h->g1_rem_set()),
 _hash_seed(17), _queue_num(queue_num),
 _term_attempts(0),
 _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)),
 _tenured_alloc_buffer(g1h->desired_plab_sz(GCAllocForTenured)),
 _humongous_set.update_from_proxy(humongous_proxy_set);
 }
 }
 class G1ParCleanupCTTask : public AbstractGangTask {
-CardTableModRefBS* _ct_bs;
+G1SATBCardTableModRefBS* _ct_bs;
 G1CollectedHeap* _g1h;
 HeapRegion* volatile _su_head;
 public:
-G1ParCleanupCTTask(CardTableModRefBS* ct_bs,
+G1ParCleanupCTTask(G1SATBCardTableModRefBS* ct_bs,
 G1CollectedHeap* g1h) :
 AbstractGangTask("G1 Par Cleanup CT Task"),
 _ct_bs(ct_bs), _g1h(g1h) { }
 void work(uint worker_id) {
 };
 #ifndef PRODUCT
 class G1VerifyCardTableCleanup: public HeapRegionClosure {
 G1CollectedHeap* _g1h;
-CardTableModRefBS* _ct_bs;
+G1SATBCardTableModRefBS* _ct_bs;
 public:
-G1VerifyCardTableCleanup(G1CollectedHeap* g1h, CardTableModRefBS* ct_bs)
+G1VerifyCardTableCleanup(G1CollectedHeap* g1h, G1SATBCardTableModRefBS* ct_bs)
 : _g1h(g1h), _ct_bs(ct_bs) { }
 virtual bool doHeapRegion(HeapRegion* r) {
 if (r->is_survivor()) {
 _g1h->verify_dirty_region(r);
 } else {
 }
 };
 void G1CollectedHeap::verify_not_dirty_region(HeapRegion* hr) {
 // All of the region should be clean.
-CardTableModRefBS* ct_bs = (CardTableModRefBS*)barrier_set();
+G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
 MemRegion mr(hr->bottom(), hr->end());
 ct_bs->verify_not_dirty_region(mr);
 }
 void G1CollectedHeap::verify_dirty_region(HeapRegion* hr) {
 // retires each region and replaces it with a new one will do a
 // maximal allocation to fill in [pre_dummy_top(),end()] but will
 // not dirty that area (one less thing to have to do while holding
 // a lock). So we can only verify that [bottom(),pre_dummy_top()]
 // is dirty.
-CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set();
+G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
 MemRegion mr(hr->bottom(), hr->pre_dummy_top());
 ct_bs->verify_dirty_region(mr);
 }
 void G1CollectedHeap::verify_dirty_young_list(HeapRegion* head) {
-CardTableModRefBS* ct_bs = (CardTableModRefBS*) barrier_set();
+G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
 for (HeapRegion* hr = head; hr != NULL; hr = hr->get_next_young_region()) {
 verify_dirty_region(hr);
 }
 }
 verify_dirty_young_list(_young_list->first_region());
 }
 #endif
 void G1CollectedHeap::cleanUpCardTable() {
-CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set());
+G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
 double start = os::elapsedTime();
 {
 // Iterate over the dirty cards region list.
 G1ParCleanupCTTask cleanup_task(ct_bs, this);

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 12352:798522662fcd