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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 2188:c33825b68624

6923430: G1: assert(res != 0,"This should have worked.") 7007446: G1: expand the heap with a single step, not one region at a time Summary: Changed G1CollectedHeap::expand() to expand the committed space by calling VirtualSpace::expand_by() once rather than for every region in the expansion amount. This allows the success or failure of the expansion to be determined before creating any heap regions. Introduced a develop flag G1ExitOnExpansionFailure (false by default) that, when true, will exit the VM if the expansion of the committed space fails. Finally G1CollectedHeap::expand() returns a status back to it's caller so that the caller knows whether to attempt the allocation. Reviewed-by: brutisso, tonyp

author	johnc
date	Wed, 02 Feb 2011 10:41:20 -0800
parents	97ba643ea3ed
children	4e0069ff33df

comparison

equal deleted inserted replaced

-:986b2844f7a2
+:c33825b68624
 "res == NULL, trying the secondary_free_list");
 }
 res = new_region_try_secondary_free_list(word_size);
 }
 if (res == NULL && do_expand) {
-expand(word_size * HeapWordSize);
+if (expand(word_size * HeapWordSize)) {
-res = _free_list.remove_head_or_null();
+// The expansion succeeded and so we should have at least one
+// region on the free list.
+res = _free_list.remove_head();
+}
 }
 if (res != NULL) {
 if (G1PrintHeapRegions) {
 gclog_or_tty->print_cr("new alloc region %d:["PTR_FORMAT","PTR_FORMAT"], "
 "top "PTR_FORMAT, res->hrs_index(),
 size_t fs = _hrs->free_suffix();
 int first = humongous_obj_allocate_find_first(num_regions, word_size);
 if (first == -1) {
 // The only thing we can do now is attempt expansion.
 if (fs + x_size >= num_regions) {
-expand((num_regions - fs) * HeapRegion::GrainBytes);
+// If the number of regions we're trying to allocate for this
-first = humongous_obj_allocate_find_first(num_regions, word_size);
+// object is at most the number of regions in the free suffix,
-assert(first != -1, "this should have worked");
+// then the call to humongous_obj_allocate_find_first() above
+// should have succeeded and we wouldn't be here.
+//
+// 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");
+if (expand((num_regions - fs) * HeapRegion::GrainBytes)) {
+first = humongous_obj_allocate_find_first(num_regions, word_size);
+// If the expansion was successful then the allocation
+// should have been successful.
+assert(first != -1, "this should have worked");
+}
 }
 }
 if (first != -1) {
 // Index of last region in the series + 1.
 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;
-expand(expand_bytes);
+if (expand(expand_bytes)) {
 if (PrintGC && Verbose) {
 gclog_or_tty->print_cr("  "
 "  expanding:"
 "  max_heap_size: %6.1fK"
 "  minimum_desired_capacity: %6.1fK"
 "  expand_bytes: %6.1fK",
 (double) max_heap_size / (double) K,
 (double) minimum_desired_capacity / (double) K,
 (double) expand_bytes / (double) K);
+}
 }
 // No expansion, now see if we want to shrink
 } else if (capacity_after_gc > maximum_desired_capacity) {
 // Capacity too large, compute shrinking size
 HeapWord* G1CollectedHeap::expand_and_allocate(size_t word_size) {
 assert_at_safepoint(true /* should_be_vm_thread */);
 verify_region_sets_optional();
-size_t expand_bytes = word_size * HeapWordSize;
+size_t expand_bytes = MAX2(word_size * HeapWordSize, MinHeapDeltaBytes);
-if (expand_bytes < MinHeapDeltaBytes) {
+if (expand(expand_bytes)) {
-expand_bytes = MinHeapDeltaBytes;
+verify_region_sets_optional();
-}
+return attempt_allocation_at_safepoint(word_size,
-expand(expand_bytes);
+false /* expect_null_cur_alloc_region */);
+}
-verify_region_sets_optional();
+return NULL;
+}
-return attempt_allocation_at_safepoint(word_size,
-false /* expect_null_cur_alloc_region */);
+bool G1CollectedHeap::expand(size_t expand_bytes) {
-}
-// FIXME: both this and shrink could probably be more efficient by
-// doing one "VirtualSpace::expand_by" call rather than several.
-void G1CollectedHeap::expand(size_t expand_bytes) {
 size_t old_mem_size = _g1_storage.committed_size();
-// We expand by a minimum of 1K.
+size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes);
-expand_bytes = MAX2(expand_bytes, (size_t)K);
-size_t aligned_expand_bytes =
-ReservedSpace::page_align_size_up(expand_bytes);
 aligned_expand_bytes = align_size_up(aligned_expand_bytes,
 HeapRegion::GrainBytes);
-expand_bytes = aligned_expand_bytes;
-while (expand_bytes > 0) {
+if (Verbose && PrintGC) {
-HeapWord* base = (HeapWord*)_g1_storage.high();
+gclog_or_tty->print("Expanding garbage-first heap from %ldK by %ldK",
-// Commit more storage.
+old_mem_size/K, aligned_expand_bytes/K);
-bool successful = _g1_storage.expand_by(HeapRegion::GrainBytes);
+}
-if (!successful) {
-expand_bytes = 0;
+HeapWord* old_end = (HeapWord*)_g1_storage.high();
-} else {
+bool successful = _g1_storage.expand_by(aligned_expand_bytes);
-expand_bytes -= HeapRegion::GrainBytes;
+if (successful) {
-// Expand the committed region.
+HeapWord* new_end = (HeapWord*)_g1_storage.high();
-HeapWord* high = (HeapWord*) _g1_storage.high();
-_g1_committed.set_end(high);
+// Expand the committed region.
+_g1_committed.set_end(new_end);
+// Tell the cardtable about the expansion.
+Universe::heap()->barrier_set()->resize_covered_region(_g1_committed);
+// And the offset table as well.
+_bot_shared->resize(_g1_committed.word_size());
+expand_bytes = aligned_expand_bytes;
+HeapWord* base = old_end;
+// Create the heap regions for [old_end, new_end)
+while (expand_bytes > 0) {
+HeapWord* high = base + HeapRegion::GrainWords;
 // Create a new HeapRegion.
 MemRegion mr(base, high);
 bool is_zeroed = !_g1_max_committed.contains(base);
 HeapRegion* hr = new HeapRegion(_bot_shared, mr, is_zeroed);
-// Now update max_committed if necessary.
-_g1_max_committed.set_end(MAX2(_g1_max_committed.end(), high));
 // Add it to the HeapRegionSeq.
 _hrs->insert(hr);
 _free_list.add_as_tail(hr);
 // And we used up an expansion region to create it.
 _expansion_regions--;
-// Tell the cardtable about it.
-Universe::heap()->barrier_set()->resize_covered_region(_g1_committed);
+expand_bytes -= HeapRegion::GrainBytes;
-// And the offset table as well.
+base += HeapRegion::GrainWords;
-_bot_shared->resize(_g1_committed.word_size());
+}
+assert(base == new_end, "sanity");
+// Now update max_committed if necessary.
+_g1_max_committed.set_end(MAX2(_g1_max_committed.end(), new_end));
+} 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) {
+// 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("Expanding garbage-first heap from %ldK by %ldK to %ldK",
+gclog_or_tty->print_cr("...%s, expanded to %ldK",
-old_mem_size/K, aligned_expand_bytes/K,
+(successful ? "Successful" : "Failed"),
 new_mem_size/K);
 }
+return successful;
 }
 void G1CollectedHeap::shrink_helper(size_t shrink_bytes)
 {
 size_t old_mem_size = _g1_storage.committed_size();
 // Initialize the from_card cache structure of HeapRegionRemSet.
 HeapRegionRemSet::init_heap(max_regions());
 // Now expand into the initial heap size.
-expand(init_byte_size);
+if (!expand(init_byte_size)) {
+vm_exit_during_initialization("Failed to allocate initial heap.");
+return JNI_ENOMEM;
+}
 // Perform any initialization actions delegated to the policy.
 g1_policy()->init();
 g1_policy()->note_start_of_mark_thread();
 // FIXME
 return HeapRegion::GrainBytes/HeapWordSize;
 }
 size_t G1CollectedHeap::max_capacity() const {
-return g1_reserved_obj_bytes();
+return _g1_reserved.byte_size();
 }
 jlong G1CollectedHeap::millis_since_last_gc() {
 // assert(false, "NYI");
 return 0;
 {
 size_t expand_bytes = g1_policy()->expansion_amount();
 if (expand_bytes > 0) {
 size_t bytes_before = capacity();
-expand(expand_bytes);
+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");
+}
 }
 }
 if (mark_in_progress()) {
 concurrent_mark()->update_g1_committed();
 }
 }
 if (alloc_region == NULL) {
 // we will get a new GC alloc region
-alloc_region = new_gc_alloc_region(ap, 0);
+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 %d:["PTR_FORMAT", "PTR_FORMAT"], "
 return _hrs->length();
 }
 size_t G1CollectedHeap::max_regions() {
 return
-(size_t)align_size_up(g1_reserved_obj_bytes(), HeapRegion::GrainBytes) /
+(size_t)align_size_up(max_capacity(), HeapRegion::GrainBytes) /
 HeapRegion::GrainBytes;
 }
 void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) {
 assert(heap_lock_held_for_gc(),

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 2188:c33825b68624