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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 2152:0fa27f37d4d4

6977804: G1: remove the zero-filling thread Summary: This changeset removes the zero-filling thread from G1 and collapses the two free region lists we had before (the "free" and "unclean" lists) into one. The new free list uses the new heap region sets / lists abstractions that we'll ultimately use it to keep track of all regions in the heap. A heap region set was also introduced for the humongous regions. Finally, this change increases the concurrency between the thread that completes freeing regions (after a cleanup pause) and the rest of the system (before we'd have to wait for said thread to complete before allocating a new region). The changest also includes a lot of refactoring and code simplification. Reviewed-by: jcoomes, johnc

author	tonyp
date	Wed, 19 Jan 2011 19:30:42 -0500
parents	b158bed62ef5
children	97ba643ea3ed

comparison

equal deleted inserted replaced

-:cb913d743d09
+:0fa27f37d4d4
 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
 #include "gc_implementation/g1/concurrentMark.hpp"
 #include "gc_implementation/g1/g1RemSet.hpp"
-#include "gc_implementation/g1/heapRegion.hpp"
+#include "gc_implementation/g1/heapRegionSets.hpp"
 #include "gc_implementation/parNew/parGCAllocBuffer.hpp"
 #include "memory/barrierSet.hpp"
 #include "memory/memRegion.hpp"
 #include "memory/sharedHeap.hpp"
 typedef int CardIdx_t;     // needs to hold [ 0..CardsPerRegion )
 enum G1GCThreadGroups {
 G1CRGroup = 0,
 G1ZFGroup = 1,
-G1CMGroup = 2,
+G1CMGroup = 2
-G1CLGroup = 3
 };
 enum GCAllocPurpose {
 GCAllocForTenured,
 GCAllocForSurvived,
 friend class G1ParTask;
 friend class G1FreeGarbageRegionClosure;
 friend class RefineCardTableEntryClosure;
 friend class G1PrepareCompactClosure;
 friend class RegionSorter;
+friend class RegionResetter;
 friend class CountRCClosure;
 friend class EvacPopObjClosure;
 friend class G1ParCleanupCTTask;
 // Other related classes.
 MemRegion _g1_committed;
 // The maximum part of _g1_storage that has ever been committed.
 MemRegion _g1_max_committed;
-// The number of regions that are completely free.
+// The master free list. It will satisfy all new region allocations.
-size_t _free_regions;
+MasterFreeRegionList      _free_list;
+// 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 humongous regions.
+MasterHumongousRegionSet  _humongous_set;
 // The number of regions we could create by expansion.
 size_t _expansion_regions;
-// Return the number of free regions in the heap (by direct counting.)
-size_t count_free_regions();
-// Return the number of free regions on the free and unclean lists.
-size_t count_free_regions_list();
 // The block offset table for the G1 heap.
 G1BlockOffsetSharedArray* _bot_shared;
 // Move all of the regions off the free lists, then rebuild those free
 // lists, before and after full GC.
 void tear_down_region_lists();
 void rebuild_region_lists();
-// This sets all non-empty regions to need zero-fill (which they will if
-// they are empty after full collection.)
-void set_used_regions_to_need_zero_fill();
 // The sequence of all heap regions in the heap.
 HeapRegionSeq* _hrs;
 // The region from which normal-sized objects are currently being
 HeapRegion* _gc_alloc_region_list;
 // Determines PLAB size for a particular allocation purpose.
 static size_t desired_plab_sz(GCAllocPurpose purpose);
-// When called by par thread, require par_alloc_during_gc_lock() to be held.
+// When called by par thread, requires the FreeList_lock to be held.
 void push_gc_alloc_region(HeapRegion* hr);
 // This should only be called single-threaded.  Undeclares all GC alloc
 // regions.
 void forget_alloc_region_list();
 // These are macros so that, if the assert fires, we get the correct
 // line number, file, etc.
 #define heap_locking_asserts_err_msg(__extra_message)                         \
-err_msg("%s : Heap_lock %slocked, %sat a safepoint",                        \
+err_msg("%s : Heap_lock locked: %s, at safepoint: %s, is VM thread: %s",    \
 (__extra_message),                                                  \
-(!Heap_lock->owned_by_self()) ? "NOT " : "",                        \
+BOOL_TO_STR(Heap_lock->owned_by_self()),                            \
-(!SafepointSynchronize::is_at_safepoint()) ? "NOT " : "")
+BOOL_TO_STR(SafepointSynchronize::is_at_safepoint()),               \
+BOOL_TO_STR(Thread::current()->is_VM_thread()))
 #define assert_heap_locked()                                                  \
 do {                                                                        \
 assert(Heap_lock->owned_by_self(),                                        \
 heap_locking_asserts_err_msg("should be holding the Heap_lock"));  \
 } while (0)
-#define assert_heap_locked_or_at_safepoint()                                  \
+#define assert_heap_locked_or_at_safepoint(__should_be_vm_thread)             \
 do {                                                                        \
 assert(Heap_lock->owned_by_self() ||                                      \
-SafepointSynchronize::is_at_safepoint(), \
+(SafepointSynchronize::is_at_safepoint() &&                        \
+((__should_be_vm_thread) == Thread::current()->is_VM_thread())), \
 heap_locking_asserts_err_msg("should be holding the Heap_lock or " \
 "should be at a safepoint"));         \
 } while (0)
 #define assert_heap_locked_and_not_at_safepoint()                             \
 !SafepointSynchronize::is_at_safepoint(), \
 heap_locking_asserts_err_msg("should not be holding the Heap_lock and " \
 "should not be at a safepoint"));          \
 } while (0)
