/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_heapRegion.cpp.incl"

HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1,

                                 HeapRegion* hr, OopClosure* cl,

                                 CardTableModRefBS::PrecisionStyle precision,

                                 FilterKind fk) :

  ContiguousSpaceDCTOC(hr, cl, precision, NULL),

  _hr(hr), _fk(fk), _g1(g1)

{}

FilterOutOfRegionClosure::FilterOutOfRegionClosure(HeapRegion* r,

                                                   OopClosure* oc) :

  _r_bottom(r->bottom()), _r_end(r->end()),

  _oc(oc), _out_of_region(0)

{}

class VerifyLiveClosure: public OopClosure {

private:

  G1CollectedHeap* _g1h;

  CardTableModRefBS* _bs;

  oop _containing_obj;

  bool _failures;

  int _n_failures;

  bool _use_prev_marking;

public:

  // use_prev_marking == true  -> use "prev" marking information,

  // use_prev_marking == false -> use "next" marking information

  VerifyLiveClosure(G1CollectedHeap* g1h, bool use_prev_marking) :

    _g1h(g1h), _bs(NULL), _containing_obj(NULL),

    _failures(false), _n_failures(0), _use_prev_marking(use_prev_marking)

  {

    BarrierSet* bs = _g1h->barrier_set();

    if (bs->is_a(BarrierSet::CardTableModRef))

      _bs = (CardTableModRefBS*)bs;

  }

  void set_containing_obj(oop obj) {

    _containing_obj = obj;

  }

  bool failures() { return _failures; }

  int n_failures() { return _n_failures; }

  virtual void do_oop(narrowOop* p) {

    guarantee(false, "NYI");

  }

  void do_oop(oop* p) {

    assert(_containing_obj != NULL, "Precondition");

    assert(!_g1h->is_obj_dead_cond(_containing_obj, _use_prev_marking),

           "Precondition");

    oop obj = *p;

    if (obj != NULL) {

      bool failed = false;

      if (!_g1h->is_in_closed_subset(obj) ||

          _g1h->is_obj_dead_cond(obj, _use_prev_marking)) {

        if (!_failures) {

          gclog_or_tty->print_cr("");

          gclog_or_tty->print_cr("----------");

        }

        if (!_g1h->is_in_closed_subset(obj)) {

          gclog_or_tty->print_cr("Field "PTR_FORMAT

                        " of live obj "PTR_FORMAT

                        " points to obj "PTR_FORMAT

                        " not in the heap.",

                        p, (void*) _containing_obj, (void*) obj);

        } else {

          gclog_or_tty->print_cr("Field "PTR_FORMAT

                        " of live obj "PTR_FORMAT

                        " points to dead obj "PTR_FORMAT".",

                        p, (void*) _containing_obj, (void*) obj);

        }

        gclog_or_tty->print_cr("Live obj:");

        _containing_obj->print_on(gclog_or_tty);

        gclog_or_tty->print_cr("Bad referent:");

        obj->print_on(gclog_or_tty);

        gclog_or_tty->print_cr("----------");

        _failures = true;

        failed = true;

        _n_failures++;

      }

      if (!_g1h->full_collection()) {

        HeapRegion* from = _g1h->heap_region_containing(p);

        HeapRegion* to   = _g1h->heap_region_containing(*p);

        if (from != NULL && to != NULL &&

            from != to &&

            !to->isHumongous()) {

          jbyte cv_obj = *_bs->byte_for_const(_containing_obj);

          jbyte cv_field = *_bs->byte_for_const(p);

          const jbyte dirty = CardTableModRefBS::dirty_card_val();

          bool is_bad = !(from->is_young()

                          || to->rem_set()->contains_reference(p)

                          || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed

                              (_containing_obj->is_objArray() ?

                                  cv_field == dirty

                               : cv_obj == dirty || cv_field == dirty));

          if (is_bad) {

            if (!_failures) {

              gclog_or_tty->print_cr("");

              gclog_or_tty->print_cr("----------");

            }

            gclog_or_tty->print_cr("Missing rem set entry:");

            gclog_or_tty->print_cr("Field "PTR_FORMAT

                          " of obj "PTR_FORMAT

                          ", in region %d ["PTR_FORMAT

                          ", "PTR_FORMAT"),",

                          p, (void*) _containing_obj,

                          from->hrs_index(),

                          from->bottom(),

                          from->end());

            _containing_obj->print_on(gclog_or_tty);

            gclog_or_tty->print_cr("points to obj "PTR_FORMAT

                          " in region %d ["PTR_FORMAT

                          ", "PTR_FORMAT").",

                          (void*) obj, to->hrs_index(),

                          to->bottom(), to->end());

            obj->print_on(gclog_or_tty);

            gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.",

                          cv_obj, cv_field);

            gclog_or_tty->print_cr("----------");

            _failures = true;

            if (!failed) _n_failures++;

          }

        }

      }

    }

  }

};

template<class ClosureType>

HeapWord* walk_mem_region_loop(ClosureType* cl, G1CollectedHeap* g1h,

                               HeapRegion* hr,

                               HeapWord* cur, HeapWord* top) {

  oop cur_oop = oop(cur);

  int oop_size = cur_oop->size();

  HeapWord* next_obj = cur + oop_size;

  while (next_obj < top) {

    // Keep filtering the remembered set.

    if (!g1h->is_obj_dead(cur_oop, hr)) {

      // Bottom lies entirely below top, so we can call the

      // non-memRegion version of oop_iterate below.

      cur_oop->oop_iterate(cl);

    }

    cur = next_obj;

    cur_oop = oop(cur);

    oop_size = cur_oop->size();

    next_obj = cur + oop_size;

  }

  return cur;

}

void HeapRegionDCTOC::walk_mem_region_with_cl(MemRegion mr,

                                              HeapWord* bottom,

                                              HeapWord* top,

                                              OopClosure* cl) {

  G1CollectedHeap* g1h = _g1;

  int oop_size;

  OopClosure* cl2 = cl;

  FilterIntoCSClosure intoCSFilt(this, g1h, cl);

  FilterOutOfRegionClosure outOfRegionFilt(_hr, cl);

  switch (_fk) {

  case IntoCSFilterKind:      cl2 = &intoCSFilt; break;

  case OutOfRegionFilterKind: cl2 = &outOfRegionFilt; break;

  }

  // Start filtering what we add to the remembered set. If the object is

  // not considered dead, either because it is marked (in the mark bitmap)

  // or it was allocated after marking finished, then we add it. Otherwise

  // we can safely ignore the object.

  if (!g1h->is_obj_dead(oop(bottom), _hr)) {

    oop_size = oop(bottom)->oop_iterate(cl2, mr);

  } else {

    oop_size = oop(bottom)->size();

  }

  bottom += oop_size;

  if (bottom < top) {

    // We replicate the loop below for several kinds of possible filters.

    switch (_fk) {

    case NoFilterKind:

      bottom = walk_mem_region_loop(cl, g1h, _hr, bottom, top);

      break;

    case IntoCSFilterKind: {

      FilterIntoCSClosure filt(this, g1h, cl);

      bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top);

      break;

    }

    case OutOfRegionFilterKind: {

      FilterOutOfRegionClosure filt(_hr, cl);

      bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top);

      break;

    }

    default:

      ShouldNotReachHere();

    }

    // Last object. Need to do dead-obj filtering here too.

    if (!g1h->is_obj_dead(oop(bottom), _hr)) {

      oop(bottom)->oop_iterate(cl2, mr);

    }

  }

}

void HeapRegion::reset_after_compaction() {

  G1OffsetTableContigSpace::reset_after_compaction();

  // After a compaction the mark bitmap is invalid, so we must

  // treat all objects as being inside the unmarked area.

  zero_marked_bytes();

  init_top_at_mark_start();

}

DirtyCardToOopClosure*

HeapRegion::new_dcto_closure(OopClosure* cl,

                             CardTableModRefBS::PrecisionStyle precision,

                             HeapRegionDCTOC::FilterKind fk) {

  return new HeapRegionDCTOC(G1CollectedHeap::heap(),

                             this, cl, precision, fk);

}

void HeapRegion::hr_clear(bool par, bool clear_space) {

  _humongous_type = NotHumongous;

  _humongous_start_region = NULL;

  _in_collection_set = false;

  _is_gc_alloc_region = false;

  // Age stuff (if parallel, this will be done separately, since it needs

  // to be sequential).

  G1CollectedHeap* g1h = G1CollectedHeap::heap();

  set_young_index_in_cset(-1);

  uninstall_surv_rate_group();

  set_young_type(NotYoung);

  // In case it had been the start of a humongous sequence, reset its end.

  set_end(_orig_end);

  if (!par) {

    // If this is parallel, this will be done later.

    HeapRegionRemSet* hrrs = rem_set();

    if (hrrs != NULL) hrrs->clear();

    _claimed = InitialClaimValue;

  }

  zero_marked_bytes();

  set_sort_index(-1);

  _offsets.resize(HeapRegion::GrainWords);

  init_top_at_mark_start();

  if (clear_space) clear(SpaceDecorator::Mangle);

}

