< prev index next >

src/share/vm/gc/g1/g1RemSet.hpp

Print this page
rev 13269 : 8183539: Remove G1RemSet::_into_cset_dirty_card_queue_set


  42 class G1CollectedHeap;
  43 class G1HotCardCache;
  44 class G1RemSetScanState;
  45 class G1ParScanThreadState;
  46 class G1Policy;
  47 class G1SATBCardTableModRefBS;
  48 class G1ScanObjsDuringScanRSClosure;
  49 class G1ScanObjsDuringUpdateRSClosure;
  50 class HeapRegionClaimer;
  51 
  52 // A G1RemSet in which each heap region has a rem set that records the
  53 // external heap references into it.  Uses a mod ref bs to track updates,
  54 // so that they can be used to update the individual region remsets.
  55 class G1RemSet: public CHeapObj<mtGC> {
  56 private:
  57   G1RemSetScanState* _scan_state;
  58   G1CardLiveData _card_live_data;
  59 
  60   G1RemSetSummary _prev_period_summary;
  61 
  62   // A DirtyCardQueueSet that is used to hold cards that contain
  63   // references into the current collection set. This is used to
  64   // update the remembered sets of the regions in the collection
  65   // set in the event of an evacuation failure.
  66   DirtyCardQueueSet _into_cset_dirty_card_queue_set;
  67 
  68   // Scan all remembered sets of the collection set for references into the collection
  69   // set.
  70   void scan_rem_set(G1ParScanThreadState* pss,
  71                     CodeBlobClosure* heap_region_codeblobs,
  72                     uint worker_i);
  73 
  74   // Flush remaining refinement buffers for cross-region references to either evacuate references
  75   // into the collection set or update the remembered set.
  76   void update_rem_set(DirtyCardQueue* into_cset_dcq, G1ParScanThreadState* pss, uint worker_i);
  77 
  78   G1CollectedHeap* _g1;
  79   size_t _num_conc_refined_cards; // Number of cards refined concurrently to the mutator.
  80 
  81   CardTableModRefBS*     _ct_bs;
  82   G1Policy*              _g1p;
  83   G1HotCardCache*        _hot_card_cache;
  84 
  85 public:
  86   // Gives an approximation on how many threads can be expected to add records to
  87   // a remembered set in parallel. This can be used for sizing data structures to
  88   // decrease performance losses due to data structure sharing.
  89   // Examples for quantities that influence this value are the maximum number of
  90   // mutator threads, maximum number of concurrent refinement or GC threads.
  91   static uint num_par_rem_sets();
  92 
  93   // Initialize data that depends on the heap size being known.
  94   void initialize(size_t capacity, uint max_regions);
  95 
  96   // This is called to reset dual hash tables after the gc pause


 116   // call.  Must call each of these once before and after (in sequential
 117   // code) any thread calls oops_into_collection_set_do.
 118   void prepare_for_oops_into_collection_set_do();
 119   void cleanup_after_oops_into_collection_set_do();
 120 
 121   G1RemSetScanState* scan_state() const { return _scan_state; }
 122 
 123   // Record, if necessary, the fact that *p (where "p" is in region "from",
 124   // which is required to be non-NULL) has changed to a new non-NULL value.
 125   template <class T> void par_write_ref(HeapRegion* from, T* p, uint tid);
 126 
 127   // Eliminates any remembered set entries that correspond to dead heap ranges.
 128   void scrub(uint worker_num, HeapRegionClaimer* hrclaimer);
 129 
 130   // Refine the card corresponding to "card_ptr". Safe to be called concurrently
 131   // to the mutator.
 132   void refine_card_concurrently(jbyte* card_ptr,
 133                                 uint worker_i);
 134 
 135   // Refine the card corresponding to "card_ptr", applying the given closure to
 136   // all references found. Returns "true" if the given card contains
 137   // oops that have references into the current collection set. Must only be
 138   // called during gc.
 139   bool refine_card_during_gc(jbyte* card_ptr,
 140                              G1ScanObjsDuringUpdateRSClosure* update_rs_cl);
 141 
 142   // Print accumulated summary info from the start of the VM.
 143   void print_summary_info();
 144 
 145   // Print accumulated summary info from the last time called.
 146   void print_periodic_summary_info(const char* header, uint period_count);
 147 
 148   size_t num_conc_refined_cards() const { return _num_conc_refined_cards; }
 149 
 150   void create_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
 151   void finalize_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
 152 
 153   // Verify that the liveness count data created concurrently matches one created
 154   // during this safepoint.
 155   void verify_card_live_data(WorkGang* workers, G1CMBitMap* actual_bitmap);
 156 
 157   void clear_card_live_data(WorkGang* workers);
 158 
 159 #ifdef ASSERT
 160   void verify_card_live_data_is_clear();




  42 class G1CollectedHeap;
  43 class G1HotCardCache;
  44 class G1RemSetScanState;
  45 class G1ParScanThreadState;
  46 class G1Policy;
  47 class G1SATBCardTableModRefBS;
  48 class G1ScanObjsDuringScanRSClosure;
  49 class G1ScanObjsDuringUpdateRSClosure;
  50 class HeapRegionClaimer;
  51 
  52 // A G1RemSet in which each heap region has a rem set that records the
  53 // external heap references into it.  Uses a mod ref bs to track updates,
  54 // so that they can be used to update the individual region remsets.
  55 class G1RemSet: public CHeapObj<mtGC> {
  56 private:
  57   G1RemSetScanState* _scan_state;
  58   G1CardLiveData _card_live_data;
  59 
  60   G1RemSetSummary _prev_period_summary;
  61 






  62   // Scan all remembered sets of the collection set for references into the collection
  63   // set.
  64   void scan_rem_set(G1ParScanThreadState* pss,
  65                     CodeBlobClosure* heap_region_codeblobs,
  66                     uint worker_i);
  67 
  68   // Flush remaining refinement buffers for cross-region references to either evacuate references
  69   // into the collection set or update the remembered set.
  70   void update_rem_set(G1ParScanThreadState* pss, uint worker_i);
  71 
  72   G1CollectedHeap* _g1;
  73   size_t _num_conc_refined_cards; // Number of cards refined concurrently to the mutator.
  74 
  75   CardTableModRefBS*     _ct_bs;
  76   G1Policy*              _g1p;
  77   G1HotCardCache*        _hot_card_cache;
  78 
  79 public:
  80   // Gives an approximation on how many threads can be expected to add records to
  81   // a remembered set in parallel. This can be used for sizing data structures to
  82   // decrease performance losses due to data structure sharing.
  83   // Examples for quantities that influence this value are the maximum number of
  84   // mutator threads, maximum number of concurrent refinement or GC threads.
  85   static uint num_par_rem_sets();
  86 
  87   // Initialize data that depends on the heap size being known.
  88   void initialize(size_t capacity, uint max_regions);
  89 
  90   // This is called to reset dual hash tables after the gc pause


 110   // call.  Must call each of these once before and after (in sequential
 111   // code) any thread calls oops_into_collection_set_do.
 112   void prepare_for_oops_into_collection_set_do();
 113   void cleanup_after_oops_into_collection_set_do();
 114 
 115   G1RemSetScanState* scan_state() const { return _scan_state; }
 116 
 117   // Record, if necessary, the fact that *p (where "p" is in region "from",
 118   // which is required to be non-NULL) has changed to a new non-NULL value.
 119   template <class T> void par_write_ref(HeapRegion* from, T* p, uint tid);
 120 
 121   // Eliminates any remembered set entries that correspond to dead heap ranges.
 122   void scrub(uint worker_num, HeapRegionClaimer* hrclaimer);
 123 
 124   // Refine the card corresponding to "card_ptr". Safe to be called concurrently
 125   // to the mutator.
 126   void refine_card_concurrently(jbyte* card_ptr,
 127                                 uint worker_i);
 128 
 129   // Refine the card corresponding to "card_ptr", applying the given closure to
 130   // all references found. Must only be called during gc.
 131   void refine_card_during_gc(jbyte* card_ptr, G1ScanObjsDuringUpdateRSClosure* update_rs_cl);



 132 
 133   // Print accumulated summary info from the start of the VM.
 134   void print_summary_info();
 135 
 136   // Print accumulated summary info from the last time called.
 137   void print_periodic_summary_info(const char* header, uint period_count);
 138 
 139   size_t num_conc_refined_cards() const { return _num_conc_refined_cards; }
 140 
 141   void create_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
 142   void finalize_card_live_data(WorkGang* workers, G1CMBitMap* mark_bitmap);
 143 
 144   // Verify that the liveness count data created concurrently matches one created
 145   // during this safepoint.
 146   void verify_card_live_data(WorkGang* workers, G1CMBitMap* actual_bitmap);
 147 
 148   void clear_card_live_data(WorkGang* workers);
 149 
 150 #ifdef ASSERT
 151   void verify_card_live_data_is_clear();


< prev index next >