-#define assert_at_safepoint()                                                 \
+#define assert_at_safepoint(__should_be_vm_thread)                            \
 do {                                                                        \
-assert(SafepointSynchronize::is_at_safepoint(),                           \
+assert(SafepointSynchronize::is_at_safepoint() &&                         \
+((__should_be_vm_thread) == Thread::current()->is_VM_thread()), \
 heap_locking_asserts_err_msg("should be at a safepoint"));         \
 } while (0)
 #define assert_not_at_safepoint()                                             \
 do {                                                                        \
 YoungList*  _young_list;
 // The current policy object for the collector.
 G1CollectorPolicy* _g1_policy;
-// Parallel allocation lock to protect the current allocation region.
+// This is the second level of trying to allocate a new region. If
-Mutex  _par_alloc_during_gc_lock;
+// new_region_work didn't find a region in the free_list, this call
-Mutex* par_alloc_during_gc_lock() { return &_par_alloc_during_gc_lock; }
+// will check whether there's anything available in the
+// secondary_free_list and/or wait for more regions to appear in that
-// If possible/desirable, allocate a new HeapRegion for normal object
+// list, if _free_regions_coming is set.
-// allocation sufficient for an allocation of the given "word_size".
+HeapRegion* new_region_try_secondary_free_list(size_t word_size);
-// If "do_expand" is true, will attempt to expand the heap if necessary
-// to to satisfy the request.  If "zero_filled" is true, requires a
+// It will try to allocate a single non-humongous HeapRegion
-// zero-filled region.
+// sufficient for an allocation of the given word_size.  If
-// (Returning NULL will trigger a GC.)
+// do_expand is true, it will attempt to expand the heap if
-virtual HeapRegion* newAllocRegion_work(size_t word_size,
+// necessary to satisfy the allocation request. Note that word_size
-bool do_expand,
+// is only used to make sure that we expand sufficiently but, given
-bool zero_filled);
+// that the allocation request is assumed not to be humongous,
+// having word_size is not strictly necessary (expanding by a single
-virtual HeapRegion* newAllocRegion(size_t word_size,
+// region will always be sufficient). But let's keep that parameter
-bool zero_filled = true) {
+// in case we need it in the future.
-return newAllocRegion_work(word_size, false, zero_filled);
+HeapRegion* new_region_work(size_t word_size, bool do_expand);
-}
-virtual HeapRegion* newAllocRegionWithExpansion(int purpose,
+// It will try to allocate a new region to be used for allocation by
-size_t word_size,
+// mutator threads. It will not try to expand the heap if not region
-bool zero_filled = true);
+// is available.
+HeapRegion* new_alloc_region(size_t word_size) {
+return new_region_work(word_size, false /* do_expand */);
+}
+// It will try to allocate a new region to be used for allocation by
+// a GC thread. It will try to expand the heap if no region is
+// available.
+HeapRegion* new_gc_alloc_region(int purpose, size_t word_size);
+int humongous_obj_allocate_find_first(size_t num_regions, size_t word_size);
 // Attempt to allocate an object of the given (very large) "word_size".
 // Returns "NULL" on failure.
-virtual HeapWord* humongous_obj_allocate(size_t word_size);
+HeapWord* humongous_obj_allocate(size_t word_size);
 // The following two methods, allocate_new_tlab() and
 // mem_allocate(), are the two main entry points from the runtime
 // into the G1's allocation routines. They have the following
 // assumptions:
 OopClosure* non_root_closure);
 // Invoke "save_marks" on all heap regions.
 void save_marks();
-// Free a heap region.
+// It frees a non-humongous region by initializing its contents and
-void free_region(HeapRegion* hr);
+// adding it to the free list that's passed as a parameter (this is
-// A component of "free_region", exposed for 'batching'.
+// usually a local list which will be appended to the master free
-// All the params after "hr" are out params: the used bytes of the freed
+// list later). The used bytes of freed regions are accumulated in
-// region(s), the number of H regions cleared, the number of regions
+// pre_used. If par is true, the region's RSet will not be freed
-// freed, and pointers to the head and tail of a list of freed contig
+// up. The assumption is that this will be done later.
-// regions, linked throught the "next_on_unclean_list" field.
+void free_region(HeapRegion* hr,
-void free_region_work(HeapRegion* hr,
+size_t* pre_used,
-size_t& pre_used,
+FreeRegionList* free_list,
-size_t& cleared_h,
+bool par);
-size_t& freed_regions,
-UncleanRegionList* list,
+// It frees a humongous region by collapsing it into individual
-bool par = false);
+// regions and calling free_region() for each of them. The freed
+// regions will be added to the free list that's passed as a parameter
+// (this is usually a local list which will be appended to the
+// master free list later). The used bytes of freed regions are
+// accumulated in pre_used. If par is true, the region's RSet will
+// not be freed up. The assumption is that this will be done later.
+void free_humongous_region(HeapRegion* hr,
+size_t* pre_used,
+FreeRegionList* free_list,
+HumongousRegionSet* humongous_proxy_set,
+bool par);
 // The concurrent marker (and the thread it runs in.)
 ConcurrentMark* _cm;
 ConcurrentMarkThread* _cmThread;
 bool _mark_in_progress;
 // The concurrent refiner.
 ConcurrentG1Refine* _cg1r;
-// The concurrent zero-fill thread.
-ConcurrentZFThread* _czft;
 // The parallel task queues
 RefToScanQueueSet *_task_queues;
 // True iff a evacuation has failed in the current collection.
 G1H_PS_NumElements
 };
 SubTasksDone* _process_strong_tasks;