// <PREDICTION>

void HeapRegion::calc_gc_efficiency() {

  G1CollectedHeap* g1h = G1CollectedHeap::heap();

  _gc_efficiency = (double) garbage_bytes() /

                            g1h->predict_region_elapsed_time_ms(this, false);

}

// </PREDICTION>

void HeapRegion::set_startsHumongous() {

  _humongous_type = StartsHumongous;

  _humongous_start_region = this;

  assert(end() == _orig_end, "Should be normal before alloc.");

}

bool HeapRegion::claimHeapRegion(jint claimValue) {

  jint current = _claimed;

  if (current != claimValue) {

    jint res = Atomic::cmpxchg(claimValue, &_claimed, current);

    if (res == current) {

      return true;

    }

  }

  return false;

}

HeapWord* HeapRegion::next_block_start_careful(HeapWord* addr) {

  HeapWord* low = addr;

  HeapWord* high = end();

  while (low < high) {

    size_t diff = pointer_delta(high, low);

    // Must add one below to bias toward the high amount.  Otherwise, if

  // "high" were at the desired value, and "low" were one less, we

    // would not converge on "high".  This is not symmetric, because

    // we set "high" to a block start, which might be the right one,

    // which we don't do for "low".

    HeapWord* middle = low + (diff+1)/2;

    if (middle == high) return high;

    HeapWord* mid_bs = block_start_careful(middle);

    if (mid_bs < addr) {

      low = middle;

    } else {

      high = mid_bs;

    }

  }

  assert(low == high && low >= addr, "Didn't work.");

  return low;

}

void HeapRegion::set_next_on_unclean_list(HeapRegion* r) {

  assert(r == NULL || r->is_on_unclean_list(), "Malformed unclean list.");

  _next_in_special_set = r;

}

void HeapRegion::set_on_unclean_list(bool b) {

  _is_on_unclean_list = b;

}

void HeapRegion::initialize(MemRegion mr, bool clear_space, bool mangle_space) {

  G1OffsetTableContigSpace::initialize(mr, false, mangle_space);

  hr_clear(false/*par*/, clear_space);

}

#ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away

#pragma warning( disable:4355 ) // 'this' : used in base member initializer list

#endif // _MSC_VER

HeapRegion::

HeapRegion(G1BlockOffsetSharedArray* sharedOffsetArray,

                     MemRegion mr, bool is_zeroed)

  : G1OffsetTableContigSpace(sharedOffsetArray, mr, is_zeroed),

    _next_fk(HeapRegionDCTOC::NoFilterKind),

    _hrs_index(-1),

    _humongous_type(NotHumongous), _humongous_start_region(NULL),

    _in_collection_set(false), _is_gc_alloc_region(false),

    _is_on_free_list(false), _is_on_unclean_list(false),

    _next_in_special_set(NULL), _orig_end(NULL),

    _claimed(InitialClaimValue), _evacuation_failed(false),

    _prev_marked_bytes(0), _next_marked_bytes(0), _sort_index(-1),

    _young_type(NotYoung), _next_young_region(NULL),

    _next_dirty_cards_region(NULL),

    _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1),

    _rem_set(NULL), _zfs(NotZeroFilled)

{

  _orig_end = mr.end();

  // Note that initialize() will set the start of the unmarked area of the

  // region.

  this->initialize(mr, !is_zeroed, SpaceDecorator::Mangle);

  set_top(bottom());

  set_saved_mark();

  _rem_set =  new HeapRegionRemSet(sharedOffsetArray, this);

  assert(HeapRegionRemSet::num_par_rem_sets() > 0, "Invariant.");

  // In case the region is allocated during a pause, note the top.

  // We haven't done any counting on a brand new region.

  _top_at_conc_mark_count = bottom();

}

class NextCompactionHeapRegionClosure: public HeapRegionClosure {

  const HeapRegion* _target;

  bool _target_seen;

  HeapRegion* _last;

  CompactibleSpace* _res;

public:

  NextCompactionHeapRegionClosure(const HeapRegion* target) :

    _target(target), _target_seen(false), _res(NULL) {}

  bool doHeapRegion(HeapRegion* cur) {

    if (_target_seen) {

      if (!cur->isHumongous()) {

        _res = cur;

        return true;

      }

    } else if (cur == _target) {

      _target_seen = true;

    }

    return false;

  }

  CompactibleSpace* result() { return _res; }

};

