1/*
2 * Copyright (c) 2002, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
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#ifndef SHARE_GC_PARALLEL_PSADAPTIVESIZEPOLICY_HPP
26#define SHARE_GC_PARALLEL_PSADAPTIVESIZEPOLICY_HPP
27
28#include "gc/shared/adaptiveSizePolicy.hpp"
29#include "gc/shared/gcCause.hpp"
30#include "gc/shared/gcStats.hpp"
31#include "gc/shared/gcUtil.hpp"
32#include "utilities/align.hpp"
33
34// This class keeps statistical information and computes the
35// optimal free space for both the young and old generation
36// based on current application characteristics (based on gc cost
37// and application footprint).
38//
39// It also computes an optimal tenuring threshold between the young
40// and old generations, so as to equalize the cost of collections
41// of those generations, as well as optimal survivor space sizes
42// for the young generation.
43//
44// While this class is specifically intended for a generational system
45// consisting of a young gen (containing an Eden and two semi-spaces)
46// and a tenured gen, as well as a perm gen for reflective data, it
47// makes NO references to specific generations.
48//
49// 05/02/2003 Update
50// The 1.5 policy makes use of data gathered for the costs of GC on
51// specific generations. That data does reference specific
52// generation. Also diagnostics specific to generations have
53// been added.
54
55// Forward decls
56class elapsedTimer;
57
58class PSAdaptiveSizePolicy : public AdaptiveSizePolicy {
59 friend class PSGCAdaptivePolicyCounters;
60 private:
61 // These values are used to record decisions made during the
62 // policy. For example, if the young generation was decreased
63 // to decrease the GC cost of minor collections the value
64 // decrease_young_gen_for_throughput_true is used.
65
66 // Last calculated sizes, in bytes, and aligned
67 // NEEDS_CLEANUP should use sizes.hpp, but it works in ints, not size_t's
68
69 // Time statistics
70 AdaptivePaddedAverage* _avg_major_pause;
71
72 // Footprint statistics
73 AdaptiveWeightedAverage* _avg_base_footprint;
74
75 // Statistical data gathered for GC
76 GCStats _gc_stats;
77
78 const double _collection_cost_margin_fraction;
79
80 // Variable for estimating the major and minor pause times.
81 // These variables represent linear least-squares fits of
82 // the data.
83 // major pause time vs. old gen size
84 LinearLeastSquareFit* _major_pause_old_estimator;
85 // major pause time vs. young gen size
86 LinearLeastSquareFit* _major_pause_young_estimator;
87
88
89 // These record the most recent collection times. They
90 // are available as an alternative to using the averages
91 // for making ergonomic decisions.
92 double _latest_major_mutator_interval_seconds;
93
94 const size_t _space_alignment; // alignment for eden, survivors
95
96 const double _gc_minor_pause_goal_sec; // goal for maximum minor gc pause
97
98 // The amount of live data in the heap at the last full GC, used
99 // as a baseline to help us determine when we need to perform the
100 // next full GC.
101 size_t _live_at_last_full_gc;
102
103 // decrease/increase the old generation for minor pause time
104 int _change_old_gen_for_min_pauses;
105
106 // increase/decrease the young generation for major pause time
107 int _change_young_gen_for_maj_pauses;
108
109
110 // Flag indicating that the adaptive policy is ready to use
111 bool _old_gen_policy_is_ready;
112
113 // To facilitate faster growth at start up, supplement the normal
114 // growth percentage for the young gen eden and the
115 // old gen space for promotion with these value which decay
116 // with increasing collections.
117 uint _young_gen_size_increment_supplement;
118 uint _old_gen_size_increment_supplement;
119
120 // The number of bytes absorbed from eden into the old gen by moving the
121 // boundary over live data.
122 size_t _bytes_absorbed_from_eden;
123
124 private:
125
126 // Accessors
127 AdaptivePaddedAverage* avg_major_pause() const { return _avg_major_pause; }
128 double gc_minor_pause_goal_sec() const { return _gc_minor_pause_goal_sec; }
129
130 void adjust_eden_for_minor_pause_time(bool is_full_gc,
131 size_t* desired_eden_size_ptr);
132 // Change the generation sizes to achieve a GC pause time goal
133 // Returned sizes are not necessarily aligned.
134 void adjust_promo_for_pause_time(bool is_full_gc,
135 size_t* desired_promo_size_ptr,
136 size_t* desired_eden_size_ptr);
137 void adjust_eden_for_pause_time(bool is_full_gc,
138 size_t* desired_promo_size_ptr,
139 size_t* desired_eden_size_ptr);
140 // Change the generation sizes to achieve an application throughput goal
141 // Returned sizes are not necessarily aligned.
142 void adjust_promo_for_throughput(bool is_full_gc,
143 size_t* desired_promo_size_ptr);
144 void adjust_eden_for_throughput(bool is_full_gc,
145 size_t* desired_eden_size_ptr);
146 // Change the generation sizes to achieve minimum footprint
147 // Returned sizes are not aligned.
148 size_t adjust_promo_for_footprint(size_t desired_promo_size,
149 size_t desired_total);
150 size_t adjust_eden_for_footprint(size_t desired_promo_size,
151 size_t desired_total);
152
153 // Size in bytes for an increment or decrement of eden.
154 virtual size_t eden_increment(size_t cur_eden, uint percent_change);
155 virtual size_t eden_decrement(size_t cur_eden);
156 size_t eden_decrement_aligned_down(size_t cur_eden);
157 size_t eden_increment_with_supplement_aligned_up(size_t cur_eden);
158
159 // Size in bytes for an increment or decrement of the promotion area
160 virtual size_t promo_increment(size_t cur_promo, uint percent_change);
161 virtual size_t promo_decrement(size_t cur_promo);
162 size_t promo_decrement_aligned_down(size_t cur_promo);
163 size_t promo_increment_with_supplement_aligned_up(size_t cur_promo);
164
165 // Returns a change that has been scaled down. Result
166 // is not aligned. (If useful, move to some shared
167 // location.)
168 size_t scale_down(size_t change, double part, double total);
169
170 protected:
171 // Time accessors
172
173 // Footprint accessors
174 size_t live_space() const {
175 return (size_t)(avg_base_footprint()->average() +
176 avg_young_live()->average() +
177 avg_old_live()->average());
178 }
179 size_t free_space() const {
180 return _eden_size + _promo_size;
181 }
182
183 void set_promo_size(size_t new_size) {
184 _promo_size = new_size;
185 }
186 void set_survivor_size(size_t new_size) {
187 _survivor_size = new_size;
188 }
189
190 // Update estimators
191 void update_minor_pause_old_estimator(double minor_pause_in_ms);
192
193 virtual GCPolicyKind kind() const { return _gc_ps_adaptive_size_policy; }
194
195 public:
196 // Use by ASPSYoungGen and ASPSOldGen to limit boundary moving.
197 size_t eden_increment_aligned_up(size_t cur_eden);
198 size_t eden_increment_aligned_down(size_t cur_eden);
199 size_t promo_increment_aligned_up(size_t cur_promo);
200 size_t promo_increment_aligned_down(size_t cur_promo);
201
202 virtual size_t eden_increment(size_t cur_eden);
203 virtual size_t promo_increment(size_t cur_promo);
204
205 // Accessors for use by performance counters
206 AdaptivePaddedNoZeroDevAverage* avg_promoted() const {
207 return _gc_stats.avg_promoted();
208 }
209 AdaptiveWeightedAverage* avg_base_footprint() const {
210 return _avg_base_footprint;
211 }
212
213 // Input arguments are initial free space sizes for young and old
214 // generations, the initial survivor space size, the
215 // alignment values and the pause & throughput goals.
216 //
217 // NEEDS_CLEANUP this is a singleton object
218 PSAdaptiveSizePolicy(size_t init_eden_size,
219 size_t init_promo_size,
220 size_t init_survivor_size,
221 size_t space_alignment,
222 double gc_pause_goal_sec,
223 double gc_minor_pause_goal_sec,
224 uint gc_time_ratio);
225
226 // Methods indicating events of interest to the adaptive size policy,
227 // called by GC algorithms. It is the responsibility of users of this
228 // policy to call these methods at the correct times!
229 void major_collection_begin();
230 void major_collection_end(size_t amount_live, GCCause::Cause gc_cause);
231
232 void tenured_allocation(size_t size) {
233 _avg_pretenured->sample(size);
234 }
235
236 // Accessors
237 // NEEDS_CLEANUP should use sizes.hpp
238
239 static size_t calculate_free_based_on_live(size_t live, uintx ratio_as_percentage);
240
241 size_t calculated_old_free_size_in_bytes() const;
242
243 size_t average_old_live_in_bytes() const {
244 return (size_t) avg_old_live()->average();
245 }
246
247 size_t average_promoted_in_bytes() const {
248 return (size_t)avg_promoted()->average();
249 }
250
251 size_t padded_average_promoted_in_bytes() const {
252 return (size_t)avg_promoted()->padded_average();
253 }
254
255 int change_young_gen_for_maj_pauses() {
256 return _change_young_gen_for_maj_pauses;
257 }
258 void set_change_young_gen_for_maj_pauses(int v) {
259 _change_young_gen_for_maj_pauses = v;
260 }
261
262 int change_old_gen_for_min_pauses() {
263 return _change_old_gen_for_min_pauses;
264 }
265 void set_change_old_gen_for_min_pauses(int v) {
266 _change_old_gen_for_min_pauses = v;
267 }
268
269 // Return true if the old generation size was changed
270 // to try to reach a pause time goal.
271 bool old_gen_changed_for_pauses() {
272 bool result = _change_old_gen_for_maj_pauses != 0 ||
273 _change_old_gen_for_min_pauses != 0;
274 return result;
275 }
276
277 // Return true if the young generation size was changed
278 // to try to reach a pause time goal.
279 bool young_gen_changed_for_pauses() {
280 bool result = _change_young_gen_for_min_pauses != 0 ||
281 _change_young_gen_for_maj_pauses != 0;
282 return result;
283 }
284 // end flags for pause goal
285
286 // Return true if the old generation size was changed
287 // to try to reach a throughput goal.
288 bool old_gen_changed_for_throughput() {
289 bool result = _change_old_gen_for_throughput != 0;
290 return result;
291 }
292
293 // Return true if the young generation size was changed
294 // to try to reach a throughput goal.
295 bool young_gen_changed_for_throughput() {
296 bool result = _change_young_gen_for_throughput != 0;
297 return result;
298 }
299
300 int decrease_for_footprint() { return _decrease_for_footprint; }
301
302
303 // Accessors for estimators. The slope of the linear fit is
304 // currently all that is used for making decisions.
305
306 LinearLeastSquareFit* major_pause_old_estimator() {
307 return _major_pause_old_estimator;
308 }
309
310 LinearLeastSquareFit* major_pause_young_estimator() {
311 return _major_pause_young_estimator;
312 }
313
314
315 virtual void clear_generation_free_space_flags();
316
317 float major_pause_old_slope() { return _major_pause_old_estimator->slope(); }
318 float major_pause_young_slope() {
319 return _major_pause_young_estimator->slope();
320 }
321 float major_collection_slope() { return _major_collection_estimator->slope();}
322
323 bool old_gen_policy_is_ready() { return _old_gen_policy_is_ready; }
324
325 // Given the amount of live data in the heap, should we
326 // perform a Full GC?
327 bool should_full_GC(size_t live_in_old_gen);
328
329 // Calculates optimal (free) space sizes for both the young and old
330 // generations. Stores results in _eden_size and _promo_size.
331 // Takes current used space in all generations as input, as well
332 // as an indication if a full gc has just been performed, for use
333 // in deciding if an OOM error should be thrown.
334 void compute_generations_free_space(size_t young_live,
335 size_t eden_live,
336 size_t old_live,
337 size_t cur_eden, // current eden in bytes
338 size_t max_old_gen_size,
339 size_t max_eden_size,
340 bool is_full_gc);
341
342 void compute_eden_space_size(size_t young_live,
343 size_t eden_live,
344 size_t cur_eden, // current eden in bytes
345 size_t max_eden_size,
346 bool is_full_gc);
347
348 void compute_old_gen_free_space(size_t old_live,
349 size_t cur_eden, // current eden in bytes
350 size_t max_old_gen_size,
351 bool is_full_gc);
352
353 // Calculates new survivor space size; returns a new tenuring threshold
354 // value. Stores new survivor size in _survivor_size.
355 uint compute_survivor_space_size_and_threshold(bool is_survivor_overflow,
356 uint tenuring_threshold,
357 size_t survivor_limit);
358
359 // Return the maximum size of a survivor space if the young generation were of
360 // size gen_size.
361 size_t max_survivor_size(size_t gen_size) {
362 // Never allow the target survivor size to grow more than MinSurvivorRatio
363 // of the young generation size. We cannot grow into a two semi-space
364 // system, with Eden zero sized. Even if the survivor space grows, from()
365 // might grow by moving the bottom boundary "down" -- so from space will
366 // remain almost full anyway (top() will be near end(), but there will be a
367 // large filler object at the bottom).
368 const size_t sz = gen_size / MinSurvivorRatio;
369 const size_t alignment = _space_alignment;
370 return sz > alignment ? align_down(sz, alignment) : alignment;
371 }
372
373 size_t live_at_last_full_gc() {
374 return _live_at_last_full_gc;
375 }
376
377 size_t bytes_absorbed_from_eden() const { return _bytes_absorbed_from_eden; }
378 void reset_bytes_absorbed_from_eden() { _bytes_absorbed_from_eden = 0; }
379
380 void set_bytes_absorbed_from_eden(size_t val) {
381 _bytes_absorbed_from_eden = val;
382 }
383
384 // Update averages that are always used (even
385 // if adaptive sizing is turned off).
386 void update_averages(bool is_survivor_overflow,
387 size_t survived,
388 size_t promoted);
389
390 // Printing support
391 virtual bool print() const;
392
393 // Decay the supplemental growth additive.
394 void decay_supplemental_growth(bool is_full_gc);
395};
396
397#endif // SHARE_GC_PARALLEL_PSADAPTIVESIZEPOLICY_HPP
398