-// List of regions which require zero filling.
+volatile bool _free_regions_coming;
-UncleanRegionList _unclean_region_list;
-bool _unclean_regions_coming;
 public:
 SubTasksDone* process_strong_tasks() { return _process_strong_tasks; }
 // The number of regions that are completely free.
 size_t max_regions();
 // The number of regions that are completely free.
-size_t free_regions();
+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(); }
-// True iff the ZF thread should run.
-bool should_zf();
 // The number of regions available for "regular" expansion.
 size_t expansion_regions() { return _expansion_regions; }
-#ifndef PRODUCT
+// verify_region_sets() performs verification over the region
-bool regions_accounted_for();
+// lists. It will be compiled in the product code to be used when
-bool print_region_accounting_info();
+// necessary (i.e., during heap verification).
-void print_region_counts();
+void verify_region_sets();
-#endif
+// verify_region_sets_optional() is planted in the code for
-HeapRegion* alloc_region_from_unclean_list(bool zero_filled);
+// list verification in non-product builds (and it can be enabled in
-HeapRegion* alloc_region_from_unclean_list_locked(bool zero_filled);
+// product builds by definning HEAP_REGION_SET_FORCE_VERIFY to be 1).
+#if HEAP_REGION_SET_FORCE_VERIFY
-void put_region_on_unclean_list(HeapRegion* r);
+void verify_region_sets_optional() {
-void put_region_on_unclean_list_locked(HeapRegion* r);
+verify_region_sets();
+}
-void prepend_region_list_on_unclean_list(UncleanRegionList* list);
+#else // HEAP_REGION_SET_FORCE_VERIFY
-void prepend_region_list_on_unclean_list_locked(UncleanRegionList* list);
+void verify_region_sets_optional() { }
+#endif // HEAP_REGION_SET_FORCE_VERIFY
-void set_unclean_regions_coming(bool b);
-void set_unclean_regions_coming_locked(bool b);
+#ifdef ASSERT
-// Wait for cleanup to be complete.
+bool is_on_free_list(HeapRegion* hr) {
-void wait_for_cleanup_complete();
+return hr->containing_set() == &_free_list;
-// Like above, but assumes that the calling thread owns the Heap_lock.
+}
-void wait_for_cleanup_complete_locked();
+bool is_on_humongous_set(HeapRegion* hr) {
-// Return the head of the unclean list.
+return hr->containing_set() == &_humongous_set;
-HeapRegion* peek_unclean_region_list_locked();
+}
-// Remove and return the head of the unclean list.
+#endif // ASSERT
-HeapRegion* pop_unclean_region_list_locked();
+// Wrapper for the region list operations that can be called from
-// List of regions which are zero filled and ready for allocation.
+// methods outside this class.
-HeapRegion* _free_region_list;
-// Number of elements on the free list.
+void secondary_free_list_add_as_tail(FreeRegionList* list) {
-size_t _free_region_list_size;
+_secondary_free_list.add_as_tail(list);
+}
-// If the head of the unclean list is ZeroFilled, move it to the free
-// list.
+void append_secondary_free_list() {
-bool move_cleaned_region_to_free_list_locked();
+_free_list.add_as_tail(&_secondary_free_list);
-bool move_cleaned_region_to_free_list();
+}
-void put_free_region_on_list_locked(HeapRegion* r);
+void append_secondary_free_list_if_not_empty() {
-void put_free_region_on_list(HeapRegion* r);
+if (!_secondary_free_list.is_empty()) {
+MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
-// Remove and return the head element of the free list.
+append_secondary_free_list();
-HeapRegion* pop_free_region_list_locked();
+}
+}
-// If "zero_filled" is true, we first try the free list, then we try the
-// unclean list, zero-filling the result.  If "zero_filled" is false, we
+void set_free_regions_coming();
-// first try the unclean list, then the zero-filled list.
+void reset_free_regions_coming();
-HeapRegion* alloc_free_region_from_lists(bool zero_filled);
+bool free_regions_coming() { return _free_regions_coming; }
+void wait_while_free_regions_coming();
-// Verify the integrity of the region lists.
-void remove_allocated_regions_from_lists();
-bool verify_region_lists();
-bool verify_region_lists_locked();
-size_t unclean_region_list_length();
-size_t free_region_list_length();
 // Perform a collection of the heap; intended for use in implementing
 // "System.gc".  This probably implies as full a collection as the
 // "CollectedHeap" supports.
 virtual void collect(GCCause::Cause cause);
 virtual void collect_as_vm_thread(GCCause::Cause cause);
 // True iff a evacuation has failed in the most-recent collection.
 bool evacuation_failed() { return _evacuation_failed; }
