1 /* 2 * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 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_SHARED_CARDTABLERS_HPP 26 #define SHARE_VM_GC_SHARED_CARDTABLERS_HPP 27 28 #include "gc/shared/cardTable.hpp" 29 #include "memory/memRegion.hpp" 30 #include "oops/oop.hpp" 31 32 class DirtyCardToOopClosure; 33 class Generation; 34 class Space; 35 class OopsInGenClosure; 36 37 // Helper to remember modified oops in all clds. 38 class CLDRemSet { 39 bool _accumulate_modified_oops; 40 public: 41 CLDRemSet() : _accumulate_modified_oops(false) {} 42 void set_accumulate_modified_oops(bool value) { _accumulate_modified_oops = value; } 43 bool accumulate_modified_oops() { return _accumulate_modified_oops; } 44 bool mod_union_is_clear(); 45 void clear_mod_union(); 46 }; 47 48 // This RemSet uses a card table both as shared data structure 49 // for a mod ref barrier set and for the rem set information. 50 51 class CardTableRS: public CardTable { 52 friend class VMStructs; 53 // Below are private classes used in impl. 54 friend class VerifyCTSpaceClosure; 55 friend class ClearNoncleanCardWrapper; 56 57 CLDRemSet _cld_rem_set; 58 59 void verify_space(Space* s, HeapWord* gen_start); 60 61 enum ExtendedCardValue { 62 youngergen_card = CT_MR_BS_last_reserved + 1, 63 // These are for parallel collection. 64 // There are three P (parallel) youngergen card values. In general, this 65 // needs to be more than the number of generations (including the perm 66 // gen) that might have younger_refs_do invoked on them separately. So 67 // if we add more gens, we have to add more values. 68 youngergenP1_card = CT_MR_BS_last_reserved + 2, 69 youngergenP2_card = CT_MR_BS_last_reserved + 3, 70 youngergenP3_card = CT_MR_BS_last_reserved + 4, 71 cur_youngergen_and_prev_nonclean_card = 72 CT_MR_BS_last_reserved + 5 73 }; 74 75 // An array that contains, for each generation, the card table value last 76 // used as the current value for a younger_refs_do iteration of that 77 // portion of the table. The perm gen is index 0. The young gen is index 1, 78 // but will always have the value "clean_card". The old gen is index 2. 79 jbyte* _last_cur_val_in_gen; 80 81 jbyte _cur_youngergen_card_val; 82 83 // Number of generations, plus one for lingering PermGen issues in CardTableRS. 84 static const int _regions_to_iterate = 3; 85 86 jbyte cur_youngergen_card_val() { 87 return _cur_youngergen_card_val; 88 } 89 void set_cur_youngergen_card_val(jbyte v) { 90 _cur_youngergen_card_val = v; 91 } 92 bool is_prev_youngergen_card_val(jbyte v) { 93 return 94 youngergen_card <= v && 95 v < cur_youngergen_and_prev_nonclean_card && 96 v != _cur_youngergen_card_val; 97 } 98 // Return a youngergen_card_value that is not currently in use. 99 jbyte find_unused_youngergenP_card_value(); 100 101 public: 102 CardTableRS(MemRegion whole_heap, bool scanned_concurrently); 103 ~CardTableRS(); 104 105 CLDRemSet* cld_rem_set() { return &_cld_rem_set; } 106 107 void younger_refs_in_space_iterate(Space* sp, OopsInGenClosure* cl, uint n_threads); 108 109 virtual void verify_used_region_at_save_marks(Space* sp) const NOT_DEBUG_RETURN; 110 111 // Override. 112 void prepare_for_younger_refs_iterate(bool parallel); 113 114 // Card table entries are cleared before application; "blk" is 115 // responsible for dirtying if the oop is still older-to-younger after 116 // closure application. 117 void younger_refs_iterate(Generation* g, OopsInGenClosure* blk, uint n_threads); 118 119 void inline_write_ref_field_gc(void* field, oop new_val) { 120 jbyte* byte = byte_for(field); 121 *byte = youngergen_card; 122 } 123 void write_ref_field_gc_work(void* field, oop new_val) { 124 inline_write_ref_field_gc(field, new_val); 125 } 126 127 // Override. Might want to devirtualize this in the same fashion as 128 // above. Ensures that the value of the card for field says that it's 129 // a younger card in the current collection. 130 virtual void write_ref_field_gc_par(void* field, oop new_val); 131 132 bool is_aligned(HeapWord* addr) { 133 return is_card_aligned(addr); 134 } 135 136 void verify(); 137 void initialize(); 138 139 void clear_into_younger(Generation* old_gen); 140 141 void invalidate_or_clear(Generation* old_gen); 142 143 bool is_prev_nonclean_card_val(jbyte v) { 144 return 145 youngergen_card <= v && 146 v <= cur_youngergen_and_prev_nonclean_card && 147 v != _cur_youngergen_card_val; 148 } 149 150 static bool youngergen_may_have_been_dirty(jbyte cv) { 151 return cv == CardTableRS::cur_youngergen_and_prev_nonclean_card; 152 } 153 154 // *** Support for parallel card scanning. 155 156 // dirty and precleaned are equivalent wrt younger_refs_iter. 157 static bool card_is_dirty_wrt_gen_iter(jbyte cv) { 158 return cv == dirty_card || cv == precleaned_card; 159 } 160 161 // Returns "true" iff the value "cv" will cause the card containing it 162 // to be scanned in the current traversal. May be overridden by 163 // subtypes. 164 bool card_will_be_scanned(jbyte cv); 165 166 // Returns "true" iff the value "cv" may have represented a dirty card at 167 // some point. 168 bool card_may_have_been_dirty(jbyte cv); 169 170 // Iterate over the portion of the card-table which covers the given 171 // region mr in the given space and apply cl to any dirty sub-regions 172 // of mr. Clears the dirty cards as they are processed. 173 void non_clean_card_iterate_possibly_parallel(Space* sp, MemRegion mr, 174 OopsInGenClosure* cl, CardTableRS* ct, 175 uint n_threads); 176 177 // Work method used to implement non_clean_card_iterate_possibly_parallel() 178 // above in the parallel case. 179 virtual void non_clean_card_iterate_parallel_work(Space* sp, MemRegion mr, 180 OopsInGenClosure* cl, CardTableRS* ct, 181 uint n_threads); 182 183 // This is an array, one element per covered region of the card table. 184 // Each entry is itself an array, with one element per chunk in the 185 // covered region. Each entry of these arrays is the lowest non-clean 186 // card of the corresponding chunk containing part of an object from the 187 // previous chunk, or else NULL. 188 typedef jbyte* CardPtr; 189 typedef CardPtr* CardArr; 190 CardArr* _lowest_non_clean; 191 size_t* _lowest_non_clean_chunk_size; 192 uintptr_t* _lowest_non_clean_base_chunk_index; 193 volatile int* _last_LNC_resizing_collection; 194 195 virtual bool is_in_young(oop obj) const; 196 }; 197 198 class ClearNoncleanCardWrapper: public MemRegionClosure { 199 DirtyCardToOopClosure* _dirty_card_closure; 200 CardTableRS* _ct; 201 bool _is_par; 202 private: 203 // Clears the given card, return true if the corresponding card should be 204 // processed. 205 inline bool clear_card(jbyte* entry); 206 // Work methods called by the clear_card() 207 inline bool clear_card_serial(jbyte* entry); 208 inline bool clear_card_parallel(jbyte* entry); 209 // check alignment of pointer 210 bool is_word_aligned(jbyte* entry); 211 212 public: 213 ClearNoncleanCardWrapper(DirtyCardToOopClosure* dirty_card_closure, CardTableRS* ct, bool is_par); 214 void do_MemRegion(MemRegion mr); 215 }; 216 217 #endif // SHARE_VM_GC_SHARED_CARDTABLERS_HPP