graal-jvmci-8: src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 20404:227a9e5e4b4a

8057536: Refactor G1 to allow context specific allocations Summary: Splitting out a g1 allocator class to simply specialized allocators which can associate each allocation with a given context. Reviewed-by: mgerdin, brutisso

author	sjohanss
date	Fri, 05 Sep 2014 09:49:19 +0200
parents	a8ea2f110d87
children	d35872270666

comparison

equal deleted inserted replaced

-:8ec8971f511a
+:227a9e5e4b4a
 */
 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
+#include "gc_implementation/g1/g1AllocationContext.hpp"
+#include "gc_implementation/g1/g1Allocator.hpp"
 #include "gc_implementation/g1/concurrentMark.hpp"
 #include "gc_implementation/g1/evacuationInfo.hpp"
 #include "gc_implementation/g1/g1AllocRegion.hpp"
 #include "gc_implementation/g1/g1BiasedArray.hpp"
 #include "gc_implementation/g1/g1HRPrinter.hpp"
 typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
 typedef int RegionIdx_t;   // needs to hold [ 0..max_regions() )
 typedef int CardIdx_t;     // needs to hold [ 0..CardsPerRegion )
-enum GCAllocPurpose {
-GCAllocForTenured,
-GCAllocForSurvived,
-GCAllocPurposeCount
-};
 class YoungList : public CHeapObj<mtGC> {
 private:
 G1CollectedHeap* _g1h;
 HeapRegion* _head;
 // debugging
 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 SurvivorGCAllocRegion : 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:
-SurvivorGCAllocRegion()
-: G1AllocRegion("Survivor GC Alloc Region", false /* bot_updates */) { }
-};
-class OldGCAllocRegion : 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:
-OldGCAllocRegion()
-: G1AllocRegion("Old GC Alloc Region", true /* bot_updates */) { }
-// This specialization of release() makes sure that the last card that has been
-// allocated into has been completely filled by a dummy object.
-// This avoids races when remembered set scanning wants to update the BOT of the
-// last card in the retained old gc alloc region, and allocation threads
-// allocating into that card at the same time.
-virtual HeapRegion* release();
 };
 // The G1 STW is alive closure.
 // An instance is embedded into the G1CH and used as the
 // (optional) _is_alive_non_header closure in the STW
 friend class VM_G1IncCollectionPause;
 friend class VMStructs;
 friend class MutatorAllocRegion;
 friend class SurvivorGCAllocRegion;
 friend class OldGCAllocRegion;
+friend class G1Allocator;
+friend class G1DefaultAllocator;
+friend class G1ResManAllocator;
 // Closures used in implementation.
 template <G1Barrier barrier, G1Mark do_mark_object>
 friend class G1ParCopyClosure;
 friend class G1IsAliveClosure;
 friend class G1EvacuateFollowersClosure;
 friend class G1ParScanThreadState;
 friend class G1ParScanClosureSuper;
 friend class G1ParEvacuateFollowersClosure;
 friend class G1ParTask;
+friend class G1ParGCAllocator;
+friend class G1DefaultParGCAllocator;
 friend class G1FreeGarbageRegionClosure;
 friend class RefineCardTableEntryClosure;
 friend class G1PrepareCompactClosure;
 friend class RegionSorter;
 friend class RegionResetter;
 G1RegionMappingChangedListener _listener;
 // The sequence of all heap regions in the heap.
 HeapRegionManager _hrm;
-// Alloc region used to satisfy mutator allocation requests.
+// Class that handles the different kinds of allocations.
-MutatorAllocRegion _mutator_alloc_region;
+G1Allocator* _allocator;
-// Alloc region used to satisfy allocation requests by the GC for
-// survivor objects.
-SurvivorGCAllocRegion _survivor_gc_alloc_region;
 // PLAB sizing policy for survivors.
 PLABStats _survivor_plab_stats;
-// Alloc region used to satisfy allocation requests by the GC for
-// old objects.
-OldGCAllocRegion _old_gc_alloc_region;
 // PLAB sizing policy for tenured objects.
 PLABStats _old_plab_stats;
-PLABStats* stats_for_purpose(GCAllocPurpose purpose) {
-PLABStats* stats = NULL;
-switch (purpose) {
-case GCAllocForSurvived:
-stats = &_survivor_plab_stats;
-break;
-case GCAllocForTenured:
-stats = &_old_plab_stats;
-break;
-default:
-assert(false, "unrecognized GCAllocPurpose");
-}
-return stats;
-}
-// The last old region we allocated to during the last GC.
-// Typically, it is not full so we should re-use it during the next GC.
-HeapRegion* _retained_old_gc_alloc_region;
 // It specifies whether we should attempt to expand the heap after a
 // region allocation failure. If heap expansion fails we set this to
 // false so that we don't re-attempt the heap expansion (it's likely
 // that subsequent expansion attempts will also fail if one fails).
 void release_mutator_alloc_region();
 // It initializes the GC alloc regions at the start of a GC.
 void init_gc_alloc_regions(EvacuationInfo& evacuation_info);
-// Setup the retained old gc alloc region as the currrent old gc alloc region.
-void use_retained_old_gc_alloc_region(EvacuationInfo& evacuation_info);
 // It releases the GC alloc regions at the end of a GC.
 void release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info);
 // It does any cleanup that needs to be done on the GC alloc regions
 // before a Full GC.
 void abandon_gc_alloc_regions();
 // Helper for monitoring and management support.
 G1MonitoringSupport* _g1mm;
