graal-jvmci-8: src/share/vm/memory/cardTableModRefBS.hpp annotate

annotate src/share/vm/memory/cardTableModRefBS.hpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank

author	ysr
date	Wed, 07 Sep 2011 13:55:42 -0700
parents	7d64aa23eb96
children	ea640b5e949a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	25 #ifndef SHARE_VM_MEMORY_CARDTABLEMODREFBS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	26 #define SHARE_VM_MEMORY_CARDTABLEMODREFBS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	28 #include "memory/modRefBarrierSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	29 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	30 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	31
0 a61af66fc99e Initial load duke parents: diff changeset	32 // This kind of "BarrierSet" allows a "CollectedHeap" to detect and
a61af66fc99e Initial load duke parents: diff changeset	33 // enumerate ref fields that have been modified (since the last
a61af66fc99e Initial load duke parents: diff changeset	34 // enumeration.)
a61af66fc99e Initial load duke parents: diff changeset	35
a61af66fc99e Initial load duke parents: diff changeset	36 // As it currently stands, this barrier is imprecise: when a ref field in
a61af66fc99e Initial load duke parents: diff changeset	37 // an object "o" is modified, the card table entry for the card containing
a61af66fc99e Initial load duke parents: diff changeset	38 // the head of "o" is dirtied, not necessarily the card containing the
a61af66fc99e Initial load duke parents: diff changeset	39 // modified field itself. For object arrays, however, the barrier is
a61af66fc99e Initial load duke parents: diff changeset	40 // precise; only the card containing the modified element is dirtied.
a61af66fc99e Initial load duke parents: diff changeset	41 // Any MemRegionClosures used to scan dirty cards should take these
a61af66fc99e Initial load duke parents: diff changeset	42 // considerations into account.
a61af66fc99e Initial load duke parents: diff changeset	43
a61af66fc99e Initial load duke parents: diff changeset	44 class Generation;
a61af66fc99e Initial load duke parents: diff changeset	45 class OopsInGenClosure;
a61af66fc99e Initial load duke parents: diff changeset	46 class DirtyCardToOopClosure;
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	47 class ClearNoncleanCardWrapper;
0 a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49 class CardTableModRefBS: public ModRefBarrierSet {
a61af66fc99e Initial load duke parents: diff changeset	50 // Some classes get to look at some private stuff.
a61af66fc99e Initial load duke parents: diff changeset	51 friend class BytecodeInterpreter;
a61af66fc99e Initial load duke parents: diff changeset	52 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	53 friend class CardTableRS;
a61af66fc99e Initial load duke parents: diff changeset	54 friend class CheckForUnmarkedOops; // Needs access to raw card bytes.
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1552 diff changeset	55 friend class SharkBuilder;
0 a61af66fc99e Initial load duke parents: diff changeset	56 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	57 // For debugging.
a61af66fc99e Initial load duke parents: diff changeset	58 friend class GuaranteeNotModClosure;
a61af66fc99e Initial load duke parents: diff changeset	59 #endif
a61af66fc99e Initial load duke parents: diff changeset	60 protected:
a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 enum CardValues {
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	67 dirty_card = 0,
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	73 };
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 // dirty and precleaned are equivalent wrt younger_refs_iter.
a61af66fc99e Initial load duke parents: diff changeset	76 static bool card_is_dirty_wrt_gen_iter(jbyte cv) {
a61af66fc99e Initial load duke parents: diff changeset	77 return cv == dirty_card \|\| cv == precleaned_card;
a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 // Returns "true" iff the value "cv" will cause the card containing it
a61af66fc99e Initial load duke parents: diff changeset	81 // to be scanned in the current traversal. May be overridden by
a61af66fc99e Initial load duke parents: diff changeset	82 // subtypes.
a61af66fc99e Initial load duke parents: diff changeset	83 virtual bool card_will_be_scanned(jbyte cv) {
a61af66fc99e Initial load duke parents: diff changeset	84 return CardTableModRefBS::card_is_dirty_wrt_gen_iter(cv);
a61af66fc99e Initial load duke parents: diff changeset	85 }
a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 // Returns "true" iff the value "cv" may have represented a dirty card at
a61af66fc99e Initial load duke parents: diff changeset	88 // some point.
a61af66fc99e Initial load duke parents: diff changeset	89 virtual bool card_may_have_been_dirty(jbyte cv) {
a61af66fc99e Initial load duke parents: diff changeset	90 return card_is_dirty_wrt_gen_iter(cv);
a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93 // The declaration order of these const fields is important; see the
a61af66fc99e Initial load duke parents: diff changeset	94 // constructor before changing.
a61af66fc99e Initial load duke parents: diff changeset	95 const MemRegion _whole_heap; // the region covered by the card table
a61af66fc99e Initial load duke parents: diff changeset	96 const size_t _guard_index; // index of very last element in the card
a61af66fc99e Initial load duke parents: diff changeset	97 // table; it is set to a guard value
a61af66fc99e Initial load duke parents: diff changeset	98 // (last_card) and should never be modified
a61af66fc99e Initial load duke parents: diff changeset	99 const size_t _last_valid_index; // index of the last valid element
a61af66fc99e Initial load duke parents: diff changeset	100 const size_t _page_size; // page size used when mapping _byte_map
a61af66fc99e Initial load duke parents: diff changeset	101 const size_t _byte_map_size; // in bytes
a61af66fc99e Initial load duke parents: diff changeset	102 jbyte* _byte_map; // the card marking array
a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 int _cur_covered_regions;
a61af66fc99e Initial load duke parents: diff changeset	105 // The covered regions should be in address order.
a61af66fc99e Initial load duke parents: diff changeset	106 MemRegion* _covered;
a61af66fc99e Initial load duke parents: diff changeset	107 // The committed regions correspond one-to-one to the covered regions.
a61af66fc99e Initial load duke parents: diff changeset	108 // They represent the card-table memory that has been committed to service
a61af66fc99e Initial load duke parents: diff changeset	109 // the corresponding covered region. It may be that committed region for
a61af66fc99e Initial load duke parents: diff changeset	110 // one covered region corresponds to a larger region because of page-size
a61af66fc99e Initial load duke parents: diff changeset	111 // roundings. Thus, a committed region for one covered region may
a61af66fc99e Initial load duke parents: diff changeset	112 // actually extend onto the card-table space for the next covered region.
a61af66fc99e Initial load duke parents: diff changeset	113 MemRegion* _committed;
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 // The last card is a guard card, and we commit the page for it so
a61af66fc99e Initial load duke parents: diff changeset	116 // we can use the card for verification purposes. We make sure we never
a61af66fc99e Initial load duke parents: diff changeset	117 // uncommit the MemRegion for that page.
a61af66fc99e Initial load duke parents: diff changeset	118 MemRegion _guard_region;
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120 protected:
a61af66fc99e Initial load duke parents: diff changeset	121 // Initialization utilities; covered_words is the size of the covered region
a61af66fc99e Initial load duke parents: diff changeset	122 // in, um, words.
a61af66fc99e Initial load duke parents: diff changeset	123 inline size_t cards_required(size_t covered_words);
a61af66fc99e Initial load duke parents: diff changeset	124 inline size_t compute_byte_map_size();
a61af66fc99e Initial load duke parents: diff changeset	125
a61af66fc99e Initial load duke parents: diff changeset	126 // Finds and return the index of the region, if any, to which the given
a61af66fc99e Initial load duke parents: diff changeset	127 // region would be contiguous. If none exists, assign a new region and
a61af66fc99e Initial load duke parents: diff changeset	128 // returns its index. Requires that no more than the maximum number of
a61af66fc99e Initial load duke parents: diff changeset	129 // covered regions defined in the constructor are ever in use.
a61af66fc99e Initial load duke parents: diff changeset	130 int find_covering_region_by_base(HeapWord* base);
a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 // Same as above, but finds the region containing the given address
a61af66fc99e Initial load duke parents: diff changeset	133 // instead of starting at a given base address.
a61af66fc99e Initial load duke parents: diff changeset	134 int find_covering_region_containing(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	135
a61af66fc99e Initial load duke parents: diff changeset	136 // Resize one of the regions covered by the remembered set.
a61af66fc99e Initial load duke parents: diff changeset	137 void resize_covered_region(MemRegion new_region);
a61af66fc99e Initial load duke parents: diff changeset	138
a61af66fc99e Initial load duke parents: diff changeset	139 // Returns the leftmost end of a committed region corresponding to a
a61af66fc99e Initial load duke parents: diff changeset	140 // covered region before covered region "ind", or else "NULL" if "ind" is
a61af66fc99e Initial load duke parents: diff changeset	141 // the first covered region.
a61af66fc99e Initial load duke parents: diff changeset	142 HeapWord* largest_prev_committed_end(int ind) const;
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 // Returns the part of the region mr that doesn't intersect with
a61af66fc99e Initial load duke parents: diff changeset	145 // any committed region other than self. Used to prevent uncommitting
a61af66fc99e Initial load duke parents: diff changeset	146 // regions that are also committed by other regions. Also protects
a61af66fc99e Initial load duke parents: diff changeset	147 // against uncommitting the guard region.
a61af66fc99e Initial load duke parents: diff changeset	148 MemRegion committed_unique_to_self(int self, MemRegion mr) const;
a61af66fc99e Initial load duke parents: diff changeset	149
a61af66fc99e Initial load duke parents: diff changeset	150 // Mapping from address to card marking array entry
a61af66fc99e Initial load duke parents: diff changeset	151 jbyte* byte_for(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	156 jbyte* result = &byte_map_base[uintptr_t(p) >> card_shift];
a61af66fc99e Initial load duke parents: diff changeset	157 assert(result >= _byte_map && result < _byte_map + _byte_map_size,
a61af66fc99e Initial load duke parents: diff changeset	158 "out of bounds accessor for card marking array");
a61af66fc99e Initial load duke parents: diff changeset	159 return result;
a61af66fc99e Initial load duke parents: diff changeset	160 }
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 // The card table byte one after the card marking array
a61af66fc99e Initial load duke parents: diff changeset	163 // entry for argument address. Typically used for higher bounds
a61af66fc99e Initial load duke parents: diff changeset	164 // for loops iterating through the card table.
a61af66fc99e Initial load duke parents: diff changeset	165 jbyte* byte_after(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	166 return byte_for(p) + 1;
a61af66fc99e Initial load duke parents: diff changeset	167 }
a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169 // Iterate over the portion of the card-table which covers the given
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	190
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	191 protected:
0 a61af66fc99e Initial load duke parents: diff changeset	192 // Dirty the bytes corresponding to "mr" (not all of which must be
a61af66fc99e Initial load duke parents: diff changeset	193 // covered.)
a61af66fc99e Initial load duke parents: diff changeset	194 void dirty_MemRegion(MemRegion mr);
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 // Clear (to clean_card) the bytes entirely contained within "mr" (not
a61af66fc99e Initial load duke parents: diff changeset	197 // all of which must be covered.)
a61af66fc99e Initial load duke parents: diff changeset	198 void clear_MemRegion(MemRegion mr);
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 // *** Support for parallel card scanning.
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 // This is an array, one element per covered region of the card table.
a61af66fc99e Initial load duke parents: diff changeset	203 // Each entry is itself an array, with one element per chunk in the
a61af66fc99e Initial load duke parents: diff changeset	204 // covered region. Each entry of these arrays is the lowest non-clean
a61af66fc99e Initial load duke parents: diff changeset	205 // card of the corresponding chunk containing part of an object from the
a61af66fc99e Initial load duke parents: diff changeset	206 // previous chunk, or else NULL.
a61af66fc99e Initial load duke parents: diff changeset	207 typedef jbyte* CardPtr;
a61af66fc99e Initial load duke parents: diff changeset	208 typedef CardPtr* CardArr;
a61af66fc99e Initial load duke parents: diff changeset	209 CardArr* _lowest_non_clean;
a61af66fc99e Initial load duke parents: diff changeset	210 size_t* _lowest_non_clean_chunk_size;
a61af66fc99e Initial load duke parents: diff changeset	211 uintptr_t* _lowest_non_clean_base_chunk_index;
a61af66fc99e Initial load duke parents: diff changeset	212 int* _last_LNC_resizing_collection;
a61af66fc99e Initial load duke parents: diff changeset	213
a61af66fc99e Initial load duke parents: diff changeset	214 // Initializes "lowest_non_clean" to point to the array for the region
a61af66fc99e Initial load duke parents: diff changeset	215 // covering "sp", and "lowest_non_clean_base_chunk_index" to the chunk
a61af66fc99e Initial load duke parents: diff changeset	216 // index of the corresponding to the first element of that array.
a61af66fc99e Initial load duke parents: diff changeset	217 // Ensures that these arrays are of sufficient size, allocating if necessary.
a61af66fc99e Initial load duke parents: diff changeset	218 // May be called by several threads concurrently.
a61af66fc99e Initial load duke parents: diff changeset	219 void get_LNC_array_for_space(Space* sp,
a61af66fc99e Initial load duke parents: diff changeset	220 jbyte**& lowest_non_clean,
a61af66fc99e Initial load duke parents: diff changeset	221 uintptr_t& lowest_non_clean_base_chunk_index,
a61af66fc99e Initial load duke parents: diff changeset	222 size_t& lowest_non_clean_chunk_size);
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 // Returns the number of chunks necessary to cover "mr".
a61af66fc99e Initial load duke parents: diff changeset	225 size_t chunks_to_cover(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	226 return (size_t)(addr_to_chunk_index(mr.last()) -
a61af66fc99e Initial load duke parents: diff changeset	227 addr_to_chunk_index(mr.start()) + 1);
a61af66fc99e Initial load duke parents: diff changeset	228 }
a61af66fc99e Initial load duke parents: diff changeset	229
a61af66fc99e Initial load duke parents: diff changeset	230 // Returns the index of the chunk in a stride which
a61af66fc99e Initial load duke parents: diff changeset	231 // covers the given address.
a61af66fc99e Initial load duke parents: diff changeset	232 uintptr_t addr_to_chunk_index(const void* addr) {
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	235 }
a61af66fc99e Initial load duke parents: diff changeset	236
a61af66fc99e Initial load duke parents: diff changeset	237 // Apply cl, which must either itself apply dcto_cl or be dcto_cl,
a61af66fc99e Initial load duke parents: diff changeset	238 // to the cards in the stride (of n_strides) within the given space.
a61af66fc99e Initial load duke parents: diff changeset	239 void process_stride(Space* sp,
a61af66fc99e Initial load duke parents: diff changeset	240 MemRegion used,
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	244 jbyte** lowest_non_clean,
a61af66fc99e Initial load duke parents: diff changeset	245 uintptr_t lowest_non_clean_base_chunk_index,
a61af66fc99e Initial load duke parents: diff changeset	246 size_t lowest_non_clean_chunk_size);
a61af66fc99e Initial load duke parents: diff changeset	247
a61af66fc99e Initial load duke parents: diff changeset	248 // Makes sure that chunk boundaries are handled appropriately, by
a61af66fc99e Initial load duke parents: diff changeset	249 // adjusting the min_done of dcto_cl, and by using a special card-table
a61af66fc99e Initial load duke parents: diff changeset	250 // value to indicate how min_done should be set.
a61af66fc99e Initial load duke parents: diff changeset	251 void process_chunk_boundaries(Space* sp,
a61af66fc99e Initial load duke parents: diff changeset	252 DirtyCardToOopClosure* dcto_cl,
a61af66fc99e Initial load duke parents: diff changeset	253 MemRegion chunk_mr,
a61af66fc99e Initial load duke parents: diff changeset	254 MemRegion used,
a61af66fc99e Initial load duke parents: diff changeset	255 jbyte** lowest_non_clean,
a61af66fc99e Initial load duke parents: diff changeset	256 uintptr_t lowest_non_clean_base_chunk_index,
a61af66fc99e Initial load duke parents: diff changeset	257 size_t lowest_non_clean_chunk_size);
a61af66fc99e Initial load duke parents: diff changeset	258
a61af66fc99e Initial load duke parents: diff changeset	259 public:
a61af66fc99e Initial load duke parents: diff changeset	260 // Constants
a61af66fc99e Initial load duke parents: diff changeset	261 enum SomePublicConstants {
a61af66fc99e Initial load duke parents: diff changeset	262 card_shift = 9,
a61af66fc99e Initial load duke parents: diff changeset	263 card_size = 1 << card_shift,
a61af66fc99e Initial load duke parents: diff changeset	264 card_size_in_words = card_size / sizeof(HeapWord)
a61af66fc99e Initial load duke parents: diff changeset	265 };
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	274 // For RTTI simulation.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 CardTableModRefBS(MemRegion whole_heap, int max_covered_regions);
a61af66fc99e Initial load duke parents: diff changeset	280
a61af66fc99e Initial load duke parents: diff changeset	281 // *** Barrier set functions.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	286 // Note that this assumes the perm gen is the highest generation
a61af66fc99e Initial load duke parents: diff changeset	287 // in the address space
a61af66fc99e Initial load duke parents: diff changeset	288 return new_val != NULL && !new_val->is_perm();
a61af66fc99e Initial load duke parents: diff changeset	289 }
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 // Record a reference update. Note that these versions are precise!
a61af66fc99e Initial load duke parents: diff changeset	292 // The scanning code has to handle the fact that the write barrier may be
a61af66fc99e Initial load duke parents: diff changeset	293 // either precise or imprecise. We make non-virtual inline variants of
a61af66fc99e Initial load duke parents: diff changeset	294 // these functions here for performance.
a61af66fc99e Initial load duke parents: diff changeset	295 protected:
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	298 public:
a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300 bool has_write_ref_array_opt() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	301 bool has_write_region_opt() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 inline void inline_write_region(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	304 dirty_MemRegion(mr);
a61af66fc99e Initial load duke parents: diff changeset	305 }
a61af66fc99e Initial load duke parents: diff changeset	306 protected:
a61af66fc99e Initial load duke parents: diff changeset	307 void write_region_work(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	308 inline_write_region(mr);
a61af66fc99e Initial load duke parents: diff changeset	309 }
a61af66fc99e Initial load duke parents: diff changeset	310 public:
a61af66fc99e Initial load duke parents: diff changeset	311
a61af66fc99e Initial load duke parents: diff changeset	312 inline void inline_write_ref_array(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	313 dirty_MemRegion(mr);
a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315 protected:
a61af66fc99e Initial load duke parents: diff changeset	316 void write_ref_array_work(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	317 inline_write_ref_array(mr);
a61af66fc99e Initial load duke parents: diff changeset	318 }
a61af66fc99e Initial load duke parents: diff changeset	319 public:
a61af66fc99e Initial load duke parents: diff changeset	320
a61af66fc99e Initial load duke parents: diff changeset	321 bool is_aligned(HeapWord* addr) {
a61af66fc99e Initial load duke parents: diff changeset	322 return is_card_aligned(addr);
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325 // *** Card-table-barrier-specific things.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	331 *byte = dirty_card;
a61af66fc99e Initial load duke parents: diff changeset	332 }
a61af66fc99e Initial load duke parents: diff changeset	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 0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	349 void set_card_claimed(size_t card_index) {
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	350 jbyte val = _byte_map[card_index];
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	351 if (val == clean_card_val()) {
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	352 val = (jbyte)claimed_card_val();
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	353 } else {
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	354 val \|= (jbyte)claimed_card_val();
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	355 }
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	356 _byte_map[card_index] = val;
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	357 }
0414c1049f15 6923991: G1: improve scalability of RSet scanning iveresov parents: 940 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	372 // Card marking array base (adjusted for heap low boundary)
a61af66fc99e Initial load duke parents: diff changeset	373 // This would be the 0th element of _byte_map, if the heap started at 0x0.
a61af66fc99e Initial load duke parents: diff changeset	374 // But since the heap starts at some higher address, this points to somewhere
a61af66fc99e Initial load duke parents: diff changeset	375 // before the beginning of the actual _byte_map.
a61af66fc99e Initial load duke parents: diff changeset	376 jbyte* byte_map_base;
a61af66fc99e Initial load duke parents: diff changeset	377
a61af66fc99e Initial load duke parents: diff changeset	378 // Return true if "p" is at the start of a card.
a61af66fc99e Initial load duke parents: diff changeset	379 bool is_card_aligned(HeapWord* p) {
a61af66fc99e Initial load duke parents: diff changeset	380 jbyte* pcard = byte_for(p);
a61af66fc99e Initial load duke parents: diff changeset	381 return (addr_for(pcard) == p);
a61af66fc99e Initial load duke parents: diff changeset	382 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	389 // The kinds of precision a CardTableModRefBS may offer.
a61af66fc99e Initial load duke parents: diff changeset	390 enum PrecisionStyle {
a61af66fc99e Initial load duke parents: diff changeset	391 Precise,
a61af66fc99e Initial load duke parents: diff changeset	392 ObjHeadPreciseArray
a61af66fc99e Initial load duke parents: diff changeset	393 };
a61af66fc99e Initial load duke parents: diff changeset	394
a61af66fc99e Initial load duke parents: diff changeset	395 // Tells what style of precision this card table offers.
a61af66fc99e Initial load duke parents: diff changeset	396 PrecisionStyle precision() {
a61af66fc99e Initial load duke parents: diff changeset	397 return ObjHeadPreciseArray; // Only one supported for now.
a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	404
a61af66fc99e Initial load duke parents: diff changeset	405 // *** Card-table-RemSet-specific things.
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 // Invoke "cl.do_MemRegion" on a set of MemRegions that collectively
a61af66fc99e Initial load duke parents: diff changeset	408 // includes all the modified cards (expressing each card as a
a61af66fc99e Initial load duke parents: diff changeset	409 // MemRegion). Thus, several modified cards may be lumped into one
a61af66fc99e Initial load duke parents: diff changeset	410 // region. The regions are non-overlapping, and are visited in
a61af66fc99e Initial load duke parents: diff changeset	411 // decreasing address order. (This order aids with imprecise card
a61af66fc99e Initial load duke parents: diff changeset	412 // marking, where a dirty card may cause scanning, and summarization
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	416 }
a61af66fc99e Initial load duke parents: diff changeset	417
a61af66fc99e Initial load duke parents: diff changeset	418 // Like the "mod_cards_iterate" above, except only invokes the closure
a61af66fc99e Initial load duke parents: diff changeset	419 // for cards within the MemRegion "mr" (which is required to be
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	423 }
a61af66fc99e Initial load duke parents: diff changeset	424
a61af66fc99e Initial load duke parents: diff changeset	425 static uintx ct_max_alignment_constraint();
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	430
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	437
a61af66fc99e Initial load duke parents: diff changeset	438 // Set all the dirty cards in the given region to precleaned state.
a61af66fc99e Initial load duke parents: diff changeset	439 void preclean_dirty_cards(MemRegion mr);
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	468 return byte_for(p) - _byte_map;
a61af66fc99e Initial load duke parents: diff changeset	469 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	475 void verify();
a61af66fc99e Initial load duke parents: diff changeset	476 void verify_guard();
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	483
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	486 }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	487
0 a61af66fc99e Initial load duke parents: diff changeset	488 };
a61af66fc99e Initial load duke parents: diff changeset	489
a61af66fc99e Initial load duke parents: diff changeset	490 class CardTableRS;
a61af66fc99e Initial load duke parents: diff changeset	491
a61af66fc99e Initial load duke parents: diff changeset	492 // A specialization for the CardTableRS gen rem set.
a61af66fc99e Initial load duke parents: diff changeset	493 class CardTableModRefBSForCTRS: public CardTableModRefBS {
a61af66fc99e Initial load duke parents: diff changeset	494 CardTableRS* _rs;
a61af66fc99e Initial load duke parents: diff changeset	495 protected:
a61af66fc99e Initial load duke parents: diff changeset	496 bool card_will_be_scanned(jbyte cv);
a61af66fc99e Initial load duke parents: diff changeset	497 bool card_may_have_been_dirty(jbyte cv);
a61af66fc99e Initial load duke parents: diff changeset	498 public:
a61af66fc99e Initial load duke parents: diff changeset	499 CardTableModRefBSForCTRS(MemRegion whole_heap,
a61af66fc99e Initial load duke parents: diff changeset	500 int max_covered_regions) :
a61af66fc99e Initial load duke parents: diff changeset	501 CardTableModRefBS(whole_heap, max_covered_regions) {}
a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 void set_CTRS(CardTableRS* rs) { _rs = rs; }
a61af66fc99e Initial load duke parents: diff changeset	504 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	505
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	506
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	507 #endif // SHARE_VM_MEMORY_CARDTABLEMODREFBS_HPP

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/cardTableModRefBS.hpp @ 3917:eca1193ca245