< prev index next >

src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp

Print this page

 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 
 27 #include "gc/shenandoah/shenandoahCollectionSet.hpp"
 28 #include "gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp"
 29 #include "gc/shenandoah/shenandoahFreeSet.hpp"
 30 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 31 #include "gc/shenandoah/shenandoahHeapRegion.inline.hpp"
 32 #include "logging/log.hpp"
 33 #include "logging/logTag.hpp"
 34 
 35 ShenandoahCompactHeuristics::ShenandoahCompactHeuristics() : ShenandoahHeuristics() {

 36   SHENANDOAH_ERGO_ENABLE_FLAG(ExplicitGCInvokesConcurrent);
 37   SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahImplicitGCInvokesConcurrent);
 38   SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahUncommit);
 39   SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahAlwaysClearSoftRefs);
 40   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahAllocationThreshold,  10);
 41   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahImmediateThreshold,   100);
 42   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahUncommitDelay,        1000);
 43   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahGuaranteedGCInterval, 30000);
 44   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahGarbageThreshold,     10);
 45 }
 46 
 47 bool ShenandoahCompactHeuristics::should_start_gc() {
 48   ShenandoahHeap* heap = ShenandoahHeap::heap();
 49 
 50   size_t max_capacity = heap->max_capacity();
 51   size_t capacity = heap->soft_max_capacity();
 52   size_t available = heap->free_set()->available();
 53 
 54   // Make sure the code below treats available without the soft tail.
 55   size_t soft_tail = max_capacity - capacity;
 56   available = (available > soft_tail) ? (available - soft_tail) : 0;
 57 
 58   size_t threshold_bytes_allocated = capacity / 100 * ShenandoahAllocationThreshold;
 59   size_t min_threshold = capacity / 100 * ShenandoahMinFreeThreshold;
 60 
 61   if (available < min_threshold) {
 62     log_info(gc)("Trigger: Free (" SIZE_FORMAT "%s) is below minimum threshold (" SIZE_FORMAT "%s)",
 63                  byte_size_in_proper_unit(available),     proper_unit_for_byte_size(available),
 64                  byte_size_in_proper_unit(min_threshold), proper_unit_for_byte_size(min_threshold));
 65     return true;
 66   }
 67 
 68   size_t bytes_allocated = heap->bytes_allocated_since_gc_start();
 69   if (bytes_allocated > threshold_bytes_allocated) {
 70     log_info(gc)("Trigger: Allocated since last cycle (" SIZE_FORMAT "%s) is larger than allocation threshold (" SIZE_FORMAT "%s)",
 71                  byte_size_in_proper_unit(bytes_allocated),           proper_unit_for_byte_size(bytes_allocated),
 72                  byte_size_in_proper_unit(threshold_bytes_allocated), proper_unit_for_byte_size(threshold_bytes_allocated));
 73     return true;
 74   }
 75 
 76   return ShenandoahHeuristics::should_start_gc();
 77 }
 78 
 79 void ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
 80                                                                         RegionData* data, size_t size,
 81                                                                         size_t actual_free) {
 82   // Do not select too large CSet that would overflow the available free space
 83   size_t max_cset = actual_free * 3 / 4;
 84 
 85   log_info(gc, ergo)("CSet Selection. Actual Free: " SIZE_FORMAT "%s, Max CSet: " SIZE_FORMAT "%s",
 86                      byte_size_in_proper_unit(actual_free), proper_unit_for_byte_size(actual_free),
 87                      byte_size_in_proper_unit(max_cset),    proper_unit_for_byte_size(max_cset));
 88 

 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 
 27 #include "gc/shenandoah/shenandoahCollectionSet.hpp"
 28 #include "gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp"
 29 #include "gc/shenandoah/shenandoahFreeSet.hpp"
 30 #include "gc/shenandoah/shenandoahGeneration.hpp"
 31 #include "gc/shenandoah/shenandoahHeapRegion.inline.hpp"
 32 #include "logging/log.hpp"
 33 #include "logging/logTag.hpp"
 34 
 35 ShenandoahCompactHeuristics::ShenandoahCompactHeuristics(ShenandoahGeneration* generation) :
 36   ShenandoahHeuristics(generation) {
 37   SHENANDOAH_ERGO_ENABLE_FLAG(ExplicitGCInvokesConcurrent);
 38   SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahImplicitGCInvokesConcurrent);
 39   SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahUncommit);
 40   SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahAlwaysClearSoftRefs);
 41   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahAllocationThreshold,  10);
 42   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahImmediateThreshold,   100);
 43   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahUncommitDelay,        1000);
 44   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahGuaranteedGCInterval, 30000);
 45   SHENANDOAH_ERGO_OVERRIDE_DEFAULT(ShenandoahGarbageThreshold,     10);
 46 }
 47 
 48 bool ShenandoahCompactHeuristics::should_start_gc() {
 49   size_t max_capacity = _generation->max_capacity();
 50   size_t capacity = _generation->soft_max_capacity();
 51   size_t available = _generation->available();


 52 
 53   // Make sure the code below treats available without the soft tail.
 54   size_t soft_tail = max_capacity - capacity;
 55   available = (available > soft_tail) ? (available - soft_tail) : 0;
 56 
 57   size_t threshold_bytes_allocated = capacity / 100 * ShenandoahAllocationThreshold;
 58   size_t min_threshold = capacity / 100 * ShenandoahMinFreeThreshold;
 59 
 60   if (available < min_threshold) {
 61     log_info(gc)("Trigger: Free (" SIZE_FORMAT "%s) is below minimum threshold (" SIZE_FORMAT "%s)",
 62                  byte_size_in_proper_unit(available),     proper_unit_for_byte_size(available),
 63                  byte_size_in_proper_unit(min_threshold), proper_unit_for_byte_size(min_threshold));
 64     return true;
 65   }
 66 
 67   size_t bytes_allocated = _generation->bytes_allocated_since_gc_start();
 68   if (bytes_allocated > threshold_bytes_allocated) {
 69     log_info(gc)("Trigger: Allocated since last cycle (" SIZE_FORMAT "%s) is larger than allocation threshold (" SIZE_FORMAT "%s)",
 70                  byte_size_in_proper_unit(bytes_allocated),           proper_unit_for_byte_size(bytes_allocated),
 71                  byte_size_in_proper_unit(threshold_bytes_allocated), proper_unit_for_byte_size(threshold_bytes_allocated));
 72     return true;
 73   }
 74 
 75   return ShenandoahHeuristics::should_start_gc();
 76 }
 77 
 78 void ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
 79                                                                         RegionData* data, size_t size,
 80                                                                         size_t actual_free) {
 81   // Do not select too large CSet that would overflow the available free space
 82   size_t max_cset = actual_free * 3 / 4;
 83 
 84   log_info(gc, ergo)("CSet Selection. Actual Free: " SIZE_FORMAT "%s, Max CSet: " SIZE_FORMAT "%s",
 85                      byte_size_in_proper_unit(actual_free), proper_unit_for_byte_size(actual_free),
 86                      byte_size_in_proper_unit(max_cset),    proper_unit_for_byte_size(max_cset));
 87 
< prev index next >