/*

 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.

 * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/symbolTable.hpp"

#include "gc_implementation/g1/concurrentMark.inline.hpp"

#include "gc_implementation/g1/concurrentMarkThread.inline.hpp"

#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"

#include "gc_implementation/g1/g1CollectorPolicy.hpp"

#include "gc_implementation/g1/g1ErgoVerbose.hpp"

#include "gc_implementation/g1/g1OopClosures.inline.hpp"

#include "gc_implementation/g1/g1RemSet.hpp"

#include "gc_implementation/g1/heapRegion.inline.hpp"

#include "gc_implementation/g1/heapRegionRemSet.hpp"

#include "gc_implementation/g1/heapRegionSeq.inline.hpp"

#include "gc_implementation/shared/vmGCOperations.hpp"

#include "memory/genOopClosures.inline.hpp"

#include "memory/referencePolicy.hpp"

#include "memory/resourceArea.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/java.hpp"

// Concurrent marking bit map wrapper

CMBitMapRO::CMBitMapRO(ReservedSpace rs, int shifter) :

  _bm((uintptr_t*)NULL,0),

  _shifter(shifter) {

  _bmStartWord = (HeapWord*)(rs.base());

  _bmWordSize  = rs.size()/HeapWordSize;    // rs.size() is in bytes

  ReservedSpace brs(ReservedSpace::allocation_align_size_up(

                     (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1));

  guarantee(brs.is_reserved(), "couldn't allocate concurrent marking bit map");

  // For now we'll just commit all of the bit map up fromt.

  // Later on we'll try to be more parsimonious with swap.

  guarantee(_virtual_space.initialize(brs, brs.size()),

            "couldn't reseve backing store for concurrent marking bit map");

  assert(_virtual_space.committed_size() == brs.size(),

         "didn't reserve backing store for all of concurrent marking bit map?");

  _bm.set_map((uintptr_t*)_virtual_space.low());

  assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >=

         _bmWordSize, "inconsistency in bit map sizing");

  _bm.set_size(_bmWordSize >> _shifter);

}

HeapWord* CMBitMapRO::getNextMarkedWordAddress(HeapWord* addr,

                                               HeapWord* limit) const {

  // First we must round addr *up* to a possible object boundary.

  addr = (HeapWord*)align_size_up((intptr_t)addr,

                                  HeapWordSize << _shifter);

  size_t addrOffset = heapWordToOffset(addr);

  if (limit == NULL) {

    limit = _bmStartWord + _bmWordSize;

  }

  size_t limitOffset = heapWordToOffset(limit);

  size_t nextOffset = _bm.get_next_one_offset(addrOffset, limitOffset);

  HeapWord* nextAddr = offsetToHeapWord(nextOffset);

  assert(nextAddr >= addr, "get_next_one postcondition");

  assert(nextAddr == limit || isMarked(nextAddr),

         "get_next_one postcondition");

  return nextAddr;

}

HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(HeapWord* addr,

                                                 HeapWord* limit) const {

  size_t addrOffset = heapWordToOffset(addr);

  if (limit == NULL) {

    limit = _bmStartWord + _bmWordSize;

  }

  size_t limitOffset = heapWordToOffset(limit);

  size_t nextOffset = _bm.get_next_zero_offset(addrOffset, limitOffset);

  HeapWord* nextAddr = offsetToHeapWord(nextOffset);

  assert(nextAddr >= addr, "get_next_one postcondition");

  assert(nextAddr == limit || !isMarked(nextAddr),

         "get_next_one postcondition");

  return nextAddr;

}

int CMBitMapRO::heapWordDiffToOffsetDiff(size_t diff) const {

  assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");

  return (int) (diff >> _shifter);

}

#ifndef PRODUCT

bool CMBitMapRO::covers(ReservedSpace rs) const {

  // assert(_bm.map() == _virtual_space.low(), "map inconsistency");

  assert(((size_t)_bm.size() * (size_t)(1 << _shifter)) == _bmWordSize,

         "size inconsistency");

  return _bmStartWord == (HeapWord*)(rs.base()) &&

         _bmWordSize  == rs.size()>>LogHeapWordSize;

}

#endif

void CMBitMap::clearAll() {

  _bm.clear();

  return;

}

void CMBitMap::markRange(MemRegion mr) {

  mr.intersection(MemRegion(_bmStartWord, _bmWordSize));

  assert(!mr.is_empty(), "unexpected empty region");

  assert((offsetToHeapWord(heapWordToOffset(mr.end())) ==

          ((HeapWord *) mr.end())),

         "markRange memory region end is not card aligned");

  // convert address range into offset range

  _bm.at_put_range(heapWordToOffset(mr.start()),

                   heapWordToOffset(mr.end()), true);

}

void CMBitMap::clearRange(MemRegion mr) {

  mr.intersection(MemRegion(_bmStartWord, _bmWordSize));

  assert(!mr.is_empty(), "unexpected empty region");

  // convert address range into offset range

  _bm.at_put_range(heapWordToOffset(mr.start()),

                   heapWordToOffset(mr.end()), false);

}

MemRegion CMBitMap::getAndClearMarkedRegion(HeapWord* addr,

                                            HeapWord* end_addr) {

  HeapWord* start = getNextMarkedWordAddress(addr);

  start = MIN2(start, end_addr);

  HeapWord* end   = getNextUnmarkedWordAddress(start);

  end = MIN2(end, end_addr);

  assert(start <= end, "Consistency check");

  MemRegion mr(start, end);

  if (!mr.is_empty()) {

    clearRange(mr);

  }

  return mr;

}

CMMarkStack::CMMarkStack(ConcurrentMark* cm) :

  _base(NULL), _cm(cm)

#ifdef ASSERT

  , _drain_in_progress(false)

  , _drain_in_progress_yields(false)

#endif

{}

void CMMarkStack::allocate(size_t size) {

  _base = NEW_C_HEAP_ARRAY(oop, size);

  if (_base == NULL) {

    vm_exit_during_initialization("Failed to allocate CM region mark stack");

  }

  _index = 0;

  _capacity = (jint) size;

  _saved_index = -1;

  NOT_PRODUCT(_max_depth = 0);

}

CMMarkStack::~CMMarkStack() {

  if (_base != NULL) {

    FREE_C_HEAP_ARRAY(oop, _base);

  }

}

void CMMarkStack::par_push(oop ptr) {

  while (true) {

    if (isFull()) {

      _overflow = true;

      return;

    }

    // Otherwise...

    jint index = _index;

    jint next_index = index+1;

    jint res = Atomic::cmpxchg(next_index, &_index, index);

    if (res == index) {

      _base[index] = ptr;

      // Note that we don't maintain this atomically.  We could, but it

      // doesn't seem necessary.

      NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));

      return;

    }

    // Otherwise, we need to try again.

  }

}

void CMMarkStack::par_adjoin_arr(oop* ptr_arr, int n) {

  while (true) {

    if (isFull()) {

      _overflow = true;

      return;

    }

    // Otherwise...

    jint index = _index;

    jint next_index = index + n;

    if (next_index > _capacity) {

      _overflow = true;

      return;

    }

    jint res = Atomic::cmpxchg(next_index, &_index, index);

    if (res == index) {

      for (int i = 0; i < n; i++) {

        int ind = index + i;

        assert(ind < _capacity, "By overflow test above.");

        _base[ind] = ptr_arr[i];

      }

      NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));

      return;

    }

    // Otherwise, we need to try again.

  }

}

void CMMarkStack::par_push_arr(oop* ptr_arr, int n) {

  MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);

  jint start = _index;

  jint next_index = start + n;

  if (next_index > _capacity) {

    _overflow = true;

    return;

  }

  // Otherwise.

  _index = next_index;

  for (int i = 0; i < n; i++) {

    int ind = start + i;

    assert(ind < _capacity, "By overflow test above.");

    _base[ind] = ptr_arr[i];

  }

}

bool CMMarkStack::par_pop_arr(oop* ptr_arr, int max, int* n) {

  MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);

  jint index = _index;

  if (index == 0) {

    *n = 0;

    return false;

  } else {

    int k = MIN2(max, index);

    jint new_ind = index - k;

    for (int j = 0; j < k; j++) {

      ptr_arr[j] = _base[new_ind + j];

    }

    _index = new_ind;

    *n = k;

    return true;

  }

}

template<class OopClosureClass>

bool CMMarkStack::drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after) {

  assert(!_drain_in_progress || !_drain_in_progress_yields || yield_after

         || SafepointSynchronize::is_at_safepoint(),

         "Drain recursion must be yield-safe.");

  bool res = true;

  debug_only(_drain_in_progress = true);

  debug_only(_drain_in_progress_yields = yield_after);

  while (!isEmpty()) {

    oop newOop = pop();

    assert(G1CollectedHeap::heap()->is_in_reserved(newOop), "Bad pop");

    assert(newOop->is_oop(), "Expected an oop");

    assert(bm == NULL || bm->isMarked((HeapWord*)newOop),

           "only grey objects on this stack");

    newOop->oop_iterate(cl);

    if (yield_after && _cm->do_yield_check()) {

      res = false;

      break;

    }

  }

  debug_only(_drain_in_progress = false);

  return res;

}

void CMMarkStack::note_start_of_gc() {

  assert(_saved_index == -1,

         "note_start_of_gc()/end_of_gc() bracketed incorrectly");

  _saved_index = _index;

}

void CMMarkStack::note_end_of_gc() {

  // This is intentionally a guarantee, instead of an assert. If we

  // accidentally add something to the mark stack during GC, it

  // will be a correctness issue so it's better if we crash. we'll

  // only check this once per GC anyway, so it won't be a performance

  // issue in any way.

  guarantee(_saved_index == _index,

            err_msg("saved index: %d index: %d", _saved_index, _index));

  _saved_index = -1;

}

void CMMarkStack::oops_do(OopClosure* f) {

  assert(_saved_index == _index,

         err_msg("saved index: %d index: %d", _saved_index, _index));

  for (int i = 0; i < _index; i += 1) {

    f->do_oop(&_base[i]);

  }

}

bool ConcurrentMark::not_yet_marked(oop obj) const {

  return (_g1h->is_obj_ill(obj)

          || (_g1h->is_in_permanent(obj)

              && !nextMarkBitMap()->isMarked((HeapWord*)obj)));

}

CMRootRegions::CMRootRegions() :

  _young_list(NULL), _cm(NULL), _scan_in_progress(false),

  _should_abort(false),  _next_survivor(NULL) { }

void CMRootRegions::init(G1CollectedHeap* g1h, ConcurrentMark* cm) {

  _young_list = g1h->young_list();

  _cm = cm;

}

void CMRootRegions::prepare_for_scan() {

  assert(!scan_in_progress(), "pre-condition");

  // Currently, only survivors can be root regions.

  assert(_next_survivor == NULL, "pre-condition");

  _next_survivor = _young_list->first_survivor_region();

  _scan_in_progress = (_next_survivor != NULL);

  _should_abort = false;

}

HeapRegion* CMRootRegions::claim_next() {

  if (_should_abort) {

    // If someone has set the should_abort flag, we return NULL to

    // force the caller to bail out of their loop.

    return NULL;

  }

  // Currently, only survivors can be root regions.

  HeapRegion* res = _next_survivor;

  if (res != NULL) {

    MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);

    // Read it again in case it changed while we were waiting for the lock.

    res = _next_survivor;

    if (res != NULL) {

      if (res == _young_list->last_survivor_region()) {

        // We just claimed the last survivor so store NULL to indicate

        // that we're done.

        _next_survivor = NULL;

      } else {

        _next_survivor = res->get_next_young_region();

      }

    } else {

      // Someone else claimed the last survivor while we were trying

      // to take the lock so nothing else to do.

    }

  }

  assert(res == NULL || res->is_survivor(), "post-condition");

  return res;

}

void CMRootRegions::scan_finished() {

  assert(scan_in_progress(), "pre-condition");

  // Currently, only survivors can be root regions.

  if (!_should_abort) {

    assert(_next_survivor == NULL, "we should have claimed all survivors");

  }

  _next_survivor = NULL;

  {

    MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);

    _scan_in_progress = false;

    RootRegionScan_lock->notify_all();

  }

}

bool CMRootRegions::wait_until_scan_finished() {

  if (!scan_in_progress()) return false;

  {

    MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);

    while (scan_in_progress()) {

      RootRegionScan_lock->wait(Mutex::_no_safepoint_check_flag);

    }

  }

  return true;

}

#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

uint ConcurrentMark::scale_parallel_threads(uint n_par_threads) {

  return MAX2((n_par_threads + 2) / 4, 1U);

}

ConcurrentMark::ConcurrentMark(ReservedSpace rs,

                               int max_regions) :

  _markBitMap1(rs, MinObjAlignment - 1),

  _markBitMap2(rs, MinObjAlignment - 1),

  _parallel_marking_threads(0),

  _max_parallel_marking_threads(0),

  _sleep_factor(0.0),

  _marking_task_overhead(1.0),

  _cleanup_sleep_factor(0.0),

  _cleanup_task_overhead(1.0),

  _cleanup_list("Cleanup List"),

  _region_bm(max_regions, false /* in_resource_area*/),

  _card_bm((rs.size() + CardTableModRefBS::card_size - 1) >>

           CardTableModRefBS::card_shift,

           false /* in_resource_area*/),

  _prevMarkBitMap(&_markBitMap1),

  _nextMarkBitMap(&_markBitMap2),

  _markStack(this),

  // _finger set in set_non_marking_state

  _max_task_num(MAX2((uint)ParallelGCThreads, 1U)),

  // _active_tasks set in set_non_marking_state

  // _tasks set inside the constructor

  _task_queues(new CMTaskQueueSet((int) _max_task_num)),

  _terminator(ParallelTaskTerminator((int) _max_task_num, _task_queues)),

  _has_overflown(false),

  _concurrent(false),

  _has_aborted(false),

  _restart_for_overflow(false),

  _concurrent_marking_in_progress(false),

  // _verbose_level set below

  _init_times(),

  _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),

  _cleanup_times(),

  _total_counting_time(0.0),

  _total_rs_scrub_time(0.0),

  _parallel_workers(NULL),

  _count_card_bitmaps(NULL),

  _count_marked_bytes(NULL) {

  CMVerboseLevel verbose_level = (CMVerboseLevel) G1MarkingVerboseLevel;

  if (verbose_level < no_verbose) {

    verbose_level = no_verbose;

  }

  if (verbose_level > high_verbose) {

    verbose_level = high_verbose;

  }

  _verbose_level = verbose_level;

  if (verbose_low()) {

    gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", "

                           "heap end = "PTR_FORMAT, _heap_start, _heap_end);

  }

  _markStack.allocate(MarkStackSize);

  // Create & start a ConcurrentMark thread.

  _cmThread = new ConcurrentMarkThread(this);

  assert(cmThread() != NULL, "CM Thread should have been created");

  assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm");

  _g1h = G1CollectedHeap::heap();

  assert(CGC_lock != NULL, "Where's the CGC_lock?");

  assert(_markBitMap1.covers(rs), "_markBitMap1 inconsistency");

  assert(_markBitMap2.covers(rs), "_markBitMap2 inconsistency");

  SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();

  satb_qs.set_buffer_size(G1SATBBufferSize);

  _root_regions.init(_g1h, this);

  _tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_task_num);

  _accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_task_num);

  _count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap,  _max_task_num);

  _count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_task_num);

  BitMap::idx_t card_bm_size = _card_bm.size();

  // so that the assertion in MarkingTaskQueue::task_queue doesn't fail

  _active_tasks = _max_task_num;

  for (int i = 0; i < (int) _max_task_num; ++i) {

    CMTaskQueue* task_queue = new CMTaskQueue();

    task_queue->initialize();

    _task_queues->register_queue(i, task_queue);

    _count_card_bitmaps[i] = BitMap(card_bm_size, false);

    _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, max_regions);

    _tasks[i] = new CMTask(i, this,

                           _count_marked_bytes[i],

                           &_count_card_bitmaps[i],

                           task_queue, _task_queues);

    _accum_task_vtime[i] = 0.0;

  }

  // Calculate the card number for the bottom of the heap. Used