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