1 /* 2 * Copyright (c) 2001, 2020, 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_GC_SHARED_CARDTABLERS_HPP 26 #define SHARE_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 CardValue* _last_cur_val_in_gen; 80 81 CardValue _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 CardValue cur_youngergen_card_val() { 87 return _cur_youngergen_card_val; 88 } 89 void set_cur_youngergen_card_val(CardValue v) { 90 _cur_youngergen_card_val = v; 91 } 92 bool is_prev_youngergen_card_val(CardValue 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 CardValue 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 CardValue* 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 bool is_aligned(HeapWord* addr) { 128 return is_card_aligned(addr); 129 } 130 131 void verify(); 132 void initialize(); 133 134 void clear_into_younger(Generation* old_gen); 135 136 void invalidate_or_clear(Generation* old_gen); 137 138 bool is_prev_nonclean_card_val(CardValue v) { 139 return 140 youngergen_card <= v && 141 v <= cur_youngergen_and_prev_nonclean_card && 142 v != _cur_youngergen_card_val; 143 } 144 145 static bool youngergen_may_have_been_dirty(CardValue cv) { 146 return cv == CardTableRS::cur_youngergen_and_prev_nonclean_card; 147 } 148 149 // *** Support for parallel card scanning. 150 151 // dirty and precleaned are equivalent wrt younger_refs_iter. 152 static bool card_is_dirty_wrt_gen_iter(CardValue cv) { 153 return cv == dirty_card; 154 } 155 156 // Returns "true" iff the value "cv" will cause the card containing it 157 // to be scanned in the current traversal. May be overridden by 158 // subtypes. 159 bool card_will_be_scanned(CardValue cv); 160 161 // Returns "true" iff the value "cv" may have represented a dirty card at 162 // some point. 163 bool card_may_have_been_dirty(CardValue cv); 164 165 // Iterate over the portion of the card-table which covers the given 166 // region mr in the given space and apply cl to any dirty sub-regions 167 // of mr. Clears the dirty cards as they are processed. 168 void non_clean_card_iterate_possibly_parallel(Space* sp, MemRegion mr, 169 OopsInGenClosure* cl, CardTableRS* ct, 170 uint n_threads); 171 172 // Work method used to implement non_clean_card_iterate_possibly_parallel() 173 // above in the parallel case. 174 virtual void non_clean_card_iterate_parallel_work(Space* sp, MemRegion mr, 175 OopsInGenClosure* cl, CardTableRS* ct, 176 uint n_threads); 177 178 // This is an array, one element per covered region of the card table. 179 // Each entry is itself an array, with one element per chunk in the 180 // covered region. Each entry of these arrays is the lowest non-clean 181 // card of the corresponding chunk containing part of an object from the 182 // previous chunk, or else NULL. 183 typedef CardValue* CardPtr; 184 typedef CardPtr* CardArr; 185 CardArr* _lowest_non_clean; 186 size_t* _lowest_non_clean_chunk_size; 187 uintptr_t* _lowest_non_clean_base_chunk_index; 188 volatile int* _last_LNC_resizing_collection; 189 190 virtual bool is_in_young(oop obj) const; 191 }; 192 193 class ClearNoncleanCardWrapper: public MemRegionClosure { 194 DirtyCardToOopClosure* _dirty_card_closure; 195 CardTableRS* _ct; 196 bool _is_par; 197 198 public: 199 200 typedef CardTable::CardValue CardValue; 201 private: 202 // Clears the given card, return true if the corresponding card should be 203 // processed. 204 inline bool clear_card(CardValue* entry); 205 // Work methods called by the clear_card() 206 inline bool clear_card_serial(CardValue* entry); 207 inline bool clear_card_parallel(CardValue* entry); 208 // check alignment of pointer 209 bool is_word_aligned(CardValue* entry); 210 211 public: 212 ClearNoncleanCardWrapper(DirtyCardToOopClosure* dirty_card_closure, CardTableRS* ct, bool is_par); 213 void do_MemRegion(MemRegion mr); 214 }; 215 216 #endif // SHARE_GC_SHARED_CARDTABLERS_HPP