| /* |
| * Copyright (c) 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/g1YoungGenSizer.hpp" |
| #include "gc/g1/heapRegion.hpp" |
| #include "logging/log.hpp" |
| |
| G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true), |
| _min_desired_young_length(0), _max_desired_young_length(0) { |
| if (FLAG_IS_CMDLINE(NewRatio)) { |
| if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) { |
| log_warning(gc, ergo)("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio"); |
| } else { |
| _sizer_kind = SizerNewRatio; |
| _adaptive_size = false; |
| return; |
| } |
| } |
| |
| if (NewSize > MaxNewSize) { |
| if (FLAG_IS_CMDLINE(MaxNewSize)) { |
| log_warning(gc, ergo)("NewSize (" SIZE_FORMAT "k) is greater than the MaxNewSize (" SIZE_FORMAT "k). " |
| "A new max generation size of " SIZE_FORMAT "k will be used.", |
| NewSize/K, MaxNewSize/K, NewSize/K); |
| } |
| MaxNewSize = NewSize; |
| } |
| |
| if (FLAG_IS_CMDLINE(NewSize)) { |
| _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes), |
| 1U); |
| if (FLAG_IS_CMDLINE(MaxNewSize)) { |
| _max_desired_young_length = |
| MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), |
| 1U); |
| _sizer_kind = SizerMaxAndNewSize; |
| _adaptive_size = _min_desired_young_length == _max_desired_young_length; |
| } else { |
| _sizer_kind = SizerNewSizeOnly; |
| } |
| } else if (FLAG_IS_CMDLINE(MaxNewSize)) { |
| _max_desired_young_length = |
| MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), |
| 1U); |
| _sizer_kind = SizerMaxNewSizeOnly; |
| } |
| } |
| |
| uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) { |
| uint default_value = (new_number_of_heap_regions * G1NewSizePercent) / 100; |
| return MAX2(1U, default_value); |
| } |
| |
| uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) { |
| uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100; |
| return MAX2(1U, default_value); |
| } |
| |
| void G1YoungGenSizer::recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length) { |
| assert(number_of_heap_regions > 0, "Heap must be initialized"); |
| |
| switch (_sizer_kind) { |
| case SizerDefaults: |
| *min_young_length = calculate_default_min_length(number_of_heap_regions); |
| *max_young_length = calculate_default_max_length(number_of_heap_regions); |
| break; |
| case SizerNewSizeOnly: |
| *max_young_length = calculate_default_max_length(number_of_heap_regions); |
| *max_young_length = MAX2(*min_young_length, *max_young_length); |
| break; |
| case SizerMaxNewSizeOnly: |
| *min_young_length = calculate_default_min_length(number_of_heap_regions); |
| *min_young_length = MIN2(*min_young_length, *max_young_length); |
| break; |
| case SizerMaxAndNewSize: |
| // Do nothing. Values set on the command line, don't update them at runtime. |
| break; |
| case SizerNewRatio: |
| *min_young_length = number_of_heap_regions / (NewRatio + 1); |
| *max_young_length = *min_young_length; |
| break; |
| default: |
| ShouldNotReachHere(); |
| } |
| |
| assert(*min_young_length <= *max_young_length, "Invalid min/max young gen size values"); |
| } |
| |
| uint G1YoungGenSizer::max_young_length(uint number_of_heap_regions) { |
| // We need to pass the desired values because recalculation may not update these |
| // values in some cases. |
| uint temp = _min_desired_young_length; |
| uint result = _max_desired_young_length; |
| recalculate_min_max_young_length(number_of_heap_regions, &temp, &result); |
| return result; |
| } |
| |
| void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) { |
| recalculate_min_max_young_length(new_number_of_heap_regions, &_min_desired_young_length, |
| &_max_desired_young_length); |
| } |