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/g1CollectedHeap.hpp"
27 #include "gc/g1/g1HeapSizingPolicy.hpp"
28 #include "gc/g1/g1Analytics.hpp"
29 #include "logging/log.hpp"
30 #include "runtime/globals.hpp"
31 #include "utilities/debug.hpp"
32 #include "utilities/globalDefinitions.hpp"
33
34 G1HeapSizingPolicy* G1HeapSizingPolicy::create(const G1CollectedHeap* g1h, const G1Analytics* analytics) {
35 return new G1HeapSizingPolicy(g1h, analytics);
36 }
37
38 G1HeapSizingPolicy::G1HeapSizingPolicy(const G1CollectedHeap* g1h, const G1Analytics* analytics) :
39 _g1h(g1h),
40 _analytics(analytics),
41 _num_prev_pauses_for_heuristics(analytics->number_of_recorded_pause_times()) {
42
43 assert(MinOverThresholdForGrowth < _num_prev_pauses_for_heuristics, "Threshold must be less than %u", _num_prev_pauses_for_heuristics);
44 clear_ratio_check_data();
45 }
46
47 void G1HeapSizingPolicy::clear_ratio_check_data() {
48 _ratio_over_threshold_count = 0;
49 _ratio_over_threshold_sum = 0.0;
50 _pauses_since_start = 0;
51 }
52
53 size_t G1HeapSizingPolicy::expansion_amount() {
54 double recent_gc_overhead = _analytics->recent_avg_pause_time_ratio() * 100.0;
55 double last_gc_overhead = _analytics->last_pause_time_ratio() * 100.0;
56 assert(GCTimeRatio > 0,
57 "we should have set it to a default value set_g1_gc_flags() "
58 "if a user set it to 0");
59 const double gc_overhead_percent = 100.0 * (1.0 / (1.0 + GCTimeRatio));
60
61 double threshold = gc_overhead_percent;
62 size_t expand_bytes = 0;
63
64 // If the heap is at less than half its maximum size, scale the threshold down,
65 // to a limit of 1. Thus the smaller the heap is, the more likely it is to expand,
66 // though the scaling code will likely keep the increase small.
67 if (_g1h->capacity() <= _g1h->max_capacity() / 2) {
68 threshold *= (double)_g1h->capacity() / (double)(_g1h->max_capacity() / 2);
69 threshold = MAX2(threshold, 1.0);
70 }
71
72 // If the last GC time ratio is over the threshold, increment the count of
73 // times it has been exceeded, and add this ratio to the sum of exceeded
142 // Ensure the expansion size is at least the minimum growth amount
143 // and at most the remaining uncommitted byte size.
144 expand_bytes = MAX2(expand_bytes, min_expand_bytes);
145 expand_bytes = MIN2(expand_bytes, uncommitted_bytes);
146
147 clear_ratio_check_data();
148 } else {
149 // An expansion was not triggered. If we've started counting, increment
150 // the number of checks we've made in the current window. If we've
151 // reached the end of the window without resizing, clear the counters to
152 // start again the next time we see a ratio above the threshold.
153 if (_ratio_over_threshold_count > 0) {
154 _pauses_since_start++;
155 if (_pauses_since_start > _num_prev_pauses_for_heuristics) {
156 clear_ratio_check_data();
157 }
158 }
159 }
160
161 return expand_bytes;
162 }
|
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/g1CollectedHeap.hpp"
27 #include "gc/g1/g1HeapSizingPolicy.hpp"
28 #include "gc/g1/g1Analytics.hpp"
29 #include "gc/g1/g1Policy.hpp"
30 #include "logging/log.hpp"
31 #include "runtime/globals.hpp"
32 #include "utilities/debug.hpp"
33 #include "utilities/globalDefinitions.hpp"
34
35 G1HeapSizingPolicy* G1HeapSizingPolicy::create(const G1CollectedHeap* g1h, const G1Analytics* analytics) {
36 return new G1HeapSizingPolicy(g1h, analytics);
37 }
38
39 G1HeapSizingPolicy::G1HeapSizingPolicy(const G1CollectedHeap* g1h, const G1Analytics* analytics) :
40 _g1h(g1h),
41 _analytics(analytics),
42 _num_prev_pauses_for_heuristics(analytics->number_of_recorded_pause_times()) {
43
44 assert(MinOverThresholdForGrowth < _num_prev_pauses_for_heuristics, "Threshold must be less than %u", _num_prev_pauses_for_heuristics);
45 clear_ratio_check_data();
46 }
47
48 void G1HeapSizingPolicy::clear_ratio_check_data() {
49 _ratio_over_threshold_count = 0;
50 _ratio_over_threshold_sum = 0.0;
51 _pauses_since_start = 0;
52 }
53
54 size_t G1HeapSizingPolicy::expansion_amount_after_young_collection() {
55 double recent_gc_overhead = _analytics->recent_avg_pause_time_ratio() * 100.0;
56 double last_gc_overhead = _analytics->last_pause_time_ratio() * 100.0;
57 assert(GCTimeRatio > 0,
58 "we should have set it to a default value set_g1_gc_flags() "
59 "if a user set it to 0");
60 const double gc_overhead_percent = 100.0 * (1.0 / (1.0 + GCTimeRatio));
61
62 double threshold = gc_overhead_percent;
63 size_t expand_bytes = 0;
64
65 // If the heap is at less than half its maximum size, scale the threshold down,
66 // to a limit of 1. Thus the smaller the heap is, the more likely it is to expand,
67 // though the scaling code will likely keep the increase small.
68 if (_g1h->capacity() <= _g1h->max_capacity() / 2) {
69 threshold *= (double)_g1h->capacity() / (double)(_g1h->max_capacity() / 2);
70 threshold = MAX2(threshold, 1.0);
71 }
72
73 // If the last GC time ratio is over the threshold, increment the count of
74 // times it has been exceeded, and add this ratio to the sum of exceeded
143 // Ensure the expansion size is at least the minimum growth amount
144 // and at most the remaining uncommitted byte size.
145 expand_bytes = MAX2(expand_bytes, min_expand_bytes);
146 expand_bytes = MIN2(expand_bytes, uncommitted_bytes);
147
148 clear_ratio_check_data();
149 } else {
150 // An expansion was not triggered. If we've started counting, increment
151 // the number of checks we've made in the current window. If we've
152 // reached the end of the window without resizing, clear the counters to
153 // start again the next time we see a ratio above the threshold.
154 if (_ratio_over_threshold_count > 0) {
155 _pauses_since_start++;
156 if (_pauses_since_start > _num_prev_pauses_for_heuristics) {
157 clear_ratio_check_data();
158 }
159 }
160 }
161
162 return expand_bytes;
163 }
164
165 size_t G1HeapSizingPolicy::target_heap_capacity(size_t used_bytes, uintx free_ratio) const {
166 const double free_percentage = (double) free_ratio / 100.0;
167 const double used_percentage = 1.0 - free_percentage;
168
169 // We have to be careful here as these two calculations can overflow
170 // 32-bit size_t's.
171 double used_bytes_d = (double) used_bytes;
172 double desired_capacity_d = used_bytes_d / used_percentage;
173 // Let's make sure that they are both under the max heap size, which
174 // by default will make it fit into a size_t.
175 double desired_capacity_upper_bound = (double) MaxHeapSize;
176 desired_capacity_d = MIN2(desired_capacity_d, desired_capacity_upper_bound);
177 // We can now safely turn it into size_t's.
178 return (size_t) desired_capacity_d;
179 }
180
181 size_t G1HeapSizingPolicy::shrink_amount_at_last_mixed_gc(size_t desired_bytes_after_concurrent_mark) {
182 size_t shrink_bytes = 0;
183 const size_t capacity_after_gc = _g1h->capacity();
184 const size_t used_after_gc = capacity_after_gc - _g1h->unused_committed_regions_in_bytes();
185 size_t maximum_desired_capacity = target_heap_capacity(used_after_gc, MaxHeapFreeRatio);
186 // soft_max_capacity can be smaller
187 maximum_desired_capacity = MIN2(maximum_desired_capacity, _g1h->soft_max_capacity());
188 // Make sure not less than _minimum_desired_bytes_after_last_cm
189 maximum_desired_capacity = MAX2(maximum_desired_capacity, desired_bytes_after_concurrent_mark);
190
191 if (capacity_after_gc > maximum_desired_capacity) {
192 shrink_bytes = capacity_after_gc - maximum_desired_capacity;
193 }
194
195 return shrink_bytes;
196 }
|