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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 20336:6701abbc4441

8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data Summary: Let HeapRegionSeq manage the heap region and auxiliary data to decrease the amount of responsibilities of G1CollectedHeap, and encapsulate this work from other code. Reviewed-by: jwilhelm, jmasa, mgerdin, brutisso

author	tschatzl
date	Tue, 19 Aug 2014 10:50:27 +0200
parents	eec72fa4b108
children	1f1d373cd044

comparison

equal deleted inserted replaced

-:eec72fa4b108
+:6701abbc4441
 #include "gc_implementation/g1/g1RemSet.inline.hpp"
 #include "gc_implementation/g1/g1StringDedup.hpp"
 #include "gc_implementation/g1/g1YCTypes.hpp"
 #include "gc_implementation/g1/heapRegion.inline.hpp"
 #include "gc_implementation/g1/heapRegionRemSet.hpp"
-#include "gc_implementation/g1/heapRegionSeq.inline.hpp"
+#include "gc_implementation/g1/heapRegionSet.inline.hpp"
 #include "gc_implementation/g1/vm_operations_g1.hpp"
 #include "gc_implementation/shared/gcHeapSummary.hpp"
 #include "gc_implementation/shared/gcTimer.hpp"
 #include "gc_implementation/shared/gcTrace.hpp"
 #include "gc_implementation/shared/gcTraceTime.hpp"
 // It looks as if there are free regions available on the
 // secondary_free_list. Let's move them to the free_list and try
 // again to allocate from it.
 append_secondary_free_list();
-assert(!_free_list.is_empty(), "if the secondary_free_list was not "
+assert(_hrs.num_free_regions() > 0, "if the secondary_free_list was not "
 "empty we should have moved at least one entry to the free_list");
-HeapRegion* res = _free_list.remove_region(is_old);
+HeapRegion* res = _hrs.allocate_free_region(is_old);
 if (G1ConcRegionFreeingVerbose) {
 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : "
 "allocated "HR_FORMAT" from secondary_free_list",
 HR_FORMAT_PARAMS(res));
 }
 return res;
 }
 }
 }
-res = _free_list.remove_region(is_old);
+res = _hrs.allocate_free_region(is_old);
 if (res == NULL) {
 if (G1ConcRegionFreeingVerbose) {
 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : "
 "res == NULL, trying the secondary_free_list");
 word_size * HeapWordSize);
 if (expand(word_size * HeapWordSize)) {
 // Given that expand() succeeded in expanding the heap, and we
 // always expand the heap by an amount aligned to the heap
 // region size, the free list should in theory not be empty.
-// In either case remove_region() will check for NULL.
+// In either case allocate_free_region() will check for NULL.
-res = _free_list.remove_region(is_old);
+res = _hrs.allocate_free_region(is_old);
 } else {
 _expand_heap_after_alloc_failure = false;
 }
 }
 return res;
