/*

 * 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/collectionSetChooser.hpp"

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

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

#include "runtime/atomic.hpp"

// Even though we don't use the GC efficiency in our heuristics as

// much as we used to, we still order according to GC efficiency. This

// will cause regions with a lot of live objects and large RSets to

// end up at the end of the array. Given that we might skip collecting

// the last few old regions, if after a few mixed GCs the remaining

// have reclaimable bytes under a certain threshold, the hope is that

// the ones we'll skip are ones with both large RSets and a lot of

// live objects, not the ones with just a lot of live objects if we

// ordered according to the amount of reclaimable bytes per region.

static int order_regions(HeapRegion* hr1, HeapRegion* hr2) {

  if (hr1 == NULL) {

    if (hr2 == NULL) {

      return 0;

    } else {

      return 1;

    }

  } else if (hr2 == NULL) {

    return -1;

  }

  double gc_eff1 = hr1->gc_efficiency();

  double gc_eff2 = hr2->gc_efficiency();

  if (gc_eff1 > gc_eff2) {

    return -1;

  } if (gc_eff1 < gc_eff2) {

    return 1;

  } else {

    return 0;

  }

}

static int order_regions(HeapRegion** hr1p, HeapRegion** hr2p) {

  return order_regions(*hr1p, *hr2p);

}

CollectionSetChooser::CollectionSetChooser() :

  // The line below is the worst bit of C++ hackery I've ever written

  // (Detlefs, 11/23).  You should think of it as equivalent to

  // "_regions(100, true)": initialize the growable array and inform it

  // that it should allocate its elem array(s) on the C heap.

  //

  // The first argument, however, is actually a comma expression

  // (set_allocation_type(this, C_HEAP), 100). The purpose of the

  // set_allocation_type() call is to replace the default allocation

  // type for embedded objects STACK_OR_EMBEDDED with C_HEAP. It will

  // allow to pass the assert in GenericGrowableArray() which checks

  // that a growable array object must be on C heap if elements are.

  //

  // Note: containing object is allocated on C heap since it is CHeapObj.

  //

  _regions((ResourceObj::set_allocation_type((address) &_regions,

                                             ResourceObj::C_HEAP),

                  100), true /* C_Heap */),

    _front(0), _end(0), _first_par_unreserved_idx(0),

    _region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) {

  _region_live_threshold_bytes =

    HeapRegion::GrainBytes * (size_t) G1MixedGCLiveThresholdPercent / 100;

}

#ifndef PRODUCT

void CollectionSetChooser::verify() {

  guarantee(_end <= regions_length(), "_end: %u regions length: %u", _end, regions_length());

  guarantee(_front <= _end, "_front: %u _end: %u", _front, _end);

  uint index = 0;

  size_t sum_of_reclaimable_bytes = 0;

  while (index < _front) {

    guarantee(regions_at(index) == NULL,

              "all entries before _front should be NULL");

    index += 1;

  }

  HeapRegion *prev = NULL;

  while (index < _end) {

    HeapRegion *curr = regions_at(index++);

    guarantee(curr != NULL, "Regions in _regions array cannot be NULL");

    guarantee(!curr->is_young(), "should not be young!");

    guarantee(!curr->is_pinned(),

              "Pinned region should not be in collection set (index %u)", curr->hrm_index());

    if (prev != NULL) {

      guarantee(order_regions(prev, curr) != 1,

                "GC eff prev: %1.4f GC eff curr: %1.4f",

                prev->gc_efficiency(), curr->gc_efficiency());

    }

    sum_of_reclaimable_bytes += curr->reclaimable_bytes();

    prev = curr;

  }

  guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes,

            "reclaimable bytes inconsistent, "

            "remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,

            _remaining_reclaimable_bytes, sum_of_reclaimable_bytes);

}

#endif // !PRODUCT

void CollectionSetChooser::sort_regions() {

  // First trim any unused portion of the top in the parallel case.

  if (_first_par_unreserved_idx > 0) {

    assert(_first_par_unreserved_idx <= regions_length(),

           "Or we didn't reserved enough length");

    regions_trunc_to(_first_par_unreserved_idx);

  }

  _regions.sort(order_regions);

  assert(_end <= regions_length(), "Requirement");

#ifdef ASSERT

  for (uint i = 0; i < _end; i++) {

    assert(regions_at(i) != NULL, "Should be true by sorting!");

  }

#endif // ASSERT

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

    G1PrintRegionLivenessInfoClosure cl("Post-Sorting");

    for (uint i = 0; i < _end; ++i) {

      HeapRegion* r = regions_at(i);

      cl.doHeapRegion(r);

    }

  }

  verify();

}

void CollectionSetChooser::add_region(HeapRegion* hr) {

  assert(!hr->is_pinned(),

         "Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index());

  assert(!hr->is_young(), "should not be young!");

  _regions.append(hr);

  _end++;

  _remaining_reclaimable_bytes += hr->reclaimable_bytes();

  hr->calc_gc_efficiency();

}

void CollectionSetChooser::push(HeapRegion* hr) {

  assert(hr != NULL, "Can't put back a NULL region");

  assert(_front >= 1, "Too many regions have been put back");

  _front--;

  regions_at_put(_front, hr);

  _remaining_reclaimable_bytes += hr->reclaimable_bytes();

}

void CollectionSetChooser::prepare_for_par_region_addition(uint n_threads,

                                                           uint n_regions,

                                                           uint chunk_size) {

  _first_par_unreserved_idx = 0;

  uint max_waste = n_threads * chunk_size;

  // it should be aligned with respect to chunk_size

  uint aligned_n_regions = (n_regions + chunk_size - 1) / chunk_size * chunk_size;

  assert(aligned_n_regions % chunk_size == 0, "should be aligned");

  regions_at_put_grow(aligned_n_regions + max_waste - 1, NULL);

}

uint CollectionSetChooser::claim_array_chunk(uint chunk_size) {

  uint res = (uint) Atomic::add((jint) chunk_size,

                                (volatile jint*) &_first_par_unreserved_idx);

  assert(regions_length() > res + chunk_size - 1,

         "Should already have been expanded");

  return res - chunk_size;

}

void CollectionSetChooser::set_region(uint index, HeapRegion* hr) {

  assert(regions_at(index) == NULL, "precondition");

  assert(!hr->is_young(), "should not be young!");

  regions_at_put(index, hr);

  hr->calc_gc_efficiency();

}

void CollectionSetChooser::update_totals(uint region_num,

                                         size_t reclaimable_bytes) {

  // Only take the lock if we actually need to update the totals.

  if (region_num > 0) {

    assert(reclaimable_bytes > 0, "invariant");

    // We could have just used atomics instead of taking the

    // lock. However, we currently don't have an atomic add for size_t.

    MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);

    _end += region_num;

    _remaining_reclaimable_bytes += reclaimable_bytes;

  } else {

    assert(reclaimable_bytes == 0, "invariant");

  }

}

void CollectionSetChooser::clear() {

  _regions.clear();

  _front = 0;

  _end = 0;

  _remaining_reclaimable_bytes = 0;

}

class ParKnownGarbageHRClosure: public HeapRegionClosure {

  G1CollectedHeap* _g1h;

  CSetChooserParUpdater _cset_updater;

public:

  ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted,

                           uint chunk_size) :

    _g1h(G1CollectedHeap::heap()),

    _cset_updater(hrSorted, true /* parallel */, chunk_size) { }

  bool doHeapRegion(HeapRegion* r) {

    // Do we have any marking information for this region?

    if (r->is_marked()) {

      // We will skip any region that's currently used as an old GC

      // alloc region (we should not consider those for collection

      // before we fill them up).

      if (_cset_updater.should_add(r) && !_g1h->is_old_gc_alloc_region(r)) {

        _cset_updater.add_region(r);

      }

    }

    return false;

  }

};

class ParKnownGarbageTask: public AbstractGangTask {

  CollectionSetChooser* _hrSorted;

  uint _chunk_size;

  G1CollectedHeap* _g1;

  HeapRegionClaimer _hrclaimer;

public:

  ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size, uint n_workers) :

      AbstractGangTask("ParKnownGarbageTask"),

      _hrSorted(hrSorted), _chunk_size(chunk_size),

      _g1(G1CollectedHeap::heap()), _hrclaimer(n_workers) {}

  void work(uint worker_id) {

    ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size);

    _g1->heap_region_par_iterate(&parKnownGarbageCl, worker_id, &_hrclaimer);

  }

};

uint CollectionSetChooser::calculate_parallel_work_chunk_size(uint n_workers, uint n_regions) const {

  assert(n_workers > 0, "Active gc workers should be greater than 0");

  const uint overpartition_factor = 4;

  const uint min_chunk_size = MAX2(n_regions / n_workers, 1U);

  return MAX2(n_regions / (n_workers * overpartition_factor), min_chunk_size);

}

void CollectionSetChooser::rebuild(WorkGang* workers, uint n_regions) {

  clear();

  uint n_workers = workers->active_workers();

  uint chunk_size = calculate_parallel_work_chunk_size(n_workers, n_regions);

  prepare_for_par_region_addition(n_workers, n_regions, chunk_size);

  ParKnownGarbageTask par_known_garbage_task(this, chunk_size, n_workers);

  workers->run_task(&par_known_garbage_task);

  sort_regions();

}