Mercurial > hg > graal-jvmci-8
view src/share/vm/gc_implementation/g1/collectionSetChooser.cpp @ 6629:c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
Summary: Add the flags G1EvacuationFailureALot flag (and supporting flags) to force trigger evacuation failures. The support flags control how often to trigger an evacuation failure and during which types of evacuation pause. This functionality is analogous to that of PromotionFailureALot for the other collectors.
Reviewed-by: brutisso
author | johnc |
---|---|
date | Tue, 28 Aug 2012 15:20:08 -0700 |
parents | f7a8920427a6 |
children | 37f7535e5f18 |
line wrap: on
line source
/* * 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" // 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 */), _curr_index(0), _length(0), _first_par_unreserved_idx(0), _region_live_threshold_bytes(0), _remaining_reclaimable_bytes(0) { _region_live_threshold_bytes = HeapRegion::GrainBytes * (size_t) G1OldCSetRegionLiveThresholdPercent / 100; } #ifndef PRODUCT void CollectionSetChooser::verify() { guarantee(_length <= regions_length(), err_msg("_length: %u regions length: %u", _length, regions_length())); guarantee(_curr_index <= _length, err_msg("_curr_index: %u _length: %u", _curr_index, _length)); uint index = 0; size_t sum_of_reclaimable_bytes = 0; while (index < _curr_index) { guarantee(regions_at(index) == NULL, "all entries before _curr_index should be NULL"); index += 1; } HeapRegion *prev = NULL; while (index < _length) { 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->isHumongous(), "should not be humongous!"); if (prev != NULL) { guarantee(order_regions(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 == _remaining_reclaimable_bytes, err_msg("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(_length <= regions_length(), "Requirement"); #ifdef ASSERT for (uint i = 0; i < _length; i++) { assert(regions_at(i) != NULL, "Should be true by sorting!"); } #endif // ASSERT if (G1PrintRegionLivenessInfo) { G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Sorting"); for (uint i = 0; i < _length; ++i) { HeapRegion* r = regions_at(i); cl.doHeapRegion(r); } } verify(); } uint CollectionSetChooser::calc_min_old_cset_length() { // 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) G1MixedGCCountTarget; size_t result = region_num / gc_num; // emulate ceiling if (result * gc_num < region_num) { result += 1; } return (uint) result; } uint CollectionSetChooser::calc_max_old_cset_length() { // 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 (uint) result; } void CollectionSetChooser::add_region(HeapRegion* hr) { assert(!hr->isHumongous(), "Humongous regions shouldn't be added to the collection set"); assert(!hr->is_young(), "should not be young!"); _regions.append(hr); _length++; _remaining_reclaimable_bytes += hr->reclaimable_bytes(); hr->calc_gc_efficiency(); } void CollectionSetChooser::prepare_for_par_region_addition(uint n_regions, uint chunk_size) { _first_par_unreserved_idx = 0; uint n_threads = (uint) 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(), 1U); } 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); _length += region_num; _remaining_reclaimable_bytes += reclaimable_bytes; } else { assert(reclaimable_bytes == 0, "invariant"); } } void CollectionSetChooser::clear() { _regions.clear(); _curr_index = 0; _length = 0; _remaining_reclaimable_bytes = 0; };