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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 12080:5888334c9c24

7145569: G1: optimize nmethods scanning Summary: Add a list of nmethods to the RSet for a region that contain references into the region. Skip scanning the code cache during root scanning and scan the nmethod lists during RSet scanning instead. Reviewed-by: tschatzl, brutisso, mgerdin, twisti, kvn

author	johnc
date	Thu, 15 Aug 2013 10:52:18 +0200
parents	71180a6e5080
children	f7d3b4387a16

comparison

equal deleted inserted replaced

-:bd902affe102
+:5888334c9c24
 // 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 {
 // 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();

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 12080:5888334c9c24