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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 3778:5f6f2615433a

7049999: G1: Make the G1PrintHeapRegions output consistent and complete Summary: Extend and make more consistent the output from the G1PrintHeapRegions flag. Reviewed-by: johnc, jmasa

author	tonyp
date	Fri, 24 Jun 2011 12:38:49 -0400
parents	e8b0b0392037
children	14a2fd14c0db

comparison

equal deleted inserted replaced

-:e8b0b0392037
+:5f6f2615433a
 // the desired size. So, we cannot assume that the allocation
 // will succeed.
 res = _free_list.remove_head_or_null();
 }
 }
-if (res != NULL) {
-if (G1PrintHeapRegions) {
-gclog_or_tty->print_cr("new alloc region "HR_FORMAT,
-HR_FORMAT_PARAMS(res));
-}
-}
 return res;
 }
 HeapRegion* G1CollectedHeap::new_gc_alloc_region(int purpose,
 size_t word_size) {
 HeapRegion* alloc_region = NULL;
 if (_gc_alloc_region_counts[purpose] < g1_policy()->max_regions(purpose)) {
 alloc_region = new_region(word_size, true /* do_expand */);
-if (purpose == GCAllocForSurvived && alloc_region != NULL) {
+if (alloc_region != NULL) {
-alloc_region->set_survivor();
+if (purpose == GCAllocForSurvived) {
-}
+_hr_printer.alloc(alloc_region, G1HRPrinter::Survivor);
-++_gc_alloc_region_counts[purpose];
+alloc_region->set_survivor();
+} else {
+_hr_printer.alloc(alloc_region, G1HRPrinter::Old);
+}
+++_gc_alloc_region_counts[purpose];
+}
 } else {
 g1_policy()->note_alloc_region_limit_reached(purpose);
 }
 return alloc_region;
 }
 // Now that the BOT and the object header have been initialized,
 // we can update top of the "starts humongous" region.
 assert(first_hr->bottom() < new_top && new_top <= first_hr->end(),
 "new_top should be in this region");
 first_hr->set_top(new_top);
+if (_hr_printer.is_active()) {
+HeapWord* bottom = first_hr->bottom();
+HeapWord* end = first_hr->orig_end();
+if ((first + 1) == last) {
+// the series has a single humongous region
+_hr_printer.alloc(G1HRPrinter::SingleHumongous, first_hr, new_top);
+} else {
+// the series has more than one humongous regions
+_hr_printer.alloc(G1HRPrinter::StartsHumongous, first_hr, end);
+}
+}
 // Now, we will update the top fields of the "continues humongous"
 // regions. The reason we need to do this is that, otherwise,
 // these regions would look empty and this will confuse parts of
 // G1. For example, the code that looks for a consecutive number
 if ((i + 1) == last) {
 // last continues humongous region
 assert(hr->bottom() < new_top && new_top <= hr->end(),
 "new_top should fall on this region");
 hr->set_top(new_top);
+_hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, new_top);
 } else {
 // not last one
 assert(new_top > hr->end(), "new_top should be above this region");
 hr->set_top(hr->end());
+_hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, hr->end());
 }
 }
 // If we have continues humongous regions (hr != NULL), then the
 // end of the last one should match new_end and its top should
 // match new_top.
 _g1->heap_region_par_iterate_chunked(&rebuild_rs, i,
 HeapRegion::RebuildRSClaimValue);
 }
 };
