Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/g1BlockOffsetTable.hpp @ 20211:82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
Summary: The test incorrectly assumed that it had been started with no other previous compilation activity. Fix this by allowing multiple code root free chunk lists, and use one separate from the global one to perform the test.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Wed, 16 Apr 2014 10:14:50 +0200 |
| parents | 78bbf4d43a14 |
| children | 9441d22e429a |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
7181
diff
changeset
|
2 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. |
| 342 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
342
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
342
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:
342
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1BLOCKOFFSETTABLE_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1BLOCKOFFSETTABLE_HPP | |
| 27 | |
| 28 #include "memory/memRegion.hpp" | |
| 29 #include "runtime/virtualspace.hpp" | |
| 30 #include "utilities/globalDefinitions.hpp" | |
| 31 | |
| 342 | 32 // The CollectedHeap type requires subtypes to implement a method |
| 33 // "block_start". For some subtypes, notably generational | |
| 34 // systems using card-table-based write barriers, the efficiency of this | |
| 35 // operation may be important. Implementations of the "BlockOffsetArray" | |
| 36 // class may be useful in providing such efficient implementations. | |
| 37 // | |
| 38 // While generally mirroring the structure of the BOT for GenCollectedHeap, | |
| 39 // the following types are tailored more towards G1's uses; these should, | |
| 40 // however, be merged back into a common BOT to avoid code duplication | |
| 41 // and reduce maintenance overhead. | |
| 42 // | |
| 43 // G1BlockOffsetTable (abstract) | |
| 44 // -- G1BlockOffsetArray (uses G1BlockOffsetSharedArray) | |
| 45 // -- G1BlockOffsetArrayContigSpace | |
| 46 // | |
| 47 // A main impediment to the consolidation of this code might be the | |
| 48 // effect of making some of the block_start*() calls non-const as | |
| 49 // below. Whether that might adversely affect performance optimizations | |
| 50 // that compilers might normally perform in the case of non-G1 | |
| 51 // collectors needs to be carefully investigated prior to any such | |
| 52 // consolidation. | |
| 53 | |
| 54 // Forward declarations | |
| 55 class ContiguousSpace; | |
| 56 class G1BlockOffsetSharedArray; | |
| 57 | |
| 58 class G1BlockOffsetTable VALUE_OBJ_CLASS_SPEC { | |
| 59 friend class VMStructs; | |
| 60 protected: | |
| 61 // These members describe the region covered by the table. | |
| 62 | |
| 63 // The space this table is covering. | |
| 64 HeapWord* _bottom; // == reserved.start | |
| 65 HeapWord* _end; // End of currently allocated region. | |
| 66 | |
| 67 public: | |
| 68 // Initialize the table to cover the given space. | |
| 69 // The contents of the initial table are undefined. | |
| 70 G1BlockOffsetTable(HeapWord* bottom, HeapWord* end) : | |
| 71 _bottom(bottom), _end(end) | |
| 72 { | |
| 73 assert(_bottom <= _end, "arguments out of order"); | |
| 74 } | |
| 75 | |
| 76 // Note that the committed size of the covered space may have changed, | |
| 77 // so the table size might also wish to change. | |
| 78 virtual void resize(size_t new_word_size) = 0; | |
| 79 | |
| 80 virtual void set_bottom(HeapWord* new_bottom) { | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
81 assert(new_bottom <= _end, |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
82 err_msg("new_bottom (" PTR_FORMAT ") > _end (" PTR_FORMAT ")", |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
7181
diff
changeset
|
83 p2i(new_bottom), p2i(_end))); |
| 342 | 84 _bottom = new_bottom; |
| 85 resize(pointer_delta(_end, _bottom)); | |
| 86 } | |
| 87 | |
| 88 // Requires "addr" to be contained by a block, and returns the address of | |
| 89 // the start of that block. (May have side effects, namely updating of | |
| 90 // shared array entries that "point" too far backwards. This can occur, | |
| 91 // for example, when LAB allocation is used in a space covered by the | |
| 92 // table.) | |
| 93 virtual HeapWord* block_start_unsafe(const void* addr) = 0; | |
| 94 // Same as above, but does not have any of the possible side effects | |
| 95 // discussed above. | |
| 96 virtual HeapWord* block_start_unsafe_const(const void* addr) const = 0; | |
| 97 | |
| 98 // Returns the address of the start of the block containing "addr", or | |
| 99 // else "null" if it is covered by no block. (May have side effects, | |
| 100 // namely updating of shared array entries that "point" too far | |
| 101 // backwards. This can occur, for example, when lab allocation is used | |
| 102 // in a space covered by the table.) | |
| 103 inline HeapWord* block_start(const void* addr); | |
| 104 // Same as above, but does not have any of the possible side effects | |
| 105 // discussed above. | |
| 106 inline HeapWord* block_start_const(const void* addr) const; | |
| 107 }; | |
| 108 | |
| 109 // This implementation of "G1BlockOffsetTable" divides the covered region | |
| 110 // into "N"-word subregions (where "N" = 2^"LogN". An array with an entry | |
| 111 // for each such subregion indicates how far back one must go to find the | |
| 112 // start of the chunk that includes the first word of the subregion. | |
| 113 // | |
| 114 // Each BlockOffsetArray is owned by a Space. However, the actual array | |
| 115 // may be shared by several BlockOffsetArrays; this is useful | |
| 116 // when a single resizable area (such as a generation) is divided up into | |
| 117 // several spaces in which contiguous allocation takes place, | |
| 118 // such as, for example, in G1 or in the train generation.) | |
| 119 | |
| 120 // Here is the shared array type. | |
| 121 | |
| 6197 | 122 class G1BlockOffsetSharedArray: public CHeapObj<mtGC> { |
| 342 | 123 friend class G1BlockOffsetArray; |
| 124 friend class G1BlockOffsetArrayContigSpace; | |
| 125 friend class VMStructs; | |
| 126 | |
| 127 private: | |
| 128 // The reserved region covered by the shared array. | |
| 129 MemRegion _reserved; | |
| 130 | |
| 131 // End of the current committed region. | |
| 132 HeapWord* _end; | |
| 133 | |
| 134 // Array for keeping offsets for retrieving object start fast given an | |
| 135 // address. | |
| 136 VirtualSpace _vs; | |
| 137 u_char* _offset_array; // byte array keeping backwards offsets | |
| 138 | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
139 void check_index(size_t index, const char* msg) const { |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
140 assert(index < _vs.committed_size(), |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
141 err_msg("%s - " |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
142 "index: " SIZE_FORMAT ", _vs.committed_size: " SIZE_FORMAT, |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
143 msg, index, _vs.committed_size())); |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
144 } |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
145 |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
146 void check_offset(size_t offset, const char* msg) const { |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
147 assert(offset <= N_words, |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
148 err_msg("%s - " |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
7181
diff
changeset
|
149 "offset: " SIZE_FORMAT ", N_words: " UINT32_FORMAT, |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
150 msg, offset, N_words)); |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
151 } |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
152 |
| 342 | 153 // Bounds checking accessors: |
| 154 // For performance these have to devolve to array accesses in product builds. | |
| 155 u_char offset_array(size_t index) const { | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
156 check_index(index, "index out of range"); |
| 342 | 157 return _offset_array[index]; |
| 158 } | |
| 159 | |
| 160 void set_offset_array(size_t index, u_char offset) { | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
161 check_index(index, "index out of range"); |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
162 check_offset(offset, "offset too large"); |
| 342 | 163 _offset_array[index] = offset; |
| 164 } | |
| 165 | |
| 166 void set_offset_array(size_t index, HeapWord* high, HeapWord* low) { | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
167 check_index(index, "index out of range"); |
| 342 | 168 assert(high >= low, "addresses out of order"); |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
169 check_offset(pointer_delta(high, low), "offset too large"); |
| 342 | 170 _offset_array[index] = (u_char) pointer_delta(high, low); |
| 171 } | |
| 172 | |
| 173 void set_offset_array(HeapWord* left, HeapWord* right, u_char offset) { | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
174 check_index(index_for(right - 1), "right address out of range"); |
| 342 | 175 assert(left < right, "Heap addresses out of order"); |
| 176 size_t num_cards = pointer_delta(right, left) >> LogN_words; | |
| 6610 | 177 if (UseMemSetInBOT) { |
| 178 memset(&_offset_array[index_for(left)], offset, num_cards); | |
| 179 } else { | |
| 180 size_t i = index_for(left); | |
| 181 const size_t end = i + num_cards; | |
| 182 for (; i < end; i++) { | |
| 183 _offset_array[i] = offset; | |
| 184 } | |
| 185 } | |
| 342 | 186 } |
| 187 | |
| 188 void set_offset_array(size_t left, size_t right, u_char offset) { | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
189 check_index(right, "right index out of range"); |
| 6610 | 190 assert(left <= right, "indexes out of order"); |
| 342 | 191 size_t num_cards = right - left + 1; |
| 6610 | 192 if (UseMemSetInBOT) { |
| 193 memset(&_offset_array[left], offset, num_cards); | |
| 194 } else { | |
| 195 size_t i = left; | |
| 196 const size_t end = i + num_cards; | |
| 197 for (; i < end; i++) { | |
| 198 _offset_array[i] = offset; | |
| 199 } | |
| 200 } | |
| 342 | 201 } |
| 202 | |
| 203 void check_offset_array(size_t index, HeapWord* high, HeapWord* low) const { | |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
204 check_index(index, "index out of range"); |
| 342 | 205 assert(high >= low, "addresses out of order"); |
|
7181
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
206 check_offset(pointer_delta(high, low), "offset too large"); |
|
2fc0334f613a
7194633: G1: Assertion and guarantee failures in block offset table
johnc
parents:
6610
diff
changeset
|
207 assert(_offset_array[index] == pointer_delta(high, low), "Wrong offset"); |
| 342 | 208 } |
| 209 | |
| 210 bool is_card_boundary(HeapWord* p) const; | |
| 211 | |
| 212 // Return the number of slots needed for an offset array | |
| 213 // that covers mem_region_words words. | |
| 214 // We always add an extra slot because if an object | |
| 215 // ends on a card boundary we put a 0 in the next | |
| 216 // offset array slot, so we want that slot always | |
| 217 // to be reserved. | |
| 218 | |
| 219 size_t compute_size(size_t mem_region_words) { | |
| 220 size_t number_of_slots = (mem_region_words / N_words) + 1; | |
| 221 return ReservedSpace::page_align_size_up(number_of_slots); | |
| 222 } | |
| 223 | |
| 224 public: | |
| 225 enum SomePublicConstants { | |
| 226 LogN = 9, | |
| 227 LogN_words = LogN - LogHeapWordSize, | |
| 228 N_bytes = 1 << LogN, | |
| 229 N_words = 1 << LogN_words | |
| 230 }; | |
| 231 | |
| 232 // Initialize the table to cover from "base" to (at least) | |
| 233 // "base + init_word_size". In the future, the table may be expanded | |
| 234 // (see "resize" below) up to the size of "_reserved" (which must be at | |
| 235 // least "init_word_size".) The contents of the initial table are | |
| 236 // undefined; it is the responsibility of the constituent | |
| 237 // G1BlockOffsetTable(s) to initialize cards. | |
| 238 G1BlockOffsetSharedArray(MemRegion reserved, size_t init_word_size); | |
| 239 | |
| 240 // Notes a change in the committed size of the region covered by the | |
| 241 // table. The "new_word_size" may not be larger than the size of the | |
| 242 // reserved region this table covers. | |
| 243 void resize(size_t new_word_size); | |
| 244 | |
| 245 void set_bottom(HeapWord* new_bottom); | |
| 246 | |
| 247 // Updates all the BlockOffsetArray's sharing this shared array to | |
| 248 // reflect the current "top"'s of their spaces. | |
| 249 void update_offset_arrays(); | |
| 250 | |
| 251 // Return the appropriate index into "_offset_array" for "p". | |
| 252 inline size_t index_for(const void* p) const; | |
| 253 | |
| 254 // Return the address indicating the start of the region corresponding to | |
| 255 // "index" in "_offset_array". | |
| 256 inline HeapWord* address_for_index(size_t index) const; | |
| 257 }; | |
| 258 | |
| 259 // And here is the G1BlockOffsetTable subtype that uses the array. | |
| 260 | |
| 261 class G1BlockOffsetArray: public G1BlockOffsetTable { | |
| 262 friend class G1BlockOffsetSharedArray; | |
| 263 friend class G1BlockOffsetArrayContigSpace; | |
| 264 friend class VMStructs; | |
| 265 private: | |
| 266 enum SomePrivateConstants { | |
| 267 N_words = G1BlockOffsetSharedArray::N_words, | |
| 268 LogN = G1BlockOffsetSharedArray::LogN | |
| 269 }; | |
| 270 | |
| 271 // The following enums are used by do_block_helper | |
| 272 enum Action { | |
| 273 Action_single, // BOT records a single block (see single_block()) | |
| 274 Action_mark, // BOT marks the start of a block (see mark_block()) | |
| 275 Action_check // Check that BOT records block correctly | |
| 276 // (see verify_single_block()). | |
| 277 }; | |
| 278 | |
| 279 // This is the array, which can be shared by several BlockOffsetArray's | |
| 280 // servicing different | |
| 281 G1BlockOffsetSharedArray* _array; | |
| 282 | |
| 283 // The space that owns this subregion. | |
| 284 Space* _sp; | |
| 285 | |
| 286 // If "_sp" is a contiguous space, the field below is the view of "_sp" | |
| 287 // as a contiguous space, else NULL. | |
| 288 ContiguousSpace* _csp; | |
| 289 | |
| 290 // If true, array entries are initialized to 0; otherwise, they are | |
| 291 // initialized to point backwards to the beginning of the covered region. | |
| 292 bool _init_to_zero; | |
| 293 | |
| 294 // The portion [_unallocated_block, _sp.end()) of the space that | |
| 295 // is a single block known not to contain any objects. | |
| 296 // NOTE: See BlockOffsetArrayUseUnallocatedBlock flag. | |
| 297 HeapWord* _unallocated_block; | |
| 298 | |
| 299 // Sets the entries | |
| 300 // corresponding to the cards starting at "start" and ending at "end" | |
| 301 // to point back to the card before "start": the interval [start, end) | |
| 302 // is right-open. | |
| 303 void set_remainder_to_point_to_start(HeapWord* start, HeapWord* end); | |
| 304 // Same as above, except that the args here are a card _index_ interval | |
| 305 // that is closed: [start_index, end_index] | |
| 306 void set_remainder_to_point_to_start_incl(size_t start, size_t end); | |
| 307 | |
| 308 // A helper function for BOT adjustment/verification work | |
| 309 void do_block_internal(HeapWord* blk_start, HeapWord* blk_end, Action action); | |
| 310 | |
| 311 protected: | |
| 312 | |
| 313 ContiguousSpace* csp() const { return _csp; } | |
| 314 | |
| 315 // Returns the address of a block whose start is at most "addr". | |
| 316 // If "has_max_index" is true, "assumes "max_index" is the last valid one | |
| 317 // in the array. | |
| 318 inline HeapWord* block_at_or_preceding(const void* addr, | |
| 319 bool has_max_index, | |
| 320 size_t max_index) const; | |
| 321 | |
| 322 // "q" is a block boundary that is <= "addr"; "n" is the address of the | |
| 323 // next block (or the end of the space.) Return the address of the | |
| 324 // beginning of the block that contains "addr". Does so without side | |
| 325 // effects (see, e.g., spec of block_start.) | |
| 326 inline HeapWord* | |
| 327 forward_to_block_containing_addr_const(HeapWord* q, HeapWord* n, | |
| 328 const void* addr) const; | |
| 329 | |
| 330 // "q" is a block boundary that is <= "addr"; return the address of the | |
| 331 // beginning of the block that contains "addr". May have side effects | |
| 332 // on "this", by updating imprecise entries. | |
| 333 inline HeapWord* forward_to_block_containing_addr(HeapWord* q, | |
| 334 const void* addr); | |
| 335 | |
| 336 // "q" is a block boundary that is <= "addr"; "n" is the address of the | |
| 337 // next block (or the end of the space.) Return the address of the | |
| 338 // beginning of the block that contains "addr". May have side effects | |
| 339 // on "this", by updating imprecise entries. | |
| 340 HeapWord* forward_to_block_containing_addr_slow(HeapWord* q, | |
| 341 HeapWord* n, | |
| 342 const void* addr); | |
| 343 | |
| 344 // Requires that "*threshold_" be the first array entry boundary at or | |
| 345 // above "blk_start", and that "*index_" be the corresponding array | |
| 346 // index. If the block starts at or crosses "*threshold_", records | |
| 347 // "blk_start" as the appropriate block start for the array index | |
| 348 // starting at "*threshold_", and for any other indices crossed by the | |
| 349 // block. Updates "*threshold_" and "*index_" to correspond to the first | |
| 350 // index after the block end. | |
| 351 void alloc_block_work2(HeapWord** threshold_, size_t* index_, | |
| 352 HeapWord* blk_start, HeapWord* blk_end); | |
| 353 | |
| 354 public: | |
| 355 // The space may not have it's bottom and top set yet, which is why the | |
| 356 // region is passed as a parameter. If "init_to_zero" is true, the | |
| 357 // elements of the array are initialized to zero. Otherwise, they are | |
| 358 // initialized to point backwards to the beginning. | |
| 359 G1BlockOffsetArray(G1BlockOffsetSharedArray* array, MemRegion mr, | |
| 360 bool init_to_zero); | |
| 361 | |
| 362 // Note: this ought to be part of the constructor, but that would require | |
| 363 // "this" to be passed as a parameter to a member constructor for | |
| 364 // the containing concrete subtype of Space. | |
| 365 // This would be legal C++, but MS VC++ doesn't allow it. | |
| 366 void set_space(Space* sp); | |
| 367 | |
| 368 // Resets the covered region to the given "mr". | |
| 369 void set_region(MemRegion mr); | |
| 370 | |
| 371 // Resets the covered region to one with the same _bottom as before but | |
| 372 // the "new_word_size". | |
| 373 void resize(size_t new_word_size); | |
| 374 | |
| 375 // These must be guaranteed to work properly (i.e., do nothing) | |
| 376 // when "blk_start" ("blk" for second version) is "NULL". | |
| 377 virtual void alloc_block(HeapWord* blk_start, HeapWord* blk_end); | |
| 378 virtual void alloc_block(HeapWord* blk, size_t size) { | |
| 379 alloc_block(blk, blk + size); | |
| 380 } | |
| 381 | |
| 382 // The following methods are useful and optimized for a | |
| 383 // general, non-contiguous space. | |
| 384 | |
| 385 // Given a block [blk_start, blk_start + full_blk_size), and | |
| 386 // a left_blk_size < full_blk_size, adjust the BOT to show two | |
| 387 // blocks [blk_start, blk_start + left_blk_size) and | |
| 388 // [blk_start + left_blk_size, blk_start + full_blk_size). | |
| 389 // It is assumed (and verified in the non-product VM) that the | |
| 390 // BOT was correct for the original block. | |
| 391 void split_block(HeapWord* blk_start, size_t full_blk_size, | |
| 392 size_t left_blk_size); | |
| 393 | |
| 394 // Adjust the BOT to show that it has a single block in the | |
| 395 // range [blk_start, blk_start + size). All necessary BOT | |
| 396 // cards are adjusted, but _unallocated_block isn't. | |
| 397 void single_block(HeapWord* blk_start, HeapWord* blk_end); | |
| 398 void single_block(HeapWord* blk, size_t size) { | |
| 399 single_block(blk, blk + size); | |
| 400 } | |
| 401 | |
| 402 // Adjust BOT to show that it has a block in the range | |
| 403 // [blk_start, blk_start + size). Only the first card | |
| 404 // of BOT is touched. It is assumed (and verified in the | |
| 405 // non-product VM) that the remaining cards of the block | |
| 406 // are correct. | |
| 407 void mark_block(HeapWord* blk_start, HeapWord* blk_end); | |
| 408 void mark_block(HeapWord* blk, size_t size) { | |
| 409 mark_block(blk, blk + size); | |
| 410 } | |
| 411 | |
| 412 // Adjust _unallocated_block to indicate that a particular | |
| 413 // block has been newly allocated or freed. It is assumed (and | |
| 414 // verified in the non-product VM) that the BOT is correct for | |
| 415 // the given block. | |
| 416 inline void allocated(HeapWord* blk_start, HeapWord* blk_end) { | |
| 417 // Verify that the BOT shows [blk, blk + blk_size) to be one block. | |
| 418 verify_single_block(blk_start, blk_end); | |
| 419 if (BlockOffsetArrayUseUnallocatedBlock) { | |
| 420 _unallocated_block = MAX2(_unallocated_block, blk_end); | |
| 421 } | |
| 422 } | |
| 423 | |
| 424 inline void allocated(HeapWord* blk, size_t size) { | |
| 425 allocated(blk, blk + size); | |
| 426 } | |
| 427 | |
| 428 inline void freed(HeapWord* blk_start, HeapWord* blk_end); | |
| 429 | |
| 430 inline void freed(HeapWord* blk, size_t size); | |
| 431 | |
| 432 virtual HeapWord* block_start_unsafe(const void* addr); | |
| 433 virtual HeapWord* block_start_unsafe_const(const void* addr) const; | |
| 434 | |
| 435 // Requires "addr" to be the start of a card and returns the | |
| 436 // start of the block that contains the given address. | |
| 437 HeapWord* block_start_careful(const void* addr) const; | |
| 438 | |
| 439 // If true, initialize array slots with no allocated blocks to zero. | |
| 440 // Otherwise, make them point back to the front. | |
| 441 bool init_to_zero() { return _init_to_zero; } | |
| 442 | |
| 443 // Verification & debugging - ensure that the offset table reflects the fact | |
| 444 // that the block [blk_start, blk_end) or [blk, blk + size) is a | |
| 445 // single block of storage. NOTE: can;t const this because of | |
| 446 // call to non-const do_block_internal() below. | |
| 447 inline void verify_single_block(HeapWord* blk_start, HeapWord* blk_end) { | |
| 448 if (VerifyBlockOffsetArray) { | |
| 449 do_block_internal(blk_start, blk_end, Action_check); | |
| 450 } | |
| 451 } | |
| 452 | |
| 453 inline void verify_single_block(HeapWord* blk, size_t size) { | |
| 454 verify_single_block(blk, blk + size); | |
| 455 } | |
| 456 | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
457 // Used by region verification. Checks that the contents of the |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
458 // BOT reflect that there's a single object that spans the address |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
459 // range [obj_start, obj_start + word_size); returns true if this is |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
460 // the case, returns false if it's not. |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
461 bool verify_for_object(HeapWord* obj_start, size_t word_size) const; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
462 |
| 342 | 463 // Verify that the given block is before _unallocated_block |
| 464 inline void verify_not_unallocated(HeapWord* blk_start, | |
| 465 HeapWord* blk_end) const { | |
| 466 if (BlockOffsetArrayUseUnallocatedBlock) { | |
| 467 assert(blk_start < blk_end, "Block inconsistency?"); | |
| 468 assert(blk_end <= _unallocated_block, "_unallocated_block problem"); | |
| 469 } | |
| 470 } | |
| 471 | |
| 472 inline void verify_not_unallocated(HeapWord* blk, size_t size) const { | |
| 473 verify_not_unallocated(blk, blk + size); | |
| 474 } | |
| 475 | |
| 476 void check_all_cards(size_t left_card, size_t right_card) const; | |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1552
diff
changeset
|
477 |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
478 virtual void print_on(outputStream* out) PRODUCT_RETURN; |
| 342 | 479 }; |
| 480 | |
| 481 // A subtype of BlockOffsetArray that takes advantage of the fact | |
| 482 // that its underlying space is a ContiguousSpace, so that its "active" | |
| 483 // region can be more efficiently tracked (than for a non-contiguous space). | |
| 484 class G1BlockOffsetArrayContigSpace: public G1BlockOffsetArray { | |
| 485 friend class VMStructs; | |
| 486 | |
| 487 // allocation boundary at which offset array must be updated | |
| 488 HeapWord* _next_offset_threshold; | |
| 489 size_t _next_offset_index; // index corresponding to that boundary | |
| 490 | |
| 491 // Work function to be called when allocation start crosses the next | |
| 492 // threshold in the contig space. | |
| 493 void alloc_block_work1(HeapWord* blk_start, HeapWord* blk_end) { | |
| 494 alloc_block_work2(&_next_offset_threshold, &_next_offset_index, | |
| 495 blk_start, blk_end); | |
| 496 } | |
| 497 | |
| 498 public: | |
| 499 G1BlockOffsetArrayContigSpace(G1BlockOffsetSharedArray* array, MemRegion mr); | |
| 500 | |
| 501 // Initialize the threshold to reflect the first boundary after the | |
| 502 // bottom of the covered region. | |
| 503 HeapWord* initialize_threshold(); | |
| 504 | |
| 505 // Zero out the entry for _bottom (offset will be zero). | |
| 506 void zero_bottom_entry(); | |
| 507 | |
| 508 // Return the next threshold, the point at which the table should be | |
| 509 // updated. | |
| 510 HeapWord* threshold() const { return _next_offset_threshold; } | |
| 511 | |
| 512 // These must be guaranteed to work properly (i.e., do nothing) | |
| 513 // when "blk_start" ("blk" for second version) is "NULL". In this | |
| 514 // implementation, that's true because NULL is represented as 0, and thus | |
| 515 // never exceeds the "_next_offset_threshold". | |
| 516 void alloc_block(HeapWord* blk_start, HeapWord* blk_end) { | |
| 517 if (blk_end > _next_offset_threshold) | |
| 518 alloc_block_work1(blk_start, blk_end); | |
| 519 } | |
| 520 void alloc_block(HeapWord* blk, size_t size) { | |
| 521 alloc_block(blk, blk+size); | |
| 522 } | |
| 523 | |
| 524 HeapWord* block_start_unsafe(const void* addr); | |
| 525 HeapWord* block_start_unsafe_const(const void* addr) const; | |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1552
diff
changeset
|
526 |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
527 void set_for_starts_humongous(HeapWord* new_top); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
528 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
529 virtual void print_on(outputStream* out) PRODUCT_RETURN; |
| 342 | 530 }; |
| 1972 | 531 |
| 532 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1BLOCKOFFSETTABLE_HPP |