-}
-uint G1CollectedHeap::humongous_obj_allocate_find_first(uint num_regions,
-size_t word_size) {
-assert(isHumongous(word_size), "word_size should be humongous");
-assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition");
-uint first = G1_NULL_HRS_INDEX;
-if (num_regions == 1) {
-// Only one region to allocate, no need to go through the slower
-// path. The caller will attempt the expansion if this fails, so
-// let's not try to expand here too.
-HeapRegion* hr = new_region(word_size, true /* is_old */, false /* do_expand */);
-if (hr != NULL) {
-first = hr->hrs_index();
-} else {
-first = G1_NULL_HRS_INDEX;
-}
-} else {
-// We can't allocate humongous regions while cleanupComplete() is
-// running, since some of the regions we find to be empty might not
-// yet be added to the free list and it is not straightforward to
-// know which list they are on so that we can remove them. Note
-// that we only need to do this if we need to allocate more than
-// one region to satisfy the current humongous allocation
-// request. If we are only allocating one region we use the common
-// region allocation code (see above).
-wait_while_free_regions_coming();
-append_secondary_free_list_if_not_empty_with_lock();
-if (free_regions() >= num_regions) {
-first = _hrs.find_contiguous(num_regions);
-if (first != G1_NULL_HRS_INDEX) {
-for (uint i = first; i < first + num_regions; ++i) {
-HeapRegion* hr = region_at(i);
-assert(hr->is_empty(), "sanity");
-assert(is_on_master_free_list(hr), "sanity");
-hr->set_pending_removal(true);
-}
-_free_list.remove_all_pending(num_regions);
-}
-}
-}
-return first;
 }
 HeapWord*
 G1CollectedHeap::humongous_obj_allocate_initialize_regions(uint first,
 uint num_regions,
 size_t word_size) {
-assert(first != G1_NULL_HRS_INDEX, "pre-condition");
+assert(first != G1_NO_HRS_INDEX, "pre-condition");
 assert(isHumongous(word_size), "word_size should be humongous");
 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition");
 // Index of last region in the series + 1.
 uint last = first + num_regions;
 HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size) {
 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
 verify_region_sets_optional();
-size_t word_size_rounded = round_to(word_size, HeapRegion::GrainWords);
+uint first = G1_NO_HRS_INDEX;
-uint num_regions = (uint) (word_size_rounded / HeapRegion::GrainWords);
+uint obj_regions = (uint)(align_size_up_(word_size, HeapRegion::GrainWords) / HeapRegion::GrainWords);
-uint x_num = expansion_regions();
-uint fs = _hrs.free_suffix();
+if (obj_regions == 1) {
-uint first = humongous_obj_allocate_find_first(num_regions, word_size);
+// Only one region to allocate, try to use a fast path by directly allocating
-if (first == G1_NULL_HRS_INDEX) {
+// from the free lists. Do not try to expand here, we will potentially do that
-// The only thing we can do now is attempt expansion.
+// later.
-if (fs + x_num >= num_regions) {
+HeapRegion* hr = new_region(word_size, true /* is_old */, false /* do_expand */);
-// If the number of regions we're trying to allocate for this
+if (hr != NULL) {
-// object is at most the number of regions in the free suffix,
+first = hr->hrs_index();
-// then the call to humongous_obj_allocate_find_first() above
+}
-// should have succeeded and we wouldn't be here.
+} else {
-//
+// We can't allocate humongous regions spanning more than one region while
-// We should only be trying to expand when the free suffix is
+// cleanupComplete() is running, since some of the regions we find to be
-// not sufficient for the object _and_ we have some expansion
+// empty might not yet be added to the free list. It is not straightforward
-// room available.
+// to know in which list they are on so that we can remove them. We only
-assert(num_regions > fs, "earlier allocation should have succeeded");
+// need to do this if we need to allocate more than one region to satisfy the
+// current humongous allocation request. If we are only allocating one region
+// we use the one-region region allocation code (see above), or end up here.
+wait_while_free_regions_coming();
+append_secondary_free_list_if_not_empty_with_lock();
+// Policy: Try only empty regions (i.e. already committed first). Maybe we
+// are lucky enough to find some.
+first = _hrs.find_contiguous(obj_regions, true);
+if (first != G1_NO_HRS_INDEX) {
+_hrs.allocate_free_regions_starting_at(first, obj_regions);
+}
+}
+if (first == G1_NO_HRS_INDEX) {
+// Policy: We could not find enough regions for the humongous object in the
+// free list. Look through the heap to find a mix of free and uncommitted regions.
+// If so, try expansion.
+first = _hrs.find_contiguous(obj_regions, false);
+if (first != G1_NO_HRS_INDEX) {
+// We found something. Make sure these regions are committed, i.e. expand
+// the heap. Alternatively we could do a defragmentation GC.
 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
+_hrs.expand_at(first, obj_regions);
-// reached the desired size. So, we cannot assume that the
+g1_policy()->record_new_heap_size(num_regions());
-// allocation will succeed.
-first = humongous_obj_allocate_find_first(num_regions, word_size);
+#ifdef ASSERT
+for (uint i = first; i < first + obj_regions; ++i) {
+HeapRegion* hr = region_at(i);
+assert(hr->is_empty(), "sanity");
+assert(is_on_master_free_list(hr), "sanity");
 }
+#endif
+_hrs.allocate_free_regions_starting_at(first, obj_regions);
+} else {
+// Policy: Potentially trigger a defragmentation GC.
 }
 }
 HeapWord* result = NULL;
-if (first != G1_NULL_HRS_INDEX) {
+if (first != G1_NO_HRS_INDEX) {
-result =
+result = humongous_obj_allocate_initialize_regions(first, obj_regions, word_size);
-humongous_obj_allocate_initialize_regions(first, num_regions, word_size);
 assert(result != NULL, "it should always return a valid result");
 // A successful humongous object allocation changes the used space
 // information of the old generation so we need to recalculate the
 // sizes and update the jstat counters here.
 {
 HandleMark hm;  // Discard invalid handles created during gc
 G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs);
 }
-assert(free_regions() == 0, "we should not have added any free regions");
+assert(num_free_regions() == 0, "we should not have added any free regions");
 rebuild_region_sets(false /* free_list_only */);
 // Enqueue any discovered reference objects that have
 // not been removed from the discovered lists.
 ref_processor_stw()->enqueue_discovered_references();
 false /* expect_null_mutator_alloc_region */);
 }
 return NULL;
 }
-void G1CollectedHeap::update_committed_space(HeapWord* old_end,
-HeapWord* new_end) {
-assert(old_end != new_end, "don't call this otherwise");
-assert((HeapWord*) _g1_storage.high() == new_end, "invariant");
-// Update the committed mem region.
-_g1_committed.set_end(new_end);
-// Tell the card table about the update.
-Universe::heap()->barrier_set()->resize_covered_region(_g1_committed);
-// Tell the BOT about the update.
-_bot_shared->resize(_g1_committed.word_size());
-// 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 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) {
+if (is_maximal_no_gc()) {
 ergo_verbose0(ErgoHeapSizing,
 "did not expand the heap",
 ergo_format_reason("heap already fully expanded"));
 return false;
 }
-// First commit the memory.
+uint regions_to_expand = (uint)(aligned_expand_bytes / HeapRegion::GrainBytes);
-HeapWord* old_end = (HeapWord*) _g1_storage.high();
+assert(regions_to_expand > 0, "Must expand by at least one region");
-bool successful = _g1_storage.expand_by(aligned_expand_bytes);
-if (successful) {
+uint expanded_by = _hrs.expand_by(regions_to_expand);
-// Then propagate this update to the necessary data structures.
-HeapWord* new_end = (HeapWord*) _g1_storage.high();
+if (expanded_by > 0) {
-update_committed_space(old_end, new_end);
+size_t actual_expand_bytes = expanded_by * HeapRegion::GrainBytes;
-FreeRegionList expansion_list("Local Expansion List");
-MemRegion mr = _hrs.expand_by(old_end, new_end, &expansion_list);
-assert(mr.start() == old_end, "post-condition");
-// mr might be a smaller region than what was requested if
-// expand_by() was unable to allocate the HeapRegion instances
-assert(mr.end() <= new_end, "post-condition");
-size_t actual_expand_bytes = mr.byte_size();
 assert(actual_expand_bytes <= aligned_expand_bytes, "post-condition");
-assert(actual_expand_bytes == expansion_list.total_capacity_bytes(),
+g1_policy()->record_new_heap_size(num_regions());
-"post-condition");
-if (actual_expand_bytes < aligned_expand_bytes) {
-// We could not expand _hrs to the desired size. In this case we
-// need to shrink the committed space accordingly.
-assert(mr.end() < new_end, "invariant");
-size_t diff_bytes = aligned_expand_bytes - actual_expand_bytes;
-// First uncommit the memory.
-_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");
-}
-g1_policy()->record_new_heap_size(n_regions());
 } 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) {
+_hrs.available() >= regions_to_expand) {
 // We had head room...
 vm_exit_out_of_memory(aligned_expand_bytes, OOM_MMAP_ERROR, "G1 heap expansion");
 }
 }
-return successful;
+return regions_to_expand > 0;
 }
 void G1CollectedHeap::shrink_helper(size_t shrink_bytes) {
 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);
 uint num_regions_removed = _hrs.shrink_by(num_regions_to_remove);