+class PostCompactionPrinterClosure: public HeapRegionClosure {
+private:
+G1HRPrinter* _hr_printer;
+public:
+bool doHeapRegion(HeapRegion* hr) {
+assert(!hr->is_young(), "not expecting to find young regions");
+// We only generate output for non-empty regions.
+if (!hr->is_empty()) {
+if (!hr->isHumongous()) {
+_hr_printer->post_compaction(hr, G1HRPrinter::Old);
+} else if (hr->startsHumongous()) {
+if (hr->capacity() == (size_t) HeapRegion::GrainBytes) {
+// single humongous region
+_hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous);
+} else {
+_hr_printer->post_compaction(hr, G1HRPrinter::StartsHumongous);
+}
+} else {
+assert(hr->continuesHumongous(), "only way to get here");
+_hr_printer->post_compaction(hr, G1HRPrinter::ContinuesHumongous);
+}
+}
+return false;
+}
+PostCompactionPrinterClosure(G1HRPrinter* hr_printer)
+: _hr_printer(hr_printer) { }
+};
 bool G1CollectedHeap::do_collection(bool explicit_gc,
 bool clear_all_soft_refs,
 size_t word_size) {
 assert_at_safepoint(true /* should_be_vm_thread */);
 release_mutator_alloc_region();
 abandon_gc_alloc_regions();
 g1_rem_set()->cleanupHRRS();
 tear_down_region_lists();
+// We should call this after we retire any currently active alloc
+// regions so that all the ALLOC / RETIRE events are generated
+// before the start GC event.
+_hr_printer.start_gc(true /* full */, (size_t) total_collections());
 // We may have added regions to the current incremental collection
 // set between the last GC or pause and now. We need to clear the
 // incremental collection set and then start rebuilding it afresh
 // after this full GC.
 abandon_collection_set(g1_policy()->inc_cset_head());
 PostMCRemSetClearClosure rs_clear(mr_bs());
 heap_region_iterate(&rs_clear);
 // Resize the heap if necessary.
 resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size);
+if (_hr_printer.is_active()) {
+// We should do this after we potentially resize the heap so
+// that all the COMMIT / UNCOMMIT events are generated before
+// the end GC event.
+PostCompactionPrinterClosure cl(hr_printer());
+heap_region_iterate(&cl);
+_hr_printer.end_gc(true /* full */, (size_t) total_collections());
+}
 if (_cg1r->use_cache()) {
 _cg1r->clear_and_record_card_counts();
 _cg1r->clear_hot_cache();
 }
 _g1_storage.shrink_by(diff_bytes);
 // Then propagate this update to the necessary data structures.
 update_committed_space(new_end, mr.end());
 }
 _free_list.add_as_tail(&expansion_list);
+if (_hr_printer.is_active()) {
+HeapWord* curr = mr.start();
+while (curr < mr.end()) {
+HeapWord* curr_end = curr + HeapRegion::GrainWords;
+_hr_printer.commit(curr, curr_end);
+curr = curr_end;
+}
+assert(curr == mr.end(), "post-condition");
+}
 } else {
 // The expansion of the virtual storage space was unsuccessful.
 // Let's see if it was because we ran out of swap.
 if (G1ExitOnExpansionFailure &&
 _g1_storage.uncommitted_size() >= aligned_expand_bytes) {
 size_t num_regions_deleted = 0;
 MemRegion mr = _hrs.shrink_by(aligned_shrink_bytes, &num_regions_deleted);
 HeapWord* old_end = (HeapWord*) _g1_storage.high();
 assert(mr.end() == old_end, "post-condition");
 if (mr.byte_size() > 0) {
+if (_hr_printer.is_active()) {
+HeapWord* curr = mr.end();
+while (curr > mr.start()) {
+HeapWord* curr_end = curr;
+curr -= HeapRegion::GrainWords;
+_hr_printer.uncommit(curr, curr_end);
+}
+assert(curr == mr.start(), "post-condition");
+}
 _g1_storage.shrink_by(mr.byte_size());
 HeapWord* new_end = (HeapWord*) _g1_storage.high();
 assert(mr.start() == new_end, "post-condition");
 _expansion_regions += num_regions_deleted;
 // Necessary to satisfy locking discipline assertions.
 MutexLocker x(Heap_lock);
+// We have to initialize the printer before committing the heap, as
+// it will be used then.
+_hr_printer.set_active(G1PrintHeapRegions);
 // While there are no constraints in the GC code that HeapWordSize
 // be any particular value, there are multiple other areas in the
 // system which believe this to be true (e.g. oop->object_size in some
 // cases incorrectly returns the size in wordSize units rather than
 // HeapWordSize).
 // Forget the current alloc region (we might even choose it to be part
 // of the collection set!).
 release_mutator_alloc_region();
+// We should call this after we retire the mutator alloc
+// region(s) so that all the ALLOC / RETIRE events are generated
+// before the start GC event.
+_hr_printer.start_gc(false /* full */, (size_t) total_collections());
 // The elapsed time induced by the start time below deliberately elides
 // the possible verification above.
 double start_time_sec = os::elapsedTime();
 size_t start_used_bytes = used();
 _young_list->print();
 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
 #endif // YOUNG_LIST_VERBOSE
 g1_policy()->choose_collection_set(target_pause_time_ms);
+if (_hr_printer.is_active()) {
+HeapRegion* hr = g1_policy()->collection_set();
+while (hr != NULL) {
+G1HRPrinter::RegionType type;
+if (!hr->is_young()) {
+type = G1HRPrinter::Old;
+} else if (hr->is_survivor()) {
+type = G1HRPrinter::Survivor;
+} else {
+type = G1HRPrinter::Eden;
+}
+_hr_printer.cset(hr);
+hr = hr->next_in_collection_set();
+}
+}
 // We have chosen the complete collection set. If marking is
 // active then, we clear the region fields of any of the
 // concurrent marking tasks whose region fields point into
 // the collection set as these values will become stale. This
 assert(capacity() == _g1_storage.committed_size(), "committed size mismatch");
 assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch");
 }
 }
 }
+// We should do this after we potentially expand the heap so
+// that all the COMMIT events are generated before the end GC
+// event, and after we retire the GC alloc regions so that all
+// RETIRE events are generated before the end GC event.
+_hr_printer.end_gc(false /* full */, (size_t) total_collections());
 // We have to do this after we decide whether to expand the heap or not.
 g1_policy()->print_heap_transition();
 if (mark_in_progress()) {
 concurrent_mark()->update_g1_committed();
 // we will get a new GC alloc region
 alloc_region = new_gc_alloc_region(ap, HeapRegion::GrainWords);
 } else {
 // the region was retained from the last collection
 ++_gc_alloc_region_counts[ap];
-if (G1PrintHeapRegions) {
-gclog_or_tty->print_cr("new alloc region "HR_FORMAT,
+_hr_printer.reuse(alloc_region);
-HR_FORMAT_PARAMS(alloc_region));
-}
 }
 if (alloc_region != NULL) {
 assert(_gc_alloc_regions[ap] == NULL, "pre-condition");
 set_gc_alloc_region(ap, alloc_region);
 preserve_mark_if_necessary(old, m);
 HeapRegion* r = heap_region_containing(old);
 if (!r->evacuation_failed()) {
 r->set_evacuation_failed(true);
-if (G1PrintHeapRegions) {
+_hr_printer.evac_failure(r);
-gclog_or_tty->print("overflow in heap region "PTR_FORMAT" "
-"["PTR_FORMAT","PTR_FORMAT")\n",
-r, r->bottom(), r->end());
-}
 }
 push_on_evac_failure_scan_stack(old);
 if (!_drain_in_progress) {
 // object.
 if (par) par_allocate_remaining_space(alloc_region);
 // Now we can do the post-GC stuff on the region.
 alloc_region->note_end_of_copying();
 g1_policy()->record_after_bytes(alloc_region->used());
+_hr_printer.retire(alloc_region);
 }
 HeapWord*
 G1CollectedHeap::allocate_during_gc_slow(GCAllocPurpose purpose,
 HeapRegion*    alloc_region,
 HeapRegion* G1CollectedHeap::new_mutator_alloc_region(size_t word_size,
 bool force) {
 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
 assert(!force || g1_policy()->can_expand_young_list(),
 "if force is true we should be able to expand the young list");
-if (force || !g1_policy()->is_young_list_full()) {
+bool young_list_full = g1_policy()->is_young_list_full();
+if (force || !young_list_full) {
 HeapRegion* new_alloc_region = new_region(word_size,
 false /* do_expand */);
 if (new_alloc_region != NULL) {
 g1_policy()->update_region_num(true /* next_is_young */);
 set_region_short_lived_locked(new_alloc_region);
+_hr_printer.alloc(new_alloc_region, G1HRPrinter::Eden, young_list_full);
 g1mm()->update_eden_counters();
 return new_alloc_region;
 }
 }
 return NULL;
 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
 assert(alloc_region->is_young(), "all mutator alloc regions should be young");
 g1_policy()->add_region_to_incremental_cset_lhs(alloc_region);
 _summary_bytes_used += allocated_bytes;
+_hr_printer.retire(alloc_region);
 }
 HeapRegion* MutatorAllocRegion::allocate_new_region(size_t word_size,
 bool force) {
 return _g1h->new_mutator_alloc_region(word_size, force);

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 3778:5f6f2615433a