--- a/hotspot/src/share/vm/gc/g1/g1CollectorPolicy.cpp Mon Mar 07 17:23:59 2016 +0100
+++ b/hotspot/src/share/vm/gc/g1/g1CollectorPolicy.cpp Mon Mar 07 10:36:22 2016 +0100
@@ -31,6 +31,7 @@
#include "gc/g1/g1ConcurrentMark.hpp"
#include "gc/g1/g1IHOPControl.hpp"
#include "gc/g1/g1GCPhaseTimes.hpp"
+#include "gc/g1/g1YoungGenSizer.hpp"
#include "gc/g1/heapRegion.inline.hpp"
#include "gc/g1/heapRegionRemSet.hpp"
#include "gc/shared/gcPolicyCounters.hpp"
@@ -276,177 +277,6 @@
G1CollectorState* G1CollectorPolicy::collector_state() const { return _g1->collector_state(); }
-// There are three command line options related to the young gen size:
-// NewSize, MaxNewSize and NewRatio (There is also -Xmn, but that is
-// just a short form for NewSize==MaxNewSize). G1 will use its internal
-// heuristics to calculate the actual young gen size, so these options
-// basically only limit the range within which G1 can pick a young gen
-// size. Also, these are general options taking byte sizes. G1 will
-// internally work with a number of regions instead. So, some rounding
-// will occur.
-//
-// If nothing related to the the young gen size is set on the command
-// line we should allow the young gen to be between G1NewSizePercent
-// and G1MaxNewSizePercent of the heap size. This means that every time
-// the heap size changes, the limits for the young gen size will be
-// recalculated.
-//
-// If only -XX:NewSize is set we should use the specified value as the
-// minimum size for young gen. Still using G1MaxNewSizePercent of the
-// heap as maximum.
-//
-// If only -XX:MaxNewSize is set we should use the specified value as the
-// maximum size for young gen. Still using G1NewSizePercent of the heap
-// as minimum.
-//
-// If -XX:NewSize and -XX:MaxNewSize are both specified we use these values.
-// No updates when the heap size changes. There is a special case when
-// NewSize==MaxNewSize. This is interpreted as "fixed" and will use a
-// different heuristic for calculating the collection set when we do mixed
-// collection.
-//
-// If only -XX:NewRatio is set we should use the specified ratio of the heap
-// as both min and max. This will be interpreted as "fixed" just like the
-// NewSize==MaxNewSize case above. But we will update the min and max
-// every time the heap size changes.
-//
-// NewSize and MaxNewSize override NewRatio. So, NewRatio is ignored if it is
-// combined with either NewSize or MaxNewSize. (A warning message is printed.)
-class G1YoungGenSizer : public CHeapObj<mtGC> {
-private:
- enum SizerKind {
- SizerDefaults,
- SizerNewSizeOnly,
- SizerMaxNewSizeOnly,
- SizerMaxAndNewSize,
- SizerNewRatio
- };
- SizerKind _sizer_kind;
- uint _min_desired_young_length;
- uint _max_desired_young_length;
- bool _adaptive_size;
- uint calculate_default_min_length(uint new_number_of_heap_regions);
- uint calculate_default_max_length(uint new_number_of_heap_regions);
-
- // Update the given values for minimum and maximum young gen length in regions
- // given the number of heap regions depending on the kind of sizing algorithm.
- void recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length);
-
-public:
- G1YoungGenSizer();
- // Calculate the maximum length of the young gen given the number of regions
- // depending on the sizing algorithm.
- uint max_young_length(uint number_of_heap_regions);
-
- void heap_size_changed(uint new_number_of_heap_regions);
- uint min_desired_young_length() {
- return _min_desired_young_length;
- }
- uint max_desired_young_length() {
- return _max_desired_young_length;
- }
-
- bool adaptive_young_list_length() const {
- return _adaptive_size;
- }
-};
-
-
-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)) {
- warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio");
- } else {
- _sizer_kind = SizerNewRatio;
- _adaptive_size = false;
- return;
- }
- }
-
- if (NewSize > MaxNewSize) {
- if (FLAG_IS_CMDLINE(MaxNewSize)) {
- warning("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);
-}
-
void G1CollectorPolicy::post_heap_initialize() {
uintx max_regions = G1CollectedHeap::heap()->max_regions();
size_t max_young_size = (size_t)_young_gen_sizer->max_young_length(max_regions) * HeapRegion::GrainBytes;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc/g1/g1YoungGenSizer.cpp Mon Mar 07 10:36:22 2016 +0100
@@ -0,0 +1,122 @@
+/*
+ * 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"
+
+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)) {
+ warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio");
+ } else {
+ _sizer_kind = SizerNewRatio;
+ _adaptive_size = false;
+ return;
+ }
+ }
+
+ if (NewSize > MaxNewSize) {
+ if (FLAG_IS_CMDLINE(MaxNewSize)) {
+ warning("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);
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc/g1/g1YoungGenSizer.hpp Mon Mar 07 10:36:22 2016 +0100
@@ -0,0 +1,101 @@
+/*
+ * 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 "memory/allocation.hpp"
+
+// There are three command line options related to the young gen size:
+// NewSize, MaxNewSize and NewRatio (There is also -Xmn, but that is
+// just a short form for NewSize==MaxNewSize). G1 will use its internal
+// heuristics to calculate the actual young gen size, so these options
+// basically only limit the range within which G1 can pick a young gen
+// size. Also, these are general options taking byte sizes. G1 will
+// internally work with a number of regions instead. So, some rounding
+// will occur.
+//
+// If nothing related to the the young gen size is set on the command
+// line we should allow the young gen to be between G1NewSizePercent
+// and G1MaxNewSizePercent of the heap size. This means that every time
+// the heap size changes, the limits for the young gen size will be
+// recalculated.
+//
+// If only -XX:NewSize is set we should use the specified value as the
+// minimum size for young gen. Still using G1MaxNewSizePercent of the
+// heap as maximum.
+//
+// If only -XX:MaxNewSize is set we should use the specified value as the
+// maximum size for young gen. Still using G1NewSizePercent of the heap
+// as minimum.
+//
+// If -XX:NewSize and -XX:MaxNewSize are both specified we use these values.
+// No updates when the heap size changes. There is a special case when
+// NewSize==MaxNewSize. This is interpreted as "fixed" and will use a
+// different heuristic for calculating the collection set when we do mixed
+// collection.
+//
+// If only -XX:NewRatio is set we should use the specified ratio of the heap
+// as both min and max. This will be interpreted as "fixed" just like the
+// NewSize==MaxNewSize case above. But we will update the min and max
+// every time the heap size changes.
+//
+// NewSize and MaxNewSize override NewRatio. So, NewRatio is ignored if it is
+// combined with either NewSize or MaxNewSize. (A warning message is printed.)
+class G1YoungGenSizer : public CHeapObj<mtGC> {
+private:
+ enum SizerKind {
+ SizerDefaults,
+ SizerNewSizeOnly,
+ SizerMaxNewSizeOnly,
+ SizerMaxAndNewSize,
+ SizerNewRatio
+ };
+ SizerKind _sizer_kind;
+ uint _min_desired_young_length;
+ uint _max_desired_young_length;
+ bool _adaptive_size;
+ uint calculate_default_min_length(uint new_number_of_heap_regions);
+ uint calculate_default_max_length(uint new_number_of_heap_regions);
+
+ // Update the given values for minimum and maximum young gen length in regions
+ // given the number of heap regions depending on the kind of sizing algorithm.
+ void recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length);
+
+public:
+ G1YoungGenSizer();
+ // Calculate the maximum length of the young gen given the number of regions
+ // depending on the sizing algorithm.
+ uint max_young_length(uint number_of_heap_regions);
+
+ void heap_size_changed(uint new_number_of_heap_regions);
+ uint min_desired_young_length() {
+ return _min_desired_young_length;
+ }
+ uint max_desired_young_length() {
+ return _max_desired_young_length;
+ }
+
+ bool adaptive_young_list_length() const {
+ return _adaptive_size;
+ }
+};
+