1 /*
   2  * Copyright (c) 2001, 2019, 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  */
  24 
  25 #ifndef SHARE_GC_G1_HEAPREGION_HPP
  26 #define SHARE_GC_G1_HEAPREGION_HPP
  27 
  28 #include "gc/g1/g1BlockOffsetTable.hpp"
  29 #include "gc/g1/g1HeapRegionTraceType.hpp"
  30 #include "gc/g1/heapRegionTracer.hpp"
  31 #include "gc/g1/heapRegionType.hpp"
  32 #include "gc/g1/survRateGroup.hpp"
  33 #include "gc/shared/ageTable.hpp"
  34 #include "gc/shared/spaceDecorator.hpp"
  35 #include "gc/shared/verifyOption.hpp"
  36 #include "runtime/mutex.hpp"
  37 #include "utilities/macros.hpp"
  38 
  39 class G1CollectedHeap;
  40 class G1CMBitMap;
  41 class HeapRegionRemSet;
  42 class HeapRegion;
  43 class HeapRegionSetBase;
  44 class nmethod;
  45 
  46 #define HR_FORMAT "%u:(%s)[" PTR_FORMAT "," PTR_FORMAT "," PTR_FORMAT "]"
  47 #define HR_FORMAT_PARAMS(_hr_) \
  48                 (_hr_)->hrm_index(), \
  49                 (_hr_)->get_short_type_str(), \
  50                 p2i((_hr_)->bottom()), p2i((_hr_)->top()), p2i((_hr_)->end())
  51 
  52 // sentinel value for hrm_index
  53 #define G1_NO_HRM_INDEX ((uint) -1)
  54 
  55 // A HeapRegion is the smallest piece of a G1CollectedHeap that
  56 // can be collected independently.
  57 
  58 // Each heap region is self contained. top() and end() can never
  59 // be set beyond the end of the region. For humongous objects,
  60 // the first region is a StartsHumongous region. If the humongous
  61 // object is larger than a heap region, the following regions will
  62 // be of type ContinuesHumongous. In this case the top() of the
  63 // StartHumongous region and all ContinuesHumongous regions except
  64 // the last will point to their own end. The last ContinuesHumongous
  65 // region may have top() equal the end of object if there isn't
  66 // room for filler objects to pad out to the end of the region.
  67 class HeapRegion : public CHeapObj<mtGC> {
  68   friend class VMStructs;
  69 
  70   HeapWord* const _bottom;
  71   HeapWord* const _end;
  72 
  73   HeapWord* volatile _top;
  74   HeapWord* _compaction_top;
  75 
  76   G1BlockOffsetTablePart _bot_part;
  77   Mutex _par_alloc_lock;
  78   // When we need to retire an allocation region, while other threads
  79   // are also concurrently trying to allocate into it, we typically
  80   // allocate a dummy object at the end of the region to ensure that
  81   // no more allocations can take place in it. However, sometimes we
  82   // want to know where the end of the last "real" object we allocated
  83   // into the region was and this is what this keeps track.
  84   HeapWord* _pre_dummy_top;
  85 
  86 public:
  87   HeapWord* bottom() const         { return _bottom; }
  88   HeapWord* end() const            { return _end;    }
  89 
  90   void set_compaction_top(HeapWord* compaction_top) { _compaction_top = compaction_top; }
  91   HeapWord* compaction_top() const { return _compaction_top; }
  92 
  93   void set_top(HeapWord* value) { _top = value; }
  94   HeapWord* top() const { return _top; }
  95 
  96   // See the comment above in the declaration of _pre_dummy_top for an
  97   // explanation of what it is.
  98   void set_pre_dummy_top(HeapWord* pre_dummy_top) {
  99     assert(is_in(pre_dummy_top) && pre_dummy_top <= top(), "pre-condition");
 100     _pre_dummy_top = pre_dummy_top;
 101   }
 102   HeapWord* pre_dummy_top() { return (_pre_dummy_top == NULL) ? top() : _pre_dummy_top; }
 103   void reset_pre_dummy_top() { _pre_dummy_top = NULL; }
 104 
 105   // Returns true iff the given the heap  region contains the
 106   // given address as part of an allocated object. This may
 107   // be a potentially, so we restrict its use to assertion checks only.
 108   bool is_in(const void* p) const {
 109     return is_in_reserved(p);
 110   }
 111   bool is_in(oop obj) const {
 112     return is_in((void*)obj);
 113   }
 114   // Returns true iff the given reserved memory of the space contains the
 115   // given address.
 116   bool is_in_reserved(const void* p) const { return _bottom <= p && p < _end; }
 117 
 118   size_t capacity()     const { return byte_size(bottom(), end()); }
 119   size_t used() const { return byte_size(bottom(), top()); }
 120   size_t free() const { return byte_size(top(), end()); }
 121 
 122   bool is_empty() const { return used() == 0; }
 123 
 124 private:
 125   void reset_after_compaction() { set_top(compaction_top()); }
 126 
 127   void clear(bool mangle_space);
 128 
 129   HeapWord* block_start_const(const void* p) const;
 130 
 131   void mangle_unused_area() PRODUCT_RETURN;
 132 
 133   // Try to allocate at least min_word_size and up to desired_size from this region.
 134   // Returns NULL if not possible, otherwise sets actual_word_size to the amount of
 135   // space allocated.
 136   // This version assumes that all allocation requests to this HeapRegion are properly
 137   // synchronized.
 138   inline HeapWord* allocate_impl(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
 139   // Try to allocate at least min_word_size and up to desired_size from this HeapRegion.
 140   // Returns NULL if not possible, otherwise sets actual_word_size to the amount of
 141   // space allocated.
 142   // This version synchronizes with other calls to par_allocate_impl().
 143   inline HeapWord* par_allocate_impl(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
 144 
 145 public:
 146   HeapWord* block_start(const void* p);
 147 
 148   void object_iterate(ObjectClosure* blk);
 149 
 150   // Allocation (return NULL if full).  Assumes the caller has established
 151   // mutually exclusive access to the HeapRegion.
 152   HeapWord* allocate(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
 153   // Allocation (return NULL if full).  Enforces mutual exclusion internally.
 154   HeapWord* par_allocate(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size);
 155 
 156   HeapWord* allocate(size_t word_size);
 157   HeapWord* par_allocate(size_t word_size);
 158 
 159   inline HeapWord* par_allocate_no_bot_updates(size_t min_word_size, size_t desired_word_size, size_t* word_size);
 160   inline HeapWord* allocate_no_bot_updates(size_t word_size);
 161   inline HeapWord* allocate_no_bot_updates(size_t min_word_size, size_t desired_word_size, size_t* actual_size);
 162 
 163   // Full GC support methods.
 164 
 165   HeapWord* initialize_threshold();
 166   HeapWord* cross_threshold(HeapWord* start, HeapWord* end);
 167   // Update heap region to be consistent after Full GC compaction.
 168   void reset_humongous_during_compaction() {
 169     assert(is_humongous(),
 170            "should only be called for humongous regions");
 171 
 172     zero_marked_bytes();
 173     init_top_at_mark_start();
 174   }
 175   // Update heap region to be consistent after Full GC compaction.
 176   void complete_compaction();
 177 
 178   // All allocated blocks are occupied by objects in a HeapRegion
 179   bool block_is_obj(const HeapWord* p) const;
 180 
 181   // Returns whether the given object is dead based on TAMS and bitmap.
 182   bool is_obj_dead(const oop obj, const G1CMBitMap* const prev_bitmap) const;
 183 
 184   // Returns the object size for all valid block starts
 185   // and the amount of unallocated words if called on top()
 186   size_t block_size(const HeapWord* p) const;
 187 
 188   // Scans through the region using the bitmap to determine what
 189   // objects to call size_t ApplyToMarkedClosure::apply(oop) for.
 190   template<typename ApplyToMarkedClosure>
 191   inline void apply_to_marked_objects(G1CMBitMap* bitmap, ApplyToMarkedClosure* closure);
 192 
 193   void reset_bot() {
 194     _bot_part.reset_bot();
 195   }
 196 
 197 private:
 198   // The remembered set for this region.
 199   HeapRegionRemSet* _rem_set;
 200 
 201   // Cached index of this region in the heap region sequence.
 202   const uint _hrm_index;
 203 
 204   HeapRegionType _type;
 205 
 206   // For a humongous region, region in which it starts.
 207   HeapRegion* _humongous_start_region;
 208 
 209   // True iff an attempt to evacuate an object in the region failed.
 210   bool _evacuation_failed;
 211 
 212   static const uint InvalidCSetIndex = UINT_MAX;
 213 
 214   // The index in the optional regions array, if this region
 215   // is considered optional during a mixed collections.
 216   uint _index_in_opt_cset;
 217 
 218   // Fields used by the HeapRegionSetBase class and subclasses.
 219   HeapRegion* _next;
 220   HeapRegion* _prev;
 221 #ifdef ASSERT
 222   HeapRegionSetBase* _containing_set;
 223 #endif // ASSERT
 224 
 225   // The start of the unmarked area. The unmarked area extends from this
 226   // word until the top and/or end of the region, and is the part
 227   // of the region for which no marking was done, i.e. objects may
 228   // have been allocated in this part since the last mark phase.
 229   // "prev" is the top at the start of the last completed marking.
 230   // "next" is the top at the start of the in-progress marking (if any.)
 231   HeapWord* _prev_top_at_mark_start;
 232   HeapWord* _next_top_at_mark_start;
 233 
 234   // We use concurrent marking to determine the amount of live data
 235   // in each heap region.
 236   size_t _prev_marked_bytes;    // Bytes known to be live via last completed marking.
 237   size_t _next_marked_bytes;    // Bytes known to be live via in-progress marking.
 238 
 239   void init_top_at_mark_start() {
 240     assert(_prev_marked_bytes == 0 &&
 241            _next_marked_bytes == 0,
 242            "Must be called after zero_marked_bytes.");
 243     _prev_top_at_mark_start = _next_top_at_mark_start = bottom();
 244   }
 245 
 246   // Data for young region survivor prediction.
 247   uint  _young_index_in_cset;
 248   SurvRateGroup* _surv_rate_group;
 249   int  _age_index;
 250 
 251   // Cached attributes used in the collection set policy information
 252 
 253   // The calculated GC efficiency of the region.
 254   double _gc_efficiency;
 255 
 256   // The remembered set length that was added to the total value
 257   // for the collection set.
 258   size_t _recorded_rs_length;
 259 
 260   // The predicted elapsed time that was added to total value
 261   // for the collection set.
 262   double _predicted_elapsed_time_ms;
 263 
 264   uint _node_index;
 265 
 266   void report_region_type_change(G1HeapRegionTraceType::Type to);
 267 
 268   // Returns whether the given object address refers to a dead object, and either the
 269   // size of the object (if live) or the size of the block (if dead) in size.
 270   // May
 271   // - only called with obj < top()
 272   // - not called on humongous objects or archive regions
 273   inline bool is_obj_dead_with_size(const oop obj, const G1CMBitMap* const prev_bitmap, size_t* size) const;
 274 
 275   // Iterate over the references covered by the given MemRegion in a humongous
 276   // object and apply the given closure to them.
 277   // Humongous objects are allocated directly in the old-gen. So we need special
 278   // handling for concurrent processing encountering an in-progress allocation.
 279   // Returns the address after the last actually scanned or NULL if the area could
 280   // not be scanned (That should only happen when invoked concurrently with the
 281   // mutator).
 282   template <class Closure, bool is_gc_active>
 283   inline HeapWord* do_oops_on_memregion_in_humongous(MemRegion mr,
 284                                                      Closure* cl,
 285                                                      G1CollectedHeap* g1h);
 286 
 287   // Returns the block size of the given (dead, potentially having its class unloaded) object
 288   // starting at p extending to at most the prev TAMS using the given mark bitmap.
 289   inline size_t block_size_using_bitmap(const HeapWord* p, const G1CMBitMap* const prev_bitmap) const;
 290 public:
 291   HeapRegion(uint hrm_index, G1BlockOffsetTable* bot, MemRegion mr);
 292 
 293   // If this region is a member of a HeapRegionManager, the index in that
 294   // sequence, otherwise -1.
 295   uint hrm_index() const { return _hrm_index; }
 296 
 297   // Initializing the HeapRegion not only resets the data structure, but also
 298   // resets the BOT for that heap region.
 299   // The default values for clear_space means that we will do the clearing if
 300   // there's clearing to be done ourselves. We also always mangle the space.
 301   void initialize(bool clear_space = false, bool mangle_space = SpaceDecorator::Mangle);
 302 
 303   static int    LogOfHRGrainBytes;
 304   static int    LogOfHRGrainWords;
 305   static int    LogCardsPerRegion;
 306 
 307   static size_t GrainBytes;
 308   static size_t GrainWords;
 309   static size_t CardsPerRegion;
 310 
 311   static size_t align_up_to_region_byte_size(size_t sz) {
 312     return (sz + (size_t) GrainBytes - 1) &
 313                                       ~((1 << (size_t) LogOfHRGrainBytes) - 1);
 314   }
 315 
 316   // Returns whether a field is in the same region as the obj it points to.
 317   template <typename T>
 318   static bool is_in_same_region(T* p, oop obj) {
 319     assert(p != NULL, "p can't be NULL");
 320     assert(obj != NULL, "obj can't be NULL");
 321     return (((uintptr_t) p ^ cast_from_oop<uintptr_t>(obj)) >> LogOfHRGrainBytes) == 0;
 322   }
 323 
 324   static size_t max_region_size();
 325   static size_t min_region_size_in_words();
 326 
 327   // It sets up the heap region size (GrainBytes / GrainWords), as
 328   // well as other related fields that are based on the heap region
 329   // size (LogOfHRGrainBytes / LogOfHRGrainWords /
 330   // CardsPerRegion). All those fields are considered constant
 331   // throughout the JVM's execution, therefore they should only be set
 332   // up once during initialization time.
 333   static void setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size);
 334 
 335   // The number of bytes marked live in the region in the last marking phase.
 336   size_t marked_bytes()    { return _prev_marked_bytes; }
 337   size_t live_bytes() {
 338     return (top() - prev_top_at_mark_start()) * HeapWordSize + marked_bytes();
 339   }
 340 
 341   // The number of bytes counted in the next marking.
 342   size_t next_marked_bytes() { return _next_marked_bytes; }
 343   // The number of bytes live wrt the next marking.
 344   size_t next_live_bytes() {
 345     return
 346       (top() - next_top_at_mark_start()) * HeapWordSize + next_marked_bytes();
 347   }
 348 
 349   // A lower bound on the amount of garbage bytes in the region.
 350   size_t garbage_bytes() {
 351     size_t used_at_mark_start_bytes =
 352       (prev_top_at_mark_start() - bottom()) * HeapWordSize;
 353     return used_at_mark_start_bytes - marked_bytes();
 354   }
 355 
 356   // Return the amount of bytes we'll reclaim if we collect this
 357   // region. This includes not only the known garbage bytes in the
 358   // region but also any unallocated space in it, i.e., [top, end),
 359   // since it will also be reclaimed if we collect the region.
 360   size_t reclaimable_bytes() {
 361     size_t known_live_bytes = live_bytes();
 362     assert(known_live_bytes <= capacity(), "sanity");
 363     return capacity() - known_live_bytes;
 364   }
 365 
 366   // An upper bound on the number of live bytes in the region.
 367   size_t max_live_bytes() { return used() - garbage_bytes(); }
 368 
 369   void add_to_marked_bytes(size_t incr_bytes) {
 370     _next_marked_bytes = _next_marked_bytes + incr_bytes;
 371   }
 372 
 373   void zero_marked_bytes()      {
 374     _prev_marked_bytes = _next_marked_bytes = 0;
 375   }
 376   // Get the start of the unmarked area in this region.
 377   HeapWord* prev_top_at_mark_start() const { return _prev_top_at_mark_start; }
 378   HeapWord* next_top_at_mark_start() const { return _next_top_at_mark_start; }
 379 
 380   // Note the start or end of marking. This tells the heap region
 381   // that the collector is about to start or has finished (concurrently)
 382   // marking the heap.
 383 
 384   // Notify the region that concurrent marking is starting. Initialize
 385   // all fields related to the next marking info.
 386   inline void note_start_of_marking();
 387 
 388   // Notify the region that concurrent marking has finished. Copy the
 389   // (now finalized) next marking info fields into the prev marking
 390   // info fields.
 391   inline void note_end_of_marking();
 392 
 393   const char* get_type_str() const { return _type.get_str(); }
 394   const char* get_short_type_str() const { return _type.get_short_str(); }
 395   G1HeapRegionTraceType::Type get_trace_type() { return _type.get_trace_type(); }
 396 
 397   bool is_free() const { return _type.is_free(); }
 398 
 399   bool is_young()    const { return _type.is_young();    }
 400   bool is_eden()     const { return _type.is_eden();     }
 401   bool is_survivor() const { return _type.is_survivor(); }
 402 
 403   bool is_humongous() const { return _type.is_humongous(); }
 404   bool is_starts_humongous() const { return _type.is_starts_humongous(); }
 405   bool is_continues_humongous() const { return _type.is_continues_humongous();   }
 406 
 407   bool is_old() const { return _type.is_old(); }
 408 
 409   bool is_old_or_humongous() const { return _type.is_old_or_humongous(); }
 410 
 411   bool is_old_or_humongous_or_archive() const { return _type.is_old_or_humongous_or_archive(); }
 412 
 413   // A pinned region contains objects which are not moved by garbage collections.
 414   // Humongous regions and archive regions are pinned.
 415   bool is_pinned() const { return _type.is_pinned(); }
 416 
 417   // An archive region is a pinned region, also tagged as old, which
 418   // should not be marked during mark/sweep. This allows the address
 419   // space to be shared by JVM instances.
 420   bool is_archive()        const { return _type.is_archive(); }
 421   bool is_open_archive()   const { return _type.is_open_archive(); }
 422   bool is_closed_archive() const { return _type.is_closed_archive(); }
 423 
 424   void set_free();
 425 
 426   void set_eden();
 427   void set_eden_pre_gc();
 428   void set_survivor();
 429 
 430   void move_to_old();
 431   void set_old();
 432 
 433   void set_open_archive();
 434   void set_closed_archive();
 435 
 436   // For a humongous region, region in which it starts.
 437   HeapRegion* humongous_start_region() const {
 438     return _humongous_start_region;
 439   }
 440 
 441   // Makes the current region be a "starts humongous" region, i.e.,
 442   // the first region in a series of one or more contiguous regions
 443   // that will contain a single "humongous" object.
 444   //
 445   // obj_top : points to the top of the humongous object.
 446   // fill_size : size of the filler object at the end of the region series.
 447   void set_starts_humongous(HeapWord* obj_top, size_t fill_size);
 448 
 449   // Makes the current region be a "continues humongous'
 450   // region. first_hr is the "start humongous" region of the series
 451   // which this region will be part of.
 452   void set_continues_humongous(HeapRegion* first_hr);
 453 
 454   // Unsets the humongous-related fields on the region.
 455   void clear_humongous();
 456 
 457   // If the region has a remembered set, return a pointer to it.
 458   HeapRegionRemSet* rem_set() const {
 459     return _rem_set;
 460   }
 461 
 462   inline bool in_collection_set() const;
 463 
 464   // Methods used by the HeapRegionSetBase class and subclasses.
 465 
 466   // Getter and setter for the next and prev fields used to link regions into
 467   // linked lists.
 468   void set_next(HeapRegion* next) { _next = next; }
 469   HeapRegion* next()              { return _next; }
 470 
 471   void set_prev(HeapRegion* prev) { _prev = prev; }
 472   HeapRegion* prev()              { return _prev; }
 473 
 474   // Every region added to a set is tagged with a reference to that
 475   // set. This is used for doing consistency checking to make sure that
 476   // the contents of a set are as they should be and it's only
 477   // available in non-product builds.
 478 #ifdef ASSERT
 479   void set_containing_set(HeapRegionSetBase* containing_set) {
 480     assert((containing_set == NULL && _containing_set != NULL) ||
 481            (containing_set != NULL && _containing_set == NULL),
 482            "containing_set: " PTR_FORMAT " "
 483            "_containing_set: " PTR_FORMAT,
 484            p2i(containing_set), p2i(_containing_set));
 485 
 486     _containing_set = containing_set;
 487   }
 488 
 489   HeapRegionSetBase* containing_set() { return _containing_set; }
 490 #else // ASSERT
 491   void set_containing_set(HeapRegionSetBase* containing_set) { }
 492 
 493   // containing_set() is only used in asserts so there's no reason
 494   // to provide a dummy version of it.
 495 #endif // ASSERT
 496 
 497 
 498   // Reset the HeapRegion to default values.
 499   // If skip_remset is true, do not clear the remembered set.
 500   // If clear_space is true, clear the HeapRegion's memory.
 501   // If locked is true, assume we are the only thread doing this operation.
 502   void hr_clear(bool skip_remset, bool clear_space, bool locked = false);
 503   // Clear the card table corresponding to this region.
 504   void clear_cardtable();
 505 
 506   // Returns the "evacuation_failed" property of the region.
 507   bool evacuation_failed() { return _evacuation_failed; }
 508 
 509   // Sets the "evacuation_failed" property of the region.
 510   void set_evacuation_failed(bool b) {
 511     _evacuation_failed = b;
 512 
 513     if (b) {
 514       _next_marked_bytes = 0;
 515     }
 516   }
 517 
 518   // Notify the region that we are about to start processing
 519   // self-forwarded objects during evac failure handling.
 520   void note_self_forwarding_removal_start(bool during_initial_mark,
 521                                           bool during_conc_mark);
 522 
 523   // Notify the region that we have finished processing self-forwarded
 524   // objects during evac failure handling.
 525   void note_self_forwarding_removal_end(size_t marked_bytes);
 526 
 527   uint index_in_opt_cset() const {
 528     assert(has_index_in_opt_cset(), "Opt cset index not set.");
 529     return _index_in_opt_cset;
 530   }
 531   bool has_index_in_opt_cset() const { return _index_in_opt_cset != InvalidCSetIndex; }
 532   void set_index_in_opt_cset(uint index) { _index_in_opt_cset = index; }
 533   void clear_index_in_opt_cset() { _index_in_opt_cset = InvalidCSetIndex; }
 534 
 535   void calc_gc_efficiency(void);
 536   double gc_efficiency() const { return _gc_efficiency;}
 537 
 538   uint  young_index_in_cset() const { return _young_index_in_cset; }
 539   void clear_young_index_in_cset() { _young_index_in_cset = 0; }
 540   void set_young_index_in_cset(uint index) {
 541     assert(index != UINT_MAX, "just checking");
 542     assert(index != 0, "just checking");
 543     assert(is_young(), "pre-condition");
 544     _young_index_in_cset = index;
 545   }
 546 
 547   int age_in_surv_rate_group() {
 548     assert(_surv_rate_group != NULL, "pre-condition");
 549     assert(_age_index > -1, "pre-condition");
 550     return _surv_rate_group->age_in_group(_age_index);
 551   }
 552 
 553   void record_surv_words_in_group(size_t words_survived) {
 554     assert(_surv_rate_group != NULL, "pre-condition");
 555     assert(_age_index > -1, "pre-condition");
 556     int age_in_group = age_in_surv_rate_group();
 557     _surv_rate_group->record_surviving_words(age_in_group, words_survived);
 558   }
 559 
 560   int age_in_surv_rate_group_cond() {
 561     if (_surv_rate_group != NULL)
 562       return age_in_surv_rate_group();
 563     else
 564       return -1;
 565   }
 566 
 567   SurvRateGroup* surv_rate_group() {
 568     return _surv_rate_group;
 569   }
 570 
 571   void install_surv_rate_group(SurvRateGroup* surv_rate_group) {
 572     assert(surv_rate_group != NULL, "pre-condition");
 573     assert(_surv_rate_group == NULL, "pre-condition");
 574     assert(is_young(), "pre-condition");
 575 
 576     _surv_rate_group = surv_rate_group;
 577     _age_index = surv_rate_group->next_age_index();
 578   }
 579 
 580   void uninstall_surv_rate_group() {
 581     if (_surv_rate_group != NULL) {
 582       assert(_age_index > -1, "pre-condition");
 583       assert(is_young(), "pre-condition");
 584 
 585       _surv_rate_group = NULL;
 586       _age_index = -1;
 587     } else {
 588       assert(_age_index == -1, "pre-condition");
 589     }
 590   }
 591 
 592   // Determine if an object has been allocated since the last
 593   // mark performed by the collector. This returns true iff the object
 594   // is within the unmarked area of the region.
 595   bool obj_allocated_since_prev_marking(oop obj) const {
 596     return (HeapWord *) obj >= prev_top_at_mark_start();
 597   }
 598   bool obj_allocated_since_next_marking(oop obj) const {
 599     return (HeapWord *) obj >= next_top_at_mark_start();
 600   }
 601 
 602   // Iterate over the objects overlapping the given memory region, applying cl
 603   // to all references in the region.  This is a helper for
 604   // G1RemSet::refine_card*, and is tightly coupled with them.
 605   // mr must not be empty. Must be trimmed to the allocated/parseable space in this region.
 606   // This region must be old or humongous.
 607   // Returns the next unscanned address if the designated objects were successfully
 608   // processed, NULL if an unparseable part of the heap was encountered (That should
 609   // only happen when invoked concurrently with the mutator).
 610   template <bool is_gc_active, class Closure>
 611   inline HeapWord* oops_on_memregion_seq_iterate_careful(MemRegion mr, Closure* cl);
 612 
 613   size_t recorded_rs_length() const        { return _recorded_rs_length; }
 614   double predicted_elapsed_time_ms() const { return _predicted_elapsed_time_ms; }
 615 
 616   void set_recorded_rs_length(size_t rs_length) {
 617     _recorded_rs_length = rs_length;
 618   }
 619 
 620   void set_predicted_elapsed_time_ms(double ms) {
 621     _predicted_elapsed_time_ms = ms;
 622   }
 623 
 624   // Routines for managing a list of code roots (attached to the
 625   // this region's RSet) that point into this heap region.
 626   void add_strong_code_root(nmethod* nm);
 627   void add_strong_code_root_locked(nmethod* nm);
 628   void remove_strong_code_root(nmethod* nm);
 629 
 630   // Applies blk->do_code_blob() to each of the entries in
 631   // the strong code roots list for this region
 632   void strong_code_roots_do(CodeBlobClosure* blk) const;
 633 
 634   uint node_index() const { return _node_index; }
 635   void set_node_index(uint node_index) { _node_index = node_index; }
 636 
 637   // Verify that the entries on the strong code root list for this
 638   // region are live and include at least one pointer into this region.
 639   void verify_strong_code_roots(VerifyOption vo, bool* failures) const;
 640 
 641   void print() const;
 642   void print_on(outputStream* st) const;
 643 
 644   // vo == UsePrevMarking -> use "prev" marking information,
 645   // vo == UseNextMarking -> use "next" marking information
 646   // vo == UseFullMarking -> use "next" marking bitmap but no TAMS
 647   //
 648   // NOTE: Only the "prev" marking information is guaranteed to be
 649   // consistent most of the time, so most calls to this should use
 650   // vo == UsePrevMarking.
 651   // Currently, there is only one case where this is called with
 652   // vo == UseNextMarking, which is to verify the "next" marking
 653   // information at the end of remark.
 654   // Currently there is only one place where this is called with
 655   // vo == UseFullMarking, which is to verify the marking during a
 656   // full GC.
 657   void verify(VerifyOption vo, bool *failures) const;
 658 
 659   // Verify using the "prev" marking information
 660   void verify() const;
 661 
 662   void verify_rem_set(VerifyOption vo, bool *failures) const;
 663   void verify_rem_set() const;
 664 };
 665 
 666 // HeapRegionClosure is used for iterating over regions.
 667 // Terminates the iteration when the "do_heap_region" method returns "true".
 668 class HeapRegionClosure : public StackObj {
 669   friend class HeapRegionManager;
 670   friend class G1CollectionSet;
 671   friend class G1CollectionSetCandidates;
 672 
 673   bool _is_complete;
 674   void set_incomplete() { _is_complete = false; }
 675 
 676 public:
 677   HeapRegionClosure(): _is_complete(true) {}
 678 
 679   // Typically called on each region until it returns true.
 680   virtual bool do_heap_region(HeapRegion* r) = 0;
 681 
 682   // True after iteration if the closure was applied to all heap regions
 683   // and returned "false" in all cases.
 684   bool is_complete() { return _is_complete; }
 685 };
 686 
 687 #endif // SHARE_GC_G1_HEAPREGION_HPP