< prev index next >

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

Print this page




   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "gc/g1/collectionSetChooser.hpp"
  27 #include "gc/g1/g1CollectedHeap.inline.hpp"
  28 #include "gc/g1/g1CollectorPolicy.hpp"
  29 #include "gc/g1/g1ErgoVerbose.hpp"
  30 #include "gc/shared/space.inline.hpp"
  31 #include "runtime/atomic.inline.hpp"
  32 
  33 // Even though we don't use the GC efficiency in our heuristics as
  34 // much as we used to, we still order according to GC efficiency. This
  35 // will cause regions with a lot of live objects and large RSets to
  36 // end up at the end of the array. Given that we might skip collecting
  37 // the last few old regions, if after a few mixed GCs the remaining
  38 // have reclaimable bytes under a certain threshold, the hope is that
  39 // the ones we'll skip are ones with both large RSets and a lot of
  40 // live objects, not the ones with just a lot of live objects if we
  41 // ordered according to the amount of reclaimable bytes per region.
  42 static int order_regions(HeapRegion* hr1, HeapRegion* hr2) {
  43   if (hr1 == NULL) {
  44     if (hr2 == NULL) {
  45       return 0;
  46     } else {
  47       return 1;
  48     }
  49   } else if (hr2 == NULL) {


 119             "reclaimable bytes inconsistent, "
 120             "remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,
 121             _remaining_reclaimable_bytes, sum_of_reclaimable_bytes);
 122 }
 123 #endif // !PRODUCT
 124 
 125 void CollectionSetChooser::sort_regions() {
 126   // First trim any unused portion of the top in the parallel case.
 127   if (_first_par_unreserved_idx > 0) {
 128     assert(_first_par_unreserved_idx <= regions_length(),
 129            "Or we didn't reserved enough length");
 130     regions_trunc_to(_first_par_unreserved_idx);
 131   }
 132   _regions.sort(order_regions);
 133   assert(_end <= regions_length(), "Requirement");
 134 #ifdef ASSERT
 135   for (uint i = 0; i < _end; i++) {
 136     assert(regions_at(i) != NULL, "Should be true by sorting!");
 137   }
 138 #endif // ASSERT
 139   if (G1PrintRegionLivenessInfo) {
 140     G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting");
 141     for (uint i = 0; i < _end; ++i) {
 142       HeapRegion* r = regions_at(i);
 143       cl.doHeapRegion(r);
 144     }
 145   }
 146   verify();
 147 }
 148 
 149 
 150 void CollectionSetChooser::add_region(HeapRegion* hr) {
 151   assert(!hr->is_pinned(),
 152          "Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index());
 153   assert(!hr->is_young(), "should not be young!");
 154   _regions.append(hr);
 155   _end++;
 156   _remaining_reclaimable_bytes += hr->reclaimable_bytes();
 157   hr->calc_gc_efficiency();
 158 }
 159 
 160 void CollectionSetChooser::push(HeapRegion* hr) {




   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "gc/g1/collectionSetChooser.hpp"
  27 #include "gc/g1/g1CollectedHeap.inline.hpp"
  28 #include "gc/g1/g1CollectorPolicy.hpp"

  29 #include "gc/shared/space.inline.hpp"
  30 #include "runtime/atomic.inline.hpp"
  31 
  32 // Even though we don't use the GC efficiency in our heuristics as
  33 // much as we used to, we still order according to GC efficiency. This
  34 // will cause regions with a lot of live objects and large RSets to
  35 // end up at the end of the array. Given that we might skip collecting
  36 // the last few old regions, if after a few mixed GCs the remaining
  37 // have reclaimable bytes under a certain threshold, the hope is that
  38 // the ones we'll skip are ones with both large RSets and a lot of
  39 // live objects, not the ones with just a lot of live objects if we
  40 // ordered according to the amount of reclaimable bytes per region.
  41 static int order_regions(HeapRegion* hr1, HeapRegion* hr2) {
  42   if (hr1 == NULL) {
  43     if (hr2 == NULL) {
  44       return 0;
  45     } else {
  46       return 1;
  47     }
  48   } else if (hr2 == NULL) {


 118             "reclaimable bytes inconsistent, "
 119             "remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,
 120             _remaining_reclaimable_bytes, sum_of_reclaimable_bytes);
 121 }
 122 #endif // !PRODUCT
 123 
 124 void CollectionSetChooser::sort_regions() {
 125   // First trim any unused portion of the top in the parallel case.
 126   if (_first_par_unreserved_idx > 0) {
 127     assert(_first_par_unreserved_idx <= regions_length(),
 128            "Or we didn't reserved enough length");
 129     regions_trunc_to(_first_par_unreserved_idx);
 130   }
 131   _regions.sort(order_regions);
 132   assert(_end <= regions_length(), "Requirement");
 133 #ifdef ASSERT
 134   for (uint i = 0; i < _end; i++) {
 135     assert(regions_at(i) != NULL, "Should be true by sorting!");
 136   }
 137 #endif // ASSERT
 138   if (log_is_enabled(Trace, gc, liveness)) {
 139     G1PrintRegionLivenessInfoClosure cl("Post-Sorting");
 140     for (uint i = 0; i < _end; ++i) {
 141       HeapRegion* r = regions_at(i);
 142       cl.doHeapRegion(r);
 143     }
 144   }
 145   verify();
 146 }
 147 
 148 
 149 void CollectionSetChooser::add_region(HeapRegion* hr) {
 150   assert(!hr->is_pinned(),
 151          "Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index());
 152   assert(!hr->is_young(), "should not be young!");
 153   _regions.append(hr);
 154   _end++;
 155   _remaining_reclaimable_bytes += hr->reclaimable_bytes();
 156   hr->calc_gc_efficiency();
 157 }
 158 
 159 void CollectionSetChooser::push(HeapRegion* hr) {


< prev index next >