/*

 * Copyright (c) 2001, 2017, 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/metadataOnStackMark.hpp"

#include "classfile/symbolTable.hpp"

#include "code/codeCache.hpp"

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

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

#include "gc/g1/g1CollectorState.hpp"

#include "gc/g1/g1ConcurrentMark.inline.hpp"

#include "gc/g1/g1HeapVerifier.hpp"

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

#include "gc/g1/g1CardLiveData.inline.hpp"

#include "gc/g1/g1Policy.hpp"

#include "gc/g1/g1StringDedup.hpp"

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

#include "gc/g1/heapRegionRemSet.hpp"

#include "gc/g1/heapRegionSet.inline.hpp"

#include "gc/g1/suspendibleThreadSet.hpp"

#include "gc/shared/gcId.hpp"

#include "gc/shared/gcTimer.hpp"

#include "gc/shared/gcTrace.hpp"

#include "gc/shared/gcTraceTime.inline.hpp"

#include "gc/shared/genOopClosures.inline.hpp"

#include "gc/shared/referencePolicy.hpp"

#include "gc/shared/strongRootsScope.hpp"

#include "gc/shared/taskqueue.inline.hpp"

#include "gc/shared/vmGCOperations.hpp"

#include "logging/log.hpp"

#include "memory/allocation.hpp"

#include "memory/resourceArea.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/atomic.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/prefetch.inline.hpp"

#include "services/memTracker.hpp"

#include "utilities/growableArray.hpp"

// Concurrent marking bit map wrapper

G1CMBitMapRO::G1CMBitMapRO(int shifter) :

  _bm(),

  _shifter(shifter) {

  _bmStartWord = 0;

  _bmWordSize = 0;

}

HeapWord* G1CMBitMapRO::getNextMarkedWordAddress(const HeapWord* addr,

                                                 const HeapWord* limit) const {

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

  addr = align_up(addr, HeapWordSize << _shifter);

  size_t addrOffset = heapWordToOffset(addr);

  assert(limit != NULL, "limit must not be NULL");

  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;

}

#ifndef PRODUCT

bool G1CMBitMapRO::covers(MemRegion heap_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*)(heap_rs.start()) &&

         _bmWordSize  == heap_rs.word_size();

}

#endif

void G1CMBitMapRO::print_on_error(outputStream* st, const char* prefix) const {

  _bm.print_on_error(st, prefix);

}

size_t G1CMBitMap::compute_size(size_t heap_size) {

  return ReservedSpace::allocation_align_size_up(heap_size / mark_distance());

}

size_t G1CMBitMap::mark_distance() {

  return MinObjAlignmentInBytes * BitsPerByte;

}

void G1CMBitMap::initialize(MemRegion heap, G1RegionToSpaceMapper* storage) {

  _bmStartWord = heap.start();

  _bmWordSize = heap.word_size();

  _bm = BitMapView((BitMap::bm_word_t*) storage->reserved().start(), _bmWordSize >> _shifter);

  storage->set_mapping_changed_listener(&_listener);

}

void G1CMBitMapMappingChangedListener::on_commit(uint start_region, size_t num_regions, bool zero_filled) {

  if (zero_filled) {

    return;

  }

  // We need to clear the bitmap on commit, removing any existing information.

  MemRegion mr(G1CollectedHeap::heap()->bottom_addr_for_region(start_region), num_regions * HeapRegion::GrainWords);

  _bm->clear_range(mr);

}

void G1CMBitMap::clear_range(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);

}

G1CMMarkStack::G1CMMarkStack() :

  _max_chunk_capacity(0),

  _base(NULL),

  _chunk_capacity(0) {

  set_empty();

}

bool G1CMMarkStack::resize(size_t new_capacity) {

  assert(is_empty(), "Only resize when stack is empty.");

  assert(new_capacity <= _max_chunk_capacity,

         "Trying to resize stack to " SIZE_FORMAT " chunks when the maximum is " SIZE_FORMAT, new_capacity, _max_chunk_capacity);

  TaskQueueEntryChunk* new_base = MmapArrayAllocator<TaskQueueEntryChunk, mtGC>::allocate_or_null(new_capacity);

  if (new_base == NULL) {

    log_warning(gc)("Failed to reserve memory for new overflow mark stack with " SIZE_FORMAT " chunks and size " SIZE_FORMAT "B.", new_capacity, new_capacity * sizeof(TaskQueueEntryChunk));

    return false;

  }

  // Release old mapping.

  if (_base != NULL) {

    MmapArrayAllocator<TaskQueueEntryChunk, mtGC>::free(_base, _chunk_capacity);

  }

  _base = new_base;

  _chunk_capacity = new_capacity;

  set_empty();

  return true;

}

size_t G1CMMarkStack::capacity_alignment() {

  return (size_t)lcm(os::vm_allocation_granularity(), sizeof(TaskQueueEntryChunk)) / sizeof(G1TaskQueueEntry);

}

bool G1CMMarkStack::initialize(size_t initial_capacity, size_t max_capacity) {

  guarantee(_max_chunk_capacity == 0, "G1CMMarkStack already initialized.");

  size_t const TaskEntryChunkSizeInVoidStar = sizeof(TaskQueueEntryChunk) / sizeof(G1TaskQueueEntry);

  _max_chunk_capacity = align_up(max_capacity, capacity_alignment()) / TaskEntryChunkSizeInVoidStar;

  size_t initial_chunk_capacity = align_up(initial_capacity, capacity_alignment()) / TaskEntryChunkSizeInVoidStar;

  guarantee(initial_chunk_capacity <= _max_chunk_capacity,

            "Maximum chunk capacity " SIZE_FORMAT " smaller than initial capacity " SIZE_FORMAT,

            _max_chunk_capacity,

            initial_chunk_capacity);

  log_debug(gc)("Initialize mark stack with " SIZE_FORMAT " chunks, maximum " SIZE_FORMAT,

                initial_chunk_capacity, _max_chunk_capacity);

  return resize(initial_chunk_capacity);

}

void G1CMMarkStack::expand() {

  if (_chunk_capacity == _max_chunk_capacity) {

    log_debug(gc)("Can not expand overflow mark stack further, already at maximum capacity of " SIZE_FORMAT " chunks.", _chunk_capacity);

    return;

  }

  size_t old_capacity = _chunk_capacity;

  // Double capacity if possible

  size_t new_capacity = MIN2(old_capacity * 2, _max_chunk_capacity);

  if (resize(new_capacity)) {

    log_debug(gc)("Expanded mark stack capacity from " SIZE_FORMAT " to " SIZE_FORMAT " chunks",

                  old_capacity, new_capacity);

  } else {

    log_warning(gc)("Failed to expand mark stack capacity from " SIZE_FORMAT " to " SIZE_FORMAT " chunks",

                    old_capacity, new_capacity);

  }

}

G1CMMarkStack::~G1CMMarkStack() {

  if (_base != NULL) {

    MmapArrayAllocator<TaskQueueEntryChunk, mtGC>::free(_base, _chunk_capacity);

  }

}

void G1CMMarkStack::add_chunk_to_list(TaskQueueEntryChunk* volatile* list, TaskQueueEntryChunk* elem) {

  elem->next = *list;

  *list = elem;

}

void G1CMMarkStack::add_chunk_to_chunk_list(TaskQueueEntryChunk* elem) {

  MutexLockerEx x(MarkStackChunkList_lock, Mutex::_no_safepoint_check_flag);

  add_chunk_to_list(&_chunk_list, elem);

  _chunks_in_chunk_list++;

}

void G1CMMarkStack::add_chunk_to_free_list(TaskQueueEntryChunk* elem) {

  MutexLockerEx x(MarkStackFreeList_lock, Mutex::_no_safepoint_check_flag);

  add_chunk_to_list(&_free_list, elem);

}

G1CMMarkStack::TaskQueueEntryChunk* G1CMMarkStack::remove_chunk_from_list(TaskQueueEntryChunk* volatile* list) {

  TaskQueueEntryChunk* result = *list;

  if (result != NULL) {

    *list = (*list)->next;

  }

  return result;

}

G1CMMarkStack::TaskQueueEntryChunk* G1CMMarkStack::remove_chunk_from_chunk_list() {

  MutexLockerEx x(MarkStackChunkList_lock, Mutex::_no_safepoint_check_flag);

  TaskQueueEntryChunk* result = remove_chunk_from_list(&_chunk_list);

  if (result != NULL) {

    _chunks_in_chunk_list--;

  }

  return result;

}

G1CMMarkStack::TaskQueueEntryChunk* G1CMMarkStack::remove_chunk_from_free_list() {

  MutexLockerEx x(MarkStackFreeList_lock, Mutex::_no_safepoint_check_flag);

  return remove_chunk_from_list(&_free_list);

}

G1CMMarkStack::TaskQueueEntryChunk* G1CMMarkStack::allocate_new_chunk() {

  // This dirty read of _hwm is okay because we only ever increase the _hwm in parallel code.

  // Further this limits _hwm to a value of _chunk_capacity + #threads, avoiding

  // wraparound of _hwm.

  if (_hwm >= _chunk_capacity) {

    return NULL;

  }

  size_t cur_idx = Atomic::add(1, &_hwm) - 1;

  if (cur_idx >= _chunk_capacity) {

    return NULL;

  }

  TaskQueueEntryChunk* result = ::new (&_base[cur_idx]) TaskQueueEntryChunk;

  result->next = NULL;

  return result;

}

bool G1CMMarkStack::par_push_chunk(G1TaskQueueEntry* ptr_arr) {

  // Get a new chunk.

  TaskQueueEntryChunk* new_chunk = remove_chunk_from_free_list();

  if (new_chunk == NULL) {

    // Did not get a chunk from the free list. Allocate from backing memory.

    new_chunk = allocate_new_chunk();

    if (new_chunk == NULL) {

      return false;

    }

  }

  Copy::conjoint_memory_atomic(ptr_arr, new_chunk->data, EntriesPerChunk * sizeof(G1TaskQueueEntry));

  add_chunk_to_chunk_list(new_chunk);

  return true;

}

bool G1CMMarkStack::par_pop_chunk(G1TaskQueueEntry* ptr_arr) {

  TaskQueueEntryChunk* cur = remove_chunk_from_chunk_list();

  if (cur == NULL) {

    return false;

  }

  Copy::conjoint_memory_atomic(cur->data, ptr_arr, EntriesPerChunk * sizeof(G1TaskQueueEntry));

  add_chunk_to_free_list(cur);

  return true;

}

void G1CMMarkStack::set_empty() {

  _chunks_in_chunk_list = 0;

  _hwm = 0;

  _chunk_list = NULL;

  _free_list = NULL;

}

G1CMRootRegions::G1CMRootRegions() :

  _cm(NULL), _scan_in_progress(false),

  _should_abort(false), _claimed_survivor_index(0) { }

void G1CMRootRegions::init(const G1SurvivorRegions* survivors, G1ConcurrentMark* cm) {

  _survivors = survivors;

  _cm = cm;

}

void G1CMRootRegions::prepare_for_scan() {

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

  // Currently, only survivors can be root regions.

  _claimed_survivor_index = 0;

  _scan_in_progress = _survivors->regions()->is_nonempty();

  _should_abort = false;

}

HeapRegion* G1CMRootRegions::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.

  const GrowableArray<HeapRegion*>* survivor_regions = _survivors->regions();

  int claimed_index = Atomic::add(1, &_claimed_survivor_index) - 1;

  if (claimed_index < survivor_regions->length()) {

    return survivor_regions->at(claimed_index);

  }

  return NULL;

}

uint G1CMRootRegions::num_root_regions() const {

  return (uint)_survivors->regions()->length();

}

void G1CMRootRegions::notify_scan_done() {

  MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);

  _scan_in_progress = false;

  RootRegionScan_lock->notify_all();

}

void G1CMRootRegions::cancel_scan() {

  notify_scan_done();

}

void G1CMRootRegions::scan_finished() {

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

  // Currently, only survivors can be root regions.

  if (!_should_abort) {

    assert(_claimed_survivor_index >= 0, "otherwise comparison is invalid: %d", _claimed_survivor_index);

    assert((uint)_claimed_survivor_index >= _survivors->length(),

           "we should have claimed all survivors, claimed index = %u, length = %u",

           (uint)_claimed_survivor_index, _survivors->length());

  }

  notify_scan_done();

}

bool G1CMRootRegions::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;

}

uint G1ConcurrentMark::scale_parallel_threads(uint n_par_threads) {

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

}

G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h, G1RegionToSpaceMapper* prev_bitmap_storage, G1RegionToSpaceMapper* next_bitmap_storage) :

  _g1h(g1h),

  _markBitMap1(),

  _markBitMap2(),

  _parallel_marking_threads(0),

  _max_parallel_marking_threads(0),

  _sleep_factor(0.0),

  _marking_task_overhead(1.0),

  _cleanup_list("Cleanup List"),

  _prevMarkBitMap(&_markBitMap1),

  _nextMarkBitMap(&_markBitMap2),

  _global_mark_stack(),

  // _finger set in set_non_marking_state

  _max_worker_id(ParallelGCThreads),

  // _active_tasks set in set_non_marking_state

  // _tasks set inside the constructor

  _task_queues(new G1CMTaskQueueSet((int) _max_worker_id)),

  _terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)),

  _has_overflown(false),

  _concurrent(false),

  _has_aborted(false),

  _restart_for_overflow(false),

  _concurrent_marking_in_progress(false),

  _gc_timer_cm(new (ResourceObj::C_HEAP, mtGC) ConcurrentGCTimer()),

  _gc_tracer_cm(new (ResourceObj::C_HEAP, mtGC) G1OldTracer()),

  // _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),

  _completed_initialization(false) {

  _markBitMap1.initialize(g1h->reserved_region(), prev_bitmap_storage);

  _markBitMap2.initialize(g1h->reserved_region(), next_bitmap_storage);

  // 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");

  if (_cmThread->osthread() == NULL) {

      vm_shutdown_during_initialization("Could not create ConcurrentMarkThread");

  }

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

  assert(_markBitMap1.covers(g1h->reserved_region()), "_markBitMap1 inconsistency");

  assert(_markBitMap2.covers(g1h->reserved_region()), "_markBitMap2 inconsistency");

  SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();

  satb_qs.set_buffer_size(G1SATBBufferSize);

  _root_regions.init(_g1h->survivor(), this);

  if (ConcGCThreads > ParallelGCThreads) {

    log_warning(gc)("Can't have more ConcGCThreads (%u) than ParallelGCThreads (%u).",

                    ConcGCThreads, ParallelGCThreads);

    return;

  }

  if (!FLAG_IS_DEFAULT(ConcGCThreads) && ConcGCThreads > 0) {

    // Note: ConcGCThreads has precedence over G1MarkingOverheadPercent

    // if both are set

    _sleep_factor             = 0.0;

    _marking_task_overhead    = 1.0;

  } else if (G1MarkingOverheadPercent > 0) {

    // We will calculate the number of parallel marking threads based

    // on a target overhead with respect to the soft real-time goal

    double marking_overhead = (double) G1MarkingOverheadPercent / 100.0;

    double overall_cm_overhead =

      (double) MaxGCPauseMillis * marking_overhead /

      (double) GCPauseIntervalMillis;

    double cpu_ratio = 1.0 / os::initial_active_processor_count();

    double marking_thread_num = ceil(overall_cm_overhead / cpu_ratio);

    double marking_task_overhead =

      overall_cm_overhead / marking_thread_num * os::initial_active_processor_count();

    double sleep_factor =

                       (1.0 - marking_task_overhead) / marking_task_overhead;

    FLAG_SET_ERGO(uint, ConcGCThreads, (uint) marking_thread_num);

    _sleep_factor             = sleep_factor;

    _marking_task_overhead    = marking_task_overhead;

  } else {

    // Calculate the number of parallel marking threads by scaling

    // the number of parallel GC threads.

    uint marking_thread_num = scale_parallel_threads(ParallelGCThreads);

    FLAG_SET_ERGO(uint, ConcGCThreads, marking_thread_num);

    _sleep_factor             = 0.0;

    _marking_task_overhead    = 1.0;

  }

  assert(ConcGCThreads > 0, "Should have been set");

  log_debug(gc)("ConcGCThreads: %u", ConcGCThreads);

  log_debug(gc)("ParallelGCThreads: %u", ParallelGCThreads);