63   bool _defer_initial_card_mark;

    52   bool       _defer_initial_card_mark;

    53   CardTable* _card_table;

    65   // a word's worth (row) of clean card values

    55   CardTableModRefBS(CardTable* card_table, const BarrierSet::FakeRtti& fake_rtti);

    66   static const intptr_t clean_card_row = (intptr_t)(-1);

    67 

    68   // The declaration order of these const fields is important; see the

    69   // constructor before changing.

    70   const MemRegion _whole_heap;       // the region covered by the card table

    71   size_t          _guard_index;      // index of very last element in the card

    72                                      // table; it is set to a guard value

    73                                      // (last_card) and should never be modified

    74   size_t          _last_valid_index; // index of the last valid element

    75   const size_t    _page_size;        // page size used when mapping _byte_map

    76   size_t          _byte_map_size;    // in bytes

    77   jbyte*          _byte_map;         // the card marking array

    78 

    79   // Some barrier sets create tables whose elements correspond to parts of

    80   // the heap; the CardTableModRefBS is an example.  Such barrier sets will

    81   // normally reserve space for such tables, and commit parts of the table

    82   // "covering" parts of the heap that are committed. At most one covered

    83   // region per generation is needed.

    84   static const int _max_covered_regions = 2;

    85 

    86   int _cur_covered_regions;

    87 

    88   // The covered regions should be in address order.

    89   MemRegion* _covered;

    90   // The committed regions correspond one-to-one to the covered regions.

    91   // They represent the card-table memory that has been committed to service

    92   // the corresponding covered region.  It may be that committed region for

    93   // one covered region corresponds to a larger region because of page-size

    94   // roundings.  Thus, a committed region for one covered region may

    95   // actually extend onto the card-table space for the next covered region.

    96   MemRegion* _committed;

    97 

    98   // The last card is a guard card, and we commit the page for it so

    99   // we can use the card for verification purposes. We make sure we never

   100   // uncommit the MemRegion for that page.

   101   MemRegion _guard_region;

   102 

   103   inline size_t compute_byte_map_size();

   104 

   105   // Finds and return the index of the region, if any, to which the given

   106   // region would be contiguous.  If none exists, assign a new region and

   107   // returns its index.  Requires that no more than the maximum number of

   108   // covered regions defined in the constructor are ever in use.

   109   int find_covering_region_by_base(HeapWord* base);

   110 

   111   // Same as above, but finds the region containing the given address

   112   // instead of starting at a given base address.

   113   int find_covering_region_containing(HeapWord* addr);

   114 

   115   // Resize one of the regions covered by the remembered set.

   116   virtual void resize_covered_region(MemRegion new_region);

   117 

   118   // Returns the leftmost end of a committed region corresponding to a

   119   // covered region before covered region "ind", or else "NULL" if "ind" is

   120   // the first covered region.

   121   HeapWord* largest_prev_committed_end(int ind) const;

   122 

   123   // Returns the part of the region mr that doesn't intersect with

   124   // any committed region other than self.  Used to prevent uncommitting

   125   // regions that are also committed by other regions.  Also protects

   126   // against uncommitting the guard region.

   127   MemRegion committed_unique_to_self(int self, MemRegion mr) const;

   128 

   129   // Mapping from address to card marking array entry

   130   jbyte* byte_for(const void* p) const {

   131     assert(_whole_heap.contains(p),

   132            "Attempt to access p = " PTR_FORMAT " out of bounds of "

   133            " card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",

   134            p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()));

   135     jbyte* result = &byte_map_base[uintptr_t(p) >> card_shift];

   136     assert(result >= _byte_map && result < _byte_map + _byte_map_size,

   137            "out of bounds accessor for card marking array");

   138     return result;

   139   }

   140 

   141   // The card table byte one after the card marking array

   142   // entry for argument address. Typically used for higher bounds

   143   // for loops iterating through the card table.

   144   jbyte* byte_after(const void* p) const {

   145     return byte_for(p) + 1;

   146   }

   147 

   148   // Dirty the bytes corresponding to "mr" (not all of which must be

   149   // covered.)

   150   void dirty_MemRegion(MemRegion mr);

   151 

   152   // Clear (to clean_card) the bytes entirely contained within "mr" (not

   153   // all of which must be covered.)

   154   void clear_MemRegion(MemRegion mr);

   157   // Constants

    58   CardTableModRefBS(CardTable* card_table);

   158   enum SomePublicConstants {

    59   ~CardTableModRefBS();

   159     card_shift                  = 9,

   160     card_size                   = 1 << card_shift,

   161     card_size_in_words          = card_size / sizeof(HeapWord)

   162   };

   164   static int clean_card_val()      { return clean_card; }

    61   CardTable* card_table() const { return _card_table; }

   165   static int clean_card_mask_val() { return clean_card_mask; }

   166   static int dirty_card_val()      { return dirty_card; }

   167   static int claimed_card_val()    { return claimed_card; }

   168   static int precleaned_card_val() { return precleaned_card; }

   169   static int deferred_card_val()   { return deferred_card; }

   173   // *** Barrier set functions.

    65   void write_region(MemRegion mr) {

   174 

    66     invalidate(mr);

   175   // Initialization utilities; covered_words is the size of the covered region

   176   // in, um, words.

   177   inline size_t cards_required(size_t covered_words) {

   178     // Add one for a guard card, used to detect errors.

   179     const size_t words = align_up(covered_words, card_size_in_words);

   180     return words / card_size_in_words + 1;

   184   CardTableModRefBS(MemRegion whole_heap, const BarrierSet::FakeRtti& fake_rtti);

    70   void write_ref_array_work(MemRegion mr);

   185   ~CardTableModRefBS();

   355   virtual bool card_mark_must_follow_store() const = 0;

   116   virtual bool card_mark_must_follow_store() const;

   356 

   357   virtual bool is_in_young(oop obj) const = 0;