jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp

-:ed80554efa25
+:8aae2050e83e
 // The secondary free list which contains regions that have been
 // freed up during the cleanup process. This will be appended to the
 // master free list when appropriate.
 SecondaryFreeRegionList   _secondary_free_list;
+// It keeps track of the old regions.
+MasterOldRegionSet        _old_set;
 // It keeps track of the humongous regions.
 MasterHumongousRegionSet  _humongous_set;
 // The number of regions we could create by expansion.
 size_t _expansion_regions;
 // The block offset table for the G1 heap.
 G1BlockOffsetSharedArray* _bot_shared;
-// Move all of the regions off the free lists, then rebuild those free
+// Tears down the region sets / lists so that they are empty and the
-// lists, before and after full GC.
+// regions on the heap do not belong to a region set / list. The
-void tear_down_region_lists();
+// only exception is the humongous set which we leave unaltered. If
-void rebuild_region_lists();
+// free_list_only is true, it will only tear down the master free
+// list. It is called before a Full GC (free_list_only == false) or
+// before heap shrinking (free_list_only == true).
+void tear_down_region_sets(bool free_list_only);
+// Rebuilds the region sets / lists so that they are repopulated to
+// reflect the contents of the heap. The only exception is the
+// humongous set which was not torn down in the first place. If
+// free_list_only is true, it will only rebuild the master free
+// list. It is called after a Full GC (free_list_only == false) or
+// after heap shrinking (free_list_only == true).
+void rebuild_region_sets(bool free_list_only);
 // The sequence of all heap regions in the heap.
 HeapRegionSeq _hrs;
 // Alloc region used to satisfy mutator allocation requests.
 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
 append_secondary_free_list();
 }
 }
+void old_set_remove(HeapRegion* hr) {
+_old_set.remove(hr);
+}
 void set_free_regions_coming();
 void reset_free_regions_coming();
 bool free_regions_coming() { return _free_regions_coming; }
 void wait_while_free_regions_coming();
 // free_humongous_region() depending on the type of the region that
 // is passed to it.
 void free_region_if_empty(HeapRegion* hr,
 size_t* pre_used,
 FreeRegionList* free_list,
+OldRegionSet* old_proxy_set,
 HumongousRegionSet* humongous_proxy_set,
 HRRSCleanupTask* hrrs_cleanup_task,
 bool par);
 // It appends the free list to the master free list and updates the
 // master humongous list according to the contents of the proxy
 // list. It also adjusts the total used bytes according to pre_used
 // (if par is true, it will do so by taking the ParGCRareEvent_lock).
 void update_sets_after_freeing_regions(size_t pre_used,
 FreeRegionList* free_list,
+OldRegionSet* old_proxy_set,
 HumongousRegionSet* humongous_proxy_set,
 bool par);
 // Returns "TRUE" iff "p" points into the allocated area of the heap.
 virtual bool is_in(const void* p) const;
 // Convenience function to be used in situations where the heap type can be
 // asserted to be this type.
 static G1CollectedHeap* heap();
-void empty_young_list();
 void set_region_short_lived_locked(HeapRegion* hr);
 // add appropriate methods for any other surv rate groups
 YoungList* young_list() { return _young_list; }

Mercurial > jdk8-mips64-public > hotspot / file comparison

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

src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp