Sat, 06 Oct 2012 01:17:44 -0700
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
1 /*
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP
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"
36 #ifndef SERIALGC
38 // A HeapRegion is the smallest piece of a G1CollectedHeap that
39 // can be collected independently.
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.
48 class CompactibleSpace;
49 class ContiguousSpace;
50 class HeapRegionRemSet;
51 class HeapRegionRemSetIterator;
52 class HeapRegion;
53 class HeapRegionSetBase;
55 #define HR_FORMAT "%u:(%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_)->startsHumongous() ? "HS" : \
60 (_hr_)->continuesHumongous() ? "HC" : \
61 !(_hr_)->is_empty() ? "O" : "F", \
62 (_hr_)->bottom(), (_hr_)->top(), (_hr_)->end()
64 // sentinel value for hrs_index
65 #define G1_NULL_HRS_INDEX ((uint) -1)
67 // A dirty card to oop closure for heap regions. It
68 // knows how to get the G1 heap and how to use the bitmap
69 // in the concurrent marker used by G1 to filter remembered
70 // sets.
72 class HeapRegionDCTOC : public ContiguousSpaceDCTOC {
73 public:
74 // Specification of possible DirtyCardToOopClosure filtering.
75 enum FilterKind {
76 NoFilterKind,
77 IntoCSFilterKind,
78 OutOfRegionFilterKind
79 };
81 protected:
82 HeapRegion* _hr;
83 FilterKind _fk;
84 G1CollectedHeap* _g1;
86 void walk_mem_region_with_cl(MemRegion mr,
87 HeapWord* bottom, HeapWord* top,
88 ExtendedOopClosure* cl);
90 // We don't specialize this for FilteringClosure; filtering is handled by
91 // the "FilterKind" mechanism. But we provide this to avoid a compiler
92 // warning.
93 void walk_mem_region_with_cl(MemRegion mr,
94 HeapWord* bottom, HeapWord* top,
95 FilteringClosure* cl) {
96 HeapRegionDCTOC::walk_mem_region_with_cl(mr, bottom, top,
97 (ExtendedOopClosure*)cl);
98 }
100 // Get the actual top of the area on which the closure will
101 // operate, given where the top is assumed to be (the end of the
102 // memory region passed to do_MemRegion) and where the object
103 // at the top is assumed to start. For example, an object may
104 // start at the top but actually extend past the assumed top,
105 // in which case the top becomes the end of the object.
106 HeapWord* get_actual_top(HeapWord* top, HeapWord* top_obj) {
107 return ContiguousSpaceDCTOC::get_actual_top(top, top_obj);
108 }
110 // Walk the given memory region from bottom to (actual) top
111 // looking for objects and applying the oop closure (_cl) to
112 // them. The base implementation of this treats the area as
113 // blocks, where a block may or may not be an object. Sub-
114 // classes should override this to provide more accurate
115 // or possibly more efficient walking.
116 void walk_mem_region(MemRegion mr, HeapWord* bottom, HeapWord* top) {
117 Filtering_DCTOC::walk_mem_region(mr, bottom, top);
118 }
120 public:
121 HeapRegionDCTOC(G1CollectedHeap* g1,
122 HeapRegion* hr, ExtendedOopClosure* cl,
123 CardTableModRefBS::PrecisionStyle precision,
124 FilterKind fk);
125 };
127 // The complicating factor is that BlockOffsetTable diverged
128 // significantly, and we need functionality that is only in the G1 version.
129 // So I copied that code, which led to an alternate G1 version of
130 // OffsetTableContigSpace. If the two versions of BlockOffsetTable could
131 // be reconciled, then G1OffsetTableContigSpace could go away.
133 // The idea behind time stamps is the following. Doing a save_marks on
134 // all regions at every GC pause is time consuming (if I remember
135 // well, 10ms or so). So, we would like to do that only for regions
136 // that are GC alloc regions. To achieve this, we use time
137 // stamps. For every evacuation pause, G1CollectedHeap generates a
138 // unique time stamp (essentially a counter that gets
139 // incremented). Every time we want to call save_marks on a region,
140 // we set the saved_mark_word to top and also copy the current GC
141 // time stamp to the time stamp field of the space. Reading the
142 // saved_mark_word involves checking the time stamp of the
143 // region. If it is the same as the current GC time stamp, then we
144 // can safely read the saved_mark_word field, as it is valid. If the
145 // time stamp of the region is not the same as the current GC time
146 // stamp, then we instead read top, as the saved_mark_word field is
147 // invalid. Time stamps (on the regions and also on the
148 // G1CollectedHeap) are reset at every cleanup (we iterate over
149 // the regions anyway) and at the end of a Full GC. The current scheme
150 // that uses sequential unsigned ints will fail only if we have 4b
151 // evacuation pauses between two cleanups, which is _highly_ unlikely.
153 class G1OffsetTableContigSpace: public ContiguousSpace {
154 friend class VMStructs;
155 protected:
156 G1BlockOffsetArrayContigSpace _offsets;
157 Mutex _par_alloc_lock;
158 volatile unsigned _gc_time_stamp;
159 // When we need to retire an allocation region, while other threads
160 // are also concurrently trying to allocate into it, we typically
161 // allocate a dummy object at the end of the region to ensure that
162 // no more allocations can take place in it. However, sometimes we
163 // want to know where the end of the last "real" object we allocated
164 // into the region was and this is what this keeps track.
165 HeapWord* _pre_dummy_top;
167 public:
168 G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray,
169 MemRegion mr);
171 void set_bottom(HeapWord* value);
172 void set_end(HeapWord* value);
174 virtual HeapWord* saved_mark_word() const;
175 virtual void set_saved_mark();
176 void reset_gc_time_stamp() { _gc_time_stamp = 0; }
177 unsigned get_gc_time_stamp() { return _gc_time_stamp; }
179 // See the comment above in the declaration of _pre_dummy_top for an
180 // explanation of what it is.
181 void set_pre_dummy_top(HeapWord* pre_dummy_top) {
182 assert(is_in(pre_dummy_top) && pre_dummy_top <= top(), "pre-condition");
183 _pre_dummy_top = pre_dummy_top;
184 }
185 HeapWord* pre_dummy_top() {
186 return (_pre_dummy_top == NULL) ? top() : _pre_dummy_top;
187 }
188 void reset_pre_dummy_top() { _pre_dummy_top = NULL; }
190 virtual void clear(bool mangle_space);
192 HeapWord* block_start(const void* p);
193 HeapWord* block_start_const(const void* p) const;
195 // Add offset table update.
196 virtual HeapWord* allocate(size_t word_size);
197 HeapWord* par_allocate(size_t word_size);
199 // MarkSweep support phase3
200 virtual HeapWord* initialize_threshold();
201 virtual HeapWord* cross_threshold(HeapWord* start, HeapWord* end);
203 virtual void print() const;
205 void reset_bot() {
206 _offsets.zero_bottom_entry();
207 _offsets.initialize_threshold();
208 }
210 void update_bot_for_object(HeapWord* start, size_t word_size) {
211 _offsets.alloc_block(start, word_size);
212 }
214 void print_bot_on(outputStream* out) {
215 _offsets.print_on(out);
216 }
217 };
219 class HeapRegion: public G1OffsetTableContigSpace {
220 friend class VMStructs;
221 private:
223 enum HumongousType {
224 NotHumongous = 0,
225 StartsHumongous,
226 ContinuesHumongous
227 };
229 // Requires that the region "mr" be dense with objects, and begin and end
230 // with an object.
231 void oops_in_mr_iterate(MemRegion mr, ExtendedOopClosure* cl);
233 // The remembered set for this region.
234 // (Might want to make this "inline" later, to avoid some alloc failure
235 // issues.)
236 HeapRegionRemSet* _rem_set;
238 G1BlockOffsetArrayContigSpace* offsets() { return &_offsets; }
240 protected:
241 // The index of this region in the heap region sequence.
242 uint _hrs_index;
244 HumongousType _humongous_type;
245 // For a humongous region, region in which it starts.
246 HeapRegion* _humongous_start_region;
247 // For the start region of a humongous sequence, it's original end().
248 HeapWord* _orig_end;
250 // True iff the region is in current collection_set.
251 bool _in_collection_set;
253 // True iff an attempt to evacuate an object in the region failed.
254 bool _evacuation_failed;
256 // A heap region may be a member one of a number of special subsets, each
257 // represented as linked lists through the field below. Currently, these
258 // sets include:
259 // The collection set.
260 // The set of allocation regions used in a collection pause.
261 // Spaces that may contain gray objects.
262 HeapRegion* _next_in_special_set;
264 // next region in the young "generation" region set
265 HeapRegion* _next_young_region;
267 // Next region whose cards need cleaning
268 HeapRegion* _next_dirty_cards_region;
270 // Fields used by the HeapRegionSetBase class and subclasses.
271 HeapRegion* _next;
272 #ifdef ASSERT
273 HeapRegionSetBase* _containing_set;
274 #endif // ASSERT
275 bool _pending_removal;
277 // For parallel heapRegion traversal.
278 jint _claimed;
280 // We use concurrent marking to determine the amount of live data
281 // in each heap region.
282 size_t _prev_marked_bytes; // Bytes known to be live via last completed marking.
283 size_t _next_marked_bytes; // Bytes known to be live via in-progress marking.
285 // The calculated GC efficiency of the region.
286 double _gc_efficiency;
288 enum YoungType {
289 NotYoung, // a region is not young
290 Young, // a region is young
291 Survivor // a region is young and it contains survivors
292 };
294 volatile YoungType _young_type;
295 int _young_index_in_cset;
296 SurvRateGroup* _surv_rate_group;
297 int _age_index;
299 // The start of the unmarked area. The unmarked area extends from this
300 // word until the top and/or end of the region, and is the part
301 // of the region for which no marking was done, i.e. objects may
302 // have been allocated in this part since the last mark phase.
303 // "prev" is the top at the start of the last completed marking.
304 // "next" is the top at the start of the in-progress marking (if any.)
305 HeapWord* _prev_top_at_mark_start;
306 HeapWord* _next_top_at_mark_start;
307 // If a collection pause is in progress, this is the top at the start
308 // of that pause.
310 void init_top_at_mark_start() {
311 assert(_prev_marked_bytes == 0 &&
312 _next_marked_bytes == 0,
313 "Must be called after zero_marked_bytes.");
314 HeapWord* bot = bottom();
315 _prev_top_at_mark_start = bot;
316 _next_top_at_mark_start = bot;
317 }
319 void set_young_type(YoungType new_type) {
320 //assert(_young_type != new_type, "setting the same type" );
321 // TODO: add more assertions here
322 _young_type = new_type;
323 }
325 // Cached attributes used in the collection set policy information
327 // The RSet length that was added to the total value
328 // for the collection set.
329 size_t _recorded_rs_length;
331 // The predicted elapsed time that was added to total value
332 // for the collection set.
333 double _predicted_elapsed_time_ms;
335 // The predicted number of bytes to copy that was added to
336 // the total value for the collection set.
337 size_t _predicted_bytes_to_copy;
339 public:
340 HeapRegion(uint hrs_index,
341 G1BlockOffsetSharedArray* sharedOffsetArray,
342 MemRegion mr);
344 static int LogOfHRGrainBytes;
345 static int LogOfHRGrainWords;
347 static size_t GrainBytes;
348 static size_t GrainWords;
349 static size_t CardsPerRegion;
351 static size_t align_up_to_region_byte_size(size_t sz) {
352 return (sz + (size_t) GrainBytes - 1) &
353 ~((1 << (size_t) LogOfHRGrainBytes) - 1);
354 }
356 // It sets up the heap region size (GrainBytes / GrainWords), as
357 // well as other related fields that are based on the heap region
358 // size (LogOfHRGrainBytes / LogOfHRGrainWords /
359 // CardsPerRegion). All those fields are considered constant
360 // throughout the JVM's execution, therefore they should only be set
361 // up once during initialization time.
362 static void setup_heap_region_size(uintx min_heap_size);
364 enum ClaimValues {
365 InitialClaimValue = 0,
366 FinalCountClaimValue = 1,
367 NoteEndClaimValue = 2,
368 ScrubRemSetClaimValue = 3,
369 ParVerifyClaimValue = 4,
370 RebuildRSClaimValue = 5,
371 ParEvacFailureClaimValue = 6,
372 AggregateCountClaimValue = 7,
373 VerifyCountClaimValue = 8
374 };
376 inline HeapWord* par_allocate_no_bot_updates(size_t word_size) {
377 assert(is_young(), "we can only skip BOT updates on young regions");
378 return ContiguousSpace::par_allocate(word_size);
379 }
380 inline HeapWord* allocate_no_bot_updates(size_t word_size) {
381 assert(is_young(), "we can only skip BOT updates on young regions");
382 return ContiguousSpace::allocate(word_size);
383 }
385 // If this region is a member of a HeapRegionSeq, the index in that
386 // sequence, otherwise -1.
387 uint hrs_index() const { return _hrs_index; }
389 // The number of bytes marked live in the region in the last marking phase.
390 size_t marked_bytes() { return _prev_marked_bytes; }
391 size_t live_bytes() {
392 return (top() - prev_top_at_mark_start()) * HeapWordSize + marked_bytes();
393 }
395 // The number of bytes counted in the next marking.
396 size_t next_marked_bytes() { return _next_marked_bytes; }
397 // The number of bytes live wrt the next marking.
398 size_t next_live_bytes() {
399 return
400 (top() - next_top_at_mark_start()) * HeapWordSize + next_marked_bytes();
401 }
403 // A lower bound on the amount of garbage bytes in the region.
404 size_t garbage_bytes() {
405 size_t used_at_mark_start_bytes =
406 (prev_top_at_mark_start() - bottom()) * HeapWordSize;
407 assert(used_at_mark_start_bytes >= marked_bytes(),
408 "Can't mark more than we have.");
409 return used_at_mark_start_bytes - marked_bytes();
410 }
412 // Return the amount of bytes we'll reclaim if we collect this
413 // region. This includes not only the known garbage bytes in the
414 // region but also any unallocated space in it, i.e., [top, end),
415 // since it will also be reclaimed if we collect the region.
416 size_t reclaimable_bytes() {
417 size_t known_live_bytes = live_bytes();
418 assert(known_live_bytes <= capacity(), "sanity");
419 return capacity() - known_live_bytes;
420 }
422 // An upper bound on the number of live bytes in the region.
423 size_t max_live_bytes() { return used() - garbage_bytes(); }
425 void add_to_marked_bytes(size_t incr_bytes) {
426 _next_marked_bytes = _next_marked_bytes + incr_bytes;
427 assert(_next_marked_bytes <= used(), "invariant" );
428 }
430 void zero_marked_bytes() {
431 _prev_marked_bytes = _next_marked_bytes = 0;
432 }
434 bool isHumongous() const { return _humongous_type != NotHumongous; }
435 bool startsHumongous() const { return _humongous_type == StartsHumongous; }
436 bool continuesHumongous() const { return _humongous_type == ContinuesHumongous; }
437 // For a humongous region, region in which it starts.
438 HeapRegion* humongous_start_region() const {
439 return _humongous_start_region;
440 }
442 // Return the number of distinct regions that are covered by this region:
443 // 1 if the region is not humongous, >= 1 if the region is humongous.
444 uint region_num() const {
445 if (!isHumongous()) {
446 return 1U;
447 } else {
448 assert(startsHumongous(), "doesn't make sense on HC regions");
449 assert(capacity() % HeapRegion::GrainBytes == 0, "sanity");
450 return (uint) (capacity() >> HeapRegion::LogOfHRGrainBytes);
451 }
452 }
454 // Return the index + 1 of the last HC regions that's associated
455 // with this HS region.
456 uint last_hc_index() const {
457 assert(startsHumongous(), "don't call this otherwise");
458 return hrs_index() + region_num();
459 }
461 // Same as Space::is_in_reserved, but will use the original size of the region.
462 // The original size is different only for start humongous regions. They get
463 // their _end set up to be the end of the last continues region of the
464 // corresponding humongous object.
465 bool is_in_reserved_raw(const void* p) const {
466 return _bottom <= p && p < _orig_end;
467 }
469 // Makes the current region be a "starts humongous" region, i.e.,
470 // the first region in a series of one or more contiguous regions
471 // that will contain a single "humongous" object. The two parameters
472 // are as follows:
473 //
474 // new_top : The new value of the top field of this region which
475 // points to the end of the humongous object that's being
476 // allocated. If there is more than one region in the series, top
477 // will lie beyond this region's original end field and on the last
478 // region in the series.
479 //
480 // new_end : The new value of the end field of this region which
481 // points to the end of the last region in the series. If there is
482 // one region in the series (namely: this one) end will be the same
483 // as the original end of this region.
484 //
485 // Updating top and end as described above makes this region look as
486 // if it spans the entire space taken up by all the regions in the
487 // series and an single allocation moved its top to new_top. This
488 // ensures that the space (capacity / allocated) taken up by all
489 // humongous regions can be calculated by just looking at the
490 // "starts humongous" regions and by ignoring the "continues
491 // humongous" regions.
492 void set_startsHumongous(HeapWord* new_top, HeapWord* new_end);
494 // Makes the current region be a "continues humongous'
495 // region. first_hr is the "start humongous" region of the series
496 // which this region will be part of.
497 void set_continuesHumongous(HeapRegion* first_hr);
499 // Unsets the humongous-related fields on the region.
500 void set_notHumongous();
502 // If the region has a remembered set, return a pointer to it.
503 HeapRegionRemSet* rem_set() const {
504 return _rem_set;
505 }
507 // True iff the region is in current collection_set.
508 bool in_collection_set() const {
509 return _in_collection_set;
510 }
511 void set_in_collection_set(bool b) {
512 _in_collection_set = b;
513 }
514 HeapRegion* next_in_collection_set() {
515 assert(in_collection_set(), "should only invoke on member of CS.");
516 assert(_next_in_special_set == NULL ||
517 _next_in_special_set->in_collection_set(),
518 "Malformed CS.");
519 return _next_in_special_set;
520 }
521 void set_next_in_collection_set(HeapRegion* r) {
522 assert(in_collection_set(), "should only invoke on member of CS.");
523 assert(r == NULL || r->in_collection_set(), "Malformed CS.");
524 _next_in_special_set = r;
525 }
527 // Methods used by the HeapRegionSetBase class and subclasses.
529 // Getter and setter for the next field used to link regions into
530 // linked lists.
531 HeapRegion* next() { return _next; }
533 void set_next(HeapRegion* next) { _next = next; }
535 // Every region added to a set is tagged with a reference to that
536 // set. This is used for doing consistency checking to make sure that
537 // the contents of a set are as they should be and it's only
538 // available in non-product builds.
539 #ifdef ASSERT
540 void set_containing_set(HeapRegionSetBase* containing_set) {
541 assert((containing_set == NULL && _containing_set != NULL) ||
542 (containing_set != NULL && _containing_set == NULL),
543 err_msg("containing_set: "PTR_FORMAT" "
544 "_containing_set: "PTR_FORMAT,
545 containing_set, _containing_set));
547 _containing_set = containing_set;
548 }
550 HeapRegionSetBase* containing_set() { return _containing_set; }
551 #else // ASSERT
552 void set_containing_set(HeapRegionSetBase* containing_set) { }
554 // containing_set() is only used in asserts so there's no reason
555 // to provide a dummy version of it.
556 #endif // ASSERT
558 // If we want to remove regions from a list in bulk we can simply tag
559 // them with the pending_removal tag and call the
560 // remove_all_pending() method on the list.
562 bool pending_removal() { return _pending_removal; }
564 void set_pending_removal(bool pending_removal) {
565 if (pending_removal) {
566 assert(!_pending_removal && containing_set() != NULL,
567 "can only set pending removal to true if it's false and "
568 "the region belongs to a region set");
569 } else {
570 assert( _pending_removal && containing_set() == NULL,
571 "can only set pending removal to false if it's true and "
572 "the region does not belong to a region set");
573 }
575 _pending_removal = pending_removal;
576 }
578 HeapRegion* get_next_young_region() { return _next_young_region; }
579 void set_next_young_region(HeapRegion* hr) {
580 _next_young_region = hr;
581 }
583 HeapRegion* get_next_dirty_cards_region() const { return _next_dirty_cards_region; }
584 HeapRegion** next_dirty_cards_region_addr() { return &_next_dirty_cards_region; }
585 void set_next_dirty_cards_region(HeapRegion* hr) { _next_dirty_cards_region = hr; }
586 bool is_on_dirty_cards_region_list() const { return get_next_dirty_cards_region() != NULL; }
588 HeapWord* orig_end() { return _orig_end; }
590 // Allows logical separation between objects allocated before and after.
591 void save_marks();
593 // Reset HR stuff to default values.
594 void hr_clear(bool par, bool clear_space);
595 void par_clear();
597 // Get the start of the unmarked area in this region.
598 HeapWord* prev_top_at_mark_start() const { return _prev_top_at_mark_start; }
599 HeapWord* next_top_at_mark_start() const { return _next_top_at_mark_start; }
601 // Apply "cl->do_oop" to (the addresses of) all reference fields in objects
602 // allocated in the current region before the last call to "save_mark".
603 void oop_before_save_marks_iterate(ExtendedOopClosure* cl);
605 // Note the start or end of marking. This tells the heap region
606 // that the collector is about to start or has finished (concurrently)
607 // marking the heap.
609 // Notify the region that concurrent marking is starting. Initialize
610 // all fields related to the next marking info.
611 inline void note_start_of_marking();
613 // Notify the region that concurrent marking has finished. Copy the
614 // (now finalized) next marking info fields into the prev marking
615 // info fields.
616 inline void note_end_of_marking();
618 // Notify the region that it will be used as to-space during a GC
619 // and we are about to start copying objects into it.
620 inline void note_start_of_copying(bool during_initial_mark);
622 // Notify the region that it ceases being to-space during a GC and
623 // we will not copy objects into it any more.
624 inline void note_end_of_copying(bool during_initial_mark);
626 // Notify the region that we are about to start processing
627 // self-forwarded objects during evac failure handling.
628 void note_self_forwarding_removal_start(bool during_initial_mark,
629 bool during_conc_mark);
631 // Notify the region that we have finished processing self-forwarded
632 // objects during evac failure handling.
633 void note_self_forwarding_removal_end(bool during_initial_mark,
634 bool during_conc_mark,
635 size_t marked_bytes);
637 // Returns "false" iff no object in the region was allocated when the
638 // last mark phase ended.
639 bool is_marked() { return _prev_top_at_mark_start != bottom(); }
641 void reset_during_compaction() {
642 assert(isHumongous() && startsHumongous(),
643 "should only be called for starts humongous regions");
645 zero_marked_bytes();
646 init_top_at_mark_start();
647 }
649 void calc_gc_efficiency(void);
650 double gc_efficiency() { return _gc_efficiency;}
652 bool is_young() const { return _young_type != NotYoung; }
653 bool is_survivor() const { return _young_type == Survivor; }
655 int young_index_in_cset() const { return _young_index_in_cset; }
656 void set_young_index_in_cset(int index) {
657 assert( (index == -1) || is_young(), "pre-condition" );
658 _young_index_in_cset = index;
659 }
661 int age_in_surv_rate_group() {
662 assert( _surv_rate_group != NULL, "pre-condition" );
663 assert( _age_index > -1, "pre-condition" );
664 return _surv_rate_group->age_in_group(_age_index);
665 }
667 void record_surv_words_in_group(size_t words_survived) {
668 assert( _surv_rate_group != NULL, "pre-condition" );
669 assert( _age_index > -1, "pre-condition" );
670 int age_in_group = age_in_surv_rate_group();
671 _surv_rate_group->record_surviving_words(age_in_group, words_survived);
672 }
674 int age_in_surv_rate_group_cond() {
675 if (_surv_rate_group != NULL)
676 return age_in_surv_rate_group();
677 else
678 return -1;
679 }
681 SurvRateGroup* surv_rate_group() {
682 return _surv_rate_group;
683 }
685 void install_surv_rate_group(SurvRateGroup* surv_rate_group) {
686 assert( surv_rate_group != NULL, "pre-condition" );
687 assert( _surv_rate_group == NULL, "pre-condition" );
688 assert( is_young(), "pre-condition" );
690 _surv_rate_group = surv_rate_group;
691 _age_index = surv_rate_group->next_age_index();
692 }
694 void uninstall_surv_rate_group() {
695 if (_surv_rate_group != NULL) {
696 assert( _age_index > -1, "pre-condition" );
697 assert( is_young(), "pre-condition" );
699 _surv_rate_group = NULL;
700 _age_index = -1;
701 } else {
702 assert( _age_index == -1, "pre-condition" );
703 }
704 }
706 void set_young() { set_young_type(Young); }
708 void set_survivor() { set_young_type(Survivor); }
710 void set_not_young() { set_young_type(NotYoung); }
712 // Determine if an object has been allocated since the last
713 // mark performed by the collector. This returns true iff the object
714 // is within the unmarked area of the region.
715 bool obj_allocated_since_prev_marking(oop obj) const {
716 return (HeapWord *) obj >= prev_top_at_mark_start();
717 }
718 bool obj_allocated_since_next_marking(oop obj) const {
719 return (HeapWord *) obj >= next_top_at_mark_start();
720 }
722 // For parallel heapRegion traversal.
723 bool claimHeapRegion(int claimValue);
724 jint claim_value() { return _claimed; }
725 // Use this carefully: only when you're sure no one is claiming...
726 void set_claim_value(int claimValue) { _claimed = claimValue; }
728 // Returns the "evacuation_failed" property of the region.
729 bool evacuation_failed() { return _evacuation_failed; }
731 // Sets the "evacuation_failed" property of the region.
732 void set_evacuation_failed(bool b) {
733 _evacuation_failed = b;
735 if (b) {
736 _next_marked_bytes = 0;
737 }
738 }
740 // Requires that "mr" be entirely within the region.
741 // Apply "cl->do_object" to all objects that intersect with "mr".
742 // If the iteration encounters an unparseable portion of the region,
743 // or if "cl->abort()" is true after a closure application,
744 // terminate the iteration and return the address of the start of the
745 // subregion that isn't done. (The two can be distinguished by querying
746 // "cl->abort()".) Return of "NULL" indicates that the iteration
747 // completed.
748 HeapWord*
749 object_iterate_mem_careful(MemRegion mr, ObjectClosure* cl);
751 // filter_young: if true and the region is a young region then we
752 // skip the iteration.
753 // card_ptr: if not NULL, and we decide that the card is not young
754 // and we iterate over it, we'll clean the card before we start the
755 // iteration.
756 HeapWord*
757 oops_on_card_seq_iterate_careful(MemRegion mr,
758 FilterOutOfRegionClosure* cl,
759 bool filter_young,
760 jbyte* card_ptr);
762 // A version of block start that is guaranteed to find *some* block
763 // boundary at or before "p", but does not object iteration, and may
764 // therefore be used safely when the heap is unparseable.
765 HeapWord* block_start_careful(const void* p) const {
766 return _offsets.block_start_careful(p);
767 }
769 // Requires that "addr" is within the region. Returns the start of the
770 // first ("careful") block that starts at or after "addr", or else the
771 // "end" of the region if there is no such block.
772 HeapWord* next_block_start_careful(HeapWord* addr);
774 size_t recorded_rs_length() const { return _recorded_rs_length; }
775 double predicted_elapsed_time_ms() const { return _predicted_elapsed_time_ms; }
776 size_t predicted_bytes_to_copy() const { return _predicted_bytes_to_copy; }
778 void set_recorded_rs_length(size_t rs_length) {
779 _recorded_rs_length = rs_length;
780 }
782 void set_predicted_elapsed_time_ms(double ms) {
783 _predicted_elapsed_time_ms = ms;
784 }
786 void set_predicted_bytes_to_copy(size_t bytes) {
787 _predicted_bytes_to_copy = bytes;
788 }
790 #define HeapRegion_OOP_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \
791 virtual void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl);
792 SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DECL)
794 virtual CompactibleSpace* next_compaction_space() const;
796 virtual void reset_after_compaction();
798 void print() const;
799 void print_on(outputStream* st) const;
801 // vo == UsePrevMarking -> use "prev" marking information,
802 // vo == UseNextMarking -> use "next" marking information
803 // vo == UseMarkWord -> use the mark word in the object header
804 //
805 // NOTE: Only the "prev" marking information is guaranteed to be
806 // consistent most of the time, so most calls to this should use
807 // vo == UsePrevMarking.
808 // Currently, there is only one case where this is called with
809 // vo == UseNextMarking, which is to verify the "next" marking
810 // information at the end of remark.
811 // Currently there is only one place where this is called with
812 // vo == UseMarkWord, which is to verify the marking during a
813 // full GC.
814 void verify(VerifyOption vo, bool *failures) const;
816 // Override; it uses the "prev" marking information
817 virtual void verify() const;
818 };
820 // HeapRegionClosure is used for iterating over regions.
821 // Terminates the iteration when the "doHeapRegion" method returns "true".
822 class HeapRegionClosure : public StackObj {
823 friend class HeapRegionSeq;
824 friend class G1CollectedHeap;
826 bool _complete;
827 void incomplete() { _complete = false; }
829 public:
830 HeapRegionClosure(): _complete(true) {}
832 // Typically called on each region until it returns true.
833 virtual bool doHeapRegion(HeapRegion* r) = 0;
835 // True after iteration if the closure was applied to all heap regions
836 // and returned "false" in all cases.
837 bool complete() { return _complete; }
838 };
840 #endif // SERIALGC
842 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP