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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 3914:20213c8a3c40

7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions Summary: It introduces ergonomic decision logging in G1 for the following heuristics: heap sizing, collection set construction, concurrent cycle initiation, and partially-young GC start/end. The code has a bit of refactoring in a few places to make the decision logging possible. It also replaces alternative ad-hoc logging that we have under different parameters and switches (G1_DEBUG, G1PolicyVerbose). Reviewed-by: johnc, ysr

author	tonyp
date	Wed, 07 Sep 2011 12:21:23 -0400
parents	eeae91c9baba
children	05550041d664

comparison

equal deleted inserted replaced

-:27702f012017
+:20213c8a3c40
 #include "gc_implementation/g1/concurrentG1RefineThread.hpp"
 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
 #include "gc_implementation/g1/g1AllocRegion.inline.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
+#include "gc_implementation/g1/g1ErgoVerbose.hpp"
 #include "gc_implementation/g1/g1MarkSweep.hpp"
 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
 #include "gc_implementation/g1/g1RemSet.inline.hpp"
 #include "gc_implementation/g1/heapRegionRemSet.hpp"
 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
 "res == NULL, trying the secondary_free_list");
 }
 res = new_region_try_secondary_free_list();
 }
 if (res == NULL && do_expand) {
+ergo_verbose1(ErgoHeapSizing,
+"attempt heap expansion",
+ergo_format_reason("region allocation request failed")
+ergo_format_byte("allocation request"),
+word_size * HeapWordSize);
 if (expand(word_size * HeapWordSize)) {
 // Even though the heap was expanded, it might not have reached
 // the desired size. So, we cannot assume that the allocation
 // will succeed.
 res = _free_list.remove_head_or_null();
 // We should only be trying to expand when the free suffix is
 // not sufficient for the object _and_ we have some expansion
 // room available.
 assert(num_regions > fs, "earlier allocation should have succeeded");
+ergo_verbose1(ErgoHeapSizing,
+"attempt heap expansion",
+ergo_format_reason("humongous allocation request failed")
+ergo_format_byte("allocation request"),
+word_size * HeapWordSize);
 if (expand((num_regions - fs) * HeapRegion::GrainBytes)) {
 // Even though the heap was expanded, it might not have
 // reached the desired size. So, we cannot assume that the
 // allocation will succeed.
 first = humongous_obj_allocate_find_first(num_regions, word_size);
 // allocate a new region. So the mutator alloc region should be NULL.
 assert(_mutator_alloc_region.get() == NULL, "only way to get here");
 if (GC_locker::is_active_and_needs_gc()) {
 if (g1_policy()->can_expand_young_list()) {
+// No need for an ergo verbose message here,
+// can_expand_young_list() does this when it returns true.
 result = _mutator_alloc_region.attempt_allocation_force(word_size,
 false /* bot_updates */);
 if (result != NULL) {
 return result;
 }
 // Should not be less than the heap min size. No need to adjust it
 // with respect to the heap max size as it's an upper bound (i.e.,
 // we'll try to make the capacity smaller than it, not greater).
 maximum_desired_capacity =  MAX2(maximum_desired_capacity, min_heap_size);
-if (PrintGC && Verbose) {
-const double free_percentage =
-(double) free_after_gc / (double) capacity_after_gc;
-gclog_or_tty->print_cr("Computing new size after full GC ");
-gclog_or_tty->print_cr("  "
-"  minimum_free_percentage: %6.2f",
-minimum_free_percentage);
-gclog_or_tty->print_cr("  "
-"  maximum_free_percentage: %6.2f",
-maximum_free_percentage);
-gclog_or_tty->print_cr("  "
-"  capacity: %6.1fK"
-"  minimum_desired_capacity: %6.1fK"
-"  maximum_desired_capacity: %6.1fK",
-(double) capacity_after_gc / (double) K,
-(double) minimum_desired_capacity / (double) K,
-(double) maximum_desired_capacity / (double) K);
-gclog_or_tty->print_cr("  "
-"  free_after_gc: %6.1fK"
-"  used_after_gc: %6.1fK",
-(double) free_after_gc / (double) K,
-(double) used_after_gc / (double) K);
-gclog_or_tty->print_cr("  "
-"   free_percentage: %6.2f",
-free_percentage);
-}
 if (capacity_after_gc < minimum_desired_capacity) {
 // Don't expand unless it's significant
 size_t expand_bytes = minimum_desired_capacity - capacity_after_gc;
-if (expand(expand_bytes)) {
+ergo_verbose4(ErgoHeapSizing,
-if (PrintGC && Verbose) {
+"attempt heap expansion",
-gclog_or_tty->print_cr("  "
+ergo_format_reason("capacity lower than "
-"  expanding:"
+"min desired capacity after Full GC")
-"  max_heap_size: %6.1fK"
+ergo_format_byte("capacity")
-"  minimum_desired_capacity: %6.1fK"
+ergo_format_byte("occupancy")
-"  expand_bytes: %6.1fK",
+ergo_format_byte_perc("min desired capacity"),
-(double) max_heap_size / (double) K,
+capacity_after_gc, used_after_gc,
-(double) minimum_desired_capacity / (double) K,
+minimum_desired_capacity, (double) MinHeapFreeRatio);
-(double) expand_bytes / (double) K);
+expand(expand_bytes);
-}
-}
 // No expansion, now see if we want to shrink
 } else if (capacity_after_gc > maximum_desired_capacity) {
 // Capacity too large, compute shrinking size
 size_t shrink_bytes = capacity_after_gc - maximum_desired_capacity;
+ergo_verbose4(ErgoHeapSizing,
+"attempt heap shrinking",
+ergo_format_reason("capacity higher than "
+"max desired capacity after Full GC")
+ergo_format_byte("capacity")
+ergo_format_byte("occupancy")
+ergo_format_byte_perc("max desired capacity"),
+capacity_after_gc, used_after_gc,
+maximum_desired_capacity, (double) MaxHeapFreeRatio);
 shrink(shrink_bytes);
-if (PrintGC && Verbose) {
-gclog_or_tty->print_cr("  "
-"  shrinking:"
-"  min_heap_size: %6.1fK"
-"  maximum_desired_capacity: %6.1fK"
-"  shrink_bytes: %6.1fK",
-(double) min_heap_size / (double) K,
-(double) maximum_desired_capacity / (double) K,
-(double) shrink_bytes / (double) K);
-}
 }
 }
 HeapWord*
 assert_at_safepoint(true /* should_be_vm_thread */);
 verify_region_sets_optional();
 size_t expand_bytes = MAX2(word_size * HeapWordSize, MinHeapDeltaBytes);
+ergo_verbose1(ErgoHeapSizing,
+"attempt heap expansion",
+ergo_format_reason("allocation request failed")
+ergo_format_byte("allocation request"),
+word_size * HeapWordSize);
 if (expand(expand_bytes)) {
 _hrs.verify_optional();
 verify_region_sets_optional();
 return attempt_allocation_at_safepoint(word_size,
 false /* expect_null_mutator_alloc_region */);
 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,
-if (Verbose && PrintGC) {
+"expand the heap",
-gclog_or_tty->print("Expanding garbage-first heap from %ldK by %ldK",
+ergo_format_byte("requested expansion amount")
-old_mem_size/K, aligned_expand_bytes/K);
+ergo_format_byte("attempted expansion amount"),
-}
+expand_bytes, aligned_expand_bytes);
 // First commit the memory.
 HeapWord* old_end = (HeapWord*) _g1_storage.high();
 bool successful = _g1_storage.expand_by(aligned_expand_bytes);
 if (successful) {
 curr = curr_end;
 }
 assert(curr == mr.end(), "post-condition");
 }
 } else {
+ergo_verbose0(ErgoHeapSizing,
+"did not expand the heap",
+ergo_format_reason("heap expansion operation failed"));
 // 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) {
 // We had head room...
 vm_exit_out_of_memory(aligned_expand_bytes, "G1 heap expansion");
 }
-}
-if (Verbose && PrintGC) {
-size_t new_mem_size = _g1_storage.committed_size();
-gclog_or_tty->print_cr("...%s, expanded to %ldK",
-(successful ? "Successful" : "Failed"),
-new_mem_size/K);
 }
 return successful;
 }
 void G1CollectedHeap::shrink_helper(size_t shrink_bytes) {
 HeapRegion::GrainBytes);
 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");
+ergo_verbose3(ErgoHeapSizing,
+"shrink the heap",
+ergo_format_byte("requested shrinking amount")
+ergo_format_byte("aligned shrinking amount")
+ergo_format_byte("attempted shrinking amount"),
+shrink_bytes, aligned_shrink_bytes, mr.byte_size());
 if (mr.byte_size() > 0) {
 if (_hr_printer.is_active()) {
 HeapWord* curr = mr.end();
 while (curr > mr.start()) {
 HeapWord* curr_end = curr;
 assert(mr.start() == new_end, "post-condition");
 _expansion_regions += num_regions_deleted;
 update_committed_space(old_end, new_end);
 HeapRegionRemSet::shrink_heap(n_regions());
+} else {
-if (Verbose && PrintGC) {
+ergo_verbose0(ErgoHeapSizing,
-size_t new_mem_size = _g1_storage.committed_size();
+"did not shrink the heap",
-gclog_or_tty->print_cr("Shrinking garbage-first heap from %ldK by %ldK to %ldK",
+ergo_format_reason("heap shrinking operation failed"));
-old_mem_size/K, aligned_shrink_bytes/K,
-new_mem_size/K);
-}
 }
 }
 void G1CollectedHeap::shrink(size_t shrink_bytes) {
 verify_region_sets_optional();
 {
 size_t expand_bytes = g1_policy()->expansion_amount();
 if (expand_bytes > 0) {
 size_t bytes_before = capacity();
+// No need for an ergo verbose message here,
+// expansion_amount() does this when it returns a value > 0.
 if (!expand(expand_bytes)) {
 // We failed to expand the heap so let's verify that
 // committed/uncommitted amount match the backing store
 assert(capacity() == _g1_storage.committed_size(), "committed size mismatch");
 assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch");
 G1IsAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
 void do_object(oop p) { assert(false, "Do not call."); }
 bool do_object_b(oop p) {
 // It is reachable if it is outside the collection set, or is inside
 // and forwarded.
-#ifdef G1_DEBUG
-gclog_or_tty->print_cr("is alive "PTR_FORMAT" in CS %d forwarded %d overall %d",
-(void*) p, _g1->obj_in_cs(p), p->is_forwarded(),
-!_g1->obj_in_cs(p) || p->is_forwarded());
-#endif // G1_DEBUG
 return !_g1->obj_in_cs(p) || p->is_forwarded();
 }
 };
 class G1KeepAliveClosure: public OopClosure {
 public:
 G1KeepAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
 void do_oop(narrowOop* p) { guarantee(false, "Not needed"); }
 void do_oop(      oop* p) {
 oop obj = *p;
-#ifdef G1_DEBUG
-if (PrintGC && Verbose) {
-gclog_or_tty->print_cr("keep alive *"PTR_FORMAT" = "PTR_FORMAT" "PTR_FORMAT,
-p, (void*) obj, (void*) *p);
-}
-#endif // G1_DEBUG
 if (_g1->obj_in_cs(obj)) {
 assert( obj->is_forwarded(), "invariant" );
 *p = obj->forwardee();
-#ifdef G1_DEBUG
-gclog_or_tty->print_cr("     in CSet: moved "PTR_FORMAT" -> "PTR_FORMAT,
-(void*) obj, (void*) *p);
-#endif // G1_DEBUG
 }
 }
 };
 class UpdateRSetDeferred : public OopsInHeapRegionClosure {

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 3914:20213c8a3c40