-HeapWord* old_end = (HeapWord*) _g1_storage.high();
 size_t shrunk_bytes = num_regions_removed * HeapRegion::GrainBytes;
 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, shrunk_bytes);
 if (num_regions_removed > 0) {
-_g1_storage.shrink_by(shrunk_bytes);
+g1_policy()->record_new_heap_size(num_regions());
-HeapWord* new_end = (HeapWord*) _g1_storage.high();
-if (_hr_printer.is_active()) {
-HeapWord* curr = old_end;
-while (curr > new_end) {
-HeapWord* curr_end = curr;
-curr -= HeapRegion::GrainWords;
-_hr_printer.uncommit(curr, curr_end);
-}
-}
-_expansion_regions += num_regions_removed;
-update_committed_space(old_end, new_end);
-HeapRegionRemSet::shrink_heap(n_regions());
-g1_policy()->record_new_heap_size(n_regions());
 } else {
 ergo_verbose0(ErgoHeapSizing,
 "did not shrink the heap",
 ergo_format_reason("heap shrinking operation failed"));
 }
 _mark_in_progress(false),
 _cg1r(NULL), _summary_bytes_used(0),
 _g1mm(NULL),
 _refine_cte_cl(NULL),
 _full_collection(false),
-_free_list("Master Free List", new MasterFreeRegionListMtSafeChecker()),
 _secondary_free_list("Secondary Free List", new SecondaryFreeRegionListMtSafeChecker()),
 _old_set("Old Set", false /* humongous */, new OldRegionSetMtSafeChecker()),
 _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()),
 _humongous_is_live(),
 _has_humongous_reclaim_candidates(false),
 // Also create a G1 rem set.
 _g1_rem_set = new G1RemSet(this, g1_barrier_set());
 // Carve out the G1 part of the heap.
