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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 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
 // The one and only G1CollectedHeap, so static functions can find it.
 static G1CollectedHeap* _g1h;
 static size_t _humongous_object_threshold_in_words;
-// Storage for the G1 heap.
-VirtualSpace _g1_storage;
-MemRegion    _g1_reserved;
-// The part of _g1_storage that is currently committed.
-MemRegion _g1_committed;
-// The master free list. It will satisfy all new region allocations.
-FreeRegionList _free_list;
 // The secondary free list which contains regions that have been
-// freed up during the cleanup process. This will be appended to the
+// freed up during the cleanup process. This will be appended to
-// master free list when appropriate.
+// the master free list when appropriate.
 FreeRegionList _secondary_free_list;
 // It keeps track of the old regions.
 HeapRegionSet _old_set;
 // an allocation of the given word_size. If do_expand is true,
 // attempt to expand the heap if necessary to satisfy the allocation
 // request. If the region is to be used as an old region or for a
 // humongous object, set is_old to true. If not, to false.
 HeapRegion* new_region(size_t word_size, bool is_old, bool do_expand);
-// 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 G1_NULL_HRS_INDEX if the search
-// was unsuccessful.
-uint humongous_obj_allocate_find_first(uint 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(uint first,
 // should be treated as an approximation, not a guarantee, for use in
 // heuristic resizing decisions.
 virtual size_t unsafe_max_alloc();
 virtual bool is_maximal_no_gc() const {
-return _g1_storage.uncommitted_size() == 0;
+return _hrs.available() == 0;
 }
-// The total number of regions in the heap.
+// The current number of regions in the heap.
-uint n_regions() const { return _hrs.length(); }
+uint num_regions() const { return _hrs.length(); }
 // The max number of regions in the heap.
 uint max_regions() const { return _hrs.max_length(); }
 // The number of regions that are completely free.
-uint free_regions() const { return _free_list.length(); }
+uint num_free_regions() const { return _hrs.num_free_regions(); }
 // The number of regions that are not completely free.
-uint used_regions() const { return n_regions() - free_regions(); }
+uint num_used_regions() const { return num_regions() - num_free_regions(); }
-// The number of regions available for "regular" expansion.
-uint expansion_regions() const { return _expansion_regions; }
-// Factory method for HeapRegion instances. It will return NULL if
-// the allocation fails.
-HeapRegion* new_heap_region(uint 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;
 void verify_dirty_young_regions() PRODUCT_RETURN;
 void verify_region_sets_optional() { }
 #endif // HEAP_REGION_SET_FORCE_VERIFY
 #ifdef ASSERT
 bool is_on_master_free_list(HeapRegion* hr) {
-return hr->containing_set() == &_free_list;
+return _hrs.is_free(hr);
 }
 #endif // ASSERT
 // Wrapper for the region list operations that can be called from
 // methods outside this class.
 void secondary_free_list_add(FreeRegionList* list) {
 _secondary_free_list.add_ordered(list);
 }
 void append_secondary_free_list() {
-_free_list.add_ordered(&_secondary_free_list);
+_hrs.insert_list_into_free_list(&_secondary_free_list);
 }
 void append_secondary_free_list_if_not_empty_with_lock() {
 // If the secondary free list looks empty there's no reason to
 // take the lock and then try to append it.
 inline in_cset_state_t in_cset_state(const oop obj);
 // Return "TRUE" iff the given object address is in the reserved
 // region of g1.
 bool is_in_g1_reserved(const void* p) const {
-return _g1_reserved.contains(p);
+return _hrs.reserved().contains(p);
 }
 // Returns a MemRegion that corresponds to the space that has been
 // reserved for the heap
-MemRegion g1_reserved() {
+MemRegion g1_reserved() const {
-return _g1_reserved;
+return _hrs.reserved();
 }
 // Returns a MemRegion that corresponds to the space that has been
 // committed in the heap
 MemRegion g1_committed() {
-return _g1_committed;
+return _hrs.committed();
 }
 virtual bool is_in_closed_subset(const void* p) const;
 G1SATBCardTableModRefBS* g1_barrier_set() {
 inline HeapRegion* region_at(uint index) const;
 // Calculate the region index of the given address. Given address must be
 // within the heap.
 inline uint addr_to_region(HeapWord* addr) const;
+inline HeapWord* bottom_addr_for_region(uint index) const;
 // Divide the heap region sequence into "chunks" of some size (the number
 // of regions divided by the number of parallel threads times some
 // overpartition factor, currently 4).  Assumes that this will be called
 // in parallel by ParallelGCThreads worker threads with discinct worker
 // attempting to claim the first region in each chunk, and, if
 // successful, applying the closure to each region in the chunk (and
 // setting the claim value of the second and subsequent regions of the
 // chunk.)  For now requires that "doHeapRegion" always returns "false",
 // i.e., that a closure never attempt to abort a traversal.
-void heap_region_par_iterate_chunked(HeapRegionClosure* blk,
+void heap_region_par_iterate_chunked(HeapRegionClosure* cl,
-uint worker,
+uint worker_id,
-uint no_of_par_workers,
+uint num_workers,
-jint claim_value);
+jint claim_value) const;
 // It resets all the region claim values to the default.
 void reset_heap_region_claim_values();
 // Resets the claim values of regions in the current
 void clear_cset_start_regions();
 // Given the id of a worker, obtain or calculate a suitable
 // starting region for iterating over the current collection set.
 HeapRegion* start_cset_region_for_worker(uint worker_i);
-// This is a convenience method that is used by the
-// HeapRegionIterator classes to calculate the starting region for
-// each worker so that they do not all start from the same region.
-HeapRegion* start_region_for_worker(uint worker_i, uint no_of_par_workers);
 // Iterate over the regions (if any) in the current collection set.
 void collection_set_iterate(HeapRegionClosure* blk);
 // As above but starting from region r

Mercurial > hg > truffle

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