truffle: src/share/vm/memory/cardTableModRefBS.hpp annotate

annotate src/share/vm/memory/cardTableModRefBS.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	1f1d373cd044
children	7848fc12602b

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 14443 diff changeset	2 * Copyright (c) 2000, 2014, 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
5939 c7a555a9449a 7068625: Testing 8 bytes of card table entries at a time speeds up card-scanning brutisso parents: 4098 diff changeset	75 // a word's worth (row) of clean card values
c7a555a9449a 7068625: Testing 8 bytes of card table entries at a time speeds up card-scanning brutisso parents: 4098 diff changeset	76 static const intptr_t clean_card_row = (intptr_t)(-1);
c7a555a9449a 7068625: Testing 8 bytes of card table entries at a time speeds up card-scanning brutisso parents: 4098 diff changeset	77
0 a61af66fc99e Initial load duke parents: diff changeset	78 // dirty and precleaned are equivalent wrt younger_refs_iter.
a61af66fc99e Initial load duke parents: diff changeset	79 static bool card_is_dirty_wrt_gen_iter(jbyte cv) {
a61af66fc99e Initial load duke parents: diff changeset	80 return cv == dirty_card \|\| cv == precleaned_card;
a61af66fc99e Initial load duke parents: diff changeset	81 }
a61af66fc99e Initial load duke parents: diff changeset	82
a61af66fc99e Initial load duke parents: diff changeset	83 // Returns "true" iff the value "cv" will cause the card containing it
a61af66fc99e Initial load duke parents: diff changeset	84 // to be scanned in the current traversal. May be overridden by
a61af66fc99e Initial load duke parents: diff changeset	85 // subtypes.
a61af66fc99e Initial load duke parents: diff changeset	86 virtual bool card_will_be_scanned(jbyte cv) {
a61af66fc99e Initial load duke parents: diff changeset	87 return CardTableModRefBS::card_is_dirty_wrt_gen_iter(cv);
a61af66fc99e Initial load duke parents: diff changeset	88 }
a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90 // Returns "true" iff the value "cv" may have represented a dirty card at
a61af66fc99e Initial load duke parents: diff changeset	91 // some point.
a61af66fc99e Initial load duke parents: diff changeset	92 virtual bool card_may_have_been_dirty(jbyte cv) {
a61af66fc99e Initial load duke parents: diff changeset	93 return card_is_dirty_wrt_gen_iter(cv);
a61af66fc99e Initial load duke parents: diff changeset	94 }
a61af66fc99e Initial load duke parents: diff changeset	95
a61af66fc99e Initial load duke parents: diff changeset	96 // The declaration order of these const fields is important; see the
a61af66fc99e Initial load duke parents: diff changeset	97 // constructor before changing.
a61af66fc99e Initial load duke parents: diff changeset	98 const MemRegion _whole_heap; // the region covered by the card table
20337 1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	99 size_t _guard_index; // index of very last element in the card
0 a61af66fc99e Initial load duke parents: diff changeset	100 // table; it is set to a guard value
a61af66fc99e Initial load duke parents: diff changeset	101 // (last_card) and should never be modified
20337 1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	102 size_t _last_valid_index; // index of the last valid element
0 a61af66fc99e Initial load duke parents: diff changeset	103 const size_t _page_size; // page size used when mapping _byte_map
20337 1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	104 size_t _byte_map_size; // in bytes
0 a61af66fc99e Initial load duke parents: diff changeset	105 jbyte* _byte_map; // the card marking array
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 int _cur_covered_regions;
a61af66fc99e Initial load duke parents: diff changeset	108 // The covered regions should be in address order.
a61af66fc99e Initial load duke parents: diff changeset	109 MemRegion* _covered;
a61af66fc99e Initial load duke parents: diff changeset	110 // The committed regions correspond one-to-one to the covered regions.
a61af66fc99e Initial load duke parents: diff changeset	111 // They represent the card-table memory that has been committed to service
a61af66fc99e Initial load duke parents: diff changeset	112 // the corresponding covered region. It may be that committed region for
a61af66fc99e Initial load duke parents: diff changeset	113 // one covered region corresponds to a larger region because of page-size
a61af66fc99e Initial load duke parents: diff changeset	114 // roundings. Thus, a committed region for one covered region may
a61af66fc99e Initial load duke parents: diff changeset	115 // actually extend onto the card-table space for the next covered region.
a61af66fc99e Initial load duke parents: diff changeset	116 MemRegion* _committed;
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118 // The last card is a guard card, and we commit the page for it so
a61af66fc99e Initial load duke parents: diff changeset	119 // we can use the card for verification purposes. We make sure we never
a61af66fc99e Initial load duke parents: diff changeset	120 // uncommit the MemRegion for that page.
a61af66fc99e Initial load duke parents: diff changeset	121 MemRegion _guard_region;
a61af66fc99e Initial load duke parents: diff changeset	122
a61af66fc99e Initial load duke parents: diff changeset	123 protected:
a61af66fc99e Initial load duke parents: diff changeset	124 // Initialization utilities; covered_words is the size of the covered region
a61af66fc99e Initial load duke parents: diff changeset	125 // in, um, words.
20337 1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	126 inline size_t cards_required(size_t covered_words) {
1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	127 // Add one for a guard card, used to detect errors.
1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	128 const size_t words = align_size_up(covered_words, card_size_in_words);
1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	129 return words / card_size_in_words + 1;
1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	130 }
1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	131
0 a61af66fc99e Initial load duke parents: diff changeset	132 inline size_t compute_byte_map_size();
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 // Finds and return the index of the region, if any, to which the given
a61af66fc99e Initial load duke parents: diff changeset	135 // region would be contiguous. If none exists, assign a new region and
a61af66fc99e Initial load duke parents: diff changeset	136 // returns its index. Requires that no more than the maximum number of
a61af66fc99e Initial load duke parents: diff changeset	137 // covered regions defined in the constructor are ever in use.
a61af66fc99e Initial load duke parents: diff changeset	138 int find_covering_region_by_base(HeapWord* base);
a61af66fc99e Initial load duke parents: diff changeset	139
a61af66fc99e Initial load duke parents: diff changeset	140 // Same as above, but finds the region containing the given address
a61af66fc99e Initial load duke parents: diff changeset	141 // instead of starting at a given base address.
a61af66fc99e Initial load duke parents: diff changeset	142 int find_covering_region_containing(HeapWord* addr);
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 // Resize one of the regions covered by the remembered set.
20337 1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	145 virtual void resize_covered_region(MemRegion new_region);
0 a61af66fc99e Initial load duke parents: diff changeset	146
a61af66fc99e Initial load duke parents: diff changeset	147 // Returns the leftmost end of a committed region corresponding to a
a61af66fc99e Initial load duke parents: diff changeset	148 // covered region before covered region "ind", or else "NULL" if "ind" is
a61af66fc99e Initial load duke parents: diff changeset	149 // the first covered region.
a61af66fc99e Initial load duke parents: diff changeset	150 HeapWord* largest_prev_committed_end(int ind) const;
a61af66fc99e Initial load duke parents: diff changeset	151
a61af66fc99e Initial load duke parents: diff changeset	152 // Returns the part of the region mr that doesn't intersect with
a61af66fc99e Initial load duke parents: diff changeset	153 // any committed region other than self. Used to prevent uncommitting
a61af66fc99e Initial load duke parents: diff changeset	154 // regions that are also committed by other regions. Also protects
a61af66fc99e Initial load duke parents: diff changeset	155 // against uncommitting the guard region.
a61af66fc99e Initial load duke parents: diff changeset	156 MemRegion committed_unique_to_self(int self, MemRegion mr) const;
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // Mapping from address to card marking array entry
a61af66fc99e Initial load duke parents: diff changeset	159 jbyte* byte_for(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	160 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	161 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	162 " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")",
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 14443 diff changeset	163 p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end())));
0 a61af66fc99e Initial load duke parents: diff changeset	164 jbyte* result = &byte_map_base[uintptr_t(p) >> card_shift];
a61af66fc99e Initial load duke parents: diff changeset	165 assert(result >= _byte_map && result < _byte_map + _byte_map_size,
a61af66fc99e Initial load duke parents: diff changeset	166 "out of bounds accessor for card marking array");
a61af66fc99e Initial load duke parents: diff changeset	167 return result;
a61af66fc99e Initial load duke parents: diff changeset	168 }
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 // The card table byte one after the card marking array
a61af66fc99e Initial load duke parents: diff changeset	171 // entry for argument address. Typically used for higher bounds
a61af66fc99e Initial load duke parents: diff changeset	172 // for loops iterating through the card table.
a61af66fc99e Initial load duke parents: diff changeset	173 jbyte* byte_after(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	174 return byte_for(p) + 1;
a61af66fc99e Initial load duke parents: diff changeset	175 }
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 // Iterate over the portion of the card-table which covers the given
a61af66fc99e Initial load duke parents: diff changeset	178 // 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	179 // 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	180 // 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	181 void non_clean_card_iterate_serial(MemRegion mr, MemRegionClosure* cl);
0 a61af66fc99e Initial load duke parents: diff changeset	182
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	183 // 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	184 // 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	185 // processes them.
3357 fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3317 diff changeset	186 // 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	187 // 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	188 // some MemRegionClosures. Clean this up everywhere. XXX
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	189 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	190 OopsInGenClosure* cl, CardTableRS* ct);
0 a61af66fc99e Initial load duke parents: diff changeset	191
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	192 private:
c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	193 // 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	194 // above in the parallel case.
c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	195 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	196 OopsInGenClosure* cl, CardTableRS* ct,
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	197 int n_threads);
0 a61af66fc99e Initial load duke parents: diff changeset	198
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	199 protected:
0 a61af66fc99e Initial load duke parents: diff changeset	200 // Dirty the bytes corresponding to "mr" (not all of which must be
a61af66fc99e Initial load duke parents: diff changeset	201 // covered.)
a61af66fc99e Initial load duke parents: diff changeset	202 void dirty_MemRegion(MemRegion mr);
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204 // Clear (to clean_card) the bytes entirely contained within "mr" (not
a61af66fc99e Initial load duke parents: diff changeset	205 // all of which must be covered.)
a61af66fc99e Initial load duke parents: diff changeset	206 void clear_MemRegion(MemRegion mr);
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208 // *** Support for parallel card scanning.
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210 // This is an array, one element per covered region of the card table.
a61af66fc99e Initial load duke parents: diff changeset	211 // Each entry is itself an array, with one element per chunk in the
a61af66fc99e Initial load duke parents: diff changeset	212 // covered region. Each entry of these arrays is the lowest non-clean
a61af66fc99e Initial load duke parents: diff changeset	213 // card of the corresponding chunk containing part of an object from the
a61af66fc99e Initial load duke parents: diff changeset	214 // previous chunk, or else NULL.
a61af66fc99e Initial load duke parents: diff changeset	215 typedef jbyte* CardPtr;
a61af66fc99e Initial load duke parents: diff changeset	216 typedef CardPtr* CardArr;
a61af66fc99e Initial load duke parents: diff changeset	217 CardArr* _lowest_non_clean;
a61af66fc99e Initial load duke parents: diff changeset	218 size_t* _lowest_non_clean_chunk_size;
a61af66fc99e Initial load duke parents: diff changeset	219 uintptr_t* _lowest_non_clean_base_chunk_index;
a61af66fc99e Initial load duke parents: diff changeset	220 int* _last_LNC_resizing_collection;
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 // Initializes "lowest_non_clean" to point to the array for the region
a61af66fc99e Initial load duke parents: diff changeset	223 // covering "sp", and "lowest_non_clean_base_chunk_index" to the chunk
a61af66fc99e Initial load duke parents: diff changeset	224 // index of the corresponding to the first element of that array.
a61af66fc99e Initial load duke parents: diff changeset	225 // Ensures that these arrays are of sufficient size, allocating if necessary.
a61af66fc99e Initial load duke parents: diff changeset	226 // May be called by several threads concurrently.
a61af66fc99e Initial load duke parents: diff changeset	227 void get_LNC_array_for_space(Space* sp,
a61af66fc99e Initial load duke parents: diff changeset	228 jbyte**& lowest_non_clean,
a61af66fc99e Initial load duke parents: diff changeset	229 uintptr_t& lowest_non_clean_base_chunk_index,
a61af66fc99e Initial load duke parents: diff changeset	230 size_t& lowest_non_clean_chunk_size);
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 // Returns the number of chunks necessary to cover "mr".
a61af66fc99e Initial load duke parents: diff changeset	233 size_t chunks_to_cover(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	234 return (size_t)(addr_to_chunk_index(mr.last()) -
a61af66fc99e Initial load duke parents: diff changeset	235 addr_to_chunk_index(mr.start()) + 1);
a61af66fc99e Initial load duke parents: diff changeset	236 }
a61af66fc99e Initial load duke parents: diff changeset	237
a61af66fc99e Initial load duke parents: diff changeset	238 // Returns the index of the chunk in a stride which
a61af66fc99e Initial load duke parents: diff changeset	239 // covers the given address.
a61af66fc99e Initial load duke parents: diff changeset	240 uintptr_t addr_to_chunk_index(const void* addr) {
a61af66fc99e Initial load duke parents: diff changeset	241 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	242 return card / ParGCCardsPerStrideChunk;
0 a61af66fc99e Initial load duke parents: diff changeset	243 }
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 // Apply cl, which must either itself apply dcto_cl or be dcto_cl,
a61af66fc99e Initial load duke parents: diff changeset	246 // to the cards in the stride (of n_strides) within the given space.
a61af66fc99e Initial load duke parents: diff changeset	247 void process_stride(Space* sp,
a61af66fc99e Initial load duke parents: diff changeset	248 MemRegion used,
a61af66fc99e Initial load duke parents: diff changeset	249 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	250 OopsInGenClosure* cl,
fc2b798ab316 6883834: ParNew: assert(!_g->to()->is_in_reserved(obj),"Scanning field twice?") with LargeObjects tests ysr parents: 3317 diff changeset	251 CardTableRS* ct,
0 a61af66fc99e Initial load duke parents: diff changeset	252 jbyte** lowest_non_clean,
a61af66fc99e Initial load duke parents: diff changeset	253 uintptr_t lowest_non_clean_base_chunk_index,
a61af66fc99e Initial load duke parents: diff changeset	254 size_t lowest_non_clean_chunk_size);
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 // Makes sure that chunk boundaries are handled appropriately, by
a61af66fc99e Initial load duke parents: diff changeset	257 // adjusting the min_done of dcto_cl, and by using a special card-table
a61af66fc99e Initial load duke parents: diff changeset	258 // value to indicate how min_done should be set.
a61af66fc99e Initial load duke parents: diff changeset	259 void process_chunk_boundaries(Space* sp,
a61af66fc99e Initial load duke parents: diff changeset	260 DirtyCardToOopClosure* dcto_cl,
a61af66fc99e Initial load duke parents: diff changeset	261 MemRegion chunk_mr,
a61af66fc99e Initial load duke parents: diff changeset	262 MemRegion used,
a61af66fc99e Initial load duke parents: diff changeset	263 jbyte** lowest_non_clean,
a61af66fc99e Initial load duke parents: diff changeset	264 uintptr_t lowest_non_clean_base_chunk_index,
a61af66fc99e Initial load duke parents: diff changeset	265 size_t lowest_non_clean_chunk_size);
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 public:
a61af66fc99e Initial load duke parents: diff changeset	268 // Constants
a61af66fc99e Initial load duke parents: diff changeset	269 enum SomePublicConstants {
a61af66fc99e Initial load duke parents: diff changeset	270 card_shift = 9,
a61af66fc99e Initial load duke parents: diff changeset	271 card_size = 1 << card_shift,
a61af66fc99e Initial load duke parents: diff changeset	272 card_size_in_words = card_size / sizeof(HeapWord)
a61af66fc99e Initial load duke parents: diff changeset	273 };
a61af66fc99e Initial load duke parents: diff changeset	274
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	275 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	276 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	277 static int dirty_card_val() { return dirty_card; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	278 static int claimed_card_val() { return claimed_card; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	279 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	280 static int deferred_card_val() { return deferred_card; }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	281
0 a61af66fc99e Initial load duke parents: diff changeset	282 // For RTTI simulation.
a61af66fc99e Initial load duke parents: diff changeset	283 bool is_a(BarrierSet::Name bsn) {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	284 return bsn == BarrierSet::CardTableModRef \|\| ModRefBarrierSet::is_a(bsn);
0 a61af66fc99e Initial load duke parents: diff changeset	285 }
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 CardTableModRefBS(MemRegion whole_heap, int max_covered_regions);
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10135 diff changeset	288 ~CardTableModRefBS();
0 a61af66fc99e Initial load duke parents: diff changeset	289
20337 1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	290 virtual void initialize();
1f1d373cd044 8038423: G1: Decommit memory within heap tschatzl parents: 17937 diff changeset	291
0 a61af66fc99e Initial load duke parents: diff changeset	292 // *** Barrier set functions.
a61af66fc99e Initial load duke parents: diff changeset	293
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	294 bool has_write_ref_pre_barrier() { return false; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	295
0 a61af66fc99e Initial load duke parents: diff changeset	296 // Record a reference update. Note that these versions are precise!
a61af66fc99e Initial load duke parents: diff changeset	297 // The scanning code has to handle the fact that the write barrier may be
a61af66fc99e Initial load duke parents: diff changeset	298 // either precise or imprecise. We make non-virtual inline variants of
a61af66fc99e Initial load duke parents: diff changeset	299 // these functions here for performance.
a61af66fc99e Initial load duke parents: diff changeset	300 protected:
a61af66fc99e Initial load duke parents: diff changeset	301 void write_ref_field_work(oop obj, size_t offset, oop newVal);
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	302 virtual void write_ref_field_work(void* field, oop newVal, bool release = false);
0 a61af66fc99e Initial load duke parents: diff changeset	303 public:
a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 bool has_write_ref_array_opt() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	306 bool has_write_region_opt() { return true; }
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 inline void inline_write_region(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	309 dirty_MemRegion(mr);
a61af66fc99e Initial load duke parents: diff changeset	310 }
a61af66fc99e Initial load duke parents: diff changeset	311 protected:
a61af66fc99e Initial load duke parents: diff changeset	312 void write_region_work(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	313 inline_write_region(mr);
a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315 public:
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 inline void inline_write_ref_array(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	318 dirty_MemRegion(mr);
a61af66fc99e Initial load duke parents: diff changeset	319 }
a61af66fc99e Initial load duke parents: diff changeset	320 protected:
a61af66fc99e Initial load duke parents: diff changeset	321 void write_ref_array_work(MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	322 inline_write_ref_array(mr);
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324 public:
a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 bool is_aligned(HeapWord* addr) {
a61af66fc99e Initial load duke parents: diff changeset	327 return is_card_aligned(addr);
a61af66fc99e Initial load duke parents: diff changeset	328 }
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 // *** Card-table-barrier-specific things.
a61af66fc99e Initial load duke parents: diff changeset	331
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 628 diff changeset	332 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	333
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	334 template <class T> inline void inline_write_ref_field(T* field, oop newVal, bool release) {
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 628 diff changeset	335 jbyte* byte = byte_for((void*)field);
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	336 if (release) {
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	337 // Perform a releasing store if requested.
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	338 OrderAccess::release_store((volatile jbyte*) byte, dirty_card);
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	339 } else {
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	340 *byte = dirty_card;
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12343 diff changeset	341 }
0 a61af66fc99e Initial load duke parents: diff changeset	342 }
a61af66fc99e Initial load duke parents: diff changeset	343
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	344 // 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	345 // structure for card claiming.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	346 bool is_card_dirty(size_t card_index) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	347 return _byte_map[card_index] == dirty_card_val();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	348 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	349
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	350 void mark_card_dirty(size_t card_index) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	351 _byte_map[card_index] = dirty_card_val();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	352 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	353
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	354 bool is_card_clean(size_t card_index) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	355 return _byte_map[card_index] == clean_card_val();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	356 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	357
0 a61af66fc99e Initial load duke parents: diff changeset	358 // Card marking array base (adjusted for heap low boundary)
a61af66fc99e Initial load duke parents: diff changeset	359 // This would be the 0th element of _byte_map, if the heap started at 0x0.
a61af66fc99e Initial load duke parents: diff changeset	360 // But since the heap starts at some higher address, this points to somewhere
a61af66fc99e Initial load duke parents: diff changeset	361 // before the beginning of the actual _byte_map.
a61af66fc99e Initial load duke parents: diff changeset	362 jbyte* byte_map_base;
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 // Return true if "p" is at the start of a card.
a61af66fc99e Initial load duke parents: diff changeset	365 bool is_card_aligned(HeapWord* p) {
a61af66fc99e Initial load duke parents: diff changeset	366 jbyte* pcard = byte_for(p);
a61af66fc99e Initial load duke parents: diff changeset	367 return (addr_for(pcard) == p);
a61af66fc99e Initial load duke parents: diff changeset	368 }
a61af66fc99e Initial load duke parents: diff changeset	369
2433 abdfc822206f 7023069: G1: Introduce symmetric locking in the slow allocation path tonyp parents: 1972 diff changeset	370 HeapWord* align_to_card_boundary(HeapWord* p) {
abdfc822206f 7023069: G1: Introduce symmetric locking in the slow allocation path tonyp parents: 1972 diff changeset	371 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	372 return addr_for(pcard);
abdfc822206f 7023069: G1: Introduce symmetric locking in the slow allocation path tonyp parents: 1972 diff changeset	373 }
abdfc822206f 7023069: G1: Introduce symmetric locking in the slow allocation path tonyp parents: 1972 diff changeset	374
0 a61af66fc99e Initial load duke parents: diff changeset	375 // The kinds of precision a CardTableModRefBS may offer.
a61af66fc99e Initial load duke parents: diff changeset	376 enum PrecisionStyle {
a61af66fc99e Initial load duke parents: diff changeset	377 Precise,
a61af66fc99e Initial load duke parents: diff changeset	378 ObjHeadPreciseArray
a61af66fc99e Initial load duke parents: diff changeset	379 };
a61af66fc99e Initial load duke parents: diff changeset	380
a61af66fc99e Initial load duke parents: diff changeset	381 // Tells what style of precision this card table offers.
a61af66fc99e Initial load duke parents: diff changeset	382 PrecisionStyle precision() {
a61af66fc99e Initial load duke parents: diff changeset	383 return ObjHeadPreciseArray; // Only one supported for now.
a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385
a61af66fc99e Initial load duke parents: diff changeset	386 // ModRefBS functions.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	387 virtual void invalidate(MemRegion mr, bool whole_heap = false);
0 a61af66fc99e Initial load duke parents: diff changeset	388 void clear(MemRegion mr);
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	389 void dirty(MemRegion mr);
0 a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 // *** Card-table-RemSet-specific things.
a61af66fc99e Initial load duke parents: diff changeset	392
a61af66fc99e Initial load duke parents: diff changeset	393 // Invoke "cl.do_MemRegion" on a set of MemRegions that collectively
a61af66fc99e Initial load duke parents: diff changeset	394 // includes all the modified cards (expressing each card as a
a61af66fc99e Initial load duke parents: diff changeset	395 // MemRegion). Thus, several modified cards may be lumped into one
a61af66fc99e Initial load duke parents: diff changeset	396 // region. The regions are non-overlapping, and are visited in
a61af66fc99e Initial load duke parents: diff changeset	397 // decreasing address order. (This order aids with imprecise card
a61af66fc99e Initial load duke parents: diff changeset	398 // marking, where a dirty card may cause scanning, and summarization
a61af66fc99e Initial load duke parents: diff changeset	399 // 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	400 void mod_card_iterate(MemRegionClosure* cl) {
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	401 non_clean_card_iterate_serial(_whole_heap, cl);
0 a61af66fc99e Initial load duke parents: diff changeset	402 }
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 // Like the "mod_cards_iterate" above, except only invokes the closure
a61af66fc99e Initial load duke parents: diff changeset	405 // for cards within the MemRegion "mr" (which is required to be
a61af66fc99e Initial load duke parents: diff changeset	406 // card-aligned and sized.)
3256 c69b1043dfb1 7036482: clear argument is redundant and unused in cardtable methods ysr parents: 2433 diff changeset	407 void mod_card_iterate(MemRegion mr, MemRegionClosure* cl) {
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	408 non_clean_card_iterate_serial(mr, cl);
0 a61af66fc99e Initial load duke parents: diff changeset	409 }
a61af66fc99e Initial load duke parents: diff changeset	410
a61af66fc99e Initial load duke parents: diff changeset	411 static uintx ct_max_alignment_constraint();
a61af66fc99e Initial load duke parents: diff changeset	412
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	413 // 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	414 // MemRegion "mr".
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	415 void dirty_card_iterate(MemRegion mr, MemRegionClosure* cl);
0 a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 // Return the MemRegion corresponding to the first maximal run
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	418 // of dirty cards lying completely within MemRegion mr.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	419 // 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	420 // value.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	421 MemRegion dirty_card_range_after_reset(MemRegion mr, bool reset,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	422 int reset_val);
0 a61af66fc99e Initial load duke parents: diff changeset	423
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	424 // Provide read-only access to the card table array.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	425 const jbyte* byte_for_const(const void* p) const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	426 return byte_for(p);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	427 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	428 const jbyte* byte_after_const(const void* p) const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	429 return byte_after(p);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	430 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	431
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	432 // 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	433 HeapWord* addr_for(const jbyte* p) const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	434 assert(p >= _byte_map && p < _byte_map + _byte_map_size,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	435 "out of bounds access to card marking array");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	436 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	437 HeapWord* result = (HeapWord*) (delta << card_shift);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	438 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	439 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	440 " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")",
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 14443 diff changeset	441 p2i(result), p2i(_whole_heap.start()), p2i(_whole_heap.end())));
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	442 return result;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	443 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	444
0 a61af66fc99e Initial load duke parents: diff changeset	445 // Mapping from address to card marking array index.
489 2494ab195856 6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes. swamyv parents: 356 diff changeset	446 size_t index_for(void* p) {
0 a61af66fc99e Initial load duke parents: diff changeset	447 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	448 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	449 " card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")",
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 14443 diff changeset	450 p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end())));
0 a61af66fc99e Initial load duke parents: diff changeset	451 return byte_for(p) - _byte_map;
a61af66fc99e Initial load duke parents: diff changeset	452 }
a61af66fc99e Initial load duke parents: diff changeset	453
616 4f360ec815ba 6720309: G1: don't synchronously update RSet during evacuation pauses iveresov parents: 489 diff changeset	454 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	455 return _byte_map + card_index;
4f360ec815ba 6720309: G1: don't synchronously update RSet during evacuation pauses iveresov parents: 489 diff changeset	456 }
4f360ec815ba 6720309: G1: don't synchronously update RSet during evacuation pauses iveresov parents: 489 diff changeset	457
5984 fd09f2d8283e 7157141: crash in 64 bit with corrupted oops never parents: 5939 diff changeset	458 // Print a description of the memory for the barrier set
fd09f2d8283e 7157141: crash in 64 bit with corrupted oops never parents: 5939 diff changeset	459 virtual void print_on(outputStream* st) const;
fd09f2d8283e 7157141: crash in 64 bit with corrupted oops never parents: 5939 diff changeset	460
0 a61af66fc99e Initial load duke parents: diff changeset	461 void verify();
a61af66fc99e Initial load duke parents: diff changeset	462 void verify_guard();
a61af66fc99e Initial load duke parents: diff changeset	463
3317 063382f9b575 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...) tonyp parents: 3287 diff changeset	464 // 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	465 // !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	466 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	467 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	468 void verify_dirty_region(MemRegion mr) PRODUCT_RETURN;
0 a61af66fc99e Initial load duke parents: diff changeset	469
a61af66fc99e Initial load duke parents: diff changeset	470 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	471 return ParGCCardsPerStrideChunk * card_size_in_words;
0 a61af66fc99e Initial load duke parents: diff changeset	472 }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	473
0 a61af66fc99e Initial load duke parents: diff changeset	474 };
a61af66fc99e Initial load duke parents: diff changeset	475
a61af66fc99e Initial load duke parents: diff changeset	476 class CardTableRS;
a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 // A specialization for the CardTableRS gen rem set.
a61af66fc99e Initial load duke parents: diff changeset	479 class CardTableModRefBSForCTRS: public CardTableModRefBS {
a61af66fc99e Initial load duke parents: diff changeset	480 CardTableRS* _rs;
a61af66fc99e Initial load duke parents: diff changeset	481 protected:
a61af66fc99e Initial load duke parents: diff changeset	482 bool card_will_be_scanned(jbyte cv);
a61af66fc99e Initial load duke parents: diff changeset	483 bool card_may_have_been_dirty(jbyte cv);
a61af66fc99e Initial load duke parents: diff changeset	484 public:
a61af66fc99e Initial load duke parents: diff changeset	485 CardTableModRefBSForCTRS(MemRegion whole_heap,
a61af66fc99e Initial load duke parents: diff changeset	486 int max_covered_regions) :
a61af66fc99e Initial load duke parents: diff changeset	487 CardTableModRefBS(whole_heap, max_covered_regions) {}
a61af66fc99e Initial load duke parents: diff changeset	488
a61af66fc99e Initial load duke parents: diff changeset	489 void set_CTRS(CardTableRS* rs) { _rs = rs; }
a61af66fc99e Initial load duke parents: diff changeset	490 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	491
3287 c48ad6ab8bdf 7037276: Unnecessary double traversal of dirty card windows ysr parents: 3256 diff changeset	492
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1692 diff changeset	493 #endif // SHARE_VM_MEMORY_CARDTABLEMODREFBS_HPP

Mercurial > hg > truffle

annotate src/share/vm/memory/cardTableModRefBS.hpp @ 20543:e7d0505c8a30