Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/heapRegion.hpp @ 17833:bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
Summary: Change 8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure broke the debug build on AIX. The method do_oop_partial_array() is added in a header, but requires the inline function par_write_ref() through several inlined calls. In some cpp files, like arguments.cpp, par_write_ref() is not defined as the corresponding inline header and is not included. The AIX debug VM does not start because of the missing symbol. This change solves this by cleaning up include dependencies.
Reviewed-by: tschatzl, stefank
author | tschatzl |
---|---|
date | Fri, 04 Apr 2014 10:43:56 +0200 |
parents | 8ee855b4e667 |
children | 78bbf4d43a14 |
rev | line source |
---|---|
342 | 1 /* |
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12178
diff
changeset
|
2 * Copyright (c) 2001, 2013, 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" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6754
diff
changeset
|
35 #include "utilities/macros.hpp" |
1972 | 36 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6754
diff
changeset
|
37 #if INCLUDE_ALL_GCS |
342 | 38 |
39 // A HeapRegion is the smallest piece of a G1CollectedHeap that | |
40 // can be collected independently. | |
41 | |
42 // NOTE: Although a HeapRegion is a Space, its | |
43 // Space::initDirtyCardClosure method must not be called. | |
44 // The problem is that the existence of this method breaks | |
45 // the independence of barrier sets from remembered sets. | |
46 // The solution is to remove this method from the definition | |
47 // of a Space. | |
48 | |
49 class CompactibleSpace; | |
50 class ContiguousSpace; | |
51 class HeapRegionRemSet; | |
52 class HeapRegionRemSetIterator; | |
53 class HeapRegion; | |
2152 | 54 class HeapRegionSetBase; |
12080 | 55 class nmethod; |
2152 | 56 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
57 #define HR_FORMAT "%u:(%s)["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]" |
3766 | 58 #define HR_FORMAT_PARAMS(_hr_) \ |
59 (_hr_)->hrs_index(), \ | |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
60 (_hr_)->is_survivor() ? "S" : (_hr_)->is_young() ? "E" : \ |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
61 (_hr_)->startsHumongous() ? "HS" : \ |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
62 (_hr_)->continuesHumongous() ? "HC" : \ |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
63 !(_hr_)->is_empty() ? "O" : "F", \ |
3766 | 64 (_hr_)->bottom(), (_hr_)->top(), (_hr_)->end() |
342 | 65 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
66 // sentinel value for hrs_index |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
67 #define G1_NULL_HRS_INDEX ((uint) -1) |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
68 |
342 | 69 // A dirty card to oop closure for heap regions. It |
70 // knows how to get the G1 heap and how to use the bitmap | |
71 // in the concurrent marker used by G1 to filter remembered | |
72 // sets. | |
73 | |
74 class HeapRegionDCTOC : public ContiguousSpaceDCTOC { | |
75 public: | |
76 // Specification of possible DirtyCardToOopClosure filtering. | |
77 enum FilterKind { | |
78 NoFilterKind, | |
79 IntoCSFilterKind, | |
80 OutOfRegionFilterKind | |
81 }; | |
82 | |
83 protected: | |
84 HeapRegion* _hr; | |
85 FilterKind _fk; | |
86 G1CollectedHeap* _g1; | |
87 | |
88 void walk_mem_region_with_cl(MemRegion mr, | |
89 HeapWord* bottom, HeapWord* top, | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
90 ExtendedOopClosure* cl); |
342 | 91 |
92 // We don't specialize this for FilteringClosure; filtering is handled by | |
93 // the "FilterKind" mechanism. But we provide this to avoid a compiler | |
94 // warning. | |
95 void walk_mem_region_with_cl(MemRegion mr, | |
96 HeapWord* bottom, HeapWord* top, | |
97 FilteringClosure* cl) { | |
98 HeapRegionDCTOC::walk_mem_region_with_cl(mr, bottom, top, | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
99 (ExtendedOopClosure*)cl); |
342 | 100 } |
101 | |
102 // Get the actual top of the area on which the closure will | |
103 // operate, given where the top is assumed to be (the end of the | |
104 // memory region passed to do_MemRegion) and where the object | |
105 // at the top is assumed to start. For example, an object may | |
106 // start at the top but actually extend past the assumed top, | |
107 // in which case the top becomes the end of the object. | |
108 HeapWord* get_actual_top(HeapWord* top, HeapWord* top_obj) { | |
109 return ContiguousSpaceDCTOC::get_actual_top(top, top_obj); | |
110 } | |
111 | |
112 // Walk the given memory region from bottom to (actual) top | |
113 // looking for objects and applying the oop closure (_cl) to | |
114 // them. The base implementation of this treats the area as | |
115 // blocks, where a block may or may not be an object. Sub- | |
116 // classes should override this to provide more accurate | |
117 // or possibly more efficient walking. | |
118 void walk_mem_region(MemRegion mr, HeapWord* bottom, HeapWord* top) { | |
119 Filtering_DCTOC::walk_mem_region(mr, bottom, top); | |
120 } | |
121 | |
122 public: | |
123 HeapRegionDCTOC(G1CollectedHeap* g1, | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
124 HeapRegion* hr, ExtendedOopClosure* cl, |
342 | 125 CardTableModRefBS::PrecisionStyle precision, |
126 FilterKind fk); | |
127 }; | |
128 | |
129 // The complicating factor is that BlockOffsetTable diverged | |
130 // significantly, and we need functionality that is only in the G1 version. | |
131 // So I copied that code, which led to an alternate G1 version of | |
132 // OffsetTableContigSpace. If the two versions of BlockOffsetTable could | |
133 // be reconciled, then G1OffsetTableContigSpace could go away. | |
134 | |
135 // The idea behind time stamps is the following. Doing a save_marks on | |
136 // all regions at every GC pause is time consuming (if I remember | |
137 // well, 10ms or so). So, we would like to do that only for regions | |
138 // that are GC alloc regions. To achieve this, we use time | |
139 // stamps. For every evacuation pause, G1CollectedHeap generates a | |
140 // unique time stamp (essentially a counter that gets | |
141 // incremented). Every time we want to call save_marks on a region, | |
142 // we set the saved_mark_word to top and also copy the current GC | |
143 // time stamp to the time stamp field of the space. Reading the | |
144 // saved_mark_word involves checking the time stamp of the | |
145 // region. If it is the same as the current GC time stamp, then we | |
146 // can safely read the saved_mark_word field, as it is valid. If the | |
147 // time stamp of the region is not the same as the current GC time | |
148 // stamp, then we instead read top, as the saved_mark_word field is | |
149 // invalid. Time stamps (on the regions and also on the | |
150 // G1CollectedHeap) are reset at every cleanup (we iterate over | |
151 // the regions anyway) and at the end of a Full GC. The current scheme | |
152 // that uses sequential unsigned ints will fail only if we have 4b | |
153 // evacuation pauses between two cleanups, which is _highly_ unlikely. | |
154 | |
155 class G1OffsetTableContigSpace: public ContiguousSpace { | |
156 friend class VMStructs; | |
157 protected: | |
158 G1BlockOffsetArrayContigSpace _offsets; | |
159 Mutex _par_alloc_lock; | |
160 volatile unsigned _gc_time_stamp; | |
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
161 // 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
|
162 // 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
|
163 // 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
|
164 // 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
|
165 // 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
|
166 // 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
|
167 HeapWord* _pre_dummy_top; |
342 | 168 |
169 public: | |
170 G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray, | |
6754
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
171 MemRegion mr); |
342 | 172 |
173 void set_bottom(HeapWord* value); | |
174 void set_end(HeapWord* value); | |
175 | |
176 virtual HeapWord* saved_mark_word() const; | |
177 virtual void set_saved_mark(); | |
178 void reset_gc_time_stamp() { _gc_time_stamp = 0; } | |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
179 unsigned get_gc_time_stamp() { return _gc_time_stamp; } |
342 | 180 |
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
181 // 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
|
182 // explanation of what it is. |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
183 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
|
184 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
|
185 _pre_dummy_top = pre_dummy_top; |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
186 } |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
187 HeapWord* pre_dummy_top() { |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
188 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
|
189 } |
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2361
diff
changeset
|
190 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
|
191 |
356 | 192 virtual void clear(bool mangle_space); |
342 | 193 |
194 HeapWord* block_start(const void* p); | |
195 HeapWord* block_start_const(const void* p) const; | |
196 | |
197 // Add offset table update. | |
198 virtual HeapWord* allocate(size_t word_size); | |
199 HeapWord* par_allocate(size_t word_size); | |
200 | |
201 // MarkSweep support phase3 | |
202 virtual HeapWord* initialize_threshold(); | |
203 virtual HeapWord* cross_threshold(HeapWord* start, HeapWord* end); | |
204 | |
205 virtual void print() const; | |
2133
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 reset_bot() { |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
208 _offsets.zero_bottom_entry(); |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
209 _offsets.initialize_threshold(); |
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 |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
212 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
|
213 _offsets.alloc_block(start, word_size); |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
214 } |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
215 |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
216 void print_bot_on(outputStream* out) { |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
217 _offsets.print_on(out); |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
218 } |
342 | 219 }; |
220 | |
221 class HeapRegion: public G1OffsetTableContigSpace { | |
222 friend class VMStructs; | |
223 private: | |
224 | |
355 | 225 enum HumongousType { |
226 NotHumongous = 0, | |
227 StartsHumongous, | |
228 ContinuesHumongous | |
229 }; | |
230 | |
342 | 231 // Requires that the region "mr" be dense with objects, and begin and end |
232 // with an object. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
233 void oops_in_mr_iterate(MemRegion mr, ExtendedOopClosure* cl); |
342 | 234 |
235 // The remembered set for this region. | |
236 // (Might want to make this "inline" later, to avoid some alloc failure | |
237 // issues.) | |
238 HeapRegionRemSet* _rem_set; | |
239 | |
240 G1BlockOffsetArrayContigSpace* offsets() { return &_offsets; } | |
241 | |
242 protected: | |
3766 | 243 // The index of this region in the heap region sequence. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
244 uint _hrs_index; |
342 | 245 |
355 | 246 HumongousType _humongous_type; |
342 | 247 // For a humongous region, region in which it starts. |
248 HeapRegion* _humongous_start_region; | |
249 // For the start region of a humongous sequence, it's original end(). | |
250 HeapWord* _orig_end; | |
251 | |
252 // True iff the region is in current collection_set. | |
253 bool _in_collection_set; | |
254 | |
255 // True iff an attempt to evacuate an object in the region failed. | |
256 bool _evacuation_failed; | |
257 | |
258 // A heap region may be a member one of a number of special subsets, each | |
259 // represented as linked lists through the field below. Currently, these | |
260 // sets include: | |
261 // The collection set. | |
262 // The set of allocation regions used in a collection pause. | |
263 // Spaces that may contain gray objects. | |
264 HeapRegion* _next_in_special_set; | |
265 | |
266 // next region in the young "generation" region set | |
267 HeapRegion* _next_young_region; | |
268 | |
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
269 // Next region whose cards need cleaning |
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
270 HeapRegion* _next_dirty_cards_region; |
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
271 |
2152 | 272 // Fields used by the HeapRegionSetBase class and subclasses. |
273 HeapRegion* _next; | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17755
diff
changeset
|
274 HeapRegion* _prev; |
2152 | 275 #ifdef ASSERT |
276 HeapRegionSetBase* _containing_set; | |
277 #endif // ASSERT | |
278 bool _pending_removal; | |
279 | |
342 | 280 // For parallel heapRegion traversal. |
281 jint _claimed; | |
282 | |
283 // We use concurrent marking to determine the amount of live data | |
284 // in each heap region. | |
285 size_t _prev_marked_bytes; // Bytes known to be live via last completed marking. | |
286 size_t _next_marked_bytes; // Bytes known to be live via in-progress marking. | |
287 | |
6011 | 288 // The calculated GC efficiency of the region. |
342 | 289 double _gc_efficiency; |
290 | |
291 enum YoungType { | |
292 NotYoung, // a region is not young | |
293 Young, // a region is young | |
3766 | 294 Survivor // a region is young and it contains survivors |
342 | 295 }; |
296 | |
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
297 volatile YoungType _young_type; |
342 | 298 int _young_index_in_cset; |
299 SurvRateGroup* _surv_rate_group; | |
300 int _age_index; | |
301 | |
302 // The start of the unmarked area. The unmarked area extends from this | |
303 // word until the top and/or end of the region, and is the part | |
304 // of the region for which no marking was done, i.e. objects may | |
305 // have been allocated in this part since the last mark phase. | |
306 // "prev" is the top at the start of the last completed marking. | |
307 // "next" is the top at the start of the in-progress marking (if any.) | |
308 HeapWord* _prev_top_at_mark_start; | |
309 HeapWord* _next_top_at_mark_start; | |
310 // If a collection pause is in progress, this is the top at the start | |
311 // of that pause. | |
312 | |
313 void init_top_at_mark_start() { | |
314 assert(_prev_marked_bytes == 0 && | |
315 _next_marked_bytes == 0, | |
316 "Must be called after zero_marked_bytes."); | |
317 HeapWord* bot = bottom(); | |
318 _prev_top_at_mark_start = bot; | |
319 _next_top_at_mark_start = bot; | |
320 } | |
321 | |
322 void set_young_type(YoungType new_type) { | |
323 //assert(_young_type != new_type, "setting the same type" ); | |
324 // TODO: add more assertions here | |
325 _young_type = new_type; | |
326 } | |
327 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
328 // 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
|
329 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
330 // 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
|
331 // for the collection set. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
332 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
|
333 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
334 // 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
|
335 // for the collection set. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
336 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
|
337 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
338 // 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
|
339 // 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
|
340 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
|
341 |
342 | 342 public: |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
343 HeapRegion(uint hrs_index, |
3766 | 344 G1BlockOffsetSharedArray* sharedOffsetArray, |
6754
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
345 MemRegion mr); |
342 | 346 |
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3980
diff
changeset
|
347 static int LogOfHRGrainBytes; |
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3980
diff
changeset
|
348 static int LogOfHRGrainWords; |
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3980
diff
changeset
|
349 |
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3980
diff
changeset
|
350 static size_t GrainBytes; |
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3980
diff
changeset
|
351 static size_t GrainWords; |
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3980
diff
changeset
|
352 static size_t CardsPerRegion; |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
353 |
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
354 static size_t align_up_to_region_byte_size(size_t sz) { |
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
355 return (sz + (size_t) GrainBytes - 1) & |
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
356 ~((1 << (size_t) LogOfHRGrainBytes) - 1); |
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
357 } |
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
358 |
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12178
diff
changeset
|
359 static size_t max_region_size(); |
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12178
diff
changeset
|
360 |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
361 // 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
|
362 // 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
|
363 // size (LogOfHRGrainBytes / LogOfHRGrainWords / |
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
364 // CardsPerRegion). All those fields are considered constant |
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
811
diff
changeset
|
365 // 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
|
366 // up once during initialization time. |
12178
84683e78e713
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
12080
diff
changeset
|
367 static void setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size); |
342 | 368 |
355 | 369 enum ClaimValues { |
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4093
diff
changeset
|
370 InitialClaimValue = 0, |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4093
diff
changeset
|
371 FinalCountClaimValue = 1, |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4093
diff
changeset
|
372 NoteEndClaimValue = 2, |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4093
diff
changeset
|
373 ScrubRemSetClaimValue = 3, |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4093
diff
changeset
|
374 ParVerifyClaimValue = 4, |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4093
diff
changeset
|
375 RebuildRSClaimValue = 5, |
5988
2a0172480595
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
4912
diff
changeset
|
376 ParEvacFailureClaimValue = 6, |
2a0172480595
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
4912
diff
changeset
|
377 AggregateCountClaimValue = 7, |
12080 | 378 VerifyCountClaimValue = 8, |
379 ParMarkRootClaimValue = 9 | |
355 | 380 }; |
381 | |
2134
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
382 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
|
383 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
|
384 return ContiguousSpace::par_allocate(word_size); |
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
385 } |
b158bed62ef5
6994297: G1: do first-level slow-path allocations with a CAS
tonyp
parents:
2133
diff
changeset
|
386 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
|
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::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 |
342 | 391 // If this region is a member of a HeapRegionSeq, the index in that |
392 // sequence, otherwise -1. | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
393 uint hrs_index() const { return _hrs_index; } |
342 | 394 |
395 // The number of bytes marked live in the region in the last marking phase. | |
396 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
|
397 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
|
398 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
|
399 } |
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
400 |
342 | 401 // The number of bytes counted in the next marking. |
402 size_t next_marked_bytes() { return _next_marked_bytes; } | |
403 // The number of bytes live wrt the next marking. | |
404 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
|
405 return |
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2433
diff
changeset
|
406 (top() - next_top_at_mark_start()) * HeapWordSize + next_marked_bytes(); |
342 | 407 } |
408 | |
409 // A lower bound on the amount of garbage bytes in the region. | |
410 size_t garbage_bytes() { | |
411 size_t used_at_mark_start_bytes = | |
412 (prev_top_at_mark_start() - bottom()) * HeapWordSize; | |
413 assert(used_at_mark_start_bytes >= marked_bytes(), | |
414 "Can't mark more than we have."); | |
415 return used_at_mark_start_bytes - marked_bytes(); | |
416 } | |
417 | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
418 // Return the amount of bytes we'll reclaim if we collect this |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
419 // region. This includes not only the known garbage bytes in the |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
420 // region but also any unallocated space in it, i.e., [top, end), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
421 // since it will also be reclaimed if we collect the region. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
422 size_t reclaimable_bytes() { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
423 size_t known_live_bytes = live_bytes(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
424 assert(known_live_bytes <= capacity(), "sanity"); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
425 return capacity() - known_live_bytes; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
426 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4836
diff
changeset
|
427 |
342 | 428 // An upper bound on the number of live bytes in the region. |
429 size_t max_live_bytes() { return used() - garbage_bytes(); } | |
430 | |
431 void add_to_marked_bytes(size_t incr_bytes) { | |
432 _next_marked_bytes = _next_marked_bytes + incr_bytes; | |
4093
6071e0581859
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
4023
diff
changeset
|
433 assert(_next_marked_bytes <= used(), "invariant" ); |
342 | 434 } |
435 | |
436 void zero_marked_bytes() { | |
437 _prev_marked_bytes = _next_marked_bytes = 0; | |
438 } | |
439 | |
355 | 440 bool isHumongous() const { return _humongous_type != NotHumongous; } |
441 bool startsHumongous() const { return _humongous_type == StartsHumongous; } | |
442 bool continuesHumongous() const { return _humongous_type == ContinuesHumongous; } | |
342 | 443 // For a humongous region, region in which it starts. |
444 HeapRegion* humongous_start_region() const { | |
445 return _humongous_start_region; | |
446 } | |
447 | |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
448 // Return the number of distinct regions that are covered by this region: |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
449 // 1 if the region is not humongous, >= 1 if the region is humongous. |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
450 uint region_num() const { |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
451 if (!isHumongous()) { |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
452 return 1U; |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
453 } else { |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
454 assert(startsHumongous(), "doesn't make sense on HC regions"); |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
455 assert(capacity() % HeapRegion::GrainBytes == 0, "sanity"); |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
456 return (uint) (capacity() >> HeapRegion::LogOfHRGrainBytes); |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
457 } |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
458 } |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
459 |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
460 // Return the index + 1 of the last HC regions that's associated |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
461 // with this HS region. |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
462 uint last_hc_index() const { |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
463 assert(startsHumongous(), "don't call this otherwise"); |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
464 return hrs_index() + region_num(); |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
465 } |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
466 |
4020
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
467 // Same as Space::is_in_reserved, but will use the original size of the region. |
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
468 // The original size is different only for start humongous regions. They get |
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
469 // their _end set up to be the end of the last continues region of the |
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
470 // corresponding humongous object. |
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
471 bool is_in_reserved_raw(const void* p) const { |
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
472 return _bottom <= p && p < _orig_end; |
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
473 } |
5e5d4821bf07
7097516: G1: assert(0<= from_card && from_card<HeapRegion::CardsPerRegion) failed: Must be in range.
brutisso
parents:
3986
diff
changeset
|
474 |
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
475 // 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
|
476 // 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
|
477 // 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
|
478 // are as follows: |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
479 // |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
480 // 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
|
481 // 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
|
482 // 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
|
483 // 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
|
484 // region in the series. |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
485 // |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
486 // 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
|
487 // 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
|
488 // 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
|
489 // as the original end of this region. |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
490 // |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
491 // 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
|
492 // 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
|
493 // 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
|
494 // 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
|
495 // 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
|
496 // "starts humongous" regions and by ignoring the "continues |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
497 // humongous" regions. |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
498 void set_startsHumongous(HeapWord* new_top, HeapWord* new_end); |
342 | 499 |
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
500 // Makes the current region be a "continues humongous' |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
501 // 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
|
502 // which this region will be part of. |
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
503 void set_continuesHumongous(HeapRegion* first_hr); |
342 | 504 |
2152 | 505 // Unsets the humongous-related fields on the region. |
506 void set_notHumongous(); | |
507 | |
342 | 508 // If the region has a remembered set, return a pointer to it. |
509 HeapRegionRemSet* rem_set() const { | |
510 return _rem_set; | |
511 } | |
512 | |
513 // True iff the region is in current collection_set. | |
514 bool in_collection_set() const { | |
515 return _in_collection_set; | |
516 } | |
517 void set_in_collection_set(bool b) { | |
518 _in_collection_set = b; | |
519 } | |
520 HeapRegion* next_in_collection_set() { | |
521 assert(in_collection_set(), "should only invoke on member of CS."); | |
522 assert(_next_in_special_set == NULL || | |
523 _next_in_special_set->in_collection_set(), | |
524 "Malformed CS."); | |
525 return _next_in_special_set; | |
526 } | |
527 void set_next_in_collection_set(HeapRegion* r) { | |
528 assert(in_collection_set(), "should only invoke on member of CS."); | |
529 assert(r == NULL || r->in_collection_set(), "Malformed CS."); | |
530 _next_in_special_set = r; | |
531 } | |
532 | |
2152 | 533 // Methods used by the HeapRegionSetBase class and subclasses. |
342 | 534 |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17755
diff
changeset
|
535 // Getter and setter for the next and prev fields used to link regions into |
2152 | 536 // linked lists. |
537 HeapRegion* next() { return _next; } | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17755
diff
changeset
|
538 HeapRegion* prev() { return _prev; } |
2152 | 539 |
540 void set_next(HeapRegion* next) { _next = next; } | |
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17755
diff
changeset
|
541 void set_prev(HeapRegion* prev) { _prev = prev; } |
342 | 542 |
2152 | 543 // Every region added to a set is tagged with a reference to that |
544 // set. This is used for doing consistency checking to make sure that | |
545 // the contents of a set are as they should be and it's only | |
546 // available in non-product builds. | |
547 #ifdef ASSERT | |
548 void set_containing_set(HeapRegionSetBase* containing_set) { | |
549 assert((containing_set == NULL && _containing_set != NULL) || | |
550 (containing_set != NULL && _containing_set == NULL), | |
551 err_msg("containing_set: "PTR_FORMAT" " | |
552 "_containing_set: "PTR_FORMAT, | |
553 containing_set, _containing_set)); | |
554 | |
555 _containing_set = containing_set; | |
2361 | 556 } |
342 | 557 |
2152 | 558 HeapRegionSetBase* containing_set() { return _containing_set; } |
559 #else // ASSERT | |
560 void set_containing_set(HeapRegionSetBase* containing_set) { } | |
342 | 561 |
2361 | 562 // containing_set() is only used in asserts so there's no reason |
2152 | 563 // to provide a dummy version of it. |
564 #endif // ASSERT | |
342 | 565 |
2152 | 566 // If we want to remove regions from a list in bulk we can simply tag |
567 // them with the pending_removal tag and call the | |
568 // remove_all_pending() method on the list. | |
342 | 569 |
2152 | 570 bool pending_removal() { return _pending_removal; } |
571 | |
572 void set_pending_removal(bool pending_removal) { | |
2361 | 573 if (pending_removal) { |
574 assert(!_pending_removal && containing_set() != NULL, | |
575 "can only set pending removal to true if it's false and " | |
576 "the region belongs to a region set"); | |
577 } else { | |
578 assert( _pending_removal && containing_set() == NULL, | |
579 "can only set pending removal to false if it's true and " | |
580 "the region does not belong to a region set"); | |
581 } | |
2152 | 582 |
583 _pending_removal = pending_removal; | |
342 | 584 } |
585 | |
586 HeapRegion* get_next_young_region() { return _next_young_region; } | |
587 void set_next_young_region(HeapRegion* hr) { | |
588 _next_young_region = hr; | |
589 } | |
590 | |
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
677
diff
changeset
|
591 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
|
592 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
|
593 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
|
594 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
|
595 |
3766 | 596 HeapWord* orig_end() { return _orig_end; } |
597 | |
342 | 598 // Allows logical separation between objects allocated before and after. |
599 void save_marks(); | |
600 | |
601 // Reset HR stuff to default values. | |
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
12233
diff
changeset
|
602 void hr_clear(bool par, bool clear_space, bool locked = false); |
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
603 void par_clear(); |
342 | 604 |
605 // Get the start of the unmarked area in this region. | |
606 HeapWord* prev_top_at_mark_start() const { return _prev_top_at_mark_start; } | |
607 HeapWord* next_top_at_mark_start() const { return _next_top_at_mark_start; } | |
608 | |
609 // Apply "cl->do_oop" to (the addresses of) all reference fields in objects | |
610 // allocated in the current region before the last call to "save_mark". | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
611 void oop_before_save_marks_iterate(ExtendedOopClosure* cl); |
342 | 612 |
613 // Note the start or end of marking. This tells the heap region | |
614 // that the collector is about to start or has finished (concurrently) | |
615 // marking the heap. | |
616 | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
617 // Notify the region that concurrent marking is starting. Initialize |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
618 // all fields related to the next marking info. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
619 inline void note_start_of_marking(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
620 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
621 // Notify the region that concurrent marking has finished. Copy the |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
622 // (now finalized) next marking info fields into the prev marking |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
623 // info fields. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
624 inline void note_end_of_marking(); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
625 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
626 // Notify the region that it will be used as to-space during a GC |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
627 // and we are about to start copying objects into it. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
628 inline void note_start_of_copying(bool during_initial_mark); |
342 | 629 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
630 // Notify the region that it ceases being to-space during a GC and |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
631 // we will not copy objects into it any more. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
632 inline void note_end_of_copying(bool during_initial_mark); |
342 | 633 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
634 // Notify the region that we are about to start processing |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
635 // self-forwarded objects during evac failure handling. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
636 void note_self_forwarding_removal_start(bool during_initial_mark, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
637 bool during_conc_mark); |
342 | 638 |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
639 // Notify the region that we have finished processing self-forwarded |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
640 // objects during evac failure handling. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
641 void note_self_forwarding_removal_end(bool during_initial_mark, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
642 bool during_conc_mark, |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4783
diff
changeset
|
643 size_t marked_bytes); |
342 | 644 |
645 // Returns "false" iff no object in the region was allocated when the | |
646 // last mark phase ended. | |
647 bool is_marked() { return _prev_top_at_mark_start != bottom(); } | |
648 | |
649 void reset_during_compaction() { | |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
650 assert(isHumongous() && startsHumongous(), |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
651 "should only be called for starts humongous regions"); |
342 | 652 |
653 zero_marked_bytes(); | |
654 init_top_at_mark_start(); | |
655 } | |
656 | |
657 void calc_gc_efficiency(void); | |
658 double gc_efficiency() { return _gc_efficiency;} | |
659 | |
660 bool is_young() const { return _young_type != NotYoung; } | |
661 bool is_survivor() const { return _young_type == Survivor; } | |
662 | |
663 int young_index_in_cset() const { return _young_index_in_cset; } | |
664 void set_young_index_in_cset(int index) { | |
665 assert( (index == -1) || is_young(), "pre-condition" ); | |
666 _young_index_in_cset = index; | |
667 } | |
668 | |
669 int age_in_surv_rate_group() { | |
670 assert( _surv_rate_group != NULL, "pre-condition" ); | |
671 assert( _age_index > -1, "pre-condition" ); | |
672 return _surv_rate_group->age_in_group(_age_index); | |
673 } | |
674 | |
675 void record_surv_words_in_group(size_t words_survived) { | |
676 assert( _surv_rate_group != NULL, "pre-condition" ); | |
677 assert( _age_index > -1, "pre-condition" ); | |
678 int age_in_group = age_in_surv_rate_group(); | |
679 _surv_rate_group->record_surviving_words(age_in_group, words_survived); | |
680 } | |
681 | |
682 int age_in_surv_rate_group_cond() { | |
683 if (_surv_rate_group != NULL) | |
684 return age_in_surv_rate_group(); | |
685 else | |
686 return -1; | |
687 } | |
688 | |
689 SurvRateGroup* surv_rate_group() { | |
690 return _surv_rate_group; | |
691 } | |
692 | |
693 void install_surv_rate_group(SurvRateGroup* surv_rate_group) { | |
694 assert( surv_rate_group != NULL, "pre-condition" ); | |
695 assert( _surv_rate_group == NULL, "pre-condition" ); | |
696 assert( is_young(), "pre-condition" ); | |
697 | |
698 _surv_rate_group = surv_rate_group; | |
699 _age_index = surv_rate_group->next_age_index(); | |
700 } | |
701 | |
702 void uninstall_surv_rate_group() { | |
703 if (_surv_rate_group != NULL) { | |
704 assert( _age_index > -1, "pre-condition" ); | |
705 assert( is_young(), "pre-condition" ); | |
706 | |
707 _surv_rate_group = NULL; | |
708 _age_index = -1; | |
709 } else { | |
710 assert( _age_index == -1, "pre-condition" ); | |
711 } | |
712 } | |
713 | |
714 void set_young() { set_young_type(Young); } | |
715 | |
716 void set_survivor() { set_young_type(Survivor); } | |
717 | |
718 void set_not_young() { set_young_type(NotYoung); } | |
719 | |
720 // Determine if an object has been allocated since the last | |
721 // mark performed by the collector. This returns true iff the object | |
722 // is within the unmarked area of the region. | |
723 bool obj_allocated_since_prev_marking(oop obj) const { | |
724 return (HeapWord *) obj >= prev_top_at_mark_start(); | |
725 } | |
726 bool obj_allocated_since_next_marking(oop obj) const { | |
727 return (HeapWord *) obj >= next_top_at_mark_start(); | |
728 } | |
729 | |
730 // For parallel heapRegion traversal. | |
731 bool claimHeapRegion(int claimValue); | |
732 jint claim_value() { return _claimed; } | |
733 // Use this carefully: only when you're sure no one is claiming... | |
734 void set_claim_value(int claimValue) { _claimed = claimValue; } | |
735 | |
736 // Returns the "evacuation_failed" property of the region. | |
737 bool evacuation_failed() { return _evacuation_failed; } | |
738 | |
739 // Sets the "evacuation_failed" property of the region. | |
740 void set_evacuation_failed(bool b) { | |
741 _evacuation_failed = b; | |
742 | |
743 if (b) { | |
744 _next_marked_bytes = 0; | |
745 } | |
746 } | |
747 | |
748 // Requires that "mr" be entirely within the region. | |
749 // Apply "cl->do_object" to all objects that intersect with "mr". | |
750 // If the iteration encounters an unparseable portion of the region, | |
751 // or if "cl->abort()" is true after a closure application, | |
752 // terminate the iteration and return the address of the start of the | |
753 // subregion that isn't done. (The two can be distinguished by querying | |
754 // "cl->abort()".) Return of "NULL" indicates that the iteration | |
755 // completed. | |
756 HeapWord* | |
757 object_iterate_mem_careful(MemRegion mr, ObjectClosure* cl); | |
758 | |
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2435
diff
changeset
|
759 // 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
|
760 // 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
|
761 // 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
|
762 // 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
|
763 // iteration. |
342 | 764 HeapWord* |
765 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
|
766 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
|
767 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
|
768 jbyte* card_ptr); |
342 | 769 |
770 // A version of block start that is guaranteed to find *some* block | |
771 // boundary at or before "p", but does not object iteration, and may | |
772 // therefore be used safely when the heap is unparseable. | |
773 HeapWord* block_start_careful(const void* p) const { | |
774 return _offsets.block_start_careful(p); | |
775 } | |
776 | |
777 // Requires that "addr" is within the region. Returns the start of the | |
778 // first ("careful") block that starts at or after "addr", or else the | |
779 // "end" of the region if there is no such block. | |
780 HeapWord* next_block_start_careful(HeapWord* addr); | |
781 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
782 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
|
783 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
|
784 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
|
785 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
786 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
|
787 _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
|
788 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
789 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
790 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
|
791 _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
|
792 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
793 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
794 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
|
795 _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
|
796 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1021
diff
changeset
|
797 |
342 | 798 #define HeapRegion_OOP_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ |
799 virtual void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl); | |
800 SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DECL) | |
801 | |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
802 virtual CompactibleSpace* next_compaction_space() const; |
342 | 803 |
804 virtual void reset_after_compaction(); | |
805 | |
12080 | 806 // Routines for managing a list of code roots (attached to the |
807 // this region's RSet) that point into this heap region. | |
808 void add_strong_code_root(nmethod* nm); | |
809 void remove_strong_code_root(nmethod* nm); | |
810 | |
811 // During a collection, migrate the successfully evacuated | |
812 // strong code roots that referenced into this region to the | |
813 // new regions that they now point into. Unsuccessfully | |
814 // evacuated code roots are not migrated. | |
815 void migrate_strong_code_roots(); | |
816 | |
817 // Applies blk->do_code_blob() to each of the entries in | |
818 // the strong code roots list for this region | |
819 void strong_code_roots_do(CodeBlobClosure* blk) const; | |
820 | |
821 // Verify that the entries on the strong code root list for this | |
822 // region are live and include at least one pointer into this region. | |
823 void verify_strong_code_roots(VerifyOption vo, bool* failures) const; | |
824 | |
342 | 825 void print() const; |
826 void print_on(outputStream* st) const; | |
827 | |
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
828 // vo == UsePrevMarking -> use "prev" marking information, |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
829 // vo == UseNextMarking -> use "next" marking information |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
830 // vo == UseMarkWord -> use the mark word in the object header |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
831 // |
811 | 832 // NOTE: Only the "prev" marking information is guaranteed to be |
833 // 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
|
834 // vo == UsePrevMarking. |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
835 // 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
|
836 // vo == UseNextMarking, which is to verify the "next" marking |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
837 // information at the end of remark. |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
838 // 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
|
839 // vo == UseMarkWord, which is to verify the marking during a |
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
840 // full GC. |
6008 | 841 void verify(VerifyOption vo, bool *failures) const; |
811 | 842 |
843 // Override; it uses the "prev" marking information | |
6008 | 844 virtual void verify() const; |
342 | 845 }; |
846 | |
847 // HeapRegionClosure is used for iterating over regions. | |
848 // Terminates the iteration when the "doHeapRegion" method returns "true". | |
849 class HeapRegionClosure : public StackObj { | |
850 friend class HeapRegionSeq; | |
851 friend class G1CollectedHeap; | |
852 | |
853 bool _complete; | |
854 void incomplete() { _complete = false; } | |
855 | |
856 public: | |
857 HeapRegionClosure(): _complete(true) {} | |
858 | |
859 // Typically called on each region until it returns true. | |
860 virtual bool doHeapRegion(HeapRegion* r) = 0; | |
861 | |
862 // True after iteration if the closure was applied to all heap regions | |
863 // and returned "false" in all cases. | |
864 bool complete() { return _complete; } | |
865 }; | |
866 | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6754
diff
changeset
|
867 #endif // INCLUDE_ALL_GCS |
1972 | 868 |
869 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP |