graal-jvmci-8: src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp annotate

annotate src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp @ 10374:87c64c0438fb

6976350: G1: deal with fragmentation while copying objects during GC Summary: Create G1ParGCAllocBufferContainer to contain two buffers instead of previously using one buffer, in order to hold the first priority buffer longer. Thus, when some large objects hits the value of free space left in the first priority buffer it has an alternative to fit in the second priority buffer while the first priority buffer is given more chances to try allocating smaller objects. Overall, it will improve heap space efficiency. Reviewed-by: johnc, jmasa, brutisso Contributed-by: tamao <tao.mao@oracle.com>

author	tamao
date	Mon, 03 Jun 2013 14:37:13 -0700
parents	14d3f71f831d
children	63a4eb8bcd23 78bbf4d43a14

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10359 14d3f71f831d 8007762: Rename a bunch of methods in size policy across collectors tamao parents: 6818 diff changeset	2 * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #include "gc_implementation/shared/adaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "gc_interface/gcCause.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "memory/collectorPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "runtime/timer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "utilities/ostream.hpp"
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	31 #include "utilities/workgroup.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	32 elapsedTimer AdaptiveSizePolicy::_minor_timer;
a61af66fc99e Initial load duke parents: diff changeset	33 elapsedTimer AdaptiveSizePolicy::_major_timer;
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	34 bool AdaptiveSizePolicy::_debug_perturbation = false;
0 a61af66fc99e Initial load duke parents: diff changeset	35
a61af66fc99e Initial load duke parents: diff changeset	36 // The throughput goal is implemented as
a61af66fc99e Initial load duke parents: diff changeset	37 // _throughput_goal = 1 - ( 1 / (1 + gc_cost_ratio))
a61af66fc99e Initial load duke parents: diff changeset	38 // gc_cost_ratio is the ratio
a61af66fc99e Initial load duke parents: diff changeset	39 // application cost / gc cost
a61af66fc99e Initial load duke parents: diff changeset	40 // For example a gc_cost_ratio of 4 translates into a
a61af66fc99e Initial load duke parents: diff changeset	41 // throughput goal of .80
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43 AdaptiveSizePolicy::AdaptiveSizePolicy(size_t init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	44 size_t init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	45 size_t init_survivor_size,
a61af66fc99e Initial load duke parents: diff changeset	46 double gc_pause_goal_sec,
a61af66fc99e Initial load duke parents: diff changeset	47 uint gc_cost_ratio) :
a61af66fc99e Initial load duke parents: diff changeset	48 _eden_size(init_eden_size),
a61af66fc99e Initial load duke parents: diff changeset	49 _promo_size(init_promo_size),
a61af66fc99e Initial load duke parents: diff changeset	50 _survivor_size(init_survivor_size),
a61af66fc99e Initial load duke parents: diff changeset	51 _gc_pause_goal_sec(gc_pause_goal_sec),
a61af66fc99e Initial load duke parents: diff changeset	52 _throughput_goal(1.0 - double(1.0 / (1.0 + (double) gc_cost_ratio))),
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	53 _gc_overhead_limit_exceeded(false),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	54 _print_gc_overhead_limit_would_be_exceeded(false),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	55 _gc_overhead_limit_count(0),
0 a61af66fc99e Initial load duke parents: diff changeset	56 _latest_minor_mutator_interval_seconds(0),
a61af66fc99e Initial load duke parents: diff changeset	57 _threshold_tolerance_percent(1.0 + ThresholdTolerance/100.0),
a61af66fc99e Initial load duke parents: diff changeset	58 _young_gen_change_for_minor_throughput(0),
a61af66fc99e Initial load duke parents: diff changeset	59 _old_gen_change_for_major_throughput(0) {
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	60 assert(AdaptiveSizePolicyGCTimeLimitThreshold > 0,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	61 "No opportunity to clear SoftReferences before GC overhead limit");
0 a61af66fc99e Initial load duke parents: diff changeset	62 _avg_minor_pause =
a61af66fc99e Initial load duke parents: diff changeset	63 new AdaptivePaddedAverage(AdaptiveTimeWeight, PausePadding);
a61af66fc99e Initial load duke parents: diff changeset	64 _avg_minor_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
a61af66fc99e Initial load duke parents: diff changeset	65 _avg_minor_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
a61af66fc99e Initial load duke parents: diff changeset	66 _avg_major_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68 _avg_young_live = new AdaptiveWeightedAverage(AdaptiveSizePolicyWeight);
a61af66fc99e Initial load duke parents: diff changeset	69 _avg_old_live = new AdaptiveWeightedAverage(AdaptiveSizePolicyWeight);
a61af66fc99e Initial load duke parents: diff changeset	70 _avg_eden_live = new AdaptiveWeightedAverage(AdaptiveSizePolicyWeight);
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 _avg_survived = new AdaptivePaddedAverage(AdaptiveSizePolicyWeight,
a61af66fc99e Initial load duke parents: diff changeset	73 SurvivorPadding);
a61af66fc99e Initial load duke parents: diff changeset	74 _avg_pretenured = new AdaptivePaddedNoZeroDevAverage(
a61af66fc99e Initial load duke parents: diff changeset	75 AdaptiveSizePolicyWeight,
a61af66fc99e Initial load duke parents: diff changeset	76 SurvivorPadding);
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 _minor_pause_old_estimator =
a61af66fc99e Initial load duke parents: diff changeset	79 new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
a61af66fc99e Initial load duke parents: diff changeset	80 _minor_pause_young_estimator =
a61af66fc99e Initial load duke parents: diff changeset	81 new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
a61af66fc99e Initial load duke parents: diff changeset	82 _minor_collection_estimator =
a61af66fc99e Initial load duke parents: diff changeset	83 new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
a61af66fc99e Initial load duke parents: diff changeset	84 _major_collection_estimator =
a61af66fc99e Initial load duke parents: diff changeset	85 new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 // Start the timers
a61af66fc99e Initial load duke parents: diff changeset	88 _minor_timer.start();
a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90 _young_gen_policy_is_ready = false;
a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	93 // If the number of GC threads was set on the command line,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	94 // use it.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	95 // Else
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	96 // Calculate the number of GC threads based on the number of Java threads.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	97 // Calculate the number of GC threads based on the size of the heap.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	98 // Use the larger.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	99
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	100 int AdaptiveSizePolicy::calc_default_active_workers(uintx total_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	101 const uintx min_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	102 uintx active_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	103 uintx application_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	104 // If the user has specifically set the number of
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	105 // GC threads, use them.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	106
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	107 // If the user has turned off using a dynamic number of GC threads
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	108 // or the users has requested a specific number, set the active
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	109 // number of workers to all the workers.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	110
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	111 uintx new_active_workers = total_workers;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	112 uintx prev_active_workers = active_workers;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	113 uintx active_workers_by_JT = 0;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	114 uintx active_workers_by_heap_size = 0;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	115
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	116 // Always use at least min_workers but use up to
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	117 // GCThreadsPerJavaThreads * application threads.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	118 active_workers_by_JT =
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	119 MAX2((uintx) GCWorkersPerJavaThread * application_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	120 min_workers);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	121
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	122 // Choose a number of GC threads based on the current size
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	123 // of the heap. This may be complicated because the size of
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	124 // the heap depends on factors such as the thoughput goal.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	125 // Still a large heap should be collected by more GC threads.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	126 active_workers_by_heap_size =
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	127 MAX2((size_t) 2U, Universe::heap()->capacity() / HeapSizePerGCThread);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	128
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	129 uintx max_active_workers =
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	130 MAX2(active_workers_by_JT, active_workers_by_heap_size);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	131
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	132 // Limit the number of workers to the the number created,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	133 // (workers()).
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	134 new_active_workers = MIN2(max_active_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	135 (uintx) total_workers);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	136
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	137 // Increase GC workers instantly but decrease them more
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	138 // slowly.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	139 if (new_active_workers < prev_active_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	140 new_active_workers =
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	141 MAX2(min_workers, (prev_active_workers + new_active_workers) / 2);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	142 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	143
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	144 // Check once more that the number of workers is within the limits.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	145 assert(min_workers <= total_workers, "Minimum workers not consistent with total workers");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	146 assert(new_active_workers >= min_workers, "Minimum workers not observed");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	147 assert(new_active_workers <= total_workers, "Total workers not observed");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	148
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	149 if (ForceDynamicNumberOfGCThreads) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	150 // Assume this is debugging and jiggle the number of GC threads.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	151 if (new_active_workers == prev_active_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	152 if (new_active_workers < total_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	153 new_active_workers++;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	154 } else if (new_active_workers > min_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	155 new_active_workers--;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	156 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	157 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	158 if (new_active_workers == total_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	159 if (_debug_perturbation) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	160 new_active_workers = min_workers;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	161 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	162 _debug_perturbation = !_debug_perturbation;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	163 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	164 assert((new_active_workers <= (uintx) ParallelGCThreads) &&
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	165 (new_active_workers >= min_workers),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	166 "Jiggled active workers too much");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	167 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	168
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	169 if (TraceDynamicGCThreads) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	170 gclog_or_tty->print_cr("GCTaskManager::calc_default_active_workers() : "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	171 "active_workers(): %d new_acitve_workers: %d "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	172 "prev_active_workers: %d\n"
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	173 " active_workers_by_JT: %d active_workers_by_heap_size: %d",
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	174 active_workers, new_active_workers, prev_active_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	175 active_workers_by_JT, active_workers_by_heap_size);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	176 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	177 assert(new_active_workers > 0, "Always need at least 1");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	178 return new_active_workers;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	179 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	180
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	181 int AdaptiveSizePolicy::calc_active_workers(uintx total_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	182 uintx active_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	183 uintx application_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	184 // If the user has specifically set the number of
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	185 // GC threads, use them.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	186
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	187 // If the user has turned off using a dynamic number of GC threads
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	188 // or the users has requested a specific number, set the active
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	189 // number of workers to all the workers.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	190
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	191 int new_active_workers;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	192 if (!UseDynamicNumberOfGCThreads \|\|
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	193 (!FLAG_IS_DEFAULT(ParallelGCThreads) && !ForceDynamicNumberOfGCThreads)) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	194 new_active_workers = total_workers;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	195 } else {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	196 new_active_workers = calc_default_active_workers(total_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	197 2, /* Minimum number of workers */
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	198 active_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	199 application_workers);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	200 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	201 assert(new_active_workers > 0, "Always need at least 1");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	202 return new_active_workers;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	203 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	204
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	205 int AdaptiveSizePolicy::calc_active_conc_workers(uintx total_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	206 uintx active_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	207 uintx application_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	208 if (!UseDynamicNumberOfGCThreads \|\|
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	209 (!FLAG_IS_DEFAULT(ConcGCThreads) && !ForceDynamicNumberOfGCThreads)) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	210 return ConcGCThreads;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	211 } else {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	212 int no_of_gc_threads = calc_default_active_workers(
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	213 total_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	214 1, /* Minimum number of workers */
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	215 active_workers,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	216 application_workers);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	217 return no_of_gc_threads;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	218 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	219 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	220
0 a61af66fc99e Initial load duke parents: diff changeset	221 bool AdaptiveSizePolicy::tenuring_threshold_change() const {
a61af66fc99e Initial load duke parents: diff changeset	222 return decrement_tenuring_threshold_for_gc_cost() \|\|
a61af66fc99e Initial load duke parents: diff changeset	223 increment_tenuring_threshold_for_gc_cost() \|\|
a61af66fc99e Initial load duke parents: diff changeset	224 decrement_tenuring_threshold_for_survivor_limit();
a61af66fc99e Initial load duke parents: diff changeset	225 }
a61af66fc99e Initial load duke parents: diff changeset	226
a61af66fc99e Initial load duke parents: diff changeset	227 void AdaptiveSizePolicy::minor_collection_begin() {
a61af66fc99e Initial load duke parents: diff changeset	228 // Update the interval time
a61af66fc99e Initial load duke parents: diff changeset	229 _minor_timer.stop();
a61af66fc99e Initial load duke parents: diff changeset	230 // Save most recent collection time
a61af66fc99e Initial load duke parents: diff changeset	231 _latest_minor_mutator_interval_seconds = _minor_timer.seconds();
a61af66fc99e Initial load duke parents: diff changeset	232 _minor_timer.reset();
a61af66fc99e Initial load duke parents: diff changeset	233 _minor_timer.start();
a61af66fc99e Initial load duke parents: diff changeset	234 }
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 void AdaptiveSizePolicy::update_minor_pause_young_estimator(
a61af66fc99e Initial load duke parents: diff changeset	237 double minor_pause_in_ms) {
a61af66fc99e Initial load duke parents: diff changeset	238 double eden_size_in_mbytes = ((double)_eden_size)/((double)M);
a61af66fc99e Initial load duke parents: diff changeset	239 _minor_pause_young_estimator->update(eden_size_in_mbytes,
a61af66fc99e Initial load duke parents: diff changeset	240 minor_pause_in_ms);
a61af66fc99e Initial load duke parents: diff changeset	241 }
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 void AdaptiveSizePolicy::minor_collection_end(GCCause::Cause gc_cause) {
a61af66fc99e Initial load duke parents: diff changeset	244 // Update the pause time.
a61af66fc99e Initial load duke parents: diff changeset	245 _minor_timer.stop();
a61af66fc99e Initial load duke parents: diff changeset	246
a61af66fc99e Initial load duke parents: diff changeset	247 if (gc_cause != GCCause::_java_lang_system_gc \|\|
a61af66fc99e Initial load duke parents: diff changeset	248 UseAdaptiveSizePolicyWithSystemGC) {
a61af66fc99e Initial load duke parents: diff changeset	249 double minor_pause_in_seconds = _minor_timer.seconds();
a61af66fc99e Initial load duke parents: diff changeset	250 double minor_pause_in_ms = minor_pause_in_seconds * MILLIUNITS;
a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252 // Sample for performance counter
a61af66fc99e Initial load duke parents: diff changeset	253 _avg_minor_pause->sample(minor_pause_in_seconds);
a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255 // Cost of collection (unit-less)
a61af66fc99e Initial load duke parents: diff changeset	256 double collection_cost = 0.0;
a61af66fc99e Initial load duke parents: diff changeset	257 if ((_latest_minor_mutator_interval_seconds > 0.0) &&
a61af66fc99e Initial load duke parents: diff changeset	258 (minor_pause_in_seconds > 0.0)) {
a61af66fc99e Initial load duke parents: diff changeset	259 double interval_in_seconds =
a61af66fc99e Initial load duke parents: diff changeset	260 _latest_minor_mutator_interval_seconds + minor_pause_in_seconds;
a61af66fc99e Initial load duke parents: diff changeset	261 collection_cost =
a61af66fc99e Initial load duke parents: diff changeset	262 minor_pause_in_seconds / interval_in_seconds;
a61af66fc99e Initial load duke parents: diff changeset	263 _avg_minor_gc_cost->sample(collection_cost);
a61af66fc99e Initial load duke parents: diff changeset	264 // Sample for performance counter
a61af66fc99e Initial load duke parents: diff changeset	265 _avg_minor_interval->sample(interval_in_seconds);
a61af66fc99e Initial load duke parents: diff changeset	266 }
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // The policy does not have enough data until at least some
a61af66fc99e Initial load duke parents: diff changeset	269 // minor collections have been done.
a61af66fc99e Initial load duke parents: diff changeset	270 _young_gen_policy_is_ready =
a61af66fc99e Initial load duke parents: diff changeset	271 (_avg_minor_gc_cost->count() >= AdaptiveSizePolicyReadyThreshold);
a61af66fc99e Initial load duke parents: diff changeset	272
a61af66fc99e Initial load duke parents: diff changeset	273 // Calculate variables used to estimate pause time vs. gen sizes
a61af66fc99e Initial load duke parents: diff changeset	274 double eden_size_in_mbytes = ((double)_eden_size)/((double)M);
a61af66fc99e Initial load duke parents: diff changeset	275 update_minor_pause_young_estimator(minor_pause_in_ms);
a61af66fc99e Initial load duke parents: diff changeset	276 update_minor_pause_old_estimator(minor_pause_in_ms);
a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 if (PrintAdaptiveSizePolicy && Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	279 gclog_or_tty->print("AdaptiveSizePolicy::minor_collection_end: "
a61af66fc99e Initial load duke parents: diff changeset	280 "minor gc cost: %f average: %f", collection_cost,
a61af66fc99e Initial load duke parents: diff changeset	281 _avg_minor_gc_cost->average());
a61af66fc99e Initial load duke parents: diff changeset	282 gclog_or_tty->print_cr(" minor pause: %f minor period %f",
a61af66fc99e Initial load duke parents: diff changeset	283 minor_pause_in_ms,
a61af66fc99e Initial load duke parents: diff changeset	284 _latest_minor_mutator_interval_seconds * MILLIUNITS);
a61af66fc99e Initial load duke parents: diff changeset	285 }
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 // Calculate variable used to estimate collection cost vs. gen sizes
a61af66fc99e Initial load duke parents: diff changeset	288 assert(collection_cost >= 0.0, "Expected to be non-negative");
a61af66fc99e Initial load duke parents: diff changeset	289 _minor_collection_estimator->update(eden_size_in_mbytes, collection_cost);
a61af66fc99e Initial load duke parents: diff changeset	290 }
a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 // Interval times use this timer to measure the mutator time.
a61af66fc99e Initial load duke parents: diff changeset	293 // Reset the timer after the GC pause.
a61af66fc99e Initial load duke parents: diff changeset	294 _minor_timer.reset();
a61af66fc99e Initial load duke parents: diff changeset	295 _minor_timer.start();
a61af66fc99e Initial load duke parents: diff changeset	296 }
a61af66fc99e Initial load duke parents: diff changeset	297
a61af66fc99e Initial load duke parents: diff changeset	298 size_t AdaptiveSizePolicy::eden_increment(size_t cur_eden,
a61af66fc99e Initial load duke parents: diff changeset	299 uint percent_change) {
a61af66fc99e Initial load duke parents: diff changeset	300 size_t eden_heap_delta;
a61af66fc99e Initial load duke parents: diff changeset	301 eden_heap_delta = cur_eden / 100 * percent_change;
a61af66fc99e Initial load duke parents: diff changeset	302 return eden_heap_delta;
a61af66fc99e Initial load duke parents: diff changeset	303 }
a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 size_t AdaptiveSizePolicy::eden_increment(size_t cur_eden) {
a61af66fc99e Initial load duke parents: diff changeset	306 return eden_increment(cur_eden, YoungGenerationSizeIncrement);
a61af66fc99e Initial load duke parents: diff changeset	307 }
a61af66fc99e Initial load duke parents: diff changeset	308
a61af66fc99e Initial load duke parents: diff changeset	309 size_t AdaptiveSizePolicy::eden_decrement(size_t cur_eden) {
a61af66fc99e Initial load duke parents: diff changeset	310 size_t eden_heap_delta = eden_increment(cur_eden) /
a61af66fc99e Initial load duke parents: diff changeset	311 AdaptiveSizeDecrementScaleFactor;
a61af66fc99e Initial load duke parents: diff changeset	312 return eden_heap_delta;
a61af66fc99e Initial load duke parents: diff changeset	313 }
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 size_t AdaptiveSizePolicy::promo_increment(size_t cur_promo,
a61af66fc99e Initial load duke parents: diff changeset	316 uint percent_change) {
a61af66fc99e Initial load duke parents: diff changeset	317 size_t promo_heap_delta;
a61af66fc99e Initial load duke parents: diff changeset	318 promo_heap_delta = cur_promo / 100 * percent_change;
a61af66fc99e Initial load duke parents: diff changeset	319 return promo_heap_delta;
a61af66fc99e Initial load duke parents: diff changeset	320 }
a61af66fc99e Initial load duke parents: diff changeset	321
a61af66fc99e Initial load duke parents: diff changeset	322 size_t AdaptiveSizePolicy::promo_increment(size_t cur_promo) {
a61af66fc99e Initial load duke parents: diff changeset	323 return promo_increment(cur_promo, TenuredGenerationSizeIncrement);
a61af66fc99e Initial load duke parents: diff changeset	324 }
a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 size_t AdaptiveSizePolicy::promo_decrement(size_t cur_promo) {
a61af66fc99e Initial load duke parents: diff changeset	327 size_t promo_heap_delta = promo_increment(cur_promo);
a61af66fc99e Initial load duke parents: diff changeset	328 promo_heap_delta = promo_heap_delta / AdaptiveSizeDecrementScaleFactor;
a61af66fc99e Initial load duke parents: diff changeset	329 return promo_heap_delta;
a61af66fc99e Initial load duke parents: diff changeset	330 }
a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 double AdaptiveSizePolicy::time_since_major_gc() const {
a61af66fc99e Initial load duke parents: diff changeset	333 _major_timer.stop();
a61af66fc99e Initial load duke parents: diff changeset	334 double result = _major_timer.seconds();
a61af66fc99e Initial load duke parents: diff changeset	335 _major_timer.start();
a61af66fc99e Initial load duke parents: diff changeset	336 return result;
a61af66fc99e Initial load duke parents: diff changeset	337 }
a61af66fc99e Initial load duke parents: diff changeset	338
a61af66fc99e Initial load duke parents: diff changeset	339 // Linear decay of major gc cost
a61af66fc99e Initial load duke parents: diff changeset	340 double AdaptiveSizePolicy::decaying_major_gc_cost() const {
a61af66fc99e Initial load duke parents: diff changeset	341 double major_interval = major_gc_interval_average_for_decay();
a61af66fc99e Initial load duke parents: diff changeset	342 double major_gc_cost_average = major_gc_cost();
a61af66fc99e Initial load duke parents: diff changeset	343 double decayed_major_gc_cost = major_gc_cost_average;
a61af66fc99e Initial load duke parents: diff changeset	344 if(time_since_major_gc() > 0.0) {
a61af66fc99e Initial load duke parents: diff changeset	345 decayed_major_gc_cost = major_gc_cost() *
a61af66fc99e Initial load duke parents: diff changeset	346 (((double) AdaptiveSizeMajorGCDecayTimeScale) * major_interval)
a61af66fc99e Initial load duke parents: diff changeset	347 / time_since_major_gc();
a61af66fc99e Initial load duke parents: diff changeset	348 }
a61af66fc99e Initial load duke parents: diff changeset	349
a61af66fc99e Initial load duke parents: diff changeset	350 // The decayed cost should always be smaller than the
a61af66fc99e Initial load duke parents: diff changeset	351 // average cost but the vagaries of finite arithmetic could
a61af66fc99e Initial load duke parents: diff changeset	352 // produce a larger value in decayed_major_gc_cost so protect
a61af66fc99e Initial load duke parents: diff changeset	353 // against that.
a61af66fc99e Initial load duke parents: diff changeset	354 return MIN2(major_gc_cost_average, decayed_major_gc_cost);
a61af66fc99e Initial load duke parents: diff changeset	355 }
a61af66fc99e Initial load duke parents: diff changeset	356
a61af66fc99e Initial load duke parents: diff changeset	357 // Use a value of the major gc cost that has been decayed
a61af66fc99e Initial load duke parents: diff changeset	358 // by the factor
a61af66fc99e Initial load duke parents: diff changeset	359 //
a61af66fc99e Initial load duke parents: diff changeset	360 // average-interval-between-major-gc * AdaptiveSizeMajorGCDecayTimeScale /
a61af66fc99e Initial load duke parents: diff changeset	361 // time-since-last-major-gc
a61af66fc99e Initial load duke parents: diff changeset	362 //
a61af66fc99e Initial load duke parents: diff changeset	363 // if the average-interval-between-major-gc * AdaptiveSizeMajorGCDecayTimeScale
a61af66fc99e Initial load duke parents: diff changeset	364 // is less than time-since-last-major-gc.
a61af66fc99e Initial load duke parents: diff changeset	365 //
a61af66fc99e Initial load duke parents: diff changeset	366 // In cases where there are initial major gc's that
a61af66fc99e Initial load duke parents: diff changeset	367 // are of a relatively high cost but no later major
a61af66fc99e Initial load duke parents: diff changeset	368 // gc's, the total gc cost can remain high because
a61af66fc99e Initial load duke parents: diff changeset	369 // the major gc cost remains unchanged (since there are no major
a61af66fc99e Initial load duke parents: diff changeset	370 // gc's). In such a situation the value of the unchanging
a61af66fc99e Initial load duke parents: diff changeset	371 // major gc cost can keep the mutator throughput below
a61af66fc99e Initial load duke parents: diff changeset	372 // the goal when in fact the major gc cost is becoming diminishingly
a61af66fc99e Initial load duke parents: diff changeset	373 // small. Use the decaying gc cost only to decide whether to
a61af66fc99e Initial load duke parents: diff changeset	374 // adjust for throughput. Using it also to determine the adjustment
a61af66fc99e Initial load duke parents: diff changeset	375 // to be made for throughput also seems reasonable but there is
a61af66fc99e Initial load duke parents: diff changeset	376 // no test case to use to decide if it is the right thing to do
a61af66fc99e Initial load duke parents: diff changeset	377 // don't do it yet.
a61af66fc99e Initial load duke parents: diff changeset	378
a61af66fc99e Initial load duke parents: diff changeset	379 double AdaptiveSizePolicy::decaying_gc_cost() const {
a61af66fc99e Initial load duke parents: diff changeset	380 double decayed_major_gc_cost = major_gc_cost();
a61af66fc99e Initial load duke parents: diff changeset	381 double avg_major_interval = major_gc_interval_average_for_decay();
a61af66fc99e Initial load duke parents: diff changeset	382 if (UseAdaptiveSizeDecayMajorGCCost &&
a61af66fc99e Initial load duke parents: diff changeset	383 (AdaptiveSizeMajorGCDecayTimeScale > 0) &&
a61af66fc99e Initial load duke parents: diff changeset	384 (avg_major_interval > 0.00)) {
a61af66fc99e Initial load duke parents: diff changeset	385 double time_since_last_major_gc = time_since_major_gc();
a61af66fc99e Initial load duke parents: diff changeset	386
a61af66fc99e Initial load duke parents: diff changeset	387 // Decay the major gc cost?
a61af66fc99e Initial load duke parents: diff changeset	388 if (time_since_last_major_gc >
a61af66fc99e Initial load duke parents: diff changeset	389 ((double) AdaptiveSizeMajorGCDecayTimeScale) * avg_major_interval) {
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 // Decay using the time-since-last-major-gc
a61af66fc99e Initial load duke parents: diff changeset	392 decayed_major_gc_cost = decaying_major_gc_cost();
a61af66fc99e Initial load duke parents: diff changeset	393 if (PrintGCDetails && Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	394 gclog_or_tty->print_cr("\ndecaying_gc_cost: major interval average:"
a61af66fc99e Initial load duke parents: diff changeset	395 " %f time since last major gc: %f",
a61af66fc99e Initial load duke parents: diff changeset	396 avg_major_interval, time_since_last_major_gc);
a61af66fc99e Initial load duke parents: diff changeset	397 gclog_or_tty->print_cr(" major gc cost: %f decayed major gc cost: %f",
a61af66fc99e Initial load duke parents: diff changeset	398 major_gc_cost(), decayed_major_gc_cost);
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400 }
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402 double result = MIN2(1.0, decayed_major_gc_cost + minor_gc_cost());
a61af66fc99e Initial load duke parents: diff changeset	403 return result;
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 void AdaptiveSizePolicy::clear_generation_free_space_flags() {
a61af66fc99e Initial load duke parents: diff changeset	408 set_change_young_gen_for_min_pauses(0);
a61af66fc99e Initial load duke parents: diff changeset	409 set_change_old_gen_for_maj_pauses(0);
a61af66fc99e Initial load duke parents: diff changeset	410
a61af66fc99e Initial load duke parents: diff changeset	411 set_change_old_gen_for_throughput(0);
a61af66fc99e Initial load duke parents: diff changeset	412 set_change_young_gen_for_throughput(0);
a61af66fc99e Initial load duke parents: diff changeset	413 set_decrease_for_footprint(0);
a61af66fc99e Initial load duke parents: diff changeset	414 set_decide_at_full_gc(0);
a61af66fc99e Initial load duke parents: diff changeset	415 }
a61af66fc99e Initial load duke parents: diff changeset	416
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	417 void AdaptiveSizePolicy::check_gc_overhead_limit(
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	418 size_t young_live,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	419 size_t eden_live,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	420 size_t max_old_gen_size,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	421 size_t max_eden_size,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	422 bool is_full_gc,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	423 GCCause::Cause gc_cause,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	424 CollectorPolicy* collector_policy) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	425
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	426 // Ignore explicit GC's. Exiting here does not set the flag and
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	427 // does not reset the count. Updating of the averages for system
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	428 // GC's is still controlled by UseAdaptiveSizePolicyWithSystemGC.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	429 if (GCCause::is_user_requested_gc(gc_cause) \|\|
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	430 GCCause::is_serviceability_requested_gc(gc_cause)) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	431 return;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	432 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	433 // eden_limit is the upper limit on the size of eden based on
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	434 // the maximum size of the young generation and the sizes
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	435 // of the survivor space.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	436 // The question being asked is whether the gc costs are high
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	437 // and the space being recovered by a collection is low.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	438 // free_in_young_gen is the free space in the young generation
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	439 // after a collection and promo_live is the free space in the old
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	440 // generation after a collection.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	441 //
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	442 // Use the minimum of the current value of the live in the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	443 // young gen or the average of the live in the young gen.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	444 // If the current value drops quickly, that should be taken
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	445 // into account (i.e., don't trigger if the amount of free
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	446 // space has suddenly jumped up). If the current is much
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	447 // higher than the average, use the average since it represents
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	448 // the longer term behavor.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	449 const size_t live_in_eden =
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	450 MIN2(eden_live, (size_t) avg_eden_live()->average());
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	451 const size_t free_in_eden = max_eden_size > live_in_eden ?
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	452 max_eden_size - live_in_eden : 0;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	453 const size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average());
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	454 const size_t total_free_limit = free_in_old_gen + free_in_eden;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	455 const size_t total_mem = max_old_gen_size + max_eden_size;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	456 const double mem_free_limit = total_mem * (GCHeapFreeLimit/100.0);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	457 const double mem_free_old_limit = max_old_gen_size * (GCHeapFreeLimit/100.0);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	458 const double mem_free_eden_limit = max_eden_size * (GCHeapFreeLimit/100.0);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	459 const double gc_cost_limit = GCTimeLimit/100.0;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	460 size_t promo_limit = (size_t)(max_old_gen_size - avg_old_live()->average());
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	461 // But don't force a promo size below the current promo size. Otherwise,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	462 // the promo size will shrink for no good reason.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	463 promo_limit = MAX2(promo_limit, _promo_size);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	464
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	465
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	466 if (PrintAdaptiveSizePolicy && (Verbose \|\|
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	467 (free_in_old_gen < (size_t) mem_free_old_limit &&
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	468 free_in_eden < (size_t) mem_free_eden_limit))) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	469 gclog_or_tty->print_cr(
10359 14d3f71f831d 8007762: Rename a bunch of methods in size policy across collectors tamao parents: 6818 diff changeset	470 "PSAdaptiveSizePolicy::check_gc_overhead_limit:"
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	471 " promo_limit: " SIZE_FORMAT
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	472 " max_eden_size: " SIZE_FORMAT
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	473 " total_free_limit: " SIZE_FORMAT
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	474 " max_old_gen_size: " SIZE_FORMAT
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	475 " max_eden_size: " SIZE_FORMAT
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	476 " mem_free_limit: " SIZE_FORMAT,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	477 promo_limit, max_eden_size, total_free_limit,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	478 max_old_gen_size, max_eden_size,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	479 (size_t) mem_free_limit);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	480 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	481
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	482 bool print_gc_overhead_limit_would_be_exceeded = false;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	483 if (is_full_gc) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	484 if (gc_cost() > gc_cost_limit &&
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	485 free_in_old_gen < (size_t) mem_free_old_limit &&
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	486 free_in_eden < (size_t) mem_free_eden_limit) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	487 // Collections, on average, are taking too much time, and
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	488 // gc_cost() > gc_cost_limit
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	489 // we have too little space available after a full gc.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	490 // total_free_limit < mem_free_limit
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	491 // where
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	492 // total_free_limit is the free space available in
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	493 // both generations
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	494 // total_mem is the total space available for allocation
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	495 // in both generations (survivor spaces are not included
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	496 // just as they are not included in eden_limit).
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	497 // mem_free_limit is a fraction of total_mem judged to be an
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	498 // acceptable amount that is still unused.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	499 // The heap can ask for the value of this variable when deciding
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	500 // whether to thrown an OutOfMemory error.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	501 // Note that the gc time limit test only works for the collections
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	502 // of the young gen + tenured gen and not for collections of the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	503 // permanent gen. That is because the calculation of the space
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	504 // freed by the collection is the free space in the young gen +
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	505 // tenured gen.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	506 // At this point the GC overhead limit is being exceeded.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	507 inc_gc_overhead_limit_count();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	508 if (UseGCOverheadLimit) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	509 if (gc_overhead_limit_count() >=
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	510 AdaptiveSizePolicyGCTimeLimitThreshold){
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	511 // All conditions have been met for throwing an out-of-memory
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	512 set_gc_overhead_limit_exceeded(true);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	513 // Avoid consecutive OOM due to the gc time limit by resetting
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	514 // the counter.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	515 reset_gc_overhead_limit_count();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	516 } else {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	517 // The required consecutive collections which exceed the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	518 // GC time limit may or may not have been reached. We
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	519 // are approaching that condition and so as not to
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	520 // throw an out-of-memory before all SoftRef's have been
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	521 // cleared, set _should_clear_all_soft_refs in CollectorPolicy.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	522 // The clearing will be done on the next GC.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	523 bool near_limit = gc_overhead_limit_near();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	524 if (near_limit) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	525 collector_policy->set_should_clear_all_soft_refs(true);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	526 if (PrintGCDetails && Verbose) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	527 gclog_or_tty->print_cr(" Nearing GC overhead limit, "
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	528 "will be clearing all SoftReference");
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	529 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	530 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	531 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	532 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	533 // Set this even when the overhead limit will not
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	534 // cause an out-of-memory. Diagnostic message indicating
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	535 // that the overhead limit is being exceeded is sometimes
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	536 // printed.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	537 print_gc_overhead_limit_would_be_exceeded = true;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	538
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	539 } else {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	540 // Did not exceed overhead limits
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	541 reset_gc_overhead_limit_count();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	542 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	543 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	544
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	545 if (UseGCOverheadLimit && PrintGCDetails && Verbose) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	546 if (gc_overhead_limit_exceeded()) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	547 gclog_or_tty->print_cr(" GC is exceeding overhead limit "
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	548 "of %d%%", GCTimeLimit);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	549 reset_gc_overhead_limit_count();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	550 } else if (print_gc_overhead_limit_would_be_exceeded) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	551 assert(gc_overhead_limit_count() > 0, "Should not be printing");
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	552 gclog_or_tty->print_cr(" GC would exceed overhead limit "
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	553 "of %d%% %d consecutive time(s)",
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	554 GCTimeLimit, gc_overhead_limit_count());
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	555 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	556 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 0 diff changeset	557 }
0 a61af66fc99e Initial load duke parents: diff changeset	558 // Printing
a61af66fc99e Initial load duke parents: diff changeset	559
a61af66fc99e Initial load duke parents: diff changeset	560 bool AdaptiveSizePolicy::print_adaptive_size_policy_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	561
a61af66fc99e Initial load duke parents: diff changeset	562 // Should only be used with adaptive size policy turned on.
a61af66fc99e Initial load duke parents: diff changeset	563 // Otherwise, there may be variables that are undefined.
a61af66fc99e Initial load duke parents: diff changeset	564 if (!UseAdaptiveSizePolicy) return false;
a61af66fc99e Initial load duke parents: diff changeset	565
a61af66fc99e Initial load duke parents: diff changeset	566 // Print goal for which action is needed.
a61af66fc99e Initial load duke parents: diff changeset	567 char* action = NULL;
a61af66fc99e Initial load duke parents: diff changeset	568 bool change_for_pause = false;
a61af66fc99e Initial load duke parents: diff changeset	569 if ((change_old_gen_for_maj_pauses() ==
a61af66fc99e Initial load duke parents: diff changeset	570 decrease_old_gen_for_maj_pauses_true) \|\|
a61af66fc99e Initial load duke parents: diff changeset	571 (change_young_gen_for_min_pauses() ==
a61af66fc99e Initial load duke parents: diff changeset	572 decrease_young_gen_for_min_pauses_true)) {
a61af66fc99e Initial load duke parents: diff changeset	573 action = (char) " pause time goal *";
a61af66fc99e Initial load duke parents: diff changeset	574 change_for_pause = true;
a61af66fc99e Initial load duke parents: diff changeset	575 } else if ((change_old_gen_for_throughput() ==
a61af66fc99e Initial load duke parents: diff changeset	576 increase_old_gen_for_throughput_true) \|\|
a61af66fc99e Initial load duke parents: diff changeset	577 (change_young_gen_for_throughput() ==
a61af66fc99e Initial load duke parents: diff changeset	578 increase_young_gen_for_througput_true)) {
a61af66fc99e Initial load duke parents: diff changeset	579 action = (char) " throughput goal *";
a61af66fc99e Initial load duke parents: diff changeset	580 } else if (decrease_for_footprint()) {
a61af66fc99e Initial load duke parents: diff changeset	581 action = (char) " reduced footprint *";
a61af66fc99e Initial load duke parents: diff changeset	582 } else {
a61af66fc99e Initial load duke parents: diff changeset	583 // No actions were taken. This can legitimately be the
a61af66fc99e Initial load duke parents: diff changeset	584 // situation if not enough data has been gathered to make
a61af66fc99e Initial load duke parents: diff changeset	585 // decisions.
a61af66fc99e Initial load duke parents: diff changeset	586 return false;
a61af66fc99e Initial load duke parents: diff changeset	587 }
a61af66fc99e Initial load duke parents: diff changeset	588
a61af66fc99e Initial load duke parents: diff changeset	589 // Pauses
a61af66fc99e Initial load duke parents: diff changeset	590 // Currently the size of the old gen is only adjusted to
a61af66fc99e Initial load duke parents: diff changeset	591 // change the major pause times.
a61af66fc99e Initial load duke parents: diff changeset	592 char* young_gen_action = NULL;
a61af66fc99e Initial load duke parents: diff changeset	593 char* tenured_gen_action = NULL;
a61af66fc99e Initial load duke parents: diff changeset	594
a61af66fc99e Initial load duke parents: diff changeset	595 char* shrink_msg = (char*) "(attempted to shrink)";
a61af66fc99e Initial load duke parents: diff changeset	596 char* grow_msg = (char*) "(attempted to grow)";
a61af66fc99e Initial load duke parents: diff changeset	597 char* no_change_msg = (char*) "(no change)";
a61af66fc99e Initial load duke parents: diff changeset	598 if (change_young_gen_for_min_pauses() ==
a61af66fc99e Initial load duke parents: diff changeset	599 decrease_young_gen_for_min_pauses_true) {
a61af66fc99e Initial load duke parents: diff changeset	600 young_gen_action = shrink_msg;
a61af66fc99e Initial load duke parents: diff changeset	601 } else if (change_for_pause) {
a61af66fc99e Initial load duke parents: diff changeset	602 young_gen_action = no_change_msg;
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 if (change_old_gen_for_maj_pauses() == decrease_old_gen_for_maj_pauses_true) {
a61af66fc99e Initial load duke parents: diff changeset	606 tenured_gen_action = shrink_msg;
a61af66fc99e Initial load duke parents: diff changeset	607 } else if (change_for_pause) {
a61af66fc99e Initial load duke parents: diff changeset	608 tenured_gen_action = no_change_msg;
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610
a61af66fc99e Initial load duke parents: diff changeset	611 // Throughput
a61af66fc99e Initial load duke parents: diff changeset	612 if (change_old_gen_for_throughput() == increase_old_gen_for_throughput_true) {
a61af66fc99e Initial load duke parents: diff changeset	613 assert(change_young_gen_for_throughput() ==
a61af66fc99e Initial load duke parents: diff changeset	614 increase_young_gen_for_througput_true,
a61af66fc99e Initial load duke parents: diff changeset	615 "Both generations should be growing");
a61af66fc99e Initial load duke parents: diff changeset	616 young_gen_action = grow_msg;
a61af66fc99e Initial load duke parents: diff changeset	617 tenured_gen_action = grow_msg;
a61af66fc99e Initial load duke parents: diff changeset	618 } else if (change_young_gen_for_throughput() ==
a61af66fc99e Initial load duke parents: diff changeset	619 increase_young_gen_for_througput_true) {
a61af66fc99e Initial load duke parents: diff changeset	620 // Only the young generation may grow at start up (before
a61af66fc99e Initial load duke parents: diff changeset	621 // enough full collections have been done to grow the old generation).
a61af66fc99e Initial load duke parents: diff changeset	622 young_gen_action = grow_msg;
a61af66fc99e Initial load duke parents: diff changeset	623 tenured_gen_action = no_change_msg;
a61af66fc99e Initial load duke parents: diff changeset	624 }
a61af66fc99e Initial load duke parents: diff changeset	625
a61af66fc99e Initial load duke parents: diff changeset	626 // Minimum footprint
a61af66fc99e Initial load duke parents: diff changeset	627 if (decrease_for_footprint() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	628 young_gen_action = shrink_msg;
a61af66fc99e Initial load duke parents: diff changeset	629 tenured_gen_action = shrink_msg;
a61af66fc99e Initial load duke parents: diff changeset	630 }
a61af66fc99e Initial load duke parents: diff changeset	631
a61af66fc99e Initial load duke parents: diff changeset	632 st->print_cr(" UseAdaptiveSizePolicy actions to meet %s", action);
a61af66fc99e Initial load duke parents: diff changeset	633 st->print_cr(" GC overhead (%%)");
a61af66fc99e Initial load duke parents: diff changeset	634 st->print_cr(" Young generation: %7.2f\t %s",
a61af66fc99e Initial load duke parents: diff changeset	635 100.0 * avg_minor_gc_cost()->average(),
a61af66fc99e Initial load duke parents: diff changeset	636 young_gen_action);
a61af66fc99e Initial load duke parents: diff changeset	637 st->print_cr(" Tenured generation: %7.2f\t %s",
a61af66fc99e Initial load duke parents: diff changeset	638 100.0 * avg_major_gc_cost()->average(),
a61af66fc99e Initial load duke parents: diff changeset	639 tenured_gen_action);
a61af66fc99e Initial load duke parents: diff changeset	640 return true;
a61af66fc99e Initial load duke parents: diff changeset	641 }
a61af66fc99e Initial load duke parents: diff changeset	642
a61af66fc99e Initial load duke parents: diff changeset	643 bool AdaptiveSizePolicy::print_adaptive_size_policy_on(
a61af66fc99e Initial load duke parents: diff changeset	644 outputStream* st,
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 4095 diff changeset	645 uint tenuring_threshold_arg) const {
0 a61af66fc99e Initial load duke parents: diff changeset	646 if (!AdaptiveSizePolicy::print_adaptive_size_policy_on(st)) {
a61af66fc99e Initial load duke parents: diff changeset	647 return false;
a61af66fc99e Initial load duke parents: diff changeset	648 }
a61af66fc99e Initial load duke parents: diff changeset	649
a61af66fc99e Initial load duke parents: diff changeset	650 // Tenuring threshold
a61af66fc99e Initial load duke parents: diff changeset	651 bool tenuring_threshold_changed = true;
a61af66fc99e Initial load duke parents: diff changeset	652 if (decrement_tenuring_threshold_for_survivor_limit()) {
a61af66fc99e Initial load duke parents: diff changeset	653 st->print(" Tenuring threshold: (attempted to decrease to avoid"
a61af66fc99e Initial load duke parents: diff changeset	654 " survivor space overflow) = ");
a61af66fc99e Initial load duke parents: diff changeset	655 } else if (decrement_tenuring_threshold_for_gc_cost()) {
a61af66fc99e Initial load duke parents: diff changeset	656 st->print(" Tenuring threshold: (attempted to decrease to balance"
a61af66fc99e Initial load duke parents: diff changeset	657 " GC costs) = ");
a61af66fc99e Initial load duke parents: diff changeset	658 } else if (increment_tenuring_threshold_for_gc_cost()) {
a61af66fc99e Initial load duke parents: diff changeset	659 st->print(" Tenuring threshold: (attempted to increase to balance"
a61af66fc99e Initial load duke parents: diff changeset	660 " GC costs) = ");
a61af66fc99e Initial load duke parents: diff changeset	661 } else {
a61af66fc99e Initial load duke parents: diff changeset	662 tenuring_threshold_changed = false;
a61af66fc99e Initial load duke parents: diff changeset	663 assert(!tenuring_threshold_change(), "(no change was attempted)");
a61af66fc99e Initial load duke parents: diff changeset	664 }
a61af66fc99e Initial load duke parents: diff changeset	665 if (tenuring_threshold_changed) {
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 4095 diff changeset	666 st->print_cr("%u", tenuring_threshold_arg);
0 a61af66fc99e Initial load duke parents: diff changeset	667 }
a61af66fc99e Initial load duke parents: diff changeset	668 return true;
a61af66fc99e Initial load duke parents: diff changeset	669 }

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp @ 10374:87c64c0438fb