< prev index next >

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

Print this page




  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_G1_G1REMSET_HPP
  26 #define SHARE_VM_GC_G1_G1REMSET_HPP
  27 
  28 #include "gc/g1/g1RemSetSummary.hpp"
  29 
  30 // A G1RemSet provides ways of iterating over pointers into a selected
  31 // collection set.
  32 
  33 class G1CollectedHeap;
  34 class ConcurrentG1Refine;
  35 class G1ParPushHeapRSClosure;

  36 
  37 // A G1RemSet in which each heap region has a rem set that records the
  38 // external heap references into it.  Uses a mod ref bs to track updates,
  39 // so that they can be used to update the individual region remsets.
  40 
  41 class G1RemSet: public CHeapObj<mtGC> {
  42 private:
  43   G1RemSetSummary _prev_period_summary;
  44 protected:
  45   G1CollectedHeap* _g1;
  46   size_t _conc_refine_cards;
  47   uint n_workers();
  48 
  49 protected:
  50   enum SomePrivateConstants {
  51     UpdateRStoMergeSync  = 0,
  52     MergeRStoDoDirtySync = 1,
  53     DoDirtySync          = 2,
  54     LastSync             = 3,
  55 
  56     SeqTask              = 0,
  57     NumSeqTasks          = 1
  58   };
  59 
  60   CardTableModRefBS*     _ct_bs;
  61   G1CollectorPolicy*     _g1p;
  62 
  63   ConcurrentG1Refine*    _cg1r;
  64 
  65   // Used for caching the closure that is responsible for scanning
  66   // references into the collection set.
  67   G1ParPushHeapRSClosure** _cset_rs_update_cl;
  68 
  69   // Print the given summary info
  70   virtual void print_summary_info(G1RemSetSummary * summary, const char * header = NULL);
  71 public:
  72   // This is called to reset dual hash tables after the gc pause
  73   // is finished and the initial hash table is no longer being
  74   // scanned.
  75   void cleanupHRRS();
  76 
  77   G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs);
  78   ~G1RemSet();
  79 
  80   // Invoke "blk->do_oop" on all pointers into the collection set
  81   // from objects in regions outside the collection set (having
  82   // invoked "blk->set_region" to set the "from" region correctly
  83   // beforehand.)
  84   //
  85   // Apply non_heap_roots on the oops of the unmarked nmethods
  86   // on the strong code roots list for each region in the
  87   // collection set.
  88   //
  89   // The "worker_i" param is for the parallel case where the id
  90   // of the worker thread calling this function can be helpful in


 122   // Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
 123   // or card, respectively, such that a region or card with a corresponding
 124   // 0 bit contains no part of any live object.  Eliminates any remembered
 125   // set entries that correspond to dead heap ranges. "worker_num" is the
 126   // parallel thread id of the current thread, and "hrclaimer" is the
 127   // HeapRegionClaimer that should be used.
 128   void scrub(BitMap* region_bm, BitMap* card_bm, uint worker_num, HeapRegionClaimer* hrclaimer);
 129 
 130   // Refine the card corresponding to "card_ptr".
 131   // If check_for_refs_into_cset is true, a true result is returned
 132   // if the given card contains oops that have references into the
 133   // current collection set.
 134   virtual bool refine_card(jbyte* card_ptr,
 135                            uint worker_i,
 136                            bool check_for_refs_into_cset);
 137 
 138   // Print accumulated summary info from the start of the VM.
 139   virtual void print_summary_info();
 140 
 141   // Print accumulated summary info from the last time called.
 142   virtual void print_periodic_summary_info(const char* header);
 143 
 144   // Prepare remembered set for verification.
 145   virtual void prepare_for_verify();
 146 
 147   size_t conc_refine_cards() const {
 148     return _conc_refine_cards;
 149   }
 150 };
 151 
 152 class UpdateRSOopClosure: public ExtendedOopClosure {
 153   HeapRegion* _from;
 154   G1RemSet* _rs;
 155   uint _worker_i;
 156 
 157   template <class T> void do_oop_work(T* p);
 158 
 159 public:
 160   UpdateRSOopClosure(G1RemSet* rs, uint worker_i = 0) :
 161     _from(NULL), _rs(rs), _worker_i(worker_i)
 162   {}


  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_G1_G1REMSET_HPP
  26 #define SHARE_VM_GC_G1_G1REMSET_HPP
  27 
  28 #include "gc/g1/g1RemSetSummary.hpp"
  29 
  30 // A G1RemSet provides ways of iterating over pointers into a selected
  31 // collection set.
  32 
  33 class G1CollectedHeap;
  34 class ConcurrentG1Refine;
  35 class G1ParPushHeapRSClosure;
  36 class outputStream;
  37 
  38 // A G1RemSet in which each heap region has a rem set that records the
  39 // external heap references into it.  Uses a mod ref bs to track updates,
  40 // so that they can be used to update the individual region remsets.
  41 
  42 class G1RemSet: public CHeapObj<mtGC> {
  43 private:
  44   G1RemSetSummary _prev_period_summary;
  45 protected:
  46   G1CollectedHeap* _g1;
  47   size_t _conc_refine_cards;
  48   uint n_workers();
  49 
  50 protected:
  51   enum SomePrivateConstants {
  52     UpdateRStoMergeSync  = 0,
  53     MergeRStoDoDirtySync = 1,
  54     DoDirtySync          = 2,
  55     LastSync             = 3,
  56 
  57     SeqTask              = 0,
  58     NumSeqTasks          = 1
  59   };
  60 
  61   CardTableModRefBS*     _ct_bs;
  62   G1CollectorPolicy*     _g1p;
  63 
  64   ConcurrentG1Refine*    _cg1r;
  65 
  66   // Used for caching the closure that is responsible for scanning
  67   // references into the collection set.
  68   G1ParPushHeapRSClosure** _cset_rs_update_cl;
  69 


  70 public:
  71   // This is called to reset dual hash tables after the gc pause
  72   // is finished and the initial hash table is no longer being
  73   // scanned.
  74   void cleanupHRRS();
  75 
  76   G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs);
  77   ~G1RemSet();
  78 
  79   // Invoke "blk->do_oop" on all pointers into the collection set
  80   // from objects in regions outside the collection set (having
  81   // invoked "blk->set_region" to set the "from" region correctly
  82   // beforehand.)
  83   //
  84   // Apply non_heap_roots on the oops of the unmarked nmethods
  85   // on the strong code roots list for each region in the
  86   // collection set.
  87   //
  88   // The "worker_i" param is for the parallel case where the id
  89   // of the worker thread calling this function can be helpful in


 121   // Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
 122   // or card, respectively, such that a region or card with a corresponding
 123   // 0 bit contains no part of any live object.  Eliminates any remembered
 124   // set entries that correspond to dead heap ranges. "worker_num" is the
 125   // parallel thread id of the current thread, and "hrclaimer" is the
 126   // HeapRegionClaimer that should be used.
 127   void scrub(BitMap* region_bm, BitMap* card_bm, uint worker_num, HeapRegionClaimer* hrclaimer);
 128 
 129   // Refine the card corresponding to "card_ptr".
 130   // If check_for_refs_into_cset is true, a true result is returned
 131   // if the given card contains oops that have references into the
 132   // current collection set.
 133   virtual bool refine_card(jbyte* card_ptr,
 134                            uint worker_i,
 135                            bool check_for_refs_into_cset);
 136 
 137   // Print accumulated summary info from the start of the VM.
 138   virtual void print_summary_info();
 139 
 140   // Print accumulated summary info from the last time called.
 141   virtual void print_periodic_summary_info(const char* header, uint period_count);
 142 
 143   // Prepare remembered set for verification.
 144   virtual void prepare_for_verify();
 145 
 146   size_t conc_refine_cards() const {
 147     return _conc_refine_cards;
 148   }
 149 };
 150 
 151 class UpdateRSOopClosure: public ExtendedOopClosure {
 152   HeapRegion* _from;
 153   G1RemSet* _rs;
 154   uint _worker_i;
 155 
 156   template <class T> void do_oop_work(T* p);
 157 
 158 public:
 159   UpdateRSOopClosure(G1RemSet* rs, uint worker_i = 0) :
 160     _from(NULL), _rs(rs), _worker_i(worker_i)
 161   {}
< prev index next >