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

-:455328d90876
+:abdfc822206f
 #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/g1AllocRegion.hpp"
 #include "gc_implementation/g1/g1RemSet.hpp"
 #include "gc_implementation/g1/heapRegionSets.hpp"
 #include "gc_implementation/parNew/parGCAllocBuffer.hpp"
 #include "memory/barrierSet.hpp"
 #include "memory/memRegion.hpp"
 bool          check_list_well_formed();
 bool          check_list_empty(bool check_sample = true);
 void          print();
 };
+class MutatorAllocRegion : public G1AllocRegion {
+protected:
+virtual HeapRegion* allocate_new_region(size_t word_size, bool force);
+virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes);
+public:
+MutatorAllocRegion()
+: G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { }
+};
 class RefineCardTableEntryClosure;
 class G1CollectedHeap : public SharedHeap {
 friend class VM_G1CollectForAllocation;
 friend class VM_GenCollectForPermanentAllocation;
 friend class VM_G1CollectFull;
 friend class VM_G1IncCollectionPause;
 friend class VMStructs;
+friend class MutatorAllocRegion;
 // Closures used in implementation.
 friend class G1ParCopyHelper;
 friend class G1IsAliveClosure;
 friend class G1EvacuateFollowersClosure;
 void rebuild_region_lists();
 // The sequence of all heap regions in the heap.
 HeapRegionSeq* _hrs;
-// The region from which normal-sized objects are currently being
+// Alloc region used to satisfy mutator allocation requests.
-// allocated.  May be NULL.
+MutatorAllocRegion _mutator_alloc_region;
-HeapRegion* _cur_alloc_region;
+// It resets the mutator alloc region before new allocations can take place.
-// Postcondition: cur_alloc_region == NULL.
+void init_mutator_alloc_region();
-void abandon_cur_alloc_region();
+// It releases the mutator alloc region.
+void release_mutator_alloc_region();
 void abandon_gc_alloc_regions();
 // The to-space memory regions into which objects are being copied during
 // a GC.
 HeapRegion* _gc_alloc_regions[GCAllocPurposeCount];
 // The current policy object for the collector.
 G1CollectorPolicy* _g1_policy;
 // This is the second level of trying to allocate a new region. If
-// new_region_work didn't find a region in the free_list, this call
+// new_region() didn't find a region on the free_list, this call will
-// will check whether there's anything available in the
+// check whether there's anything available on the
-// secondary_free_list and/or wait for more regions to appear in that
+// secondary_free_list and/or wait for more regions to appear on
-// list, if _free_regions_coming is set.
+// that list, if _free_regions_coming is set.
 HeapRegion* new_region_try_secondary_free_list();
 // Try to allocate a single non-humongous HeapRegion sufficient for
 // an allocation of the given word_size. If do_expand is true,
 // attempt to expand the heap if necessary to satisfy the allocation
 // request.
-HeapRegion* new_region_work(size_t word_size, bool do_expand);
+HeapRegion* new_region(size_t word_size, bool do_expand);
-// Try to allocate a new region to be used for allocation by a
+// Try to allocate a new region to be used for allocation by
-// mutator thread. Attempt to expand the heap if no region is
+// a GC thread. It will try to expand the heap if no region is
 // available.
-HeapRegion* new_alloc_region(size_t word_size) {
-return new_region_work(word_size, false /* do_expand */);
-}
-// Try to allocate a new region to be used for allocation by a GC
-// thread. Attempt to expand the heap if no region is available.
 HeapRegion* new_gc_alloc_region(int purpose, size_t word_size);
 // 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
 //   allocate_new_tlab().
 //
 // * All non-TLAB allocation requests should go to mem_allocate()
 //   and mem_allocate() should never be called with is_tlab == true.
 //
-// * If the GC locker is active we currently stall until we can
-//   allocate a new young region. This will be changed in the
-//   near future (see CR 6994056).
-//
 // * If either call cannot satisfy the allocation request using the
 //   current allocating region, they will try to get a new one. If
 //   this fails, they will attempt to do an evacuation pause and
 //   retry the allocation.
 //
 virtual HeapWord* mem_allocate(size_t word_size,
 bool   is_noref,
 bool   is_tlab, /* expected to be false */
 bool*  gc_overhead_limit_was_exceeded);
-// The following methods, allocate_from_cur_allocation_region(),
+// The following three methods take a gc_count_before_ret
-// attempt_allocation(), attempt_allocation_locked(),
+// parameter which is used to return the GC count if the method
-// replace_cur_alloc_region_and_allocate(),
+// returns NULL. Given that we are required to read the GC count
-// attempt_allocation_slow(), and attempt_allocation_humongous()
+// while holding the Heap_lock, and these paths will take the
-// have very awkward pre- and post-conditions with respect to
+// Heap_lock at some point, it's easier to get them to read the GC
-// locking:
+// count while holding the Heap_lock before they return NULL instead
-//
+// of the caller (namely: mem_allocate()) having to also take the
-// If they are called outside a safepoint they assume the caller
+// Heap_lock just to read the GC count.
-// holds the Heap_lock when it calls them. However, on exit they
-// will release the Heap_lock if they return a non-NULL result, but
+// First-level mutator allocation attempt: try to allocate out of
-// keep holding the Heap_lock if they return a NULL result. The
+// the mutator alloc region without taking the Heap_lock. This
-// reason for this is that we need to dirty the cards that span
+// should only be used for non-humongous allocations.
-// allocated blocks on young regions to avoid having to take the
+inline HeapWord* attempt_allocation(size_t word_size,
-// slow path of the write barrier (for performance reasons we don't
+unsigned int* gc_count_before_ret);
-// update RSets for references whose source is a young region, so we
-// don't need to look at dirty cards on young regions). But, doing
+// Second-level mutator allocation attempt: take the Heap_lock and
-// this card dirtying while holding the Heap_lock can be a
+// retry the allocation attempt, potentially scheduling a GC
-// scalability bottleneck, especially given that some allocation
+// pause. This should only be used for non-humongous allocations.
-// requests might be of non-trivial size (and the larger the region
+HeapWord* attempt_allocation_slow(size_t word_size,
-// size is, the fewer allocations requests will be considered
+unsigned int* gc_count_before_ret);
-// humongous, as the humongous size limit is a fraction of the
-// region size). So, when one of these calls succeeds in allocating
+// Takes the Heap_lock and attempts a humongous allocation. It can
-// a block it does the card dirtying after it releases the Heap_lock
+// potentially schedule a GC pause.
-// which is why it will return without holding it.
-//
-// The above assymetry is the reason why locking / unlocking is done
-// explicitly (i.e., with Heap_lock->lock() and
-// Heap_lock->unlocked()) instead of using MutexLocker and
-// MutexUnlocker objects. The latter would ensure that the lock is
-// unlocked / re-locked at every possible exit out of the basic
-// block. However, we only want that action to happen in selected
-// places.
-//
-// Further, if the above methods are called during a safepoint, then
-// naturally there's no assumption about the Heap_lock being held or
-// there's no attempt to unlock it. The parameter at_safepoint
-// indicates whether the call is made during a safepoint or not (as
-// an optimization, to avoid reading the global flag with
-// SafepointSynchronize::is_at_safepoint()).
-//
-// The methods share these parameters:
-//
-// * word_size     : the size of the allocation request in words
-// * at_safepoint  : whether the call is done at a safepoint; this
-//                   also determines whether a GC is permitted
-//                   (at_safepoint == false) or not (at_safepoint == true)
-// * do_dirtying   : whether the method should dirty the allocated
-//                   block before returning
-//
-// They all return either the address of the block, if they
-// successfully manage to allocate it, or NULL.
-// It tries to satisfy an allocation request out of the current
-// alloc region, which is passed as a parameter. It assumes that the
-// caller has checked that the current alloc region is not NULL.
-// Given that the caller has to check the current alloc region for
-// at least NULL, it might as well pass it as the first parameter so
-// that the method doesn't have to read it from the
-// _cur_alloc_region field again. It is called from both
-// attempt_allocation() and attempt_allocation_locked() and the
-// with_heap_lock parameter indicates whether the caller was holding
-// the heap lock when it called it or not.
-inline HeapWord* allocate_from_cur_alloc_region(HeapRegion* cur_alloc_region,
-size_t word_size,
-bool with_heap_lock);
-// First-level of allocation slow path: it attempts to allocate out
-// of the current alloc region in a lock-free manner using a CAS. If
-// that fails it takes the Heap_lock and calls
-// attempt_allocation_locked() for the second-level slow path.
-inline HeapWord* attempt_allocation(size_t word_size);
-// Second-level of allocation slow path: while holding the Heap_lock
-// it tries to allocate out of the current alloc region and, if that
-// fails, tries to allocate out of a new current alloc region.
-inline HeapWord* attempt_allocation_locked(size_t word_size);
-// It assumes that the current alloc region has been retired and
-// tries to allocate a new one. If it's successful, it performs the
-// allocation out of the new current alloc region and updates
-// _cur_alloc_region. Normally, it would try to allocate a new
-// region if the young gen is not full, unless can_expand is true in
-// which case it would always try to allocate a new region.
-HeapWord* replace_cur_alloc_region_and_allocate(size_t word_size,
-bool at_safepoint,
-bool do_dirtying,
-bool can_expand);
-// Third-level of allocation slow path: when we are unable to
-// allocate a new current alloc region to satisfy an allocation
-// request (i.e., when attempt_allocation_locked() fails). It will
-// try to do an evacuation pause, which might stall due to the GC
-// locker, and retry the allocation attempt when appropriate.
-HeapWord* attempt_allocation_slow(size_t word_size);
-// The method that tries to satisfy a humongous allocation
-// request. If it cannot satisfy it it will try to do an evacuation
-// pause to perhaps reclaim enough space to be able to satisfy the
-// allocation request afterwards.
 HeapWord* attempt_allocation_humongous(size_t word_size,
-bool at_safepoint);
+unsigned int* gc_count_before_ret);
-// It does the common work when we are retiring the current alloc region.
+// Allocation attempt that should be called during safepoints (e.g.,
-inline void retire_cur_alloc_region_common(HeapRegion* cur_alloc_region);
+// at the end of a successful GC). expect_null_mutator_alloc_region
+// specifies whether the mutator alloc region is expected to be NULL
-// It retires the current alloc region, which is passed as a
+// or not.
-// parameter (since, typically, the caller is already holding on to
-// it). It sets _cur_alloc_region to NULL.
-void retire_cur_alloc_region(HeapRegion* cur_alloc_region);
-// It attempts to do an allocation immediately before or after an
-// evacuation pause and can only be called by the VM thread. It has
-// slightly different assumptions that the ones before (i.e.,
-// assumes that the current alloc region has been retired).
 HeapWord* attempt_allocation_at_safepoint(size_t word_size,
-bool expect_null_cur_alloc_region);
+bool expect_null_mutator_alloc_region);
 // It dirties the cards that cover the block so that so that the post
 // write barrier never queues anything when updating objects on this
 // block. It is assumed (and in fact we assert) that the block
 // belongs to a young region.
 void par_allocate_remaining_space(HeapRegion* r);
 // Retires an allocation region when it is full or at the end of a
 // GC pause.
 void  retire_alloc_region(HeapRegion* alloc_region, bool par);
+// These two methods are the "callbacks" from the G1AllocRegion class.
+HeapRegion* new_mutator_alloc_region(size_t word_size, bool force);
+void retire_mutator_alloc_region(HeapRegion* alloc_region,
+size_t allocated_bytes);
 // - if explicit_gc is true, the GC is for a System.gc() or a heap
 //   inspection request and should collect the entire heap
 // - if clear_all_soft_refs is true, all soft references should be
 //   cleared during the GC
 // The number of regions that are not completely free.
 size_t used_regions() { return n_regions() - free_regions(); }
 // The number of regions available for "regular" expansion.
 size_t expansion_regions() { return _expansion_regions; }
+void verify_dirty_young_list(HeapRegion* head) PRODUCT_RETURN;
+void verify_dirty_young_regions() PRODUCT_RETURN;
 // verify_region_sets() performs verification over the region
 // lists. It will be compiled in the product code to be used when
 // necessary (i.e., during heap verification).
 void verify_region_sets();

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

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

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