Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/cardTableModRefBS.hpp @ 3772:6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
Summary: Perform a heap verification after the first phase of G1's full GC using objects' mark words to determine liveness. The third parameter of the heap verification routines, which was used in G1 to determine which marking bitmap to use in liveness calculations, has been changed from a boolean to an enum with values defined for using the mark word, and the 'prev' and 'next' bitmaps.
Reviewed-by: tonyp, ysr
author | johnc |
---|---|
date | Tue, 14 Jun 2011 11:01:10 -0700 |
parents | 7d64aa23eb96 |
children | ea640b5e949a |
rev | line source |
---|---|
0 | 1 /* |
3256
c69b1043dfb1
7036482: clear argument is redundant and unused in cardtable methods
ysr
parents:
2433
diff
changeset
|
2 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1261
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1261
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1261
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_MEMORY_CARDTABLEMODREFBS_HPP |
26 #define SHARE_VM_MEMORY_CARDTABLEMODREFBS_HPP | |
27 | |
28 #include "memory/modRefBarrierSet.hpp" | |
29 #include "oops/oop.hpp" | |
30 #include "oops/oop.inline2.hpp" | |
31 | |
0 | 32 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and |
33 // enumerate ref fields that have been modified (since the last | |
34 // enumeration.) | |
35 | |
36 // As it currently stands, this barrier is *imprecise*: when a ref field in | |
37 // an object "o" is modified, the card table entry for the card containing | |
38 // the head of "o" is dirtied, not necessarily the card containing the | |
39 // modified field itself. For object arrays, however, the barrier *is* | |
40 // precise; only the card containing the modified element is dirtied. | |
41 // Any MemRegionClosures used to scan dirty cards should take these | |
42 // considerations into account. | |
43 | |
44 class Generation; | |
45 class OopsInGenClosure; | |
46 class DirtyCardToOopClosure; | |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
47 class ClearNoncleanCardWrapper; |
0 | 48 |
49 class CardTableModRefBS: public ModRefBarrierSet { | |
50 // Some classes get to look at some private stuff. | |
51 friend class BytecodeInterpreter; | |
52 friend class VMStructs; | |
53 friend class CardTableRS; | |
54 friend class CheckForUnmarkedOops; // Needs access to raw card bytes. | |
1692 | 55 friend class SharkBuilder; |
0 | 56 #ifndef PRODUCT |
57 // For debugging. | |
58 friend class GuaranteeNotModClosure; | |
59 #endif | |
60 protected: | |
61 | |
62 enum CardValues { | |
63 clean_card = -1, | |
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
64 // The mask contains zeros in places for all other values. |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
65 clean_card_mask = clean_card - 31, |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
66 |
0 | 67 dirty_card = 0, |
68 precleaned_card = 1, | |
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
69 claimed_card = 2, |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
70 deferred_card = 4, |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
71 last_card = 8, |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
72 CT_MR_BS_last_reserved = 16 |
0 | 73 }; |
74 | |
75 // dirty and precleaned are equivalent wrt younger_refs_iter. | |
76 static bool card_is_dirty_wrt_gen_iter(jbyte cv) { | |
77 return cv == dirty_card || cv == precleaned_card; | |
78 } | |
79 | |
80 // Returns "true" iff the value "cv" will cause the card containing it | |
81 // to be scanned in the current traversal. May be overridden by | |
82 // subtypes. | |
83 virtual bool card_will_be_scanned(jbyte cv) { | |
84 return CardTableModRefBS::card_is_dirty_wrt_gen_iter(cv); | |
85 } | |
86 | |
87 // Returns "true" iff the value "cv" may have represented a dirty card at | |
88 // some point. | |
89 virtual bool card_may_have_been_dirty(jbyte cv) { | |
90 return card_is_dirty_wrt_gen_iter(cv); | |
91 } | |
92 | |
93 // The declaration order of these const fields is important; see the | |
94 // constructor before changing. | |
95 const MemRegion _whole_heap; // the region covered by the card table | |
96 const size_t _guard_index; // index of very last element in the card | |
97 // table; it is set to a guard value | |
98 // (last_card) and should never be modified | |
99 const size_t _last_valid_index; // index of the last valid element | |
100 const size_t _page_size; // page size used when mapping _byte_map | |
101 const size_t _byte_map_size; // in bytes | |
102 jbyte* _byte_map; // the card marking array | |
103 | |
104 int _cur_covered_regions; | |
105 // The covered regions should be in address order. | |
106 MemRegion* _covered; | |
107 // The committed regions correspond one-to-one to the covered regions. | |
108 // They represent the card-table memory that has been committed to service | |
109 // the corresponding covered region. It may be that committed region for | |
110 // one covered region corresponds to a larger region because of page-size | |
111 // roundings. Thus, a committed region for one covered region may | |
112 // actually extend onto the card-table space for the next covered region. | |
113 MemRegion* _committed; | |
114 | |
115 // The last card is a guard card, and we commit the page for it so | |
116 // we can use the card for verification purposes. We make sure we never | |
117 // uncommit the MemRegion for that page. | |
118 MemRegion _guard_region; | |
119 | |
120 protected: | |
121 // Initialization utilities; covered_words is the size of the covered region | |
122 // in, um, words. | |
123 inline size_t cards_required(size_t covered_words); | |
124 inline size_t compute_byte_map_size(); | |
125 | |
126 // Finds and return the index of the region, if any, to which the given | |
127 // region would be contiguous. If none exists, assign a new region and | |
128 // returns its index. Requires that no more than the maximum number of | |
129 // covered regions defined in the constructor are ever in use. | |
130 int find_covering_region_by_base(HeapWord* base); | |
131 | |
132 // Same as above, but finds the region containing the given address | |
133 // instead of starting at a given base address. | |
134 int find_covering_region_containing(HeapWord* addr); | |
135 | |
136 // Resize one of the regions covered by the remembered set. | |
137 void resize_covered_region(MemRegion new_region); | |
138 | |
139 // Returns the leftmost end of a committed region corresponding to a | |
140 // covered region before covered region "ind", or else "NULL" if "ind" is | |
141 // the first covered region. | |
142 HeapWord* largest_prev_committed_end(int ind) const; | |
143 | |
144 // Returns the part of the region mr that doesn't intersect with | |
145 // any committed region other than self. Used to prevent uncommitting | |
146 // regions that are also committed by other regions. Also protects | |
147 // against uncommitting the guard region. | |
148 MemRegion committed_unique_to_self(int self, MemRegion mr) const; | |
149 | |
150 // Mapping from address to card marking array entry | |
151 jbyte* byte_for(const void* p) const { | |
152 assert(_whole_heap.contains(p), | |
3359
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
153 err_msg("Attempt to access p = "PTR_FORMAT" out of bounds of " |
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
154 " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", |
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
155 p, _whole_heap.start(), _whole_heap.end())); |
0 | 156 jbyte* result = &byte_map_base[uintptr_t(p) >> card_shift]; |
157 assert(result >= _byte_map && result < _byte_map + _byte_map_size, | |
158 "out of bounds accessor for card marking array"); | |
159 return result; | |
160 } | |
161 | |
162 // The card table byte one after the card marking array | |
163 // entry for argument address. Typically used for higher bounds | |
164 // for loops iterating through the card table. | |
165 jbyte* byte_after(const void* p) const { | |
166 return byte_for(p) + 1; | |
167 } | |
168 | |
169 // Iterate over the portion of the card-table which covers the given | |
170 // region mr in the given space and apply cl to any dirty sub-regions | |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
171 // of mr. Dirty cards are _not_ cleared by the iterator method itself, |
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
172 // but closures may arrange to do so on their own should they so wish. |
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
173 void non_clean_card_iterate_serial(MemRegion mr, MemRegionClosure* cl); |
0 | 174 |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
175 // A variant of the above that will operate in a parallel mode if |
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
176 // worker threads are available, and clear the dirty cards as it |
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
177 // processes them. |
3357
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
178 // XXX ??? MemRegionClosure above vs OopsInGenClosure below XXX |
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
179 // XXX some new_dcto_cl's take OopClosure's, plus as above there are |
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
180 // some MemRegionClosures. Clean this up everywhere. XXX |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
181 void non_clean_card_iterate_possibly_parallel(Space* sp, MemRegion mr, |
3357
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
182 OopsInGenClosure* cl, CardTableRS* ct); |
0 | 183 |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
184 private: |
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
185 // Work method used to implement non_clean_card_iterate_possibly_parallel() |
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
186 // above in the parallel case. |
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
187 void non_clean_card_iterate_parallel_work(Space* sp, MemRegion mr, |
3357
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
188 OopsInGenClosure* cl, CardTableRS* ct, |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
189 int n_threads); |
0 | 190 |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
191 protected: |
0 | 192 // Dirty the bytes corresponding to "mr" (not all of which must be |
193 // covered.) | |
194 void dirty_MemRegion(MemRegion mr); | |
195 | |
196 // Clear (to clean_card) the bytes entirely contained within "mr" (not | |
197 // all of which must be covered.) | |
198 void clear_MemRegion(MemRegion mr); | |
199 | |
200 // *** Support for parallel card scanning. | |
201 | |
202 // This is an array, one element per covered region of the card table. | |
203 // Each entry is itself an array, with one element per chunk in the | |
204 // covered region. Each entry of these arrays is the lowest non-clean | |
205 // card of the corresponding chunk containing part of an object from the | |
206 // previous chunk, or else NULL. | |
207 typedef jbyte* CardPtr; | |
208 typedef CardPtr* CardArr; | |
209 CardArr* _lowest_non_clean; | |
210 size_t* _lowest_non_clean_chunk_size; | |
211 uintptr_t* _lowest_non_clean_base_chunk_index; | |
212 int* _last_LNC_resizing_collection; | |
213 | |
214 // Initializes "lowest_non_clean" to point to the array for the region | |
215 // covering "sp", and "lowest_non_clean_base_chunk_index" to the chunk | |
216 // index of the corresponding to the first element of that array. | |
217 // Ensures that these arrays are of sufficient size, allocating if necessary. | |
218 // May be called by several threads concurrently. | |
219 void get_LNC_array_for_space(Space* sp, | |
220 jbyte**& lowest_non_clean, | |
221 uintptr_t& lowest_non_clean_base_chunk_index, | |
222 size_t& lowest_non_clean_chunk_size); | |
223 | |
224 // Returns the number of chunks necessary to cover "mr". | |
225 size_t chunks_to_cover(MemRegion mr) { | |
226 return (size_t)(addr_to_chunk_index(mr.last()) - | |
227 addr_to_chunk_index(mr.start()) + 1); | |
228 } | |
229 | |
230 // Returns the index of the chunk in a stride which | |
231 // covers the given address. | |
232 uintptr_t addr_to_chunk_index(const void* addr) { | |
233 uintptr_t card = (uintptr_t) byte_for(addr); | |
3357
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
234 return card / ParGCCardsPerStrideChunk; |
0 | 235 } |
236 | |
237 // Apply cl, which must either itself apply dcto_cl or be dcto_cl, | |
238 // to the cards in the stride (of n_strides) within the given space. | |
239 void process_stride(Space* sp, | |
240 MemRegion used, | |
241 jint stride, int n_strides, | |
3357
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
242 OopsInGenClosure* cl, |
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
243 CardTableRS* ct, |
0 | 244 jbyte** lowest_non_clean, |
245 uintptr_t lowest_non_clean_base_chunk_index, | |
246 size_t lowest_non_clean_chunk_size); | |
247 | |
248 // Makes sure that chunk boundaries are handled appropriately, by | |
249 // adjusting the min_done of dcto_cl, and by using a special card-table | |
250 // value to indicate how min_done should be set. | |
251 void process_chunk_boundaries(Space* sp, | |
252 DirtyCardToOopClosure* dcto_cl, | |
253 MemRegion chunk_mr, | |
254 MemRegion used, | |
255 jbyte** lowest_non_clean, | |
256 uintptr_t lowest_non_clean_base_chunk_index, | |
257 size_t lowest_non_clean_chunk_size); | |
258 | |
259 public: | |
260 // Constants | |
261 enum SomePublicConstants { | |
262 card_shift = 9, | |
263 card_size = 1 << card_shift, | |
264 card_size_in_words = card_size / sizeof(HeapWord) | |
265 }; | |
266 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
267 static int clean_card_val() { return clean_card; } |
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
268 static int clean_card_mask_val() { return clean_card_mask; } |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
269 static int dirty_card_val() { return dirty_card; } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
270 static int claimed_card_val() { return claimed_card; } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
271 static int precleaned_card_val() { return precleaned_card; } |
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
272 static int deferred_card_val() { return deferred_card; } |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
273 |
0 | 274 // For RTTI simulation. |
275 bool is_a(BarrierSet::Name bsn) { | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
276 return bsn == BarrierSet::CardTableModRef || ModRefBarrierSet::is_a(bsn); |
0 | 277 } |
278 | |
279 CardTableModRefBS(MemRegion whole_heap, int max_covered_regions); | |
280 | |
281 // *** Barrier set functions. | |
282 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
283 bool has_write_ref_pre_barrier() { return false; } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
284 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
285 inline bool write_ref_needs_barrier(void* field, oop new_val) { |
0 | 286 // Note that this assumes the perm gen is the highest generation |
287 // in the address space | |
288 return new_val != NULL && !new_val->is_perm(); | |
289 } | |
290 | |
291 // Record a reference update. Note that these versions are precise! | |
292 // The scanning code has to handle the fact that the write barrier may be | |
293 // either precise or imprecise. We make non-virtual inline variants of | |
294 // these functions here for performance. | |
295 protected: | |
296 void write_ref_field_work(oop obj, size_t offset, oop newVal); | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
297 virtual void write_ref_field_work(void* field, oop newVal); |
0 | 298 public: |
299 | |
300 bool has_write_ref_array_opt() { return true; } | |
301 bool has_write_region_opt() { return true; } | |
302 | |
303 inline void inline_write_region(MemRegion mr) { | |
304 dirty_MemRegion(mr); | |
305 } | |
306 protected: | |
307 void write_region_work(MemRegion mr) { | |
308 inline_write_region(mr); | |
309 } | |
310 public: | |
311 | |
312 inline void inline_write_ref_array(MemRegion mr) { | |
313 dirty_MemRegion(mr); | |
314 } | |
315 protected: | |
316 void write_ref_array_work(MemRegion mr) { | |
317 inline_write_ref_array(mr); | |
318 } | |
319 public: | |
320 | |
321 bool is_aligned(HeapWord* addr) { | |
322 return is_card_aligned(addr); | |
323 } | |
324 | |
325 // *** Card-table-barrier-specific things. | |
326 | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
327 template <class T> inline void inline_write_ref_field_pre(T* field, oop newVal) {} |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
328 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
329 template <class T> inline void inline_write_ref_field(T* field, oop newVal) { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
628
diff
changeset
|
330 jbyte* byte = byte_for((void*)field); |
0 | 331 *byte = dirty_card; |
332 } | |
333 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
334 // These are used by G1, when it uses the card table as a temporary data |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
335 // structure for card claiming. |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
336 bool is_card_dirty(size_t card_index) { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
337 return _byte_map[card_index] == dirty_card_val(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
338 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
339 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
340 void mark_card_dirty(size_t card_index) { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
341 _byte_map[card_index] = dirty_card_val(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
342 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
343 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
344 bool is_card_claimed(size_t card_index) { |
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
345 jbyte val = _byte_map[card_index]; |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
346 return (val & (clean_card_mask_val() | claimed_card_val())) == claimed_card_val(); |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
347 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
348 |
1261 | 349 void set_card_claimed(size_t card_index) { |
350 jbyte val = _byte_map[card_index]; | |
351 if (val == clean_card_val()) { | |
352 val = (jbyte)claimed_card_val(); | |
353 } else { | |
354 val |= (jbyte)claimed_card_val(); | |
355 } | |
356 _byte_map[card_index] = val; | |
357 } | |
358 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
359 bool claim_card(size_t card_index); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
360 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
361 bool is_card_clean(size_t card_index) { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
362 return _byte_map[card_index] == clean_card_val(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
363 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
364 |
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
365 bool is_card_deferred(size_t card_index) { |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
366 jbyte val = _byte_map[card_index]; |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
367 return (val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val(); |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
368 } |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
369 |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
370 bool mark_card_deferred(size_t card_index); |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
371 |
0 | 372 // Card marking array base (adjusted for heap low boundary) |
373 // This would be the 0th element of _byte_map, if the heap started at 0x0. | |
374 // But since the heap starts at some higher address, this points to somewhere | |
375 // before the beginning of the actual _byte_map. | |
376 jbyte* byte_map_base; | |
377 | |
378 // Return true if "p" is at the start of a card. | |
379 bool is_card_aligned(HeapWord* p) { | |
380 jbyte* pcard = byte_for(p); | |
381 return (addr_for(pcard) == p); | |
382 } | |
383 | |
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
1972
diff
changeset
|
384 HeapWord* align_to_card_boundary(HeapWord* p) { |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
1972
diff
changeset
|
385 jbyte* pcard = byte_for(p + card_size_in_words - 1); |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
1972
diff
changeset
|
386 return addr_for(pcard); |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
1972
diff
changeset
|
387 } |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
1972
diff
changeset
|
388 |
0 | 389 // The kinds of precision a CardTableModRefBS may offer. |
390 enum PrecisionStyle { | |
391 Precise, | |
392 ObjHeadPreciseArray | |
393 }; | |
394 | |
395 // Tells what style of precision this card table offers. | |
396 PrecisionStyle precision() { | |
397 return ObjHeadPreciseArray; // Only one supported for now. | |
398 } | |
399 | |
400 // ModRefBS functions. | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
401 virtual void invalidate(MemRegion mr, bool whole_heap = false); |
0 | 402 void clear(MemRegion mr); |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
403 void dirty(MemRegion mr); |
0 | 404 |
405 // *** Card-table-RemSet-specific things. | |
406 | |
407 // Invoke "cl.do_MemRegion" on a set of MemRegions that collectively | |
408 // includes all the modified cards (expressing each card as a | |
409 // MemRegion). Thus, several modified cards may be lumped into one | |
410 // region. The regions are non-overlapping, and are visited in | |
411 // *decreasing* address order. (This order aids with imprecise card | |
412 // marking, where a dirty card may cause scanning, and summarization | |
413 // marking, of objects that extend onto subsequent cards.) | |
3256
c69b1043dfb1
7036482: clear argument is redundant and unused in cardtable methods
ysr
parents:
2433
diff
changeset
|
414 void mod_card_iterate(MemRegionClosure* cl) { |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
415 non_clean_card_iterate_serial(_whole_heap, cl); |
0 | 416 } |
417 | |
418 // Like the "mod_cards_iterate" above, except only invokes the closure | |
419 // for cards within the MemRegion "mr" (which is required to be | |
420 // card-aligned and sized.) | |
3256
c69b1043dfb1
7036482: clear argument is redundant and unused in cardtable methods
ysr
parents:
2433
diff
changeset
|
421 void mod_card_iterate(MemRegion mr, MemRegionClosure* cl) { |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
422 non_clean_card_iterate_serial(mr, cl); |
0 | 423 } |
424 | |
425 static uintx ct_max_alignment_constraint(); | |
426 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
427 // Apply closure "cl" to the dirty cards containing some part of |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
428 // MemRegion "mr". |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
429 void dirty_card_iterate(MemRegion mr, MemRegionClosure* cl); |
0 | 430 |
431 // Return the MemRegion corresponding to the first maximal run | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
432 // of dirty cards lying completely within MemRegion mr. |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
433 // If reset is "true", then sets those card table entries to the given |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
434 // value. |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
435 MemRegion dirty_card_range_after_reset(MemRegion mr, bool reset, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
436 int reset_val); |
0 | 437 |
438 // Set all the dirty cards in the given region to precleaned state. | |
439 void preclean_dirty_cards(MemRegion mr); | |
440 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
441 // Provide read-only access to the card table array. |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
442 const jbyte* byte_for_const(const void* p) const { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
443 return byte_for(p); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
444 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
445 const jbyte* byte_after_const(const void* p) const { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
446 return byte_after(p); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
447 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
448 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
449 // Mapping from card marking array entry to address of first word |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
450 HeapWord* addr_for(const jbyte* p) const { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
451 assert(p >= _byte_map && p < _byte_map + _byte_map_size, |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
452 "out of bounds access to card marking array"); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
453 size_t delta = pointer_delta(p, byte_map_base, sizeof(jbyte)); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
454 HeapWord* result = (HeapWord*) (delta << card_shift); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
455 assert(_whole_heap.contains(result), |
3359
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
456 err_msg("Returning result = "PTR_FORMAT" out of bounds of " |
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
457 " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", |
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
458 result, _whole_heap.start(), _whole_heap.end())); |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
459 return result; |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
460 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
461 |
0 | 462 // Mapping from address to card marking array index. |
489
2494ab195856
6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
swamyv
parents:
356
diff
changeset
|
463 size_t index_for(void* p) { |
0 | 464 assert(_whole_heap.contains(p), |
3359
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
465 err_msg("Attempt to access p = "PTR_FORMAT" out of bounds of " |
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
466 " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", |
7d64aa23eb96
7043891: CMS: assert(_whole_heap.contains(p)) failed: out of bounds access to card marking array
ysr
parents:
3357
diff
changeset
|
467 p, _whole_heap.start(), _whole_heap.end())); |
0 | 468 return byte_for(p) - _byte_map; |
469 } | |
470 | |
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
471 const jbyte* byte_for_index(const size_t card_index) const { |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
472 return _byte_map + card_index; |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
473 } |
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
489
diff
changeset
|
474 |
0 | 475 void verify(); |
476 void verify_guard(); | |
477 | |
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3287
diff
changeset
|
478 // val_equals -> it will check that all cards covered by mr equal val |
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3287
diff
changeset
|
479 // !val_equals -> it will check that all cards covered by mr do not equal val |
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3287
diff
changeset
|
480 void verify_region(MemRegion mr, jbyte val, bool val_equals) PRODUCT_RETURN; |
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3287
diff
changeset
|
481 void verify_not_dirty_region(MemRegion mr) PRODUCT_RETURN; |
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
845
diff
changeset
|
482 void verify_dirty_region(MemRegion mr) PRODUCT_RETURN; |
0 | 483 |
484 static size_t par_chunk_heapword_alignment() { | |
3357
fc2b798ab316
6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests
ysr
parents:
3317
diff
changeset
|
485 return ParGCCardsPerStrideChunk * card_size_in_words; |
0 | 486 } |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
487 |
0 | 488 }; |
489 | |
490 class CardTableRS; | |
491 | |
492 // A specialization for the CardTableRS gen rem set. | |
493 class CardTableModRefBSForCTRS: public CardTableModRefBS { | |
494 CardTableRS* _rs; | |
495 protected: | |
496 bool card_will_be_scanned(jbyte cv); | |
497 bool card_may_have_been_dirty(jbyte cv); | |
498 public: | |
499 CardTableModRefBSForCTRS(MemRegion whole_heap, | |
500 int max_covered_regions) : | |
501 CardTableModRefBS(whole_heap, max_covered_regions) {} | |
502 | |
503 void set_CTRS(CardTableRS* rs) { _rs = rs; } | |
504 }; | |
1972 | 505 |
3287
c48ad6ab8bdf
7037276: Unnecessary double traversal of dirty card windows
ysr
parents:
3256
diff
changeset
|
506 |
1972 | 507 #endif // SHARE_VM_MEMORY_CARDTABLEMODREFBS_HPP |