CompactibleSpace* HeapRegion::next_compaction_space() const {

  G1CollectedHeap* g1h = G1CollectedHeap::heap();

  // cast away const-ness

  HeapRegion* r = (HeapRegion*) this;

  NextCompactionHeapRegionClosure blk(r);

  g1h->heap_region_iterate_from(r, &blk);

  return blk.result();

}

void HeapRegion::set_continuesHumongous(HeapRegion* start) {

  // The order is important here.

  start->add_continuingHumongousRegion(this);

  _humongous_type = ContinuesHumongous;

  _humongous_start_region = start;

}

void HeapRegion::add_continuingHumongousRegion(HeapRegion* cont) {

  // Must join the blocks of the current H region seq with the block of the

  // added region.

  offsets()->join_blocks(bottom(), cont->bottom());

  arrayOop obj = (arrayOop)(bottom());

  obj->set_length((int) (obj->length() + cont->capacity()/jintSize));

  set_end(cont->end());

  set_top(cont->end());

}

void HeapRegion::save_marks() {

  set_saved_mark();

}

void HeapRegion::oops_in_mr_iterate(MemRegion mr, OopClosure* cl) {

  HeapWord* p = mr.start();

  HeapWord* e = mr.end();

  oop obj;

  while (p < e) {

    obj = oop(p);

    p += obj->oop_iterate(cl);

  }

  assert(p == e, "bad memregion: doesn't end on obj boundary");

}

#define HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \

void HeapRegion::oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \

  ContiguousSpace::oop_since_save_marks_iterate##nv_suffix(cl);              \

}

SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN)

void HeapRegion::oop_before_save_marks_iterate(OopClosure* cl) {

  oops_in_mr_iterate(MemRegion(bottom(), saved_mark_word()), cl);

}

#ifdef DEBUG

HeapWord* HeapRegion::allocate(size_t size) {

  jint state = zero_fill_state();

  assert(!G1CollectedHeap::heap()->allocs_are_zero_filled() ||

         zero_fill_is_allocated(),

         "When ZF is on, only alloc in ZF'd regions");

  return G1OffsetTableContigSpace::allocate(size);

}

#endif

void HeapRegion::set_zero_fill_state_work(ZeroFillState zfs) {

  assert(top() == bottom() || zfs == Allocated,

         "Region must be empty, or we must be setting it to allocated.");

  assert(ZF_mon->owned_by_self() ||

         Universe::heap()->is_gc_active(),

         "Must hold the lock or be a full GC to modify.");

  _zfs = zfs;

}

void HeapRegion::set_zero_fill_complete() {

  set_zero_fill_state_work(ZeroFilled);

  if (ZF_mon->owned_by_self()) {

    ZF_mon->notify_all();

  }

}

void HeapRegion::ensure_zero_filled() {

  MutexLockerEx x(ZF_mon, Mutex::_no_safepoint_check_flag);

  ensure_zero_filled_locked();

}

void HeapRegion::ensure_zero_filled_locked() {

  assert(ZF_mon->owned_by_self(), "Precondition");

  bool should_ignore_zf = SafepointSynchronize::is_at_safepoint();

  assert(should_ignore_zf || Heap_lock->is_locked(),

         "Either we're in a GC or we're allocating a region.");

  switch (zero_fill_state()) {

  case HeapRegion::NotZeroFilled:

    set_zero_fill_in_progress(Thread::current());

    {

      ZF_mon->unlock();

      Copy::fill_to_words(bottom(), capacity()/HeapWordSize);

      ZF_mon->lock_without_safepoint_check();

    }

    // A trap.

    guarantee(zero_fill_state() == HeapRegion::ZeroFilling

              && zero_filler() == Thread::current(),

              "AHA!  Tell Dave D if you see this...");

    set_zero_fill_complete();

    // gclog_or_tty->print_cr("Did sync ZF.");

    ConcurrentZFThread::note_sync_zfs();

    break;

  case HeapRegion::ZeroFilling:

    if (should_ignore_zf) {

      // We can "break" the lock and take over the work.

      Copy::fill_to_words(bottom(), capacity()/HeapWordSize);

      set_zero_fill_complete();

      ConcurrentZFThread::note_sync_zfs();

      break;

    } else {

      ConcurrentZFThread::wait_for_ZF_completed(this);

    }

  case HeapRegion::ZeroFilled:

    // Nothing to do.

    break;

  case HeapRegion::Allocated:

    guarantee(false, "Should not call on allocated regions.");

  }

  assert(zero_fill_state() == HeapRegion::ZeroFilled, "Post");

}

HeapWord*