src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp

Print this page
rev 5363 : imported patch filtering.diff


  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1SATBCARDTABLEMODREFBS_HPP
  26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1SATBCARDTABLEMODREFBS_HPP
  27 
  28 #include "memory/cardTableModRefBS.hpp"
  29 #include "memory/memRegion.hpp"
  30 #include "oops/oop.inline.hpp"
  31 #include "utilities/macros.hpp"
  32 
  33 #if INCLUDE_ALL_GCS
  34 
  35 class DirtyCardQueueSet;
  36 
  37 // This barrier is specialized to use a logging barrier to support
  38 // snapshot-at-the-beginning marking.
  39 
  40 class G1SATBCardTableModRefBS: public CardTableModRefBSForCTRS {





  41 public:


  42   // Add "pre_val" to a set of objects that may have been disconnected from the
  43   // pre-marking object graph.
  44   static void enqueue(oop pre_val);
  45 
  46   G1SATBCardTableModRefBS(MemRegion whole_heap,
  47                           int max_covered_regions);
  48 
  49   bool is_a(BarrierSet::Name bsn) {
  50     return bsn == BarrierSet::G1SATBCT || CardTableModRefBS::is_a(bsn);
  51   }
  52 
  53   virtual bool has_write_ref_pre_barrier() { return true; }
  54 
  55   // This notes that we don't need to access any BarrierSet data
  56   // structures, so this can be called from a static context.
  57   template <class T> static void write_ref_field_pre_static(T* field, oop newVal) {
  58     T heap_oop = oopDesc::load_heap_oop(field);
  59     if (!oopDesc::is_null(heap_oop)) {
  60       enqueue(oopDesc::decode_heap_oop(heap_oop));
  61     }


 100       was either clean or claimed. mark_card_deferred() is wait-free.
 101       We do not care if the operation is be successful because if
 102       it does not it will only result in duplicate entry in the update
 103       buffer because of the "cache-miss". So it's not worth spinning.
 104  */
 105 
 106   bool is_card_claimed(size_t card_index) {
 107     jbyte val = _byte_map[card_index];
 108     return (val & (clean_card_mask_val() | claimed_card_val())) == claimed_card_val();
 109   }
 110 
 111   void set_card_claimed(size_t card_index) {
 112       jbyte val = _byte_map[card_index];
 113       if (val == clean_card_val()) {
 114         val = (jbyte)claimed_card_val();
 115       } else {
 116         val |= (jbyte)claimed_card_val();
 117       }
 118       _byte_map[card_index] = val;
 119   }



 120 
 121   bool mark_card_deferred(size_t card_index);
 122 
 123   bool is_card_deferred(size_t card_index) {
 124     jbyte val = _byte_map[card_index];
 125     return (val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val();
 126   }
 127 
 128 };
 129 
 130 // Adds card-table logging to the post-barrier.
 131 // Usual invariant: all dirty cards are logged in the DirtyCardQueueSet.
 132 class G1SATBCardTableLoggingModRefBS: public G1SATBCardTableModRefBS {
 133  private:
 134   DirtyCardQueueSet& _dcqs;
 135  public:
 136   G1SATBCardTableLoggingModRefBS(MemRegion whole_heap,
 137                                  int max_covered_regions);
 138 
 139   bool is_a(BarrierSet::Name bsn) {




  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1SATBCARDTABLEMODREFBS_HPP
  26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1SATBCARDTABLEMODREFBS_HPP
  27 
  28 #include "memory/cardTableModRefBS.hpp"
  29 #include "memory/memRegion.hpp"
  30 #include "oops/oop.inline.hpp"
  31 #include "utilities/macros.hpp"
  32 
  33 #if INCLUDE_ALL_GCS
  34 
  35 class DirtyCardQueueSet;
  36 
  37 // This barrier is specialized to use a logging barrier to support
  38 // snapshot-at-the-beginning marking.
  39 
  40 class G1SATBCardTableModRefBS: public CardTableModRefBSForCTRS {
  41 protected:
  42   enum G1CardValues {
  43     g1_young_gen = CT_MR_BS_last_reserved << 1
  44   };
  45 
  46 public:
  47   static int g1_young_card_val()   { return g1_young_gen; }
  48 
  49   // Add "pre_val" to a set of objects that may have been disconnected from the
  50   // pre-marking object graph.
  51   static void enqueue(oop pre_val);
  52 
  53   G1SATBCardTableModRefBS(MemRegion whole_heap,
  54                           int max_covered_regions);
  55 
  56   bool is_a(BarrierSet::Name bsn) {
  57     return bsn == BarrierSet::G1SATBCT || CardTableModRefBS::is_a(bsn);
  58   }
  59 
  60   virtual bool has_write_ref_pre_barrier() { return true; }
  61 
  62   // This notes that we don't need to access any BarrierSet data
  63   // structures, so this can be called from a static context.
  64   template <class T> static void write_ref_field_pre_static(T* field, oop newVal) {
  65     T heap_oop = oopDesc::load_heap_oop(field);
  66     if (!oopDesc::is_null(heap_oop)) {
  67       enqueue(oopDesc::decode_heap_oop(heap_oop));
  68     }


 107       was either clean or claimed. mark_card_deferred() is wait-free.
 108       We do not care if the operation is be successful because if
 109       it does not it will only result in duplicate entry in the update
 110       buffer because of the "cache-miss". So it's not worth spinning.
 111  */
 112 
 113   bool is_card_claimed(size_t card_index) {
 114     jbyte val = _byte_map[card_index];
 115     return (val & (clean_card_mask_val() | claimed_card_val())) == claimed_card_val();
 116   }
 117 
 118   void set_card_claimed(size_t card_index) {
 119       jbyte val = _byte_map[card_index];
 120       if (val == clean_card_val()) {
 121         val = (jbyte)claimed_card_val();
 122       } else {
 123         val |= (jbyte)claimed_card_val();
 124       }
 125       _byte_map[card_index] = val;
 126   }
 127 
 128   void verify_g1_young_region(MemRegion mr) PRODUCT_RETURN;
 129   void g1_mark_as_young(const MemRegion& mr);
 130 
 131   bool mark_card_deferred(size_t card_index);
 132 
 133   bool is_card_deferred(size_t card_index) {
 134     jbyte val = _byte_map[card_index];
 135     return (val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val();
 136   }
 137 
 138 };
 139 
 140 // Adds card-table logging to the post-barrier.
 141 // Usual invariant: all dirty cards are logged in the DirtyCardQueueSet.
 142 class G1SATBCardTableLoggingModRefBS: public G1SATBCardTableModRefBS {
 143  private:
 144   DirtyCardQueueSet& _dcqs;
 145  public:
 146   G1SATBCardTableLoggingModRefBS(MemRegion whole_heap,
 147                                  int max_covered_regions);
 148 
 149   bool is_a(BarrierSet::Name bsn) {