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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	6b0fd0964b87 798522662fcd
children	359f7e70ae7f

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 #include "gc_implementation/g1/evacuationInfo.hpp"
 #include "gc_implementation/g1/g1AllocRegion.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/heapRegionSets.hpp"
 #include "gc_implementation/shared/hSpaceCounters.hpp"
 #include "gc_implementation/shared/parGCAllocBuffer.hpp"
 // A "G1CollectedHeap" is an implementation of a java heap for HotSpot.
 // It uses the "Garbage First" heap organization and algorithm, which
 // may combine concurrent marking with parallel, incremental compaction of
 // heap subsets that will yield large amounts of garbage.
+// Forward declarations
 class HeapRegion;
 class HRRSCleanupTask;
 class GenerationSpec;
 class OopsInHeapRegionClosure;
 class G1KlassScanClosure;
 class GenerationCounters;
 class STWGCTimer;
 class G1NewTracer;
 class G1OldTracer;
 class EvacuationFailedInfo;
+class nmethod;
 typedef OverflowTaskQueue<StarTask, mtGC>         RefToScanQueue;
 typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet;
 typedef int RegionIdx_t;   // needs to hold [ 0..max_regions() )
 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
 class G1STWIsAliveClosure: public BoolObjectClosure {
 G1CollectedHeap* _g1;
 public:
 G1STWIsAliveClosure(G1CollectedHeap* g1) : _g1(g1) {}
 bool do_object_b(oop p);
-};
-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 {
 bool in_cset_fast_test(oop obj) {
 assert(_in_cset_fast_test != NULL, "sanity");
 if (_g1_committed.contains((HeapWord*) obj)) {
 // no need to subtract the bottom of the heap from obj,
 // _in_cset_fast_test is biased
-uintx index = (uintx) obj >> HeapRegion::LogOfHRGrainBytes;
+uintx index = cast_from_oop<uintx>(obj) >> HeapRegion::LogOfHRGrainBytes;
 bool ret = _in_cset_fast_test[index];
 // let's make sure the result is consistent with what the slower
 // test returns
 assert( ret || !obj_in_cs(obj), "sanity");
 assert(!ret ||  obj_in_cs(obj), "sanity");
 // Heap_lock when we enter this method, we will pass the
 // gc_count_before (i.e., total_collections()) as a parameter since
 // it has to be read while holding the Heap_lock. Currently, both
 // methods that call do_collection_pause() release the Heap_lock
 // before the call, so it's easy to read gc_count_before just before.
-HeapWord* do_collection_pause(size_t       word_size,
+HeapWord* do_collection_pause(size_t         word_size,
-unsigned int gc_count_before,
+unsigned int   gc_count_before,
-bool*        succeeded);
+bool*          succeeded,
+GCCause::Cause gc_cause);
 // The guts of the incremental collection pause, executed by the vm
 // thread. It returns false if it is unable to do the collection due
 // to the GC locker being active, true otherwise
 bool do_collection_pause_at_safepoint(double target_pause_time_ms);
 // Actually do the work of evacuating the collection set.
 void evacuate_collection_set(EvacuationInfo& evacuation_info);
 // The g1 remembered set of the heap.
 G1RemSet* _g1_rem_set;
-// And it's mod ref barrier set, used to track updates for the above.
-ModRefBarrierSet* _mr_bs;
 // A set of cards that cover the objects for which the Rsets should be updated
 // concurrently after the collection.
 DirtyCardQueueSet _dirty_card_queue_set;
 // Initialize the G1CollectedHeap to have the initial and
 // maximum sizes and remembered and barrier sets
 // specified by the policy object.
 jint initialize();
+// Return the (conservative) maximum heap alignment for any G1 heap
+static size_t conservative_max_heap_alignment();
 // Initialize weak reference processing.
 virtual void ref_processing_init();
 void set_par_threads(uint t) {
 SharedHeap::set_par_threads(t);
 // Adaptive size policy.  No such thing for g1.
 virtual AdaptiveSizePolicy* size_policy() { return NULL; }
 // The rem set and barrier set.
 G1RemSet* g1_rem_set() const { return _g1_rem_set; }
-ModRefBarrierSet* mr_bs() const { return _mr_bs; }
 unsigned get_gc_time_stamp() {
 return _gc_time_stamp;
 }
 MemRegion g1_committed() {
 return _g1_committed;
 }
 virtual bool is_in_closed_subset(const void* p) const;
+G1SATBCardTableModRefBS* g1_barrier_set() {
+return (G1SATBCardTableModRefBS*) 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();
 // Print the maximum heap capacity.
 virtual size_t max_capacity() const;
 virtual jlong millis_since_last_gc();
+// Convenience function to be used in situations where the heap type can be
+// asserted to be this type.
+static G1CollectedHeap* heap();
+void set_region_short_lived_locked(HeapRegion* hr);
+// add appropriate methods for any other surv rate groups
+YoungList* young_list() { return _young_list; }
+// debugging
+bool check_young_list_well_formed() {
+return _young_list->check_list_well_formed();
+}
+bool check_young_list_empty(bool check_heap,
+bool check_sample = true);
+// *** Stuff related to concurrent marking.  It's not clear to me that so
+// many of these need to be public.
+// The functions below are helper functions that a subclass of
+// "CollectedHeap" can use in the implementation of its virtual
+// functions.
+// This performs a concurrent marking of the live objects in a
+// bitmap off to the side.
+void doConcurrentMark();
+bool isMarkedPrev(oop obj) const;
+bool isMarkedNext(oop obj) const;
+// 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);
+}
+// Determine if an object is dead, given only the object itself.
+// This will find the region to which the object belongs and
+// then call the region version of the same function.
+// Added if it is NULL it isn't dead.
+bool is_obj_dead(const oop obj) const {
+const HeapRegion* hr = heap_region_containing(obj);
+if (hr == NULL) {
+if (obj == NULL) return false;
+else return true;
+}
+else return is_obj_dead(obj, hr);
+}
+bool is_obj_ill(const oop obj) const {
+const HeapRegion* hr = heap_region_containing(obj);
+if (hr == NULL) {
+if (obj == NULL) return false;
+else return true;
+}
+else return is_obj_ill(obj, hr);
+}
+bool allocated_since_marking(oop obj, HeapRegion* hr, VerifyOption vo);
+HeapWord* top_at_mark_start(HeapRegion* hr, VerifyOption vo);
+bool is_marked(oop obj, VerifyOption vo);
+const char* top_at_mark_start_str(VerifyOption vo);
+ConcurrentMark* concurrent_mark() const { return _cm; }
+// Refinement
+ConcurrentG1Refine* concurrent_g1_refine() const { return _cg1r; }
+// The dirty cards region list is used to record a subset of regions
+// whose cards need clearing. The list if populated during the
+// remembered set scanning and drained during the card table
+// cleanup. Although the methods are reentrant, population/draining
+// phases must not overlap. For synchronization purposes the last
+// element on the list points to itself.
+HeapRegion* _dirty_cards_region_list;
+void push_dirty_cards_region(HeapRegion* hr);
+HeapRegion* pop_dirty_cards_region();
+// Optimized nmethod scanning support routines
+// Register the given nmethod with the G1 heap
+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();
+// 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();
+// Verification
+// The following is just to alert the verification code
+// that a full collection has occurred and that the
+// remembered sets are no longer up to date.
+bool _full_collection;
+void set_full_collection() { _full_collection = true;}
+void clear_full_collection() {_full_collection = false;}
+bool full_collection() {return _full_collection;}
 // Perform any cleanup actions necessary before allowing a verification.
 virtual void prepare_for_verify();
 // Perform verification.
 void verify(bool silent, VerifyOption vo);
 // Override; it uses the "prev" marking information
 virtual void verify(bool silent);
-virtual void print_on(outputStream* st) const;
-virtual void print_extended_on(outputStream* st) const;
-virtual void print_on_error(outputStream* st) const;
-virtual void print_gc_threads_on(outputStream* st) const;
-virtual void gc_threads_do(ThreadClosure* tc) const;
-// Override
-void print_tracing_info() const;
-// The following two methods are helpful for debugging RSet issues.
-void print_cset_rsets() PRODUCT_RETURN;
-void print_all_rsets() PRODUCT_RETURN;
-// Convenience function to be used in situations where the heap type can be
-// asserted to be this type.
-static G1CollectedHeap* heap();
-void set_region_short_lived_locked(HeapRegion* hr);
-// add appropriate methods for any other surv rate groups
-YoungList* young_list() { return _young_list; }
-// debugging
-bool check_young_list_well_formed() {
-return _young_list->check_list_well_formed();
-}
-bool check_young_list_empty(bool check_heap,
-bool check_sample = true);
-// *** Stuff related to concurrent marking.  It's not clear to me that so
-// many of these need to be public.
-// The functions below are helper functions that a subclass of
-// "CollectedHeap" can use in the implementation of its virtual
-// functions.
-// This performs a concurrent marking of the live objects in a
-// bitmap off to the side.
-void doConcurrentMark();
-bool isMarkedPrev(oop obj) const;
-bool isMarkedNext(oop obj) const;
-// 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);
-}
-// Determine if an object is dead, given only the object itself.
-// This will find the region to which the object belongs and
-// then call the region version of the same function.
-// Added if it is NULL it isn't dead.
-bool is_obj_dead(const oop obj) const {
-const HeapRegion* hr = heap_region_containing(obj);
-if (hr == NULL) {
-if (obj == NULL) return false;
-else return true;
-}
-else return is_obj_dead(obj, hr);
-}
-bool is_obj_ill(const oop obj) const {
-const HeapRegion* hr = heap_region_containing(obj);
-if (hr == NULL) {
-if (obj == NULL) return false;
-else return true;
-}
-else return is_obj_ill(obj, hr);
-}
 // The methods below are here for convenience and dispatch the
 // appropriate method depending on value of the given VerifyOption
-// parameter. The options for that parameter are:
+// parameter. The values for that parameter, and their meanings,
-//
+// are the same as those above.
-// vo == UsePrevMarking -> use "prev" marking information,
-// vo == UseNextMarking -> use "next" marking information,
-// vo == UseMarkWord    -> use mark word from object header
 bool is_obj_dead_cond(const oop obj,
 const HeapRegion* hr,
 const VerifyOption vo) const {
 switch (vo) {
 default:                            ShouldNotReachHere();
 }
 return false; // keep some compilers happy
 }
-bool allocated_since_marking(oop obj, HeapRegion* hr, VerifyOption vo);
+// Printing
-HeapWord* top_at_mark_start(HeapRegion* hr, VerifyOption vo);
-bool is_marked(oop obj, VerifyOption vo);
+virtual void print_on(outputStream* st) const;
-const char* top_at_mark_start_str(VerifyOption vo);
+virtual void print_extended_on(outputStream* st) const;
+virtual void print_on_error(outputStream* st) const;
-// The following is just to alert the verification code
-// that a full collection has occurred and that the
+virtual void print_gc_threads_on(outputStream* st) const;
-// remembered sets are no longer up to date.
+virtual void gc_threads_do(ThreadClosure* tc) const;
-bool _full_collection;
-void set_full_collection() { _full_collection = true;}
+// Override
-void clear_full_collection() {_full_collection = false;}
+void print_tracing_info() const;
-bool full_collection() {return _full_collection;}
+// The following two methods are helpful for debugging RSet issues.
-ConcurrentMark* concurrent_mark() const { return _cm; }
+void print_cset_rsets() PRODUCT_RETURN;
-ConcurrentG1Refine* concurrent_g1_refine() const { return _cg1r; }
+void print_all_rsets() PRODUCT_RETURN;
-// The dirty cards region list is used to record a subset of regions
-// whose cards need clearing. The list if populated during the
-// remembered set scanning and drained during the card table
-// cleanup. Although the methods are reentrant, population/draining
-// phases must not overlap. For synchronization purposes the last
-// element on the list points to itself.
-HeapRegion* _dirty_cards_region_list;
-void push_dirty_cards_region(HeapRegion* hr);
-HeapRegion* pop_dirty_cards_region();
 public:
 void stop_conc_gc_threads();
 size_t pending_card_num();
 class G1ParScanThreadState : public StackObj {
 protected:
 G1CollectedHeap* _g1h;
 RefToScanQueue*  _refs;
 DirtyCardQueue   _dcq;
-CardTableModRefBS* _ct_bs;
+G1SATBCardTableModRefBS* _ct_bs;
 G1RemSet* _g1_rem;
 G1ParGCAllocBufferContainer  _surviving_alloc_buffer;
 G1ParGCAllocBufferContainer  _tenured_alloc_buffer;
 G1ParGCAllocBufferContainer* _alloc_buffers[GCAllocPurposeCount];
 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;  }
-CardTableModRefBS* ctbs()                      { return _ct_bs; }
+G1SATBCardTableModRefBS* ctbs()                { return _ct_bs; }
 template <class T> void immediate_rs_update(HeapRegion* from, T* p, int tid) {
 if (!from->is_survivor()) {
 _g1_rem->par_write_ref(from, p, tid);
 }

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 12355:cefad50507d8