-// Free a region if it is totally full of garbage.  Returns the number of
+// It will free a region if it has allocated objects in it that are
-// bytes freed (0 ==> didn't free it).
+// all dead. It calls either free_region() or
-size_t free_region_if_totally_empty(HeapRegion *hr);
+// free_humongous_region() depending on the type of the region that
-void free_region_if_totally_empty_work(HeapRegion *hr,
+// is passed to it.
-size_t& pre_used,
+void free_region_if_totally_empty(HeapRegion* hr,
-size_t& cleared_h_regions,
+size_t* pre_used,
-size_t& freed_regions,
+FreeRegionList* free_list,
-UncleanRegionList* list,
+HumongousRegionSet* humongous_proxy_set,
-bool par = false);
+bool par);
-// If we've done free region work that yields the given changes, update
+// It appends the free list to the master free list and updates the
-// the relevant global variables.
+// master humongous list according to the contents of the proxy
-void finish_free_region_work(size_t pre_used,
+// list. It also adjusts the total used bytes according to pre_used
-size_t cleared_h_regions,
+// (if par is true, it will do so by taking the ParGCRareEvent_lock).
-size_t freed_regions,
+void update_sets_after_freeing_regions(size_t pre_used,
-UncleanRegionList* list);
+FreeRegionList* free_list,
+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;
 // Return "TRUE" iff the given object address is within the collection
 // At least until perm gen collection is also G1-ified, at
 // which point this should return false.
 return true;
 }
-virtual bool allocs_are_zero_filled();
 // The boundary between a "large" and "small" array of primitives, in
 // words.
 virtual size_t large_typearray_limit();
 // Returns "true" iff the given word_size is "very large".
 // </NEW PREDICTION>
 protected:
 size_t _max_heap_capacity;
-public:
-// Temporary: call to mark things unimplemented for the G1 heap (e.g.,
-// MemoryService).  In productization, we can make this assert false
-// to catch such places (as well as searching for calls to this...)
-static void g1_unimplemented();
 };
 #define use_local_bitmaps         1
 #define verify_local_bitmaps      0
 #define oop_buffer_length       256

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 2152:0fa27f37d4d4