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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 ee10217e3d03
children	d3cec14f33f3

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 */
 #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"
 #include "gc_implementation/g1/g1MonitoringSupport.hpp"
-#include "gc_implementation/g1/g1RemSet.hpp"
 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
 #include "gc_implementation/g1/g1YCTypes.hpp"
-#include "gc_implementation/g1/heapRegionSeq.hpp"
+#include "gc_implementation/g1/heapRegionManager.hpp"
 #include "gc_implementation/g1/heapRegionSet.hpp"
 #include "gc_implementation/shared/hSpaceCounters.hpp"
 #include "gc_implementation/shared/parGCAllocBuffer.hpp"
 #include "memory/barrierSet.hpp"
 #include "memory/memRegion.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 */) { }
 };
 // 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
 bool do_object_b(oop p);
 };
 class RefineCardTableEntryClosure;
+class G1RegionMappingChangedListener : public G1MappingChangedListener {
+private:
+void reset_from_card_cache(uint start_idx, size_t num_regions);
+public:
+virtual void on_commit(uint start_idx, size_t num_regions, bool zero_filled);
+};
 class G1CollectedHeap : public SharedHeap {
+friend class VM_CollectForMetadataAllocation;
 friend class VM_G1CollectForAllocation;
 friend class VM_G1CollectFull;
 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, bool do_mark_object>
+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;
 friend class CountRCClosure;
 friend class EvacPopObjClosure;
 friend class G1ParCleanupCTTask;
+friend class G1FreeHumongousRegionClosure;
 // Other related classes.
 friend class G1MarkSweep;
 private:
 // The one and only G1CollectedHeap, so static functions can find it.
 static G1CollectedHeap* _g1h;
 static size_t _humongous_object_threshold_in_words;
-// Storage for the G1 heap.
-VirtualSpace _g1_storage;
-MemRegion    _g1_reserved;
-// The part of _g1_storage that is currently committed.
-MemRegion _g1_committed;
-// The master free list. It will satisfy all new region allocations.
-FreeRegionList _free_list;
 // The secondary free list which contains regions that have been
-// freed up during the cleanup process. This will be appended to the
+// freed up during the cleanup process. This will be appended to
-// master free list when appropriate.
+// the master free list when appropriate.
 FreeRegionList _secondary_free_list;
 // It keeps track of the old regions.
 HeapRegionSet _old_set;
 // It keeps track of the humongous regions.
 HeapRegionSet _humongous_set;
+void clear_humongous_is_live_table();
+void eagerly_reclaim_humongous_regions();
 // The number of regions we could create by expansion.
 uint _expansion_regions;
 // The block offset table for the G1 heap.
 // 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);
+// Callback for region mapping changed events.
+G1RegionMappingChangedListener _listener;
 // The sequence of all heap regions in the heap.
-HeapRegionSeq _hrs;
+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
+// Statistics for each allocation context
-// survivor objects.
+AllocationContextStats _allocation_context_stats;
-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 abandon_gc_alloc_regions();
 // Helper for monitoring and management support.
 G1MonitoringSupport* _g1mm;
-// Determines PLAB size for a particular allocation purpose.
+// Records whether the region at the given index is kept live by roots or
-size_t desired_plab_sz(GCAllocPurpose purpose);
+// references from the young generation.
+class HumongousIsLiveBiasedMappedArray : public G1BiasedMappedArray<bool> {
-// Outside of GC pauses, the number of bytes used in all regions other
+protected:
-// than the current allocation region.
+bool default_value() const { return false; }
-size_t _summary_bytes_used;
+public:
+void clear() { G1BiasedMappedArray<bool>::clear(); }
-// This is used for a quick test on whether a reference points into
+void set_live(uint region) {
-// the collection set or not. Basically, we have an array, with one
+set_by_index(region, true);
-// byte per region, and that byte denotes whether the corresponding
+}
-// region is in the collection set or not. The entry corresponding
+bool is_live(uint region) {
-// the bottom of the heap, i.e., region 0, is pointed to by
+return get_by_index(region);
-// _in_cset_fast_test_base.  The _in_cset_fast_test field has been
+}
-// biased so that it actually points to address 0 of the address
+};
-// space, to make the test as fast as possible (we can simply shift
-// the address to address into it, instead of having to subtract the
+HumongousIsLiveBiasedMappedArray _humongous_is_live;
-// bottom of the heap from the address before shifting it; basically
+// Stores whether during humongous object registration we found candidate regions.
-// it works in the same way the card table works).
+// If not, we can skip a few steps.
-bool* _in_cset_fast_test;
+bool _has_humongous_reclaim_candidates;
-// The allocated array used for the fast test on whether a reference
-// points into the collection set or not. This field is also used to
-// free the array.
-bool* _in_cset_fast_test_base;
-// The length of the _in_cset_fast_test_base array.
-uint _in_cset_fast_test_length;
 volatile unsigned _gc_time_stamp;
 size_t* _surviving_young_words;
 // Clear RSets after a compaction. It also resets the GC time stamps.
 void clear_rsets_post_compaction();
 // If the HR printer is active, dump the state of the regions in the
 // heap after a compaction.
-void print_hrs_post_compaction();
+void print_hrm_post_compaction();
 double verify(bool guard, const char* msg);
 void verify_before_gc();
 void verify_after_gc();
 // attempt to expand the heap if necessary to satisfy the allocation
 // request. If the region is to be used as an old region or for a
 // humongous object, set is_old to true. If not, to false.
 HeapRegion* new_region(size_t word_size, bool is_old, bool do_expand);
-// 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
-// was unsuccessful.
-uint humongous_obj_allocate_find_first(uint num_regions,
-size_t word_size);
 // 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);
 // Enqueue any remaining discovered references
 // after processing.
 void enqueue_discovered_references(uint no_of_gc_workers);
 public:
+G1Allocator* allocator() {
+return _allocator;
+}
 G1MonitoringSupport* g1mm() {
 assert(_g1mm != NULL, "should have been initialized");
 return _g1mm;
 }
 // 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);
+inline AllocationContextStats& allocation_context_stats();
 // Do anything common to GC's.
 virtual void gc_prologue(bool full);
 virtual void gc_epilogue(bool full);
 #ifdef GRAAL
 HeapWord** top_addr() const;
 HeapWord** end_addr() const;
 #endif
+inline void set_humongous_is_live(oop obj);
+bool humongous_is_live(uint region) {
+return _humongous_is_live.is_live(region);
+}
+// Returns whether the given region (which must be a humongous (start) region)
+// is to be considered conservatively live regardless of any other conditions.
+bool humongous_region_is_always_live(uint index);
+// Register the given region to be part of the collection set.
+inline void register_humongous_region_with_in_cset_fast_test(uint index);
+// Register regions with humongous objects (actually on the start region) in
+// the in_cset_fast_test table.
+void register_humongous_regions_with_in_cset_fast_test();
 // We register a region with the fast "in collection set" test. We
 // simply set to true the array slot corresponding to this region.
 void register_region_with_in_cset_fast_test(HeapRegion* r) {
-assert(_in_cset_fast_test_base != NULL, "sanity");
+_in_cset_fast_test.set_in_cset(r->hrm_index());
-assert(r->in_collection_set(), "invariant");
-uint index = r->hrs_index();
-assert(index < _in_cset_fast_test_length, "invariant");
-assert(!_in_cset_fast_test_base[index], "invariant");
-_in_cset_fast_test_base[index] = true;
 }
 // This is a fast test on whether a reference points into the
 // collection set or not. Assume that the reference
 // points into the heap.
 inline bool in_cset_fast_test(oop obj);
 void clear_cset_fast_test() {
-assert(_in_cset_fast_test_base != NULL, "sanity");
+_in_cset_fast_test.clear();
-memset(_in_cset_fast_test_base, false,
-(size_t) _in_cset_fast_test_length * sizeof(bool));
 }
 // This is called at the start of either a concurrent cycle or a Full
 // GC to update the number of old marking cycles started.
 void increment_old_marking_cycles_started();
 // and does "scan_metadata" If "scan_rs" is
 // NULL, then this step is skipped.  The "worker_i"
 // param is for use with parallel roots processing, and should be
 // the "i" of the calling parallel worker thread's work(i) function.
 // In the sequential case this param will be ignored.
-void g1_process_strong_roots(bool is_scavenging,
+void g1_process_roots(OopClosure* scan_non_heap_roots,
-ScanningOption so,
+OopClosure* scan_non_heap_weak_roots,
-OopClosure* scan_non_heap_roots,
+OopsInHeapRegionClosure* scan_rs,
-OopsInHeapRegionClosure* scan_rs,
+CLDClosure* scan_strong_clds,
-G1KlassScanClosure* scan_klasses,
+CLDClosure* scan_weak_clds,
-uint worker_i);
+CodeBlobClosure* scan_strong_code,
+uint worker_i);
-// Apply "blk" to all the weak roots of the system.  These include
-// 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);
-// Notifies all the necessary spaces that the committed space has
-// been updated (either expanded or shrunk). It should be called
-// after _g1_storage is updated.
-void update_committed_space(HeapWord* old_end, HeapWord* new_end);
 // The concurrent marker (and the thread it runs in.)
 ConcurrentMark* _cm;
 ConcurrentMarkThread* _cmThread;
 bool _mark_in_progress;
 // The heap region entry for a given worker is valid iff
 // the associated time stamp value matches the current value
 // of G1CollectedHeap::_gc_time_stamp.
 unsigned int* _worker_cset_start_region_time_stamp;
-enum G1H_process_strong_roots_tasks {
+enum G1H_process_roots_tasks {
 G1H_PS_filter_satb_buffers,
 G1H_PS_refProcessor_oops_do,
 // Leave this one last.
 G1H_PS_NumElements
 };
 unsigned get_gc_time_stamp() {
 return _gc_time_stamp;
 }
-void reset_gc_time_stamp() {
+inline void reset_gc_time_stamp();
-_gc_time_stamp = 0;
-OrderAccess::fence();
-// Clear the cached CSet starting regions and time stamps.
-// Their validity is dependent on the GC timestamp.
-clear_cset_start_regions();
-}
 void check_gc_time_stamps() PRODUCT_RETURN;
-void increment_gc_time_stamp() {
+inline void increment_gc_time_stamp();
-++_gc_time_stamp;
-OrderAccess::fence();
-}
 // Reset the given region's GC timestamp. If it's starts humongous,
 // also reset the GC timestamp of its corresponding
 // continues humongous regions too.
 void reset_gc_time_stamps(HeapRegion* hr);
 // 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.)
 // But G1CollectedHeap doesn't yet support this.
-// Return an estimate of the maximum allocation that could be performed
-// without triggering any collection or expansion activity.  In a
-// generational collector, for example, this is probably the largest
-// allocation that could be supported (without expansion) in the youngest
-// generation.  It is "unsafe" because no locks are taken; the result
-// should be treated as an approximation, not a guarantee, for use in
-// heuristic resizing decisions.
-virtual size_t unsafe_max_alloc();
 virtual bool is_maximal_no_gc() const {
-return _g1_storage.uncommitted_size() == 0;
+return _hrm.available() == 0;
 }
-// The total number of regions in the heap.
+// The current number of regions in the heap.
-uint n_regions() { return _hrs.length(); }
+uint num_regions() const { return _hrm.length(); }
 // The max number of regions in the heap.
-uint max_regions() { return _hrs.max_length(); }
+uint max_regions() const { return _hrm.max_length(); }
 // The number of regions that are completely free.
-uint free_regions() { return _free_list.length(); }
+uint num_free_regions() const { return _hrm.num_free_regions(); }
 // The number of regions that are not completely free.
-uint used_regions() { return n_regions() - free_regions(); }
+uint num_used_regions() const { return num_regions() - num_free_regions(); }
-// The number of regions available for "regular" expansion.
-uint expansion_regions() { return _expansion_regions; }
-// Factory method for HeapRegion instances. It will return NULL if
-// the allocation fails.
-HeapRegion* new_heap_region(uint hrs_index, HeapWord* bottom);
 void verify_not_dirty_region(HeapRegion* hr) PRODUCT_RETURN;
 void verify_dirty_region(HeapRegion* hr) PRODUCT_RETURN;
 void verify_dirty_young_list(HeapRegion* head) PRODUCT_RETURN;
 void verify_dirty_young_regions() PRODUCT_RETURN;
+#ifndef PRODUCT
+// Make sure that the given bitmap has no marked objects in the
+// range [from,limit). If it does, print an error message and return
+// false. Otherwise, just return true. bitmap_name should be "prev"
+// or "next".
+bool verify_no_bits_over_tams(const char* bitmap_name, CMBitMapRO* bitmap,
+HeapWord* from, HeapWord* limit);
+// Verify that the prev / next bitmap range [tams,end) for the given
+// region has no marks. Return true if all is well, false if errors
+// are detected.
+bool verify_bitmaps(const char* caller, HeapRegion* hr);
+#endif // PRODUCT
+// If G1VerifyBitmaps is set, verify that the marking bitmaps for
+// the given region do not have any spurious marks. If errors are
+// detected, print appropriate error messages and crash.
+void check_bitmaps(const char* caller, HeapRegion* hr) PRODUCT_RETURN;
+// If G1VerifyBitmaps is set, verify that the marking bitmaps do not
+// have any spurious marks. If errors are detected, print
+// appropriate error messages and crash.
+void check_bitmaps(const char* caller) 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();
 void verify_region_sets_optional() { }
 #endif // HEAP_REGION_SET_FORCE_VERIFY
 #ifdef ASSERT
 bool is_on_master_free_list(HeapRegion* hr) {
-return hr->containing_set() == &_free_list;
+return _hrm.is_free(hr);
 }
 #endif // ASSERT
 // Wrapper for the region list operations that can be called from
 // methods outside this class.
 void secondary_free_list_add(FreeRegionList* list) {
 _secondary_free_list.add_ordered(list);
 }
 void append_secondary_free_list() {
-_free_list.add_ordered(&_secondary_free_list);
+_hrm.insert_list_into_free_list(&_secondary_free_list);
 }
 void append_secondary_free_list_if_not_empty_with_lock() {
 // If the secondary free list looks empty there's no reason to
 // take the lock and then try to append it.
 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.
 virtual void collect(GCCause::Cause cause);
 // The same as above but assume that the caller holds the Heap_lock.
 void collect_locked(GCCause::Cause cause);
+virtual bool copy_allocation_context_stats(const jint* contexts,
+jlong* totals,
+jbyte* accuracy,
+jint len);
 // True iff an evacuation has failed in the most-recent collection.
 bool evacuation_failed() { return _evacuation_failed; }
 void remove_from_old_sets(const HeapRegionSetCount& old_regions_removed, const HeapRegionSetCount& humongous_regions_removed);
 void prepend_to_freelist(FreeRegionList* list);
 void decrement_summary_bytes(size_t bytes);
 // Returns "TRUE" iff "p" points into the committed areas of the heap.
 virtual bool is_in(const void* p) const;
+#ifdef ASSERT
+// Returns whether p is in one of the available areas of the heap. Slow but
+// extensive version.
+bool is_in_exact(const void* p) const;
+#endif
 // Return "TRUE" iff the given object address is within the collection
-// set.
+// set. Slow implementation.
 inline bool obj_in_cs(oop obj);
+inline bool is_in_cset(oop obj);
+inline bool is_in_cset_or_humongous(const oop obj);
+enum in_cset_state_t {
+InNeither,           // neither in collection set nor humongous
+InCSet,              // region is in collection set only
+IsHumongous          // region is a humongous start region
+};
+private:
+// Instances of this class are used for quick tests on whether a reference points
+// into the collection set or is a humongous object (points into a humongous
+// object).
+// Each of the array's elements denotes whether the corresponding region is in
+// the collection set or a humongous region.
+// We use this to quickly reclaim humongous objects: by making a humongous region
+// succeed this test, we sort-of add it to the collection set. During the reference
+// iteration closures, when we see a humongous region, we simply mark it as
+// referenced, i.e. live.
+class G1FastCSetBiasedMappedArray : public G1BiasedMappedArray<char> {
+protected:
+char default_value() const { return G1CollectedHeap::InNeither; }
+public:
+void set_humongous(uintptr_t index) {
+assert(get_by_index(index) != InCSet, "Should not overwrite InCSet values");
+set_by_index(index, G1CollectedHeap::IsHumongous);
+}
+void clear_humongous(uintptr_t index) {
+set_by_index(index, G1CollectedHeap::InNeither);
+}
+void set_in_cset(uintptr_t index) {
+assert(get_by_index(index) != G1CollectedHeap::IsHumongous, "Should not overwrite IsHumongous value");
+set_by_index(index, G1CollectedHeap::InCSet);
+}
+bool is_in_cset_or_humongous(HeapWord* addr) const { return get_by_address(addr) != G1CollectedHeap::InNeither; }
+bool is_in_cset(HeapWord* addr) const { return get_by_address(addr) == G1CollectedHeap::InCSet; }
+G1CollectedHeap::in_cset_state_t at(HeapWord* addr) const { return (G1CollectedHeap::in_cset_state_t)get_by_address(addr); }
+void clear() { G1BiasedMappedArray<char>::clear(); }
+};
+// This array is used for a quick test on whether a reference points into
+// the collection set or not. Each of the array's elements denotes whether the
+// corresponding region is in the collection set or not.
+G1FastCSetBiasedMappedArray _in_cset_fast_test;
+public:
+inline in_cset_state_t in_cset_state(const oop obj);
 // Return "TRUE" iff the given object address is in the reserved
 // region of g1.
 bool is_in_g1_reserved(const void* p) const {
-return _g1_reserved.contains(p);
+return _hrm.reserved().contains(p);
 }
 // Returns a MemRegion that corresponds to the space that has been
 // reserved for the heap
-MemRegion g1_reserved() {
+MemRegion g1_reserved() const {
-return _g1_reserved;
+return _hrm.reserved();
-}
-// Returns a MemRegion that corresponds to the space that has been
-// committed in the heap
-MemRegion g1_committed() {
-return _g1_committed;
 }
 virtual bool is_in_closed_subset(const void* p) const;
-G1SATBCardTableModRefBS* g1_barrier_set() {
+G1SATBCardTableLoggingModRefBS* g1_barrier_set() {
-return (G1SATBCardTableModRefBS*) barrier_set();
+return (G1SATBCardTableLoggingModRefBS*) barrier_set();
 }
 // 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();
 // Iterate over all the ref-containing fields of all objects, calling
 // "cl.do_oop" on each.
 virtual void oop_iterate(ExtendedOopClosure* cl);
-// Same as above, restricted to a memory region.
-void oop_iterate(MemRegion mr, ExtendedOopClosure* cl);
 // Iterate over all objects, calling "cl.do_object" on each.
 virtual void object_iterate(ObjectClosure* cl);
 virtual void safe_object_iterate(ObjectClosure* cl) {
 object_iterate(cl);
 // iteration early if the "doHeapRegion" method returns "true".
 void heap_region_iterate(HeapRegionClosure* blk) const;
 // Return the region with the given index. It assumes the index is valid.
 inline HeapRegion* region_at(uint index) const;
+// Calculate the region index of the given address. Given address must be
+// within the heap.
+inline uint addr_to_region(HeapWord* addr) const;
+inline HeapWord* bottom_addr_for_region(uint index) const;
 // Divide the heap region sequence into "chunks" of some size (the number
 // of regions divided by the number of parallel threads times some
 // overpartition factor, currently 4).  Assumes that this will be called
 // in parallel by ParallelGCThreads worker threads with discinct worker
 // attempting to claim the first region in each chunk, and, if
 // successful, applying the closure to each region in the chunk (and
 // setting the claim value of the second and subsequent regions of the
 // chunk.)  For now requires that "doHeapRegion" always returns "false",
 // i.e., that a closure never attempt to abort a traversal.
-void heap_region_par_iterate_chunked(HeapRegionClosure* blk,
+void heap_region_par_iterate_chunked(HeapRegionClosure* cl,
-uint worker,
+uint worker_id,
-uint no_of_par_workers,
+uint num_workers,
-jint claim_value);
+jint claim_value) const;
 // It resets all the region claim values to the default.
 void reset_heap_region_claim_values();
 // Resets the claim values of regions in the current
 // Given the id of a worker, obtain or calculate a suitable
 // starting region for iterating over the current collection set.
 HeapRegion* start_cset_region_for_worker(uint worker_i);
-// This is a convenience method that is used by the
-// HeapRegionIterator classes to calculate the starting region for
-// each worker so that they do not all start from the same region.
-HeapRegion* start_region_for_worker(uint worker_i, uint no_of_par_workers);
 // Iterate over the regions (if any) in the current collection set.
 void collection_set_iterate(HeapRegionClosure* blk);
 // As above but starting from region r
 void collection_set_iterate_from(HeapRegion* r, HeapRegionClosure *blk);
-// Returns the first (lowest address) compactible space in the heap.
+HeapRegion* next_compaction_region(const HeapRegion* from) const;
-virtual CompactibleSpace* first_compactible_space();
 // A CollectedHeap will contain some number of spaces.  This finds the
 // space containing a given address, or else returns NULL.
 virtual Space* space_containing(const void* addr) const;
-// A G1CollectedHeap will contain some number of heap regions.  This
+// Returns the HeapRegion that contains addr. addr must not be NULL.
-// finds the region containing a given address, or else returns NULL.
+template <class T>
+inline HeapRegion* heap_region_containing_raw(const T addr) const;
+// Returns the HeapRegion that contains addr. addr must not be NULL.
+// If addr is within a humongous continues region, it returns its humongous start region.
 template <class T>
 inline HeapRegion* heap_region_containing(const T addr) const;
-// Like the above, but requires "addr" to be in the heap (to avoid a
-// null-check), and unlike the above, may return an continuing humongous
-// region.
-template <class T>
-inline HeapRegion* heap_region_containing_raw(const T addr) const;
 // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
 // each address in the (reserved) heap is a member of exactly
 // one block.  The defining characteristic of a block is that it is
 // possible to find its size, and thus to progress forward to the next
 // Determine if an object is dead, given the object and also
 // the region to which the object belongs. An object is dead
 // iff a) it was not allocated since the last mark and b) it
 // is not marked.
 bool is_obj_dead(const oop obj, const HeapRegion* hr) const {
 return
 !hr->obj_allocated_since_prev_marking(obj) &&
 !isMarkedPrev(obj);
 }
 // This function returns true when an object has been
 // around since the previous marking and hasn't yet
 // been marked during this marking.
 bool is_obj_ill(const oop obj, const HeapRegion* hr) const {
 return
 !hr->obj_allocated_since_next_marking(obj) &&
 !isMarkedNext(obj);
 }
 virtual void register_nmethod(nmethod* nm);
 // Unregister the given nmethod from the G1 heap
 virtual void unregister_nmethod(nmethod* nm);
-// Migrate the nmethods in the code root lists of the regions
-// in the collection set to regions in to-space. In the event
-// of an evacuation failure, nmethods that reference objects
-// that were not successfullly evacuated are not migrated.
-void migrate_strong_code_roots();
 // Free up superfluous code root memory.
 void purge_code_root_memory();
-// During an initial mark pause, mark all the code roots that
-// point into regions *not* in the collection set.
-void mark_strong_code_roots(uint worker_id);
 // Rebuild the stong code root lists for each region
 // after a full GC
 void rebuild_strong_code_roots();
 // Delete entries for dead interned string and clean up unreferenced symbols
 // in symbol table, possibly in parallel.
 void unlink_string_and_symbol_table(BoolObjectClosure* is_alive, bool unlink_strings = true, bool unlink_symbols = true);
+// Parallel phase of unloading/cleaning after G1 concurrent mark.
+void parallel_cleaning(BoolObjectClosure* is_alive, bool process_strings, bool process_symbols, bool class_unloading_occurred);
 // Redirty logged cards in the refinement queue.
 void redirty_logged_cards();
 // Verification
 protected:
 size_t _max_heap_capacity;
 };
-class G1ParGCAllocBuffer: public ParGCAllocBuffer {
-private:
-bool        _retired;
-public:
-G1ParGCAllocBuffer(size_t gclab_word_size);
-void set_buf(HeapWord* buf) {
-ParGCAllocBuffer::set_buf(buf);
-_retired = false;
-}
-void retire(bool end_of_gc, bool retain) {
-if (_retired)
-return;
-ParGCAllocBuffer::retire(end_of_gc, retain);
-_retired = true;
-}
-};
-class G1ParScanThreadState : public StackObj {
-protected:
-G1CollectedHeap* _g1h;
-RefToScanQueue*  _refs;
-DirtyCardQueue   _dcq;
-G1SATBCardTableModRefBS* _ct_bs;
-G1RemSet* _g1_rem;
-G1ParGCAllocBuffer  _surviving_alloc_buffer;
-G1ParGCAllocBuffer  _tenured_alloc_buffer;
-G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
-ageTable            _age_table;
-G1ParScanClosure    _scanner;
-size_t           _alloc_buffer_waste;
-size_t           _undo_waste;
-OopsInHeapRegionClosure*      _evac_failure_cl;
-int  _hash_seed;
-uint _queue_num;
-size_t _term_attempts;
-double _start;
-double _start_strong_roots;
-double _strong_roots_time;
-double _start_term;
-double _term_time;
-// Map from young-age-index (0 == not young, 1 is youngest) to
-// surviving words. base is what we get back from the malloc call
-size_t* _surviving_young_words_base;
-// this points into the array, as we use the first few entries for padding
-size_t* _surviving_young_words;
-#define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t))
-void   add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; }
-void   add_to_undo_waste(size_t waste)         { _undo_waste += waste; }
-DirtyCardQueue& dirty_card_queue()             { return _dcq;  }
-G1SATBCardTableModRefBS* ctbs()                { return _ct_bs; }
-template <class T> inline void immediate_rs_update(HeapRegion* from, T* p, int tid);
-template <class T> void deferred_rs_update(HeapRegion* from, T* p, int tid) {
-// If the new value of the field points to the same region or
-// is the to-space, we don't need to include it in the Rset updates.
-if (!from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && !from->is_survivor()) {
-size_t card_index = ctbs()->index_for(p);
-// If the card hasn't been added to the buffer, do it.
-if (ctbs()->mark_card_deferred(card_index)) {
-dirty_card_queue().enqueue((jbyte*)ctbs()->byte_for_index(card_index));
-}
-}
-}
-public:
-G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp);
-~G1ParScanThreadState() {
-FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC);
-}
-RefToScanQueue*   refs()            { return _refs;             }
-ageTable*         age_table()       { return &_age_table;       }
-G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) {
-return _alloc_buffers[purpose];
-}
-size_t alloc_buffer_waste() const              { return _alloc_buffer_waste; }
-size_t undo_waste() const                      { return _undo_waste; }
-#ifdef ASSERT
-bool verify_ref(narrowOop* ref) const;
-bool verify_ref(oop* ref) const;
-bool verify_task(StarTask ref) const;
-#endif // ASSERT
-template <class T> void push_on_queue(T* ref) {
-assert(verify_ref(ref), "sanity");
-refs()->push(ref);
-}
-template <class T> inline void update_rs(HeapRegion* from, T* p, int tid);
-HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz) {
-HeapWord* obj = NULL;
-size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
-if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
-G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
-add_to_alloc_buffer_waste(alloc_buf->words_remaining());
-alloc_buf->retire(false /* end_of_gc */, false /* retain */);
-HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size);
-if (buf == NULL) return NULL; // Let caller handle allocation failure.
-// Otherwise.
-alloc_buf->set_word_size(gclab_word_size);
-alloc_buf->set_buf(buf);
-obj = alloc_buf->allocate(word_sz);
-assert(obj != NULL, "buffer was definitely big enough...");
-} else {
-obj = _g1h->par_allocate_during_gc(purpose, word_sz);
-}
-return obj;
-}
-HeapWord* allocate(GCAllocPurpose purpose, size_t word_sz) {
-HeapWord* obj = alloc_buffer(purpose)->allocate(word_sz);
-if (obj != NULL) return obj;
-return allocate_slow(purpose, word_sz);
-}
-void undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz) {
-if (alloc_buffer(purpose)->contains(obj)) {
-assert(alloc_buffer(purpose)->contains(obj + word_sz - 1),
-"should contain whole object");
-alloc_buffer(purpose)->undo_allocation(obj, word_sz);
-} else {
-CollectedHeap::fill_with_object(obj, word_sz);
-add_to_undo_waste(word_sz);
-}
-}
-void set_evac_failure_closure(OopsInHeapRegionClosure* evac_failure_cl) {
-_evac_failure_cl = evac_failure_cl;
-}
-OopsInHeapRegionClosure* evac_failure_closure() {
-return _evac_failure_cl;
-}
-int* hash_seed() { return &_hash_seed; }
-uint queue_num() { return _queue_num; }
-size_t term_attempts() const  { return _term_attempts; }
-void note_term_attempt() { _term_attempts++; }
-void start_strong_roots() {
-_start_strong_roots = os::elapsedTime();
-}
-void end_strong_roots() {
-_strong_roots_time += (os::elapsedTime() - _start_strong_roots);
-}
-double strong_roots_time() const { return _strong_roots_time; }
-void start_term_time() {
-note_term_attempt();
-_start_term = os::elapsedTime();
-}
-void end_term_time() {
-_term_time += (os::elapsedTime() - _start_term);
-}
-double term_time() const { return _term_time; }
-double elapsed_time() const {
-return os::elapsedTime() - _start;
-}
-static void
-print_termination_stats_hdr(outputStream* const st = gclog_or_tty);
-void
-print_termination_stats(int i, outputStream* const st = gclog_or_tty) const;
-size_t* surviving_young_words() {
-// We add on to hide entry 0 which accumulates surviving words for
-// age -1 regions (i.e. non-young ones)
-return _surviving_young_words;
-}
-void retire_alloc_buffers() {
-for (int ap = 0; ap < GCAllocPurposeCount; ++ap) {
-size_t waste = _alloc_buffers[ap]->words_remaining();
-add_to_alloc_buffer_waste(waste);
-_alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
-true /* end_of_gc */,
-false /* retain */);
-}
-}
-private:
-#define G1_PARTIAL_ARRAY_MASK 0x2
-inline bool has_partial_array_mask(oop* ref) const {
-return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK;
-}
-// We never encode partial array oops as narrowOop*, so return false immediately.
-// This allows the compiler to create optimized code when popping references from
-// the work queue.
-inline bool has_partial_array_mask(narrowOop* ref) const {
-assert(((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) != G1_PARTIAL_ARRAY_MASK, "Partial array oop reference encoded as narrowOop*");
-return false;
-}
-// Only implement set_partial_array_mask() for regular oops, not for narrowOops.
-// We always encode partial arrays as regular oop, to allow the
-// specialization for has_partial_array_mask() for narrowOops above.
-// This means that unintentional use of this method with narrowOops are caught
-// by the compiler.
-inline oop* set_partial_array_mask(oop obj) const {
-assert(((uintptr_t)(void *)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!");
-return (oop*) ((uintptr_t)(void *)obj | G1_PARTIAL_ARRAY_MASK);
-}
-inline oop clear_partial_array_mask(oop* ref) const {
-return cast_to_oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK);
-}
-inline void do_oop_partial_array(oop* p);
-// This method is applied to the fields of the objects that have just been copied.
-template <class T> void do_oop_evac(T* p, HeapRegion* from) {
-assert(!oopDesc::is_null(oopDesc::load_decode_heap_oop(p)),
-"Reference should not be NULL here as such are never pushed to the task queue.");
-oop obj = oopDesc::load_decode_heap_oop_not_null(p);
-// Although we never intentionally push references outside of the collection
-// set, due to (benign) races in the claim mechanism during RSet scanning more
-// than one thread might claim the same card. So the same card may be
-// processed multiple times. So redo this check.
-if (_g1h->in_cset_fast_test(obj)) {
-oop forwardee;
-if (obj->is_forwarded()) {
-forwardee = obj->forwardee();
-} else {
-forwardee = copy_to_survivor_space(obj);
-}
-assert(forwardee != NULL, "forwardee should not be NULL");
-oopDesc::encode_store_heap_oop(p, forwardee);
-}
-assert(obj != NULL, "Must be");
-update_rs(from, p, queue_num());
-}
-public:
-oop copy_to_survivor_space(oop const obj);
-template <class T> inline void deal_with_reference(T* ref_to_scan);
-inline void deal_with_reference(StarTask ref);
-public:
-void trim_queue();
-};
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 20804:7848fc12602b