jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp

equal deleted inserted replaced

-:ec32bf88801c
+:d00a21009f1f
 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 */) { }
+};
 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;
+friend class SurvivorGCAllocRegion;
+friend class OldGCAllocRegion;
 // Closures used in implementation.
 friend class G1ParCopyHelper;
 friend class G1IsAliveClosure;
 friend class G1EvacuateFollowersClosure;
 HeapRegionSeq _hrs;
 // Alloc region used to satisfy mutator allocation requests.
 MutatorAllocRegion _mutator_alloc_region;
+// Alloc region used to satisfy allocation requests by the GC for
+// survivor objects.
+SurvivorGCAllocRegion _survivor_gc_alloc_region;
+// Alloc region used to satisfy allocation requests by the GC for
+// old objects.
+OldGCAllocRegion _old_gc_alloc_region;
+// 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 resets the mutator alloc region before new allocations can take place.
 void init_mutator_alloc_region();
 // It releases the mutator alloc region.
 void release_mutator_alloc_region();
+// It initializes the GC alloc regions at the start of a GC.
+void init_gc_alloc_regions();
+// It releases the GC alloc regions at the end of a GC.
+void release_gc_alloc_regions();
+// It does any cleanup that needs to be done on the GC alloc regions
+// before a Full GC.
 void abandon_gc_alloc_regions();
-// The to-space memory regions into which objects are being copied during
-// a GC.
-HeapRegion* _gc_alloc_regions[GCAllocPurposeCount];
-size_t _gc_alloc_region_counts[GCAllocPurposeCount];
-// These are the regions, one per GCAllocPurpose, that are half-full
-// at the end of a collection and that we want to reuse during the
-// next collection.
-HeapRegion* _retained_gc_alloc_regions[GCAllocPurposeCount];
-// This specifies whether we will keep the last half-full region at
-// the end of a collection so that it can be reused during the next
-// collection (this is specified per GCAllocPurpose)
-bool _retain_gc_alloc_region[GCAllocPurposeCount];
-// A list of the regions that have been set to be alloc regions in the
-// current collection.
-HeapRegion* _gc_alloc_region_list;
 // Helper for monitoring and management support.
 G1MonitoringSupport* _g1mm;
 // Determines PLAB size for a particular allocation purpose.
 static size_t desired_plab_sz(GCAllocPurpose purpose);
-// 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();
-// Should be used to set an alloc region, because there's other
-// associated bookkeeping.
-void set_gc_alloc_region(int purpose, HeapRegion* r);
-// Check well-formedness of alloc region list.
-bool check_gc_alloc_regions();
 // Outside of GC pauses, the number of bytes used in all regions other
 // than the current allocation region.
 size_t _summary_bytes_used;
 heap_locking_asserts_err_msg("should not be at a safepoint"));     \
 } while (0)
 protected:
-// Returns "true" iff none of the gc alloc regions have any allocations
-// since the last call to "save_marks".
-bool all_alloc_regions_no_allocs_since_save_marks();
-// Perform finalization stuff on all allocation regions.
-void retire_all_alloc_regions();
 // The young region list.
 YoungList*  _young_list;
 // The current policy object for the collector.
 G1CollectorPolicy* _g1_policy;
 // 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(size_t word_size, bool do_expand);
-// 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);
 // 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
 // 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);
-// Retires an allocation region when it is full or at the end of a
+// Allocation attempt during GC for a survivor object / PLAB.
-// GC pause.
+inline HeapWord* survivor_attempt_allocation(size_t word_size);
-void  retire_alloc_region(HeapRegion* alloc_region, bool par);
+// Allocation attempt during GC for an old object / PLAB.
-// These two methods are the "callbacks" from the G1AllocRegion class.
+inline HeapWord* old_attempt_allocation(size_t word_size);
+// 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 retire_mutator_alloc_region(HeapRegion* alloc_region,
 size_t allocated_bytes);
+// For GC alloc regions.
+HeapRegion* new_gc_alloc_region(size_t word_size, size_t count,
+GCAllocPurpose ap);
+void retire_gc_alloc_region(HeapRegion* alloc_region,
+size_t allocated_bytes, GCAllocPurpose ap);
 // - 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
 // JNI weak roots, the code cache, system dictionary, symbol table,
 // string table, and referents of reachable weak refs.
 void g1_process_weak_roots(OopClosure* root_closure,
 OopClosure* non_root_closure);
-// Invoke "save_marks" on all heap regions.
-void save_marks();
 // Frees a non-humongous region by initializing its contents and
 // adding it 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
 // An attempt to evacuate "obj" has failed; take necessary steps.
 oop handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, oop obj);
 void handle_evacuation_failure_common(oop obj, markOop m);
-// Ensure that the relevant gc_alloc regions are set.
-void get_gc_alloc_regions();
-// We're done with GC alloc regions. We are going to tear down the
-// gc alloc list and remove the gc alloc tag from all the regions on
-// that list. However, we will also retain the last (i.e., the one
-// that is half-full) GC alloc region, per GCAllocPurpose, for
-// possible reuse during the next collection, provided
-// _retain_gc_alloc_region[] indicates that it should be the
-// case. Said regions are kept in the _retained_gc_alloc_regions[]
-// array. If the parameter totally is set, we will not retain any
-// regions, irrespective of what _retain_gc_alloc_region[]
-// indicates.
-void release_gc_alloc_regions(bool totally);
-#ifndef PRODUCT
-// Useful for debugging.
-void print_gc_alloc_regions();
-#endif // !PRODUCT
 // Instance of the concurrent mark is_alive closure for embedding
 // into the reference processor as the is_alive_non_header. This
 // prevents unnecessary additions to the discovered lists during
 // concurrent discovery.
 G1CMIsAliveClosure _is_alive_closure;
 virtual size_t used() const;
 // This should be called when we're not holding the heap lock. The
 // result might be a bit inaccurate.
 size_t used_unlocked() const;
 size_t recalculate_used() const;
-#ifndef PRODUCT
-size_t recalculate_used_regions() const;
-#endif // PRODUCT
 // These virtual functions do the actual allocation.
 // Some heaps may offer a contiguous region for shared non-blocking
 // allocation, via inlined code (by exporting the address of the top and
 // end fields defining the extent of the contiguous allocation region.)
 MemRegion g1_committed() {
 return _g1_committed;
 }
 virtual bool is_in_closed_subset(const void* p) const;
-// Dirty card table entries covering a list of young regions.
-void dirtyCardsForYoungRegions(CardTableModRefBS* ct_bs, HeapRegion* list);
 // This resets the card table to all zeros.  It is used after
 // a collection pause which used the card table to claim cards.
 void cleanUpCardTable();

changeset 10243	d00a21009f1f
parent 10236	c4256e927bed
child 10280	3463715b5ef7