-ReservedSpace g1_rs   = heap_rs.first_part(max_byte_size);
+ReservedSpace g1_rs = heap_rs.first_part(max_byte_size);
-_g1_reserved = MemRegion((HeapWord*)g1_rs.base(),
+_hrs.initialize(g1_rs);
-g1_rs.size()/HeapWordSize);
-_g1_storage.initialize(g1_rs, 0);
-_g1_committed = MemRegion((HeapWord*)_g1_storage.low(), (size_t) 0);
-_hrs.initialize((HeapWord*) _g1_reserved.start(),
-(HeapWord*) _g1_reserved.end());
 assert(_hrs.max_length() == _expansion_regions,
 err_msg("max length: %u expansion regions: %u",
 _hrs.max_length(), _expansion_regions));
 // Do later initialization work for concurrent refinement.
 _bot_shared = new G1BlockOffsetSharedArray(_reserved,
 heap_word_size(init_byte_size));
 _g1h = this;
-_in_cset_fast_test.initialize(_g1_reserved.start(), _g1_reserved.end(), HeapRegion::GrainBytes);
+_in_cset_fast_test.initialize(_hrs.reserved().start(), _hrs.reserved().end(), HeapRegion::GrainBytes);
-_humongous_is_live.initialize(_g1_reserved.start(), _g1_reserved.end(), HeapRegion::GrainBytes);
+_humongous_is_live.initialize(_hrs.reserved().start(), _hrs.reserved().end(), HeapRegion::GrainBytes);
 // Create the ConcurrentMark data structure and thread.
 // (Must do this late, so that "max_regions" is defined.)
 _cm = new ConcurrentMark(this, heap_rs);
 if (_cm == NULL || !_cm->completed_initialization()) {
 // In case we're keeping closure specialization stats, initialize those
 // counts and that mechanism.
 SpecializationStats::clear();
-// Here we allocate the dummy full region that is required by the
+// Here we allocate the dummy HeapRegion that is required by the
-// G1AllocRegion class. If we don't pass an address in the reserved
+// G1AllocRegion class.
-// space here, lots of asserts fire.
+HeapRegion* dummy_region = _hrs.get_dummy_region();
-HeapRegion* dummy_region = new_heap_region(0 /* index of bottom region */,
-_g1_reserved.start());
 // We'll re-use the same region whether the alloc region will
 // require BOT updates or not and, if it doesn't, then a non-young
 // region will complain that it cannot support allocations without
 // BOT updates. So we'll tag the dummy region as young to avoid that.
 dummy_region->set_young();
 // is alive closure
 // (for efficiency/performance)
 }
 size_t G1CollectedHeap::capacity() const {
-return _g1_committed.byte_size();
+return _hrs.length() * HeapRegion::GrainBytes;
 }
 void G1CollectedHeap::reset_gc_time_stamps(HeapRegion* hr) {
 assert(!hr->continuesHumongous(), "pre-condition");
 hr->reset_gc_time_stamp();
 g1_policy()->phase_times()->record_evac_fail_recalc_used_time((os::elapsedTime() - recalculate_used_start) * 1000.0);
 return blk.result();
 }
 size_t G1CollectedHeap::unsafe_max_alloc() {
-if (free_regions() > 0) return HeapRegion::GrainBytes;
+if (num_free_regions() > 0) return HeapRegion::GrainBytes;
 // otherwise, is there space in the current allocation region?
 // We need to store the current allocation region in a local variable
 // here. The problem is that this method doesn't take any locks and
 // there may be other threads which overwrite the current allocation
 }
 } while (retry_gc);
 }
 bool G1CollectedHeap::is_in(const void* p) const {
-if (_g1_committed.contains(p)) {
+if (_hrs.committed().contains(p)) {
 // Given that we know that p is in the committed space,
 // heap_region_containing_raw() should successfully
 // return the containing region.
 HeapRegion* hr = heap_region_containing_raw(p);
 return hr->is_in(p);
 }
 void
 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl,
 uint worker_id,
-uint no_of_par_workers,
+uint num_workers,
-jint claim_value) {
+jint claim_value) const {
-const uint regions = n_regions();
+_hrs.par_iterate(cl, worker_id, num_workers, claim_value);
-const uint max_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
-no_of_par_workers :
-1);
-assert(UseDynamicNumberOfGCThreads ||
-no_of_par_workers == workers()->total_workers(),
-"Non dynamic should use fixed number of workers");
-// try to spread out the starting points of the workers
-const HeapRegion* start_hr =
-start_region_for_worker(worker_id, no_of_par_workers);
-const uint start_index = start_hr->hrs_index();
-// each worker will actually look at all regions
-for (uint count = 0; count < regions; ++count) {
-const uint index = (start_index + count) % regions;
-assert(0 <= index && index < regions, "sanity");
-HeapRegion* r = region_at(index);
-// we'll ignore "continues humongous" regions (we'll process them
-// when we come across their corresponding "start humongous"
-// region) and regions already claimed
-if (r->claim_value() == claim_value || r->continuesHumongous()) {
-continue;
-}
-// OK, try to claim it
-if (r->claimHeapRegion(claim_value)) {
-// success!
-assert(!r->continuesHumongous(), "sanity");
-if (r->startsHumongous()) {
-// If the region is "starts humongous" we'll iterate over its
-// "continues humongous" first; in fact we'll do them
-// first. The order is important. In on case, calling the
-// closure on the "starts humongous" region might de-allocate
-// and clear all its "continues humongous" regions and, as a
-// result, we might end up processing them twice. So, we'll do
-// them first (notice: most closures will ignore them anyway) and
-// then we'll do the "starts humongous" region.
-for (uint ch_index = index + 1; ch_index < regions; ++ch_index) {
-HeapRegion* chr = region_at(ch_index);
-// if the region has already been claimed or it's not
-// "continues humongous" we're done
-if (chr->claim_value() == claim_value ||
-!chr->continuesHumongous()) {
-break;
-}
-// No one should have claimed it directly. We can given
-// that we claimed its "starts humongous" region.
-assert(chr->claim_value() != claim_value, "sanity");
-assert(chr->humongous_start_region() == r, "sanity");
-if (chr->claimHeapRegion(claim_value)) {
-// we should always be able to claim it; no one else should
-// be trying to claim this region
-bool res2 = cl->doHeapRegion(chr);
-assert(!res2, "Should not abort");
-// Right now, this holds (i.e., no closure that actually
-// does something with "continues humongous" regions
-// clears them). We might have to weaken it in the future,
-// but let's leave these two asserts here for extra safety.
-assert(chr->continuesHumongous(), "should still be the case");
-assert(chr->humongous_start_region() == r, "sanity");
-} else {
-guarantee(false, "we should not reach here");
-}
-}
-}
-assert(!r->continuesHumongous(), "sanity");
-bool res = cl->doHeapRegion(r);
-assert(!res, "Should not abort");
-}
-}
 }
 class ResetClaimValuesClosure: public HeapRegionClosure {
 public:
 bool doHeapRegion(HeapRegion* r) {
 OrderAccess::storestore();
 _worker_cset_start_region_time_stamp[worker_i] = gc_time_stamp;
 return result;
 }
-HeapRegion* G1CollectedHeap::start_region_for_worker(uint worker_i,
-uint no_of_par_workers) {
-uint worker_num =
-G1CollectedHeap::use_parallel_gc_threads() ? no_of_par_workers : 1U;
-assert(UseDynamicNumberOfGCThreads ||
-no_of_par_workers == workers()->total_workers(),
-"Non dynamic should use fixed number of workers");
-const uint start_index = n_regions() * worker_i / worker_num;
-return region_at(start_index);
-}
 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) {
 HeapRegion* r = g1_policy()->collection_set();
 while (r != NULL) {
 HeapRegion* next = r->next_in_collection_set();
 if (cl->doHeapRegion(r)) {
 cur = next;
 }
 }
 HeapRegion* G1CollectedHeap::next_compaction_region(const HeapRegion* from) const {
-// We're not using an iterator given that it will wrap around when
+HeapRegion* result = _hrs.next_region_in_heap(from);
-// it reaches the last region and this is not what we want here.
+while (result != NULL && result->isHumongous()) {
-for (uint index = from->hrs_index() + 1; index < n_regions(); index++) {
+result = _hrs.next_region_in_heap(result);
-HeapRegion* hr = region_at(index);
+}
-if (!hr->isHumongous()) {
+return result;
-return hr;
-}
-}
-return NULL;
 }
 Space* G1CollectedHeap::space_containing(const void* addr) const {
 return heap_region_containing(addr);
 }
 return MIN2(MAX2(hr->free(), (size_t) MinTLABSize), max_tlab);
 }
 }
 size_t G1CollectedHeap::max_capacity() const {
-return _g1_reserved.byte_size();
+return _hrs.reserved().byte_size();
 }
 jlong G1CollectedHeap::millis_since_last_gc() {
 // assert(false, "NYI");
 return 0;
 void G1CollectedHeap::print_on(outputStream* st) const {
 st->print(" %-20s", "garbage-first heap");
 st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K",
 capacity()/K, used_unlocked()/K);
 st->print(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")",
-_g1_storage.low_boundary(),
+_hrs.committed().start(),
-_g1_storage.high(),
+_hrs.committed().end(),
-_g1_storage.high_boundary());
+_hrs.reserved().end());
 st->cr();
 st->print("  region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K);
 uint young_regions = _young_list->length();
 st->print("%u young (" SIZE_FORMAT "K), ", young_regions,
 (size_t) young_regions * HeapRegion::GrainBytes / K);
 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
+// We failed to expand the heap. Cannot do anything about it.
-// 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");
 }
 }
 }
 // We redo the verification but now wrt to the new CSet which
 // 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());
 if (mark_in_progress()) {
-concurrent_mark()->update_g1_committed();
+concurrent_mark()->update_heap_boundaries(_hrs.committed());
 }
 #ifdef TRACESPINNING
 ParallelTaskTerminator::print_termination_counts();
 #endif
 FreeRegionList* free_list,
 bool par,
 bool locked) {
 assert(!hr->isHumongous(), "this is only for non-humongous regions");
 assert(!hr->is_empty(), "the region should not be empty");
+assert(_hrs.is_available(hr->hrs_index()), "region should be committed");
 assert(free_list != NULL, "pre-condition");
 if (G1VerifyBitmaps) {
 MemRegion mr(hr->bottom(), hr->end());
 concurrent_mark()->clearRangePrevBitmap(mr);
 void G1CollectedHeap::prepend_to_freelist(FreeRegionList* list) {
 assert(list != NULL, "list can't be null");
 if (!list->is_empty()) {
 MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag);
-_free_list.add_ordered(list);
+_hrs.insert_list_into_free_list(list);
 }
 }
 void G1CollectedHeap::decrement_summary_bytes(size_t bytes) {
 assert(_summary_bytes_used >= bytes,
 // Note that emptying the _young_list is postponed and instead done as
 // the first step when rebuilding the regions sets again. The reason for
 // this is that during a full GC string deduplication needs to know if
 // a collected region was young or old when the full GC was initiated.
 }
-_free_list.remove_all();
+_hrs.remove_all_free_regions();
 }
 class RebuildRegionSetsClosure : public HeapRegionClosure {
 private:
 bool            _free_list_only;
 HeapRegionSet*   _old_set;
-FreeRegionList* _free_list;
+HeapRegionSeq*   _hrs;
 size_t          _total_used;
 public:
 RebuildRegionSetsClosure(bool free_list_only,
-HeapRegionSet* old_set, FreeRegionList* free_list) :
+HeapRegionSet* old_set, HeapRegionSeq* hrs) :
 _free_list_only(free_list_only),
-_old_set(old_set), _free_list(free_list), _total_used(0) {
+_old_set(old_set), _hrs(hrs), _total_used(0) {
-assert(_free_list->is_empty(), "pre-condition");
+assert(_hrs->num_free_regions() == 0, "pre-condition");
 if (!free_list_only) {
 assert(_old_set->is_empty(), "pre-condition");
 }
 }
 return false;
 }
 if (r->is_empty()) {
 // Add free regions to the free list
-_free_list->add_as_tail(r);
+_hrs->insert_into_free_list(r);
 } else if (!_free_list_only) {
 assert(!r->is_young(), "we should not come across young regions");
 if (r->isHumongous()) {
 // We ignore humongous regions, we left the humongous set unchanged
 if (!free_list_only) {
 _young_list->empty_list();
 }
-RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_free_list);
+RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_hrs);
 heap_region_iterate(&cl);
 if (!free_list_only) {
 _summary_bytes_used = cl.total_used();
 }
 class VerifyRegionListsClosure : public HeapRegionClosure {
 private:
 HeapRegionSet*   _old_set;
 HeapRegionSet*   _humongous_set;
-FreeRegionList*  _free_list;
+HeapRegionSeq*   _hrs;
 public:
 HeapRegionSetCount _old_count;
 HeapRegionSetCount _humongous_count;
 HeapRegionSetCount _free_count;
 VerifyRegionListsClosure(HeapRegionSet* old_set,
 HeapRegionSet* humongous_set,
-FreeRegionList* free_list) :
+HeapRegionSeq* hrs) :
-_old_set(old_set), _humongous_set(humongous_set), _free_list(free_list),
+_old_set(old_set), _humongous_set(humongous_set), _hrs(hrs),
 _old_count(), _humongous_count(), _free_count(){ }
 bool doHeapRegion(HeapRegion* hr) {
 if (hr->continuesHumongous()) {
 return false;
 // TODO
 } else if (hr->startsHumongous()) {
 assert(hr->containing_set() == _humongous_set, err_msg("Heap region %u is starts humongous but not in humongous set.", hr->hrs_index()));
 _humongous_count.increment(1u, hr->capacity());
 } else if (hr->is_empty()) {
-assert(hr->containing_set() == _free_list, err_msg("Heap region %u is empty but not on the free list.", hr->hrs_index()));
+assert(_hrs->is_free(hr), err_msg("Heap region %u is empty but not on the free list.", hr->hrs_index()));
 _free_count.increment(1u, hr->capacity());
 } else {
 assert(hr->containing_set() == _old_set, err_msg("Heap region %u is old but not in the old set.", hr->hrs_index()));
 _old_count.increment(1u, hr->capacity());
 }
 return false;
 }
-void verify_counts(HeapRegionSet* old_set, HeapRegionSet* humongous_set, FreeRegionList* free_list) {
+void verify_counts(HeapRegionSet* old_set, HeapRegionSet* humongous_set, HeapRegionSeq* free_list) {
 guarantee(old_set->length() == _old_count.length(), err_msg("Old set count mismatch. Expected %u, actual %u.", old_set->length(), _old_count.length()));
 guarantee(old_set->total_capacity_bytes() == _old_count.capacity(), err_msg("Old set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
 old_set->total_capacity_bytes(), _old_count.capacity()));
 guarantee(humongous_set->length() == _humongous_count.length(), err_msg("Hum set count mismatch. Expected %u, actual %u.", humongous_set->length(), _humongous_count.length()));
 guarantee(humongous_set->total_capacity_bytes() == _humongous_count.capacity(), err_msg("Hum set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
 humongous_set->total_capacity_bytes(), _humongous_count.capacity()));
-guarantee(free_list->length() == _free_count.length(), err_msg("Free list count mismatch. Expected %u, actual %u.", free_list->length(), _free_count.length()));
+guarantee(free_list->num_free_regions() == _free_count.length(), err_msg("Free list count mismatch. Expected %u, actual %u.", free_list->num_free_regions(), _free_count.length()));
 guarantee(free_list->total_capacity_bytes() == _free_count.capacity(), err_msg("Free list capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT,
 free_list->total_capacity_bytes(), _free_count.capacity()));
 }
 };
-HeapRegion* G1CollectedHeap::new_heap_region(uint hrs_index,
-HeapWord* bottom) {
-HeapWord* end = bottom + HeapRegion::GrainWords;
-MemRegion mr(bottom, end);
-assert(_g1_reserved.contains(mr), "invariant");
-// This might return NULL if the allocation fails
-return new HeapRegion(hrs_index, _bot_shared, mr);
-}
 void G1CollectedHeap::verify_region_sets() {
 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
 // First, check the explicit lists.
-_free_list.verify_list();
+_hrs.verify();
 {
 // Given that a concurrent operation might be adding regions to
 // the secondary free list we have to take the lock before
 // verifying it.
 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
 append_secondary_free_list_if_not_empty_with_lock();
 // Finally, make sure that the region accounting in the lists is
 // consistent with what we see in the heap.
-VerifyRegionListsClosure cl(&_old_set, &_humongous_set, &_free_list);
+VerifyRegionListsClosure cl(&_old_set, &_humongous_set, &_hrs);
 heap_region_iterate(&cl);
-cl.verify_counts(&_old_set, &_humongous_set, &_free_list);
+cl.verify_counts(&_old_set, &_humongous_set, &_hrs);
 }
 // Optimized nmethod scanning
 class RegisterNMethodOopClosure: public OopClosure {

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 20336:6701abbc4441