-// Determines PLAB size for a particular allocation purpose.
-size_t desired_plab_sz(GCAllocPurpose purpose);
-// Outside of GC pauses, the number of bytes used in all regions other
-// than the current allocation region.
-size_t _summary_bytes_used;
 // Records whether the region at the given index is kept live by roots or
 // references from the young generation.
 class HumongousIsLiveBiasedMappedArray : public G1BiasedMappedArray<bool> {
 protected:
 // 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,
 uint num_regions,
-size_t word_size);
+size_t word_size,
+AllocationContext_t context);
 // Attempt to allocate a humongous object of the given size. Return
 // NULL if unsuccessful.
-HeapWord* humongous_obj_allocate(size_t word_size);
+HeapWord* humongous_obj_allocate(size_t word_size, AllocationContext_t context);
 // 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:
 // Second-level mutator allocation attempt: take the Heap_lock and
 // retry the allocation attempt, potentially scheduling a GC
 // pause. This should only be used for non-humongous allocations.
 HeapWord* attempt_allocation_slow(size_t word_size,
+AllocationContext_t context,
 unsigned int* gc_count_before_ret,
 int* gclocker_retry_count_ret);
 // Takes the Heap_lock and attempts a humongous allocation. It can
 // potentially schedule a GC pause.
 // Allocation attempt that should be called during safepoints (e.g.,
 // at the end of a successful GC). expect_null_mutator_alloc_region
 // specifies whether the mutator alloc region is expected to be NULL
 // or not.
 HeapWord* attempt_allocation_at_safepoint(size_t word_size,
-bool expect_null_mutator_alloc_region);
+AllocationContext_t context,
+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.
 // Allocate blocks during garbage collection. Will ensure an
 // allocation region, either by picking one or expanding the
 // heap, and then allocate a block of the given size. The block
 // may not be a humongous - it must fit into a single heap region.
-HeapWord* par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size);
+HeapWord* par_allocate_during_gc(GCAllocPurpose purpose,
+size_t word_size,
+AllocationContext_t context);
 HeapWord* allocate_during_gc_slow(GCAllocPurpose purpose,
 HeapRegion*    alloc_region,
 bool           par,
 size_t         word_size);
 // Ensure that no further allocations can happen in "r", bearing in mind
 // that parallel threads might be attempting allocations.
 void par_allocate_remaining_space(HeapRegion* r);
 // Allocation attempt during GC for a survivor object / PLAB.
-inline HeapWord* survivor_attempt_allocation(size_t word_size);
+inline HeapWord* survivor_attempt_allocation(size_t word_size,
+AllocationContext_t context);
 // Allocation attempt during GC for an old object / PLAB.
-inline HeapWord* old_attempt_allocation(size_t word_size);
+inline HeapWord* old_attempt_allocation(size_t word_size,
+AllocationContext_t context);
 // These methods are the "callbacks" from the G1AllocRegion class.
 // For mutator alloc regions.
 HeapRegion* new_mutator_alloc_region(size_t word_size, bool force);
 void resize_if_necessary_after_full_collection(size_t word_size);
 // Callback from VM_G1CollectForAllocation operation.
 // This function does everything necessary/possible to satisfy a
 // failed allocation request (including collection, expansion, etc.)
-HeapWord* satisfy_failed_allocation(size_t word_size, bool* succeeded);
+HeapWord* satisfy_failed_allocation(size_t word_size,
+AllocationContext_t context,
+bool* succeeded);
 // Attempting to expand the heap sufficiently
 // to support an allocation of the given "word_size".  If
 // successful, perform the allocation and return the address of the
 // allocated block, or else "NULL".
-HeapWord* expand_and_allocate(size_t word_size);
+HeapWord* expand_and_allocate(size_t word_size, AllocationContext_t context);
 // Process any reference objects discovered during
 // an incremental evacuation pause.
 void process_discovered_references(uint no_of_gc_workers);
 // Expand the garbage-first heap by at least the given size (in bytes!).
 // Returns true if the heap was expanded by the requested amount;
 // false otherwise.
 // (Rounds up to a HeapRegion boundary.)
 bool expand(size_t expand_bytes);
+// Returns the PLAB statistics given a purpose.
+PLABStats* stats_for_purpose(GCAllocPurpose purpose) {
+PLABStats* stats = NULL;
+switch (purpose) {
+case GCAllocForSurvived:
+stats = &_survivor_plab_stats;
+break;
+case GCAllocForTenured:
+stats = &_old_plab_stats;
+break;
+default:
+assert(false, "unrecognized GCAllocPurpose");
+}
+return stats;
+}
+// Determines PLAB size for a particular allocation purpose.
+size_t desired_plab_sz(GCAllocPurpose purpose);
 // Do anything common to GC's.
 virtual void gc_prologue(bool full);
 virtual void gc_epilogue(bool full);
 void wait_while_free_regions_coming();
 // Determine whether the given region is one that we are using as an
 // old GC alloc region.
 bool is_old_gc_alloc_region(HeapRegion* hr) {
-return hr == _retained_old_gc_alloc_region;
+return _allocator->is_retained_old_region(hr);
 }
 // Perform a collection of the heap; intended for use in implementing
 // "System.gc".  This probably implies as full a collection as the
 // "CollectedHeap" supports.
 protected:
 size_t _max_heap_capacity;
 };
-class G1ParGCAllocBuffer: public ParGCAllocBuffer {
-private:
-bool        _retired;
-public:
-G1ParGCAllocBuffer(size_t gclab_word_size);
-virtual ~G1ParGCAllocBuffer() {
-guarantee(_retired, "Allocation buffer has not been retired");
-}
-virtual void set_buf(HeapWord* buf) {
-ParGCAllocBuffer::set_buf(buf);
-_retired = false;
-}
-virtual void retire(bool end_of_gc, bool retain) {
-if (_retired) {
-return;
-}
-ParGCAllocBuffer::retire(end_of_gc, retain);
-_retired = true;
-}
-};
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 20404:227a9e5e4b4a