Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/heapRegion.hpp @ 3772:6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
Summary: Perform a heap verification after the first phase of G1's full GC using objects' mark words to determine liveness. The third parameter of the heap verification routines, which was used in G1 to determine which marking bitmap to use in liveness calculations, has been changed from a boolean to an enum with values defined for using the mark word, and the 'prev' and 'next' bitmaps.
Reviewed-by: tonyp, ysr
| author | johnc |
|---|---|
| date | Tue, 14 Jun 2011 11:01:10 -0700 |
| parents | c3f1170908be |
| children | f44782f04dd4 |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
2 * Copyright (c) 2001, 2011, 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:
1394
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
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:
1394
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP | |
| 27 | |
| 28 #include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp" | |
| 29 #include "gc_implementation/g1/g1_specialized_oop_closures.hpp" | |
| 30 #include "gc_implementation/g1/survRateGroup.hpp" | |
| 31 #include "gc_implementation/shared/ageTable.hpp" | |
| 32 #include "gc_implementation/shared/spaceDecorator.hpp" | |
| 33 #include "memory/space.inline.hpp" | |
| 34 #include "memory/watermark.hpp" | |
| 35 | |
| 342 | 36 #ifndef SERIALGC |
| 37 | |
| 38 // A HeapRegion is the smallest piece of a G1CollectedHeap that | |
| 39 // can be collected independently. | |
| 40 | |
| 41 // NOTE: Although a HeapRegion is a Space, its | |
| 42 // Space::initDirtyCardClosure method must not be called. | |
| 43 // The problem is that the existence of this method breaks | |
| 44 // the independence of barrier sets from remembered sets. | |
| 45 // The solution is to remove this method from the definition | |
| 46 // of a Space. | |
| 47 | |
| 48 class CompactibleSpace; | |
| 49 class ContiguousSpace; | |
| 50 class HeapRegionRemSet; | |
| 51 class HeapRegionRemSetIterator; | |
| 52 class HeapRegion; | |
| 2152 | 53 class HeapRegionSetBase; |
| 54 | |
| 3766 | 55 #define HR_FORMAT SIZE_FORMAT":(%s)["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]" |
| 56 #define HR_FORMAT_PARAMS(_hr_) \ | |
| 57 (_hr_)->hrs_index(), \ | |
| 58 (_hr_)->is_survivor() ? "S" : (_hr_)->is_young() ? "E" : "-", \ | |
| 59 (_hr_)->bottom(), (_hr_)->top(), (_hr_)->end() | |
| 342 | 60 |
| 61 // A dirty card to oop closure for heap regions. It | |
| 62 // knows how to get the G1 heap and how to use the bitmap | |
| 63 // in the concurrent marker used by G1 to filter remembered | |
| 64 // sets. | |
| 65 | |
| 66 class HeapRegionDCTOC : public ContiguousSpaceDCTOC { | |
| 67 public: | |
| 68 // Specification of possible DirtyCardToOopClosure filtering. | |
| 69 enum FilterKind { | |
| 70 NoFilterKind, | |
| 71 IntoCSFilterKind, | |
| 72 OutOfRegionFilterKind | |
| 73 }; | |
| 74 | |
| 75 protected: | |
| 76 HeapRegion* _hr; | |
| 77 FilterKind _fk; | |
| 78 G1CollectedHeap* _g1; | |
| 79 | |
| 80 void walk_mem_region_with_cl(MemRegion mr, | |
| 81 HeapWord* bottom, HeapWord* top, | |
| 82 OopClosure* cl); | |
| 83 | |
| 84 // We don't specialize this for FilteringClosure; filtering is handled by | |
| 85 // the "FilterKind" mechanism. But we provide this to avoid a compiler | |
| 86 // warning. | |
| 87 void walk_mem_region_with_cl(MemRegion mr, | |
| 88 HeapWord* bottom, HeapWord* top, | |
| 89 FilteringClosure* cl) { | |
| 90 HeapRegionDCTOC::walk_mem_region_with_cl(mr, bottom, top, | |
| 91 (OopClosure*)cl); | |
| 92 } | |
| 93 | |
| 94 // Get the actual top of the area on which the closure will | |
| 95 // operate, given where the top is assumed to be (the end of the | |
| 96 // memory region passed to do_MemRegion) and where the object | |
| 97 // at the top is assumed to start. For example, an object may | |
| 98 // start at the top but actually extend past the assumed top, | |
| 99 // in which case the top becomes the end of the object. | |
| 100 HeapWord* get_actual_top(HeapWord* top, HeapWord* top_obj) { | |
| 101 return ContiguousSpaceDCTOC::get_actual_top(top, top_obj); | |
| 102 } | |
| 103 | |
| 104 // Walk the given memory region from bottom to (actual) top | |
| 105 // looking for objects and applying the oop closure (_cl) to | |
| 106 // them. The base implementation of this treats the area as | |
| 107 // blocks, where a block may or may not be an object. Sub- | |
| 108 // classes should override this to provide more accurate | |
| 109 // or possibly more efficient walking. | |
| 110 void walk_mem_region(MemRegion mr, HeapWord* bottom, HeapWord* top) { | |
| 111 Filtering_DCTOC::walk_mem_region(mr, bottom, top); | |
| 112 } | |
| 113 | |
| 114 public: | |
| 115 HeapRegionDCTOC(G1CollectedHeap* g1, | |
| 116 HeapRegion* hr, OopClosure* cl, | |
| 117 CardTableModRefBS::PrecisionStyle precision, | |
| 118 FilterKind fk); | |
| 119 }; | |
| 120 | |
| 121 | |
| 122 // The complicating factor is that BlockOffsetTable diverged | |
| 123 // significantly, and we need functionality that is only in the G1 version. | |
| 124 // So I copied that code, which led to an alternate G1 version of | |
| 125 // OffsetTableContigSpace. If the two versions of BlockOffsetTable could | |
| 126 // be reconciled, then G1OffsetTableContigSpace could go away. | |
| 127 | |
| 128 // The idea behind time stamps is the following. Doing a save_marks on | |
| 129 // all regions at every GC pause is time consuming (if I remember | |
| 130 // well, 10ms or so). So, we would like to do that only for regions | |
| 131 // that are GC alloc regions. To achieve this, we use time | |
| 132 // stamps. For every evacuation pause, G1CollectedHeap generates a | |
| 133 // unique time stamp (essentially a counter that gets | |
| 134 // incremented). Every time we want to call save_marks on a region, | |
| 135 // we set the saved_mark_word to top and also copy the current GC | |
| 136 // time stamp to the time stamp field of the space. Reading the | |
| 137 // saved_mark_word involves checking the time stamp of the | |
| 138 // region. If it is the same as the current GC time stamp, then we | |
| 139 // can safely read the saved_mark_word field, as it is valid. If the | |
| 140 // time stamp of the region is not the same as the current GC time | |
| 141 // stamp, then we instead read top, as the saved_mark_word field is | |
| 142 // invalid. Time stamps (on the regions and also on the | |
| 143 // G1CollectedHeap) are reset at every cleanup (we iterate over | |
| 144 // the regions anyway) and at the end of a Full GC. The current scheme | |
| 145 // that uses sequential unsigned ints will fail only if we have 4b | |
| 146 // evacuation pauses between two cleanups, which is _highly_ unlikely. | |
| 147 | |
| 148 class G1OffsetTableContigSpace: public ContiguousSpace { | |
| 149 friend class VMStructs; | |
| 150 protected: | |
| 151 G1BlockOffsetArrayContigSpace _offsets; | |
| 152 Mutex _par_alloc_lock; | |
| 153 volatile unsigned _gc_time_stamp; | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
154 // When we need to retire an allocation region, while other threads |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
155 // are also concurrently trying to allocate into it, we typically |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
156 // allocate a dummy object at the end of the region to ensure that |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
157 // no more allocations can take place in it. However, sometimes we |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
158 // want to know where the end of the last "real" object we allocated |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
159 // into the region was and this is what this keeps track. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
160 HeapWord* _pre_dummy_top; |
| 342 | 161 |
| 162 public: | |
| 163 // Constructor. If "is_zeroed" is true, the MemRegion "mr" may be | |
| 164 // assumed to contain zeros. | |
| 165 G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray, | |
| 166 MemRegion mr, bool is_zeroed = false); | |
| 167 | |
| 168 void set_bottom(HeapWord* value); | |
| 169 void set_end(HeapWord* value); | |
| 170 | |
| 171 virtual HeapWord* saved_mark_word() const; | |
| 172 virtual void set_saved_mark(); | |
| 173 void reset_gc_time_stamp() { _gc_time_stamp = 0; } | |
| 174 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
175 // See the comment above in the declaration of _pre_dummy_top for an |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
176 // explanation of what it is. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
177 void set_pre_dummy_top(HeapWord* pre_dummy_top) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
178 assert(is_in(pre_dummy_top) && pre_dummy_top <= top(), "pre-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
179 _pre_dummy_top = pre_dummy_top; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
180 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
181 HeapWord* pre_dummy_top() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
182 return (_pre_dummy_top == NULL) ? top() : _pre_dummy_top; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
183 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
184 void reset_pre_dummy_top() { _pre_dummy_top = NULL; } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
185 |
| 356 | 186 virtual void initialize(MemRegion mr, bool clear_space, bool mangle_space); |
| 187 virtual void clear(bool mangle_space); | |
| 342 | 188 |
| 189 HeapWord* block_start(const void* p); | |
| 190 HeapWord* block_start_const(const void* p) const; | |
| 191 | |
| 192 // Add offset table update. | |
| 193 virtual HeapWord* allocate(size_t word_size); | |
| 194 HeapWord* par_allocate(size_t word_size); | |
| 195 | |
| 196 // MarkSweep support phase3 | |
| 197 virtual HeapWord* initialize_threshold(); | |
| 198 virtual HeapWord* cross_threshold(HeapWord* start, HeapWord* end); | |
| 199 | |
| 200 virtual void print() const; | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
201 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
202 void reset_bot() { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
203 _offsets.zero_bottom_entry(); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
204 _offsets.initialize_threshold(); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
205 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
206 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
207 void update_bot_for_object(HeapWord* start, size_t word_size) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
208 _offsets.alloc_block(start, word_size); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
209 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
210 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
211 void print_bot_on(outputStream* out) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
212 _offsets.print_on(out); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
213 } |
| 342 | 214 }; |
| 215 | |
| 216 class HeapRegion: public G1OffsetTableContigSpace { | |
| 217 friend class VMStructs; | |
| 218 private: | |
| 219 | |
| 355 | 220 enum HumongousType { |
| 221 NotHumongous = 0, | |
| 222 StartsHumongous, | |
| 223 ContinuesHumongous | |
| 224 }; | |
| 225 | |
| 342 | 226 // The next filter kind that should be used for a "new_dcto_cl" call with |
| 227 // the "traditional" signature. | |
| 228 HeapRegionDCTOC::FilterKind _next_fk; | |
| 229 | |
| 230 // Requires that the region "mr" be dense with objects, and begin and end | |
| 231 // with an object. | |
| 232 void oops_in_mr_iterate(MemRegion mr, OopClosure* cl); | |
| 233 | |
| 234 // The remembered set for this region. | |
| 235 // (Might want to make this "inline" later, to avoid some alloc failure | |
| 236 // issues.) | |
| 237 HeapRegionRemSet* _rem_set; | |
| 238 | |
| 239 G1BlockOffsetArrayContigSpace* offsets() { return &_offsets; } | |
| 240 | |
| 241 protected: | |
| 3766 | 242 // The index of this region in the heap region sequence. |
| 243 size_t _hrs_index; | |
| 342 | 244 |
| 355 | 245 HumongousType _humongous_type; |
| 342 | 246 // For a humongous region, region in which it starts. |
| 247 HeapRegion* _humongous_start_region; | |
| 248 // For the start region of a humongous sequence, it's original end(). | |
| 249 HeapWord* _orig_end; | |
| 250 | |
| 251 // True iff the region is in current collection_set. | |
| 252 bool _in_collection_set; | |
| 253 | |
| 254 // Is this or has it been an allocation region in the current collection | |
| 255 // pause. | |
| 256 bool _is_gc_alloc_region; | |
| 257 | |
| 258 // True iff an attempt to evacuate an object in the region failed. | |
| 259 bool _evacuation_failed; | |
| 260 | |
| 261 // A heap region may be a member one of a number of special subsets, each | |
| 262 // represented as linked lists through the field below. Currently, these | |
| 263 // sets include: | |
| 264 // The collection set. | |
| 265 // The set of allocation regions used in a collection pause. | |
| 266 // Spaces that may contain gray objects. | |
| 267 HeapRegion* _next_in_special_set; | |
| 268 | |
| 269 // next region in the young "generation" region set | |
| 270 HeapRegion* _next_young_region; | |
| 271 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
272 // Next region whose cards need cleaning |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
273 HeapRegion* _next_dirty_cards_region; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
274 |
| 2152 | 275 // Fields used by the HeapRegionSetBase class and subclasses. |
| 276 HeapRegion* _next; | |
| 277 #ifdef ASSERT | |
| 278 HeapRegionSetBase* _containing_set; | |
| 279 #endif // ASSERT | |
| 280 bool _pending_removal; | |
| 281 | |
| 342 | 282 // For parallel heapRegion traversal. |
| 283 jint _claimed; | |
| 284 | |
| 285 // We use concurrent marking to determine the amount of live data | |
| 286 // in each heap region. | |
| 287 size_t _prev_marked_bytes; // Bytes known to be live via last completed marking. | |
| 288 size_t _next_marked_bytes; // Bytes known to be live via in-progress marking. | |
| 289 | |
| 290 // See "sort_index" method. -1 means is not in the array. | |
| 291 int _sort_index; | |
| 292 | |
| 293 // <PREDICTION> | |
| 294 double _gc_efficiency; | |
| 295 // </PREDICTION> | |
| 296 | |
| 297 enum YoungType { | |
| 298 NotYoung, // a region is not young | |
| 299 Young, // a region is young | |
| 3766 | 300 Survivor // a region is young and it contains survivors |
| 342 | 301 }; |
| 302 | |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
303 volatile YoungType _young_type; |
| 342 | 304 int _young_index_in_cset; |
| 305 SurvRateGroup* _surv_rate_group; | |
| 306 int _age_index; | |
| 307 | |
| 308 // The start of the unmarked area. The unmarked area extends from this | |
| 309 // word until the top and/or end of the region, and is the part | |
| 310 // of the region for which no marking was done, i.e. objects may | |
| 311 // have been allocated in this part since the last mark phase. | |
| 312 // "prev" is the top at the start of the last completed marking. | |
| 313 // "next" is the top at the start of the in-progress marking (if any.) | |
| 314 HeapWord* _prev_top_at_mark_start; | |
| 315 HeapWord* _next_top_at_mark_start; | |
| 316 // If a collection pause is in progress, this is the top at the start | |
| 317 // of that pause. | |
| 318 | |
| 319 // We've counted the marked bytes of objects below here. | |
| 320 HeapWord* _top_at_conc_mark_count; | |
| 321 | |
| 322 void init_top_at_mark_start() { | |
| 323 assert(_prev_marked_bytes == 0 && | |
| 324 _next_marked_bytes == 0, | |
| 325 "Must be called after zero_marked_bytes."); | |
| 326 HeapWord* bot = bottom(); | |
| 327 _prev_top_at_mark_start = bot; | |
| 328 _next_top_at_mark_start = bot; | |
| 329 _top_at_conc_mark_count = bot; | |
| 330 } | |
| 331 | |
| 332 void set_young_type(YoungType new_type) { | |
| 333 //assert(_young_type != new_type, "setting the same type" ); | |
| 334 // TODO: add more assertions here | |
| 335 _young_type = new_type; | |
| 336 } | |
| 337 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
338 // Cached attributes used in the collection set policy information |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
339 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
340 // The RSet length that was added to the total value |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
341 // for the collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
342 size_t _recorded_rs_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
343 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
344 // The predicted elapsed time that was added to total value |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
345 // for the collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
346 double _predicted_elapsed_time_ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
347 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
348 // The predicted number of bytes to copy that was added to |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
349 // the total value for the collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
350 size_t _predicted_bytes_to_copy; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
351 |
| 342 | 352 public: |
| 353 // If "is_zeroed" is "true", the region "mr" can be assumed to contain zeros. | |
| 3766 | 354 HeapRegion(size_t hrs_index, |
| 355 G1BlockOffsetSharedArray* sharedOffsetArray, | |
| 342 | 356 MemRegion mr, bool is_zeroed); |
| 357 | |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
358 static int LogOfHRGrainBytes; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
359 static int LogOfHRGrainWords; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
360 // The normal type of these should be size_t. However, they used to |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
361 // be members of an enum before and they are assumed by the |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
362 // compilers to be ints. To avoid going and fixing all their uses, |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
363 // I'm declaring them as ints. I'm not anticipating heap region |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
364 // sizes to reach anywhere near 2g, so using an int here is safe. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
365 static int GrainBytes; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
366 static int GrainWords; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
367 static int CardsPerRegion; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
368 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
369 // It sets up the heap region size (GrainBytes / GrainWords), as |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
370 // well as other related fields that are based on the heap region |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
371 // size (LogOfHRGrainBytes / LogOfHRGrainWords / |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
372 // CardsPerRegion). All those fields are considered constant |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
373 // throughout the JVM's execution, therefore they should only be set |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
374 // up once during initialization time. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
375 static void setup_heap_region_size(uintx min_heap_size); |
| 342 | 376 |
| 355 | 377 enum ClaimValues { |
| 378 InitialClaimValue = 0, | |
| 379 FinalCountClaimValue = 1, | |
| 380 NoteEndClaimValue = 2, | |
| 390 | 381 ScrubRemSetClaimValue = 3, |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
549
diff
changeset
|
382 ParVerifyClaimValue = 4, |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
549
diff
changeset
|
383 RebuildRSClaimValue = 5 |
| 355 | 384 }; |
| 385 | |
|
2134
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
386 inline HeapWord* par_allocate_no_bot_updates(size_t word_size) { |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
387 assert(is_young(), "we can only skip BOT updates on young regions"); |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
388 return ContiguousSpace::par_allocate(word_size); |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
389 } |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
390 inline HeapWord* allocate_no_bot_updates(size_t word_size) { |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
391 assert(is_young(), "we can only skip BOT updates on young regions"); |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
392 return ContiguousSpace::allocate(word_size); |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
393 } |
|
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
394 |
| 342 | 395 // If this region is a member of a HeapRegionSeq, the index in that |
| 396 // sequence, otherwise -1. | |
| 3766 | 397 size_t hrs_index() const { return _hrs_index; } |
| 342 | 398 |
| 399 // The number of bytes marked live in the region in the last marking phase. | |
| 400 size_t marked_bytes() { return _prev_marked_bytes; } | |
|
2435
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
401 size_t live_bytes() { |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
402 return (top() - prev_top_at_mark_start()) * HeapWordSize + marked_bytes(); |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
403 } |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
404 |
| 342 | 405 // The number of bytes counted in the next marking. |
| 406 size_t next_marked_bytes() { return _next_marked_bytes; } | |
| 407 // The number of bytes live wrt the next marking. | |
| 408 size_t next_live_bytes() { | |
|
2435
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
409 return |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
410 (top() - next_top_at_mark_start()) * HeapWordSize + next_marked_bytes(); |
| 342 | 411 } |
| 412 | |
| 413 // A lower bound on the amount of garbage bytes in the region. | |
| 414 size_t garbage_bytes() { | |
| 415 size_t used_at_mark_start_bytes = | |
| 416 (prev_top_at_mark_start() - bottom()) * HeapWordSize; | |
| 417 assert(used_at_mark_start_bytes >= marked_bytes(), | |
| 418 "Can't mark more than we have."); | |
| 419 return used_at_mark_start_bytes - marked_bytes(); | |
| 420 } | |
| 421 | |
| 422 // An upper bound on the number of live bytes in the region. | |
| 423 size_t max_live_bytes() { return used() - garbage_bytes(); } | |
| 424 | |
| 425 void add_to_marked_bytes(size_t incr_bytes) { | |
| 426 _next_marked_bytes = _next_marked_bytes + incr_bytes; | |
| 427 guarantee( _next_marked_bytes <= used(), "invariant" ); | |
| 428 } | |
| 429 | |
| 430 void zero_marked_bytes() { | |
| 431 _prev_marked_bytes = _next_marked_bytes = 0; | |
| 432 } | |
| 433 | |
| 355 | 434 bool isHumongous() const { return _humongous_type != NotHumongous; } |
| 435 bool startsHumongous() const { return _humongous_type == StartsHumongous; } | |
| 436 bool continuesHumongous() const { return _humongous_type == ContinuesHumongous; } | |
| 342 | 437 // For a humongous region, region in which it starts. |
| 438 HeapRegion* humongous_start_region() const { | |
| 439 return _humongous_start_region; | |
| 440 } | |
| 441 | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
442 // Makes the current region be a "starts humongous" region, i.e., |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
443 // the first region in a series of one or more contiguous regions |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
444 // that will contain a single "humongous" object. The two parameters |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
445 // are as follows: |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
446 // |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
447 // new_top : The new value of the top field of this region which |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
448 // points to the end of the humongous object that's being |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
449 // allocated. If there is more than one region in the series, top |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
450 // will lie beyond this region's original end field and on the last |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
451 // region in the series. |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
452 // |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
453 // new_end : The new value of the end field of this region which |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
454 // points to the end of the last region in the series. If there is |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
455 // one region in the series (namely: this one) end will be the same |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
456 // as the original end of this region. |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
457 // |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
458 // Updating top and end as described above makes this region look as |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
459 // if it spans the entire space taken up by all the regions in the |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
460 // series and an single allocation moved its top to new_top. This |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
461 // ensures that the space (capacity / allocated) taken up by all |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
462 // humongous regions can be calculated by just looking at the |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
463 // "starts humongous" regions and by ignoring the "continues |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
464 // humongous" regions. |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
465 void set_startsHumongous(HeapWord* new_top, HeapWord* new_end); |
| 342 | 466 |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
467 // Makes the current region be a "continues humongous' |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
468 // region. first_hr is the "start humongous" region of the series |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
469 // which this region will be part of. |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
470 void set_continuesHumongous(HeapRegion* first_hr); |
| 342 | 471 |
| 2152 | 472 // Unsets the humongous-related fields on the region. |
| 473 void set_notHumongous(); | |
| 474 | |
| 342 | 475 // If the region has a remembered set, return a pointer to it. |
| 476 HeapRegionRemSet* rem_set() const { | |
| 477 return _rem_set; | |
| 478 } | |
| 479 | |
| 480 // True iff the region is in current collection_set. | |
| 481 bool in_collection_set() const { | |
| 482 return _in_collection_set; | |
| 483 } | |
| 484 void set_in_collection_set(bool b) { | |
| 485 _in_collection_set = b; | |
| 486 } | |
| 487 HeapRegion* next_in_collection_set() { | |
| 488 assert(in_collection_set(), "should only invoke on member of CS."); | |
| 489 assert(_next_in_special_set == NULL || | |
| 490 _next_in_special_set->in_collection_set(), | |
| 491 "Malformed CS."); | |
| 492 return _next_in_special_set; | |
| 493 } | |
| 494 void set_next_in_collection_set(HeapRegion* r) { | |
| 495 assert(in_collection_set(), "should only invoke on member of CS."); | |
| 496 assert(r == NULL || r->in_collection_set(), "Malformed CS."); | |
| 497 _next_in_special_set = r; | |
| 498 } | |
| 499 | |
| 500 // True iff it is or has been an allocation region in the current | |
| 501 // collection pause. | |
| 502 bool is_gc_alloc_region() const { | |
| 503 return _is_gc_alloc_region; | |
| 504 } | |
| 505 void set_is_gc_alloc_region(bool b) { | |
| 506 _is_gc_alloc_region = b; | |
| 507 } | |
| 508 HeapRegion* next_gc_alloc_region() { | |
| 509 assert(is_gc_alloc_region(), "should only invoke on member of CS."); | |
| 510 assert(_next_in_special_set == NULL || | |
| 511 _next_in_special_set->is_gc_alloc_region(), | |
| 512 "Malformed CS."); | |
| 513 return _next_in_special_set; | |
| 514 } | |
| 515 void set_next_gc_alloc_region(HeapRegion* r) { | |
| 516 assert(is_gc_alloc_region(), "should only invoke on member of CS."); | |
| 517 assert(r == NULL || r->is_gc_alloc_region(), "Malformed CS."); | |
| 518 _next_in_special_set = r; | |
| 519 } | |
| 520 | |
| 2152 | 521 // Methods used by the HeapRegionSetBase class and subclasses. |
| 342 | 522 |
| 2152 | 523 // Getter and setter for the next field used to link regions into |
| 524 // linked lists. | |
| 525 HeapRegion* next() { return _next; } | |
| 526 | |
| 527 void set_next(HeapRegion* next) { _next = next; } | |
| 342 | 528 |
| 2152 | 529 // Every region added to a set is tagged with a reference to that |
| 530 // set. This is used for doing consistency checking to make sure that | |
| 531 // the contents of a set are as they should be and it's only | |
| 532 // available in non-product builds. | |
| 533 #ifdef ASSERT | |
| 534 void set_containing_set(HeapRegionSetBase* containing_set) { | |
| 535 assert((containing_set == NULL && _containing_set != NULL) || | |
| 536 (containing_set != NULL && _containing_set == NULL), | |
| 537 err_msg("containing_set: "PTR_FORMAT" " | |
| 538 "_containing_set: "PTR_FORMAT, | |
| 539 containing_set, _containing_set)); | |
| 540 | |
| 541 _containing_set = containing_set; | |
| 2361 | 542 } |
| 342 | 543 |
| 2152 | 544 HeapRegionSetBase* containing_set() { return _containing_set; } |
| 545 #else // ASSERT | |
| 546 void set_containing_set(HeapRegionSetBase* containing_set) { } | |
| 342 | 547 |
| 2361 | 548 // containing_set() is only used in asserts so there's no reason |
| 2152 | 549 // to provide a dummy version of it. |
| 550 #endif // ASSERT | |
| 342 | 551 |
| 2152 | 552 // If we want to remove regions from a list in bulk we can simply tag |
| 553 // them with the pending_removal tag and call the | |
| 554 // remove_all_pending() method on the list. | |
| 342 | 555 |
| 2152 | 556 bool pending_removal() { return _pending_removal; } |
| 557 | |
| 558 void set_pending_removal(bool pending_removal) { | |
| 2361 | 559 if (pending_removal) { |
| 560 assert(!_pending_removal && containing_set() != NULL, | |
| 561 "can only set pending removal to true if it's false and " | |
| 562 "the region belongs to a region set"); | |
| 563 } else { | |
| 564 assert( _pending_removal && containing_set() == NULL, | |
| 565 "can only set pending removal to false if it's true and " | |
| 566 "the region does not belong to a region set"); | |
| 567 } | |
| 2152 | 568 |
| 569 _pending_removal = pending_removal; | |
| 342 | 570 } |
| 571 | |
| 572 HeapRegion* get_next_young_region() { return _next_young_region; } | |
| 573 void set_next_young_region(HeapRegion* hr) { | |
| 574 _next_young_region = hr; | |
| 575 } | |
| 576 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
577 HeapRegion* get_next_dirty_cards_region() const { return _next_dirty_cards_region; } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
578 HeapRegion** next_dirty_cards_region_addr() { return &_next_dirty_cards_region; } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
579 void set_next_dirty_cards_region(HeapRegion* hr) { _next_dirty_cards_region = hr; } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
580 bool is_on_dirty_cards_region_list() const { return get_next_dirty_cards_region() != NULL; } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
581 |
| 3766 | 582 HeapWord* orig_end() { return _orig_end; } |
| 583 | |
| 342 | 584 // Allows logical separation between objects allocated before and after. |
| 585 void save_marks(); | |
| 586 | |
| 587 // Reset HR stuff to default values. | |
| 588 void hr_clear(bool par, bool clear_space); | |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
589 void par_clear(); |
| 342 | 590 |
| 356 | 591 void initialize(MemRegion mr, bool clear_space, bool mangle_space); |
| 342 | 592 |
| 593 // Get the start of the unmarked area in this region. | |
| 594 HeapWord* prev_top_at_mark_start() const { return _prev_top_at_mark_start; } | |
| 595 HeapWord* next_top_at_mark_start() const { return _next_top_at_mark_start; } | |
| 596 | |
| 597 // Apply "cl->do_oop" to (the addresses of) all reference fields in objects | |
| 598 // allocated in the current region before the last call to "save_mark". | |
| 599 void oop_before_save_marks_iterate(OopClosure* cl); | |
| 600 | |
| 601 // This call determines the "filter kind" argument that will be used for | |
| 602 // the next call to "new_dcto_cl" on this region with the "traditional" | |
| 603 // signature (i.e., the call below.) The default, in the absence of a | |
| 604 // preceding call to this method, is "NoFilterKind", and a call to this | |
| 605 // method is necessary for each such call, or else it reverts to the | |
| 606 // default. | |
| 607 // (This is really ugly, but all other methods I could think of changed a | |
| 608 // lot of main-line code for G1.) | |
| 609 void set_next_filter_kind(HeapRegionDCTOC::FilterKind nfk) { | |
| 610 _next_fk = nfk; | |
| 611 } | |
| 612 | |
| 613 DirtyCardToOopClosure* | |
| 614 new_dcto_closure(OopClosure* cl, | |
| 615 CardTableModRefBS::PrecisionStyle precision, | |
| 616 HeapRegionDCTOC::FilterKind fk); | |
| 617 | |
| 618 #if WHASSUP | |
| 619 DirtyCardToOopClosure* | |
| 620 new_dcto_closure(OopClosure* cl, | |
| 621 CardTableModRefBS::PrecisionStyle precision, | |
| 622 HeapWord* boundary) { | |
| 623 assert(boundary == NULL, "This arg doesn't make sense here."); | |
| 624 DirtyCardToOopClosure* res = new_dcto_closure(cl, precision, _next_fk); | |
| 625 _next_fk = HeapRegionDCTOC::NoFilterKind; | |
| 626 return res; | |
| 627 } | |
| 628 #endif | |
| 629 | |
| 630 // | |
| 631 // Note the start or end of marking. This tells the heap region | |
| 632 // that the collector is about to start or has finished (concurrently) | |
| 633 // marking the heap. | |
| 634 // | |
| 635 | |
| 636 // Note the start of a marking phase. Record the | |
| 637 // start of the unmarked area of the region here. | |
| 638 void note_start_of_marking(bool during_initial_mark) { | |
| 639 init_top_at_conc_mark_count(); | |
| 640 _next_marked_bytes = 0; | |
| 641 if (during_initial_mark && is_young() && !is_survivor()) | |
| 642 _next_top_at_mark_start = bottom(); | |
| 643 else | |
| 644 _next_top_at_mark_start = top(); | |
| 645 } | |
| 646 | |
| 647 // Note the end of a marking phase. Install the start of | |
| 648 // the unmarked area that was captured at start of marking. | |
| 649 void note_end_of_marking() { | |
| 650 _prev_top_at_mark_start = _next_top_at_mark_start; | |
| 651 _prev_marked_bytes = _next_marked_bytes; | |
| 652 _next_marked_bytes = 0; | |
| 653 | |
| 654 guarantee(_prev_marked_bytes <= | |
| 655 (size_t) (prev_top_at_mark_start() - bottom()) * HeapWordSize, | |
| 656 "invariant"); | |
| 657 } | |
| 658 | |
| 659 // After an evacuation, we need to update _next_top_at_mark_start | |
| 660 // to be the current top. Note this is only valid if we have only | |
| 661 // ever evacuated into this region. If we evacuate, allocate, and | |
| 662 // then evacuate we are in deep doodoo. | |
| 663 void note_end_of_copying() { | |
|
1021
1f19207eefc2
6847956: G1: crash in oopDesc*G1ParCopyHelper::copy_to_survivor_space(oopDesc*)
tonyp
parents:
1020
diff
changeset
|
664 assert(top() >= _next_top_at_mark_start, "Increase only"); |
|
1f19207eefc2
6847956: G1: crash in oopDesc*G1ParCopyHelper::copy_to_survivor_space(oopDesc*)
tonyp
parents:
1020
diff
changeset
|
665 _next_top_at_mark_start = top(); |
| 342 | 666 } |
| 667 | |
| 668 // Returns "false" iff no object in the region was allocated when the | |
| 669 // last mark phase ended. | |
| 670 bool is_marked() { return _prev_top_at_mark_start != bottom(); } | |
| 671 | |
| 672 // If "is_marked()" is true, then this is the index of the region in | |
| 673 // an array constructed at the end of marking of the regions in a | |
| 674 // "desirability" order. | |
| 675 int sort_index() { | |
| 676 return _sort_index; | |
| 677 } | |
| 678 void set_sort_index(int i) { | |
| 679 _sort_index = i; | |
| 680 } | |
| 681 | |
| 682 void init_top_at_conc_mark_count() { | |
| 683 _top_at_conc_mark_count = bottom(); | |
| 684 } | |
| 685 | |
| 686 void set_top_at_conc_mark_count(HeapWord *cur) { | |
| 687 assert(bottom() <= cur && cur <= end(), "Sanity."); | |
| 688 _top_at_conc_mark_count = cur; | |
| 689 } | |
| 690 | |
| 691 HeapWord* top_at_conc_mark_count() { | |
| 692 return _top_at_conc_mark_count; | |
| 693 } | |
| 694 | |
| 695 void reset_during_compaction() { | |
| 696 guarantee( isHumongous() && startsHumongous(), | |
| 697 "should only be called for humongous regions"); | |
| 698 | |
| 699 zero_marked_bytes(); | |
| 700 init_top_at_mark_start(); | |
| 701 } | |
| 702 | |
| 703 // <PREDICTION> | |
| 704 void calc_gc_efficiency(void); | |
| 705 double gc_efficiency() { return _gc_efficiency;} | |
| 706 // </PREDICTION> | |
| 707 | |
| 708 bool is_young() const { return _young_type != NotYoung; } | |
| 709 bool is_survivor() const { return _young_type == Survivor; } | |
| 710 | |
| 711 int young_index_in_cset() const { return _young_index_in_cset; } | |
| 712 void set_young_index_in_cset(int index) { | |
| 713 assert( (index == -1) || is_young(), "pre-condition" ); | |
| 714 _young_index_in_cset = index; | |
| 715 } | |
| 716 | |
| 717 int age_in_surv_rate_group() { | |
| 718 assert( _surv_rate_group != NULL, "pre-condition" ); | |
| 719 assert( _age_index > -1, "pre-condition" ); | |
| 720 return _surv_rate_group->age_in_group(_age_index); | |
| 721 } | |
| 722 | |
| 723 void record_surv_words_in_group(size_t words_survived) { | |
| 724 assert( _surv_rate_group != NULL, "pre-condition" ); | |
| 725 assert( _age_index > -1, "pre-condition" ); | |
| 726 int age_in_group = age_in_surv_rate_group(); | |
| 727 _surv_rate_group->record_surviving_words(age_in_group, words_survived); | |
| 728 } | |
| 729 | |
| 730 int age_in_surv_rate_group_cond() { | |
| 731 if (_surv_rate_group != NULL) | |
| 732 return age_in_surv_rate_group(); | |
| 733 else | |
| 734 return -1; | |
| 735 } | |
| 736 | |
| 737 SurvRateGroup* surv_rate_group() { | |
| 738 return _surv_rate_group; | |
| 739 } | |
| 740 | |
| 741 void install_surv_rate_group(SurvRateGroup* surv_rate_group) { | |
| 742 assert( surv_rate_group != NULL, "pre-condition" ); | |
| 743 assert( _surv_rate_group == NULL, "pre-condition" ); | |
| 744 assert( is_young(), "pre-condition" ); | |
| 745 | |
| 746 _surv_rate_group = surv_rate_group; | |
| 747 _age_index = surv_rate_group->next_age_index(); | |
| 748 } | |
| 749 | |
| 750 void uninstall_surv_rate_group() { | |
| 751 if (_surv_rate_group != NULL) { | |
| 752 assert( _age_index > -1, "pre-condition" ); | |
| 753 assert( is_young(), "pre-condition" ); | |
| 754 | |
| 755 _surv_rate_group = NULL; | |
| 756 _age_index = -1; | |
| 757 } else { | |
| 758 assert( _age_index == -1, "pre-condition" ); | |
| 759 } | |
| 760 } | |
| 761 | |
| 762 void set_young() { set_young_type(Young); } | |
| 763 | |
| 764 void set_survivor() { set_young_type(Survivor); } | |
| 765 | |
| 766 void set_not_young() { set_young_type(NotYoung); } | |
| 767 | |
| 768 // Determine if an object has been allocated since the last | |
| 769 // mark performed by the collector. This returns true iff the object | |
| 770 // is within the unmarked area of the region. | |
| 771 bool obj_allocated_since_prev_marking(oop obj) const { | |
| 772 return (HeapWord *) obj >= prev_top_at_mark_start(); | |
| 773 } | |
| 774 bool obj_allocated_since_next_marking(oop obj) const { | |
| 775 return (HeapWord *) obj >= next_top_at_mark_start(); | |
| 776 } | |
| 777 | |
| 778 // For parallel heapRegion traversal. | |
| 779 bool claimHeapRegion(int claimValue); | |
| 780 jint claim_value() { return _claimed; } | |
| 781 // Use this carefully: only when you're sure no one is claiming... | |
| 782 void set_claim_value(int claimValue) { _claimed = claimValue; } | |
| 783 | |
| 784 // Returns the "evacuation_failed" property of the region. | |
| 785 bool evacuation_failed() { return _evacuation_failed; } | |
| 786 | |
| 787 // Sets the "evacuation_failed" property of the region. | |
| 788 void set_evacuation_failed(bool b) { | |
| 789 _evacuation_failed = b; | |
| 790 | |
| 791 if (b) { | |
| 792 init_top_at_conc_mark_count(); | |
| 793 _next_marked_bytes = 0; | |
| 794 } | |
| 795 } | |
| 796 | |
| 797 // Requires that "mr" be entirely within the region. | |
| 798 // Apply "cl->do_object" to all objects that intersect with "mr". | |
| 799 // If the iteration encounters an unparseable portion of the region, | |
| 800 // or if "cl->abort()" is true after a closure application, | |
| 801 // terminate the iteration and return the address of the start of the | |
| 802 // subregion that isn't done. (The two can be distinguished by querying | |
| 803 // "cl->abort()".) Return of "NULL" indicates that the iteration | |
| 804 // completed. | |
| 805 HeapWord* | |
| 806 object_iterate_mem_careful(MemRegion mr, ObjectClosure* cl); | |
| 807 | |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
808 // filter_young: if true and the region is a young region then we |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
809 // skip the iteration. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
810 // card_ptr: if not NULL, and we decide that the card is not young |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
811 // and we iterate over it, we'll clean the card before we start the |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
812 // iteration. |
| 342 | 813 HeapWord* |
| 814 oops_on_card_seq_iterate_careful(MemRegion mr, | |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
815 FilterOutOfRegionClosure* cl, |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
816 bool filter_young, |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
817 jbyte* card_ptr); |
| 342 | 818 |
| 819 // A version of block start that is guaranteed to find *some* block | |
| 820 // boundary at or before "p", but does not object iteration, and may | |
| 821 // therefore be used safely when the heap is unparseable. | |
| 822 HeapWord* block_start_careful(const void* p) const { | |
| 823 return _offsets.block_start_careful(p); | |
| 824 } | |
| 825 | |
| 826 // Requires that "addr" is within the region. Returns the start of the | |
| 827 // first ("careful") block that starts at or after "addr", or else the | |
| 828 // "end" of the region if there is no such block. | |
| 829 HeapWord* next_block_start_careful(HeapWord* addr); | |
| 830 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
831 size_t recorded_rs_length() const { return _recorded_rs_length; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
832 double predicted_elapsed_time_ms() const { return _predicted_elapsed_time_ms; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
833 size_t predicted_bytes_to_copy() const { return _predicted_bytes_to_copy; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
834 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
835 void set_recorded_rs_length(size_t rs_length) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
836 _recorded_rs_length = rs_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
837 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
838 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
839 void set_predicted_elapsed_time_ms(double ms) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
840 _predicted_elapsed_time_ms = ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
841 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
842 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
843 void set_predicted_bytes_to_copy(size_t bytes) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
844 _predicted_bytes_to_copy = bytes; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
845 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
846 |
| 342 | 847 #define HeapRegion_OOP_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ |
| 848 virtual void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl); | |
| 849 SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DECL) | |
| 850 | |
| 851 CompactibleSpace* next_compaction_space() const; | |
| 852 | |
| 853 virtual void reset_after_compaction(); | |
| 854 | |
| 855 void print() const; | |
| 856 void print_on(outputStream* st) const; | |
| 857 | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
858 // vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
859 // vo == UseNextMarking -> use "next" marking information |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
860 // vo == UseMarkWord -> use the mark word in the object header |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
861 // |
| 811 | 862 // NOTE: Only the "prev" marking information is guaranteed to be |
| 863 // consistent most of the time, so most calls to this should use | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
864 // vo == UsePrevMarking. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
865 // Currently, there is only one case where this is called with |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
866 // vo == UseNextMarking, which is to verify the "next" marking |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
867 // information at the end of remark. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
868 // Currently there is only one place where this is called with |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
869 // vo == UseMarkWord, which is to verify the marking during a |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
870 // full GC. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
871 void verify(bool allow_dirty, VerifyOption vo, bool *failures) const; |
| 811 | 872 |
| 873 // Override; it uses the "prev" marking information | |
| 342 | 874 virtual void verify(bool allow_dirty) const; |
| 875 }; | |
| 876 | |
| 877 // HeapRegionClosure is used for iterating over regions. | |
| 878 // Terminates the iteration when the "doHeapRegion" method returns "true". | |
| 879 class HeapRegionClosure : public StackObj { | |
| 880 friend class HeapRegionSeq; | |
| 881 friend class G1CollectedHeap; | |
| 882 | |
| 883 bool _complete; | |
| 884 void incomplete() { _complete = false; } | |
| 885 | |
| 886 public: | |
| 887 HeapRegionClosure(): _complete(true) {} | |
| 888 | |
| 889 // Typically called on each region until it returns true. | |
| 890 virtual bool doHeapRegion(HeapRegion* r) = 0; | |
| 891 | |
| 892 // True after iteration if the closure was applied to all heap regions | |
| 893 // and returned "false" in all cases. | |
| 894 bool complete() { return _complete; } | |
| 895 }; | |
| 896 | |
| 897 #endif // SERIALGC | |
| 1972 | 898 |
| 899 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP |