Mercurial > hg > truffle
diff src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 3766:c3f1170908be
7045330: G1: Simplify/fix the HeapRegionSeq class
7042285: G1: native memory leak during humongous object allocation
6804436: G1: heap region indices should be size_t
Summary: A series of fixes and improvements to the HeapRegionSeq class: a) replace the _regions growable array with a standard C array, b) avoid de-allocating / re-allocating HeapRegion instances when the heap shrinks / grows (fix for 7042285), c) introduce fast method to map address to HeapRegion via a "biased" array pointer, d) embed the _hrs object in G1CollectedHeap, instead of pointing to it via an indirection, e) assume that all the regions added to the HeapRegionSeq instance are contiguous, f) replace int's with size_t's for indexes (and expand that to HeapRegion as part of 6804436), g) remove unnecessary / unused methods, h) rename a couple of fields (_alloc_search_start and _seq_bottom), i) fix iterate_from() not to always start from index 0 irrespective of the region passed to it, j) add a verification method to check the HeapRegionSeq assumptions, k) always call the wrappers for _hrs.iterate(), _hrs_length(), and _hrs.at() from G1CollectedHeap, not those methods directly, and l) unify the code that expands the sequence (by either re-using or creating a new HeapRegion) and make it robust wrt to a HeapRegion allocation failing.
Reviewed-by: stefank, johnc, brutisso
author | tonyp |
---|---|
date | Fri, 10 Jun 2011 13:16:40 -0400 |
parents | 053d84a76d3d |
children | 6747fd0512e0 |
line wrap: on
line diff
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Wed Jun 08 21:48:38 2011 -0400 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Fri Jun 10 13:16:40 2011 -0400 @@ -29,6 +29,7 @@ #include "gc_implementation/g1/g1AllocRegion.hpp" #include "gc_implementation/g1/g1RemSet.hpp" #include "gc_implementation/g1/g1MonitoringSupport.hpp" +#include "gc_implementation/g1/heapRegionSeq.hpp" #include "gc_implementation/g1/heapRegionSets.hpp" #include "gc_implementation/shared/hSpaceCounters.hpp" #include "gc_implementation/parNew/parGCAllocBuffer.hpp" @@ -42,7 +43,6 @@ // heap subsets that will yield large amounts of garbage. class HeapRegion; -class HeapRegionSeq; class HRRSCleanupTask; class PermanentGenerationSpec; class GenerationSpec; @@ -196,9 +196,6 @@ // The part of _g1_storage that is currently committed. MemRegion _g1_committed; - // The maximum part of _g1_storage that has ever been committed. - MemRegion _g1_max_committed; - // The master free list. It will satisfy all new region allocations. MasterFreeRegionList _free_list; @@ -222,7 +219,7 @@ void rebuild_region_lists(); // The sequence of all heap regions in the heap. - HeapRegionSeq* _hrs; + HeapRegionSeq _hrs; // Alloc region used to satisfy mutator allocation requests. MutatorAllocRegion _mutator_alloc_region; @@ -421,13 +418,15 @@ // Attempt to satisfy a humongous allocation request of the given // size by finding a contiguous set of free regions of num_regions // length and remove them from the master free list. Return the - // index of the first region or -1 if the search was unsuccessful. - int humongous_obj_allocate_find_first(size_t num_regions, size_t word_size); + // index of the first region or G1_NULL_HRS_INDEX if the search + // was unsuccessful. + size_t humongous_obj_allocate_find_first(size_t num_regions, + size_t word_size); // Initialize a contiguous set of free regions of length num_regions // and starting at index first so that they appear as a single // humongous region. - HeapWord* humongous_obj_allocate_initialize_regions(int first, + HeapWord* humongous_obj_allocate_initialize_regions(size_t first, size_t num_regions, size_t word_size); @@ -587,8 +586,8 @@ void register_region_with_in_cset_fast_test(HeapRegion* r) { assert(_in_cset_fast_test_base != NULL, "sanity"); assert(r->in_collection_set(), "invariant"); - int index = r->hrs_index(); - assert(0 <= index && (size_t) index < _in_cset_fast_test_length, "invariant"); + size_t index = r->hrs_index(); + assert(index < _in_cset_fast_test_length, "invariant"); assert(!_in_cset_fast_test_base[index], "invariant"); _in_cset_fast_test_base[index] = true; } @@ -754,6 +753,11 @@ HumongousRegionSet* humongous_proxy_set, bool par); + // Notifies all the necessary spaces that the committed space has + // been updated (either expanded or shrunk). It should be called + // after _g1_storage is updated. + void update_committed_space(HeapWord* old_end, HeapWord* new_end); + // The concurrent marker (and the thread it runs in.) ConcurrentMark* _cm; ConcurrentMarkThread* _cmThread; @@ -816,7 +820,6 @@ oop handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, oop obj); void handle_evacuation_failure_common(oop obj, markOop m); - // Ensure that the relevant gc_alloc regions are set. void get_gc_alloc_regions(); // We're done with GC alloc regions. We are going to tear down the @@ -967,15 +970,13 @@ } // The total number of regions in the heap. - size_t n_regions(); + size_t n_regions() { return _hrs.length(); } + + // The max number of regions in the heap. + size_t max_regions() { return _hrs.max_length(); } // The number of regions that are completely free. - size_t max_regions(); - - // The number of regions that are completely free. - size_t free_regions() { - return _free_list.length(); - } + size_t free_regions() { return _free_list.length(); } // The number of regions that are not completely free. size_t used_regions() { return n_regions() - free_regions(); } @@ -983,6 +984,10 @@ // The number of regions available for "regular" expansion. size_t expansion_regions() { return _expansion_regions; } + // Factory method for HeapRegion instances. It will return NULL if + // the allocation fails. + HeapRegion* new_heap_region(size_t hrs_index, HeapWord* bottom); + void verify_not_dirty_region(HeapRegion* hr) PRODUCT_RETURN; void verify_dirty_region(HeapRegion* hr) PRODUCT_RETURN; void verify_dirty_young_list(HeapRegion* head) PRODUCT_RETURN; @@ -1144,17 +1149,15 @@ // Iterate over heap regions, in address order, terminating the // iteration early if the "doHeapRegion" method returns "true". - void heap_region_iterate(HeapRegionClosure* blk); + void heap_region_iterate(HeapRegionClosure* blk) const; // Iterate over heap regions starting with r (or the first region if "r" // is NULL), in address order, terminating early if the "doHeapRegion" // method returns "true". - void heap_region_iterate_from(HeapRegion* r, HeapRegionClosure* blk); + void heap_region_iterate_from(HeapRegion* r, HeapRegionClosure* blk) const; - // As above but starting from the region at index idx. - void heap_region_iterate_from(int idx, HeapRegionClosure* blk); - - HeapRegion* region_at(size_t idx); + // Return the region with the given index. It assumes the index is valid. + HeapRegion* region_at(size_t index) const { return _hrs.at(index); } // Divide the heap region sequence into "chunks" of some size (the number // of regions divided by the number of parallel threads times some @@ -1195,12 +1198,14 @@ // A G1CollectedHeap will contain some number of heap regions. This // finds the region containing a given address, or else returns NULL. - HeapRegion* heap_region_containing(const void* addr) const; + template <class T> + inline HeapRegion* heap_region_containing(const T addr) const; // Like the above, but requires "addr" to be in the heap (to avoid a // null-check), and unlike the above, may return an continuing humongous // region. - HeapRegion* heap_region_containing_raw(const void* addr) const; + template <class T> + inline HeapRegion* heap_region_containing_raw(const T addr) const; // A CollectedHeap is divided into a dense sequence of "blocks"; that is, // each address in the (reserved) heap is a member of exactly @@ -1262,7 +1267,7 @@ return true; } - bool is_in_young(oop obj) { + bool is_in_young(const oop obj) { HeapRegion* hr = heap_region_containing(obj); return hr != NULL && hr->is_young(); } @@ -1368,11 +1373,6 @@ // Override void print_tracing_info() const; - // If "addr" is a pointer into the (reserved?) heap, returns a positive - // number indicating the "arena" within the heap in which "addr" falls. - // Or else returns 0. - virtual int addr_to_arena_id(void* addr) const; - // Convenience function to be used in situations where the heap type can be // asserted to be this type. static G1CollectedHeap* heap();