jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/g1/collectionSetChooser.cpp@a9647476d1a4 (annotated)

src/share/vm/gc_implementation/g1/collectionSetChooser.cpp@a9647476d1a4 (annotated)

src/share/vm/gc_implementation/g1/collectionSetChooser.cpp

Wed, 15 Feb 2012 13:06:53 -0500

author: tonyp
date: Wed, 15 Feb 2012 13:06:53 -0500
changeset 3539: a9647476d1a4
parent 3357: 441e946dc1af
child 3667: 21595f05bc93
permissions: -rw-r--r--

7132029: G1: mixed GC phase lasts for longer than it should
Summary: Revamp of the mechanism that chooses old regions for inclusion in the CSet. It simplifies the code and introduces min and max bounds on the number of old regions added to the CSet at each mixed GC to avoid pathological cases. It also ensures that when we do a mixed GC we'll always find old regions to add to the CSet (i.e., it eliminates the case where a mixed GC will collect no old regions which can happen today).
Reviewed-by: johnc, brutisso

 /*
  * 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 "gc_implementation/g1/collectionSetChooser.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
 #include "gc_implementation/g1/g1ErgoVerbose.hpp"
 #include "memory/space.inline.hpp"
 CSetChooserCache::CSetChooserCache() {
   for (int i = 0; i < CacheLength; ++i)
     _cache[i] = NULL;
   clear();
 }
 void CSetChooserCache::clear() {
   _occupancy = 0;
   _first = 0;
   for (int i = 0; i < CacheLength; ++i) {
     HeapRegion *hr = _cache[i];
     if (hr != NULL)
       hr->set_sort_index(-1);
     _cache[i] = NULL;
   }
 }
 #ifndef PRODUCT
 bool CSetChooserCache::verify() {
   guarantee(false, "CSetChooserCache::verify(): don't call this any more");
   int index = _first;
   HeapRegion *prev = NULL;
   for (int i = 0; i < _occupancy; ++i) {
     guarantee(_cache[index] != NULL, "cache entry should not be empty");
     HeapRegion *hr = _cache[index];
     guarantee(!hr->is_young(), "should not be young!");
     if (prev != NULL) {
       guarantee(prev->gc_efficiency() >= hr->gc_efficiency(),
                 "cache should be correctly ordered");
     }
     guarantee(hr->sort_index() == get_sort_index(index),
               "sort index should be correct");
     index = trim_index(index + 1);
     prev = hr;
   }
   for (int i = 0; i < (CacheLength - _occupancy); ++i) {
     guarantee(_cache[index] == NULL, "cache entry should be empty");
     index = trim_index(index + 1);
   }
   guarantee(index == _first, "we should have reached where we started from");
   return true;
 }
 #endif // PRODUCT
 void CSetChooserCache::insert(HeapRegion *hr) {
   guarantee(false, "CSetChooserCache::insert(): don't call this any more");
   assert(!is_full(), "cache should not be empty");
   hr->calc_gc_efficiency();
   int empty_index;
   if (_occupancy == 0) {
     empty_index = _first;
   } else {
     empty_index = trim_index(_first + _occupancy);
     assert(_cache[empty_index] == NULL, "last slot should be empty");
     int last_index = trim_index(empty_index - 1);
     HeapRegion *last = _cache[last_index];
     assert(last != NULL,"as the cache is not empty, last should not be empty");
     while (empty_index != _first &&
            last->gc_efficiency() < hr->gc_efficiency()) {
       _cache[empty_index] = last;
       last->set_sort_index(get_sort_index(empty_index));
       empty_index = last_index;
       last_index = trim_index(last_index - 1);
       last = _cache[last_index];
     }
   }
   _cache[empty_index] = hr;
   hr->set_sort_index(get_sort_index(empty_index));
   ++_occupancy;
   assert(verify(), "cache should be consistent");
 }
 HeapRegion *CSetChooserCache::remove_first() {
   guarantee(false, "CSetChooserCache::remove_first(): "
                    "don't call this any more");
   if (_occupancy > 0) {
     assert(_cache[_first] != NULL, "cache should have at least one region");
     HeapRegion *ret = _cache[_first];
     _cache[_first] = NULL;
     ret->set_sort_index(-1);
     --_occupancy;
     _first = trim_index(_first + 1);
     assert(verify(), "cache should be consistent");
     return ret;
   } else {
     return NULL;
   }
 }
 // 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 orderRegions(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 orderRegions(HeapRegion** hr1p, HeapRegion** hr2p) {
   return orderRegions(*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.
   //
   _markedRegions((ResourceObj::set_allocation_type((address)&_markedRegions,
                                              ResourceObj::C_HEAP),
 ), true /* C_Heap */),
     _curr_index(0), _length(0),
     _regionLiveThresholdBytes(0), _remainingReclaimableBytes(0),
     _first_par_unreserved_idx(0) {
   _regionLiveThresholdBytes =
     HeapRegion::GrainBytes * (size_t) G1OldCSetRegionLiveThresholdPercent / 100;
 }
 #ifndef PRODUCT
 bool CollectionSetChooser::verify() {
   guarantee(_length >= 0, err_msg("_length: %d", _length));
   guarantee(0 <= _curr_index && _curr_index <= _length,
             err_msg("_curr_index: %d _length: %d", _curr_index, _length));
   int index = 0;
   size_t sum_of_reclaimable_bytes = 0;
   while (index < _curr_index) {
     guarantee(_markedRegions.at(index) == NULL,
               "all entries before _curr_index should be NULL");
     index += 1;
   }
   HeapRegion *prev = NULL;
   while (index < _length) {
     HeapRegion *curr = _markedRegions.at(index++);
     guarantee(curr != NULL, "Regions in _markedRegions array cannot be NULL");
     int si = curr->sort_index();
     guarantee(!curr->is_young(), "should not be young!");
     guarantee(!curr->isHumongous(), "should not be humongous!");
     guarantee(si > -1 && si == (index-1), "sort index invariant");
     if (prev != NULL) {
       guarantee(orderRegions(prev, curr) != 1,
                 err_msg("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 == _remainingReclaimableBytes,
             err_msg("reclaimable bytes inconsistent, "
                     "remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT,
                     _remainingReclaimableBytes, sum_of_reclaimable_bytes));
   return true;
 }
 #endif
 void CollectionSetChooser::fillCache() {
   guarantee(false, "fillCache: don't call this any more");
   while (!_cache.is_full() && (_curr_index < _length)) {
     HeapRegion* hr = _markedRegions.at(_curr_index);
     assert(hr != NULL,
            err_msg("Unexpected NULL hr in _markedRegions at index %d",
                    _curr_index));
     _curr_index += 1;
     assert(!hr->is_young(), "should not be young!");
     assert(hr->sort_index() == _curr_index-1, "sort_index invariant");
     _markedRegions.at_put(hr->sort_index(), NULL);
     _cache.insert(hr);
     assert(!_cache.is_empty(), "cache should not be empty");
   }
   assert(verify(), "cache should be consistent");
 }
 void CollectionSetChooser::sortMarkedHeapRegions() {
   // First trim any unused portion of the top in the parallel case.
   if (_first_par_unreserved_idx > 0) {
     if (G1PrintParCleanupStats) {
       gclog_or_tty->print("     Truncating _markedRegions from %d to %d.\n",
                           _markedRegions.length(), _first_par_unreserved_idx);
     }
     assert(_first_par_unreserved_idx <= _markedRegions.length(),
            "Or we didn't reserved enough length");
     _markedRegions.trunc_to(_first_par_unreserved_idx);
   }
   _markedRegions.sort(orderRegions);
   assert(_length <= _markedRegions.length(), "Requirement");
   assert(_length == 0 || _markedRegions.at(_length - 1) != NULL,
          "Testing _length");
   assert(_length == _markedRegions.length() ||
                         _markedRegions.at(_length) == NULL, "Testing _length");
   if (G1PrintParCleanupStats) {
     gclog_or_tty->print_cr("     Sorted %d marked regions.", _length);
   }
   for (int i = 0; i < _length; i++) {
     assert(_markedRegions.at(i) != NULL, "Should be true by sorting!");
     _markedRegions.at(i)->set_sort_index(i);
   }
   if (G1PrintRegionLivenessInfo) {
     G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting");
     for (int i = 0; i < _length; ++i) {
       HeapRegion* r = _markedRegions.at(i);
       cl.doHeapRegion(r);
     }
   }
   assert(verify(), "CSet chooser verification");
 }
 size_t CollectionSetChooser::calcMinOldCSetLength() {
   // The min old CSet region bound is based on the maximum desired
   // number of mixed GCs after a cycle. I.e., even if some old regions
   // look expensive, we should add them to the CSet anyway to make
   // sure we go through the available old regions in no more than the
   // maximum desired number of mixed GCs.
   //
   // The calculation is based on the number of marked regions we added
   // to the CSet chooser in the first place, not how many remain, so
   // that the result is the same during all mixed GCs that follow a cycle.
   const size_t region_num = (size_t) _length;
   const size_t gc_num = (size_t) G1MaxMixedGCNum;
   size_t result = region_num / gc_num;
   // emulate ceiling
   if (result * gc_num < region_num) {
     result += 1;
   }
   return result;
 }
 size_t CollectionSetChooser::calcMaxOldCSetLength() {
   // The max old CSet region bound is based on the threshold expressed
   // as a percentage of the heap size. I.e., it should bound the
   // number of old regions added to the CSet irrespective of how many
   // of them are available.
   G1CollectedHeap* g1h = G1CollectedHeap::heap();
   const size_t region_num = g1h->n_regions();
   const size_t perc = (size_t) G1OldCSetRegionThresholdPercent;
   size_t result = region_num * perc / 100;
   // emulate ceiling
   if (100 * result < region_num * perc) {
     result += 1;
   }
   return result;
 }
 void CollectionSetChooser::addMarkedHeapRegion(HeapRegion* hr) {
   assert(!hr->isHumongous(),
          "Humongous regions shouldn't be added to the collection set");
   assert(!hr->is_young(), "should not be young!");
   _markedRegions.append(hr);
   _length++;
   _remainingReclaimableBytes += hr->reclaimable_bytes();
   hr->calc_gc_efficiency();
 }
 void CollectionSetChooser::prepareForAddMarkedHeapRegionsPar(size_t n_regions,
                                                              size_t chunkSize) {
   _first_par_unreserved_idx = 0;
   int n_threads = ParallelGCThreads;
   if (UseDynamicNumberOfGCThreads) {
     assert(G1CollectedHeap::heap()->workers()->active_workers() > 0,
       "Should have been set earlier");
     // This is defensive code. As the assertion above says, the number
     // of active threads should be > 0, but in case there is some path
     // or some improperly initialized variable with leads to no
     // active threads, protect against that in a product build.
     n_threads = MAX2(G1CollectedHeap::heap()->workers()->active_workers(),
 U);
   }
   size_t max_waste = n_threads * chunkSize;
   // it should be aligned with respect to chunkSize
   size_t aligned_n_regions =
                      (n_regions + (chunkSize - 1)) / chunkSize * chunkSize;
   assert( aligned_n_regions % chunkSize == 0, "should be aligned" );
   _markedRegions.at_put_grow((int)(aligned_n_regions + max_waste - 1), NULL);
 }
 jint CollectionSetChooser::getParMarkedHeapRegionChunk(jint n_regions) {
   // Don't do this assert because this can be called at a point
   // where the loop up stream will not execute again but might
   // try to claim more chunks (loop test has not been done yet).
   // assert(_markedRegions.length() > _first_par_unreserved_idx,
   //  "Striding beyond the marked regions");
   jint res = Atomic::add(n_regions, &_first_par_unreserved_idx);
   assert(_markedRegions.length() > res + n_regions - 1,
          "Should already have been expanded");
   return res - n_regions;
 }
 void CollectionSetChooser::setMarkedHeapRegion(jint index, HeapRegion* hr) {
   assert(_markedRegions.at(index) == NULL, "precondition");
   assert(!hr->is_young(), "should not be young!");
   _markedRegions.at_put(index, hr);
   hr->calc_gc_efficiency();
 }
 void CollectionSetChooser::updateTotals(jint 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);
     _length += (int) region_num;
     _remainingReclaimableBytes += reclaimable_bytes;
   } else {
     assert(reclaimable_bytes == 0, "invariant");
   }
 }
 void CollectionSetChooser::clearMarkedHeapRegions() {
   for (int i = 0; i < _markedRegions.length(); i++) {
     HeapRegion* r = _markedRegions.at(i);
     if (r != NULL) {
       r->set_sort_index(-1);
     }
   }
   _markedRegions.clear();
   _curr_index = 0;
   _length = 0;
   _remainingReclaimableBytes = 0;
 };

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/g1/collectionSetChooser.cpp@a9647476d1a4 (annotated)

src/share/vm/gc_implementation/g1/collectionSetChooser.cpp