/*

 * Copyright (c) 2001, 2016, 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 "gc/g1/concurrentG1Refine.hpp"

#include "gc/g1/concurrentG1RefineThread.hpp"

#include "gc/g1/dirtyCardQueue.hpp"

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

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

#include "gc/g1/g1FromCardCache.hpp"

#include "gc/g1/g1GCPhaseTimes.hpp"

#include "gc/g1/g1HotCardCache.hpp"

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

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

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

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

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

#include "gc/g1/heapRegionRemSet.hpp"

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

#include "memory/iterator.hpp"

#include "memory/resourceArea.hpp"

#include "oops/oop.inline.hpp"

#include "utilities/globalDefinitions.hpp"

#include "utilities/intHisto.hpp"

#include "utilities/stack.inline.hpp"

G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) :

  _g1(g1),

  _conc_refine_cards(0),

  _ct_bs(ct_bs),

  _g1p(_g1->g1_policy()),

  _cg1r(g1->concurrent_g1_refine()),

  _prev_period_summary(),

  _into_cset_dirty_card_queue_set(false)

{

  if (log_is_enabled(Trace, gc, remset)) {

    _prev_period_summary.initialize(this);

  }

  // Initialize the card queue set used to hold cards containing

  // references into the collection set.

  _into_cset_dirty_card_queue_set.initialize(NULL, // Should never be called by the Java code

                                             DirtyCardQ_CBL_mon,

                                             DirtyCardQ_FL_lock,

                                             -1, // never trigger processing

                                             -1, // no limit on length

                                             Shared_DirtyCardQ_lock,

                                             &JavaThread::dirty_card_queue_set());

}

G1RemSet::~G1RemSet() {

  }

}

uint G1RemSet::num_par_rem_sets() {

  return MAX2(DirtyCardQueueSet::num_par_ids() + ConcurrentG1Refine::thread_num(), ParallelGCThreads);

}

void G1RemSet::initialize(size_t capacity, uint max_regions) {

  G1FromCardCache::initialize(num_par_rem_sets(), max_regions);

  {

    GCTraceTime(Debug, gc, marking)("Initialize Card Live Data");

    _card_live_data.initialize(capacity, max_regions);

  }

  if (G1PretouchAuxiliaryMemory) {

    GCTraceTime(Debug, gc, marking)("Pre-Touch Card Live Data");

    _card_live_data.pretouch();

  }

}

  _code_root_cl(code_root_cl),

  _strong_code_root_scan_time_sec(0.0),

  _cards(0),

  _cards_done(0),

  _g1h = G1CollectedHeap::heap();

  _bot = _g1h->bot();

  _ct_bs = _g1h->g1_barrier_set();

  _block_size = MAX2<size_t>(G1RSetScanBlockSize, 1);

}

  // Stack allocate the DirtyCardToOopClosure instance

  // Set the "from" region in the closure.

  MemRegion card_region(_bot->address_for_index(index), BOTConstants::N_words);

  MemRegion pre_gc_allocated(r->bottom(), r->scan_top());

  MemRegion mr = pre_gc_allocated.intersection(card_region);

  if (!mr.is_empty() && !_ct_bs->is_card_claimed(index)) {

    // We make the card as "claimed" lazily (so races are possible

    // but they're benign), which reduces the number of duplicate

    // scans (the rsets of the regions in the cset can intersect).

    _ct_bs->set_card_claimed(index);

    _cards_done++;

    cl.do_MemRegion(mr);

  }

}

  double scan_start = os::elapsedTime();

  r->strong_code_roots_do(_code_root_cl);

  _strong_code_root_scan_time_sec += (os::elapsedTime() - scan_start);

}

  assert(r->in_collection_set(), "should only be called on elements of CS.");

  size_t card_index;

  // We claim cards in block so as to reduce the contention. The block size is determined by

  // the G1RSetScanBlockSize parameter.

  for (size_t current_card = 0; iter.has_next(card_index); current_card++) {

    }

    HeapWord* card_start = _g1h->bot()->address_for_index(card_index);

    HeapRegion* card_region = _g1h->heap_region_containing(card_start);

    _cards++;

    if (!card_region->is_on_dirty_cards_region_list()) {

      _g1h->push_dirty_cards_region(card_region);

    }

    // If the card is dirty, then we will scan it during updateRS.

    if (!card_region->in_collection_set() &&

        !_ct_bs->is_card_dirty(card_index)) {

    }

  }

    // Scan the strong code root list attached to the current region

    scan_strong_code_roots(r);

  }

  return false;

}

  double rs_time_start = os::elapsedTime();

  HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i);

  _g1p->phase_times()->record_time_secs(G1GCPhaseTimes::ScanRS, worker_i, scan_rs_time_sec);

}

// Closure used for updating RSets and recording references that

// point into the collection set. Only called during an

// evacuation pause.

class RefineRecordRefsIntoCSCardTableEntryClosure: public CardTableEntryClosure {

  G1RemSet* _g1rs;

  DirtyCardQueue* _into_cset_dcq;

public:

  RefineRecordRefsIntoCSCardTableEntryClosure(G1CollectedHeap* g1h,

  {}

  bool do_card_ptr(jbyte* card_ptr, uint worker_i) {

    // The only time we care about recording cards that

    // contain references that point into the collection set

    // is during RSet updating within an evacuation pause.

    // In this case worker_i should be the id of a GC worker thread.

    assert(SafepointSynchronize::is_at_safepoint(), "not during an evacuation pause");

    assert(worker_i < ParallelGCThreads, "should be a GC worker");

      // 'card_ptr' contains references that point into the collection

      // set. We need to record the card in the DCQS

      // (_into_cset_dirty_card_queue_set)

      // that's used for that purpose.

      //

      // Enqueue the card

      _into_cset_dcq->enqueue(card_ptr);

    }

    return true;

  }

};

  G1GCParPhaseTimesTracker x(_g1p->phase_times(), G1GCPhaseTimes::UpdateRS, worker_i);

  if (ConcurrentG1Refine::hot_card_cache_enabled()) {

    // Apply the closure to the entries of the hot card cache.

    G1GCParPhaseTimesTracker y(_g1p->phase_times(), G1GCPhaseTimes::ScanHCC, worker_i);

    _g1->iterate_hcc_closure(&into_cset_update_rs_cl, worker_i);

  }

  // Apply the closure to all remaining log entries.

  _g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, worker_i);

}

void G1RemSet::cleanupHRRS() {

  HeapRegionRemSet::cleanup();

}

                                             CodeBlobClosure* heap_region_codeblobs,

                                             uint worker_i) {

  // A DirtyCardQueue that is used to hold cards containing references

  // that point into the collection set. This DCQ is associated with a

  // special DirtyCardQueueSet (see g1CollectedHeap.hpp).  Under normal

  // circumstances (i.e. the pause successfully completes), these cards

  // are just discarded (there's no need to update the RSets of regions

  // that were in the collection set - after the pause these regions

  // are wholly 'free' of live objects. In the event of an evacuation

  // failure the cards/buffers in this queue set are passed to the

  // DirtyCardQueueSet that is used to manage RSet updates

  DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set);

}

void G1RemSet::prepare_for_oops_into_collection_set_do() {

  _g1->set_refine_cte_cl_concurrency(false);

  DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();

  dcqs.concatenate_logs();

}

void G1RemSet::cleanup_after_oops_into_collection_set_do() {

  // Cleanup after copy

  _g1->set_refine_cte_cl_concurrency(true);

  // Set all cards back to clean.

  _g1->cleanUpCardTable();

  DirtyCardQueueSet& into_cset_dcqs = _into_cset_dirty_card_queue_set;

  if (_g1->evacuation_failed()) {

    double restore_remembered_set_start = os::elapsedTime();

    // Restore remembered sets for the regions pointing into the collection set.

    // We just need to transfer the completed buffers from the DirtyCardQueueSet

    // used to hold cards that contain references that point into the collection set

    // to the DCQS used to hold the deferred RS updates.

    _g1->dirty_card_queue_set().merge_bufferlists(&into_cset_dcqs);

    _g1->g1_policy()->phase_times()->record_evac_fail_restore_remsets((os::elapsedTime() - restore_remembered_set_start) * 1000.0);

  }

  // Free any completed buffers in the DirtyCardQueueSet used to hold cards

  // which contain references that point into the collection.

  _into_cset_dirty_card_queue_set.clear();

  assert(_into_cset_dirty_card_queue_set.completed_buffers_num() == 0,

         "all buffers should be freed");

  _into_cset_dirty_card_queue_set.clear_n_completed_buffers();

}

class G1ScrubRSClosure: public HeapRegionClosure {

  G1CollectedHeap* _g1h;

  G1CardLiveData* _live_data;

public:

  G1ScrubRSClosure(G1CardLiveData* live_data) :

    _g1h(G1CollectedHeap::heap()),

    _live_data(live_data) { }

  bool doHeapRegion(HeapRegion* r) {

    if (!r->is_continues_humongous()) {

      r->rem_set()->scrub(_live_data);

    }

    return false;

  }

};

void G1RemSet::scrub(uint worker_num, HeapRegionClaimer *hrclaimer) {

  G1ScrubRSClosure scrub_cl(&_card_live_data);

  _g1->heap_region_par_iterate(&scrub_cl, worker_num, hrclaimer);

}

G1TriggerClosure::G1TriggerClosure() :

  _triggered(false) { }

G1InvokeIfNotTriggeredClosure::G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t_cl,

                                                             OopClosure* oop_cl)  :

  _trigger_cl(t_cl), _oop_cl(oop_cl) { }

G1Mux2Closure::G1Mux2Closure(OopClosure *c1, OopClosure *c2) :

  _c1(c1), _c2(c2) { }

G1UpdateRSOrPushRefOopClosure::

G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h,

                              G1RemSet* rs,

                              G1ParPushHeapRSClosure* push_ref_cl,

                              bool record_refs_into_cset,

                              uint worker_i) :

  _g1(g1h), _g1_rem_set(rs), _from(NULL),

  _record_refs_into_cset(record_refs_into_cset),

  _push_ref_cl(push_ref_cl), _worker_i(worker_i) { }

// Returns true if the given card contains references that point

// into the collection set, if we're checking for such references;

// false otherwise.

  assert(_g1->is_in_exact(_ct_bs->addr_for(card_ptr)),

         "Card at " PTR_FORMAT " index " SIZE_FORMAT " representing heap at " PTR_FORMAT " (%u) must be in committed heap",

         p2i(card_ptr),

         _ct_bs->index_for(_ct_bs->addr_for(card_ptr)),

         p2i(_ct_bs->addr_for(card_ptr)),

         _g1->addr_to_region(_ct_bs->addr_for(card_ptr)));

  // If the card is no longer dirty, nothing to do.

  if (*card_ptr != CardTableModRefBS::dirty_card_val()) {

    // No need to return that this card contains refs that point

    // into the collection set.

    return false;

  }

  // Construct the region representing the card.

  HeapWord* start = _ct_bs->addr_for(card_ptr);

  // And find the region containing it.

  HeapRegion* r = _g1->heap_region_containing(start);

  // Why do we have to check here whether a card is on a young region,

  // given that we dirty young regions and, as a result, the

  // post-barrier is supposed to filter them out and never to enqueue

  // them? When we allocate a new region as the "allocation region" we

  // actually dirty its cards after we release the lock, since card

  // dirtying while holding the lock was a performance bottleneck. So,

  // as a result, it is possible for other threads to actually

  // allocate objects in the region (after the acquire the lock)

  // before all the cards on the region are dirtied. This is unlikely,

  // and it doesn't happen often, but it can happen. So, the extra

  // check below filters out those cards.

  if (r->is_young()) {

    return false;

  }

  // While we are processing RSet buffers during the collection, we