truffle: src/share/vm/memory/collectorPolicy.cpp annotate

annotate src/share/vm/memory/collectorPolicy.cpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	833b0f92429a
children	d63ce76a0f0e

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17899 diff changeset	2 * Copyright (c) 2001, 2014, 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: 1888 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	26 #include "gc_implementation/shared/adaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	27 #include "gc_implementation/shared/gcPolicyCounters.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	28 #include "gc_implementation/shared/vmGCOperations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	29 #include "memory/cardTableRS.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	30 #include "memory/collectorPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	31 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	32 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	33 #include "memory/generationSpec.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	34 #include "memory/space.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	35 #include "memory/universe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	36 #include "runtime/arguments.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	37 #include "runtime/globals_extension.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	38 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	39 #include "runtime/java.hpp"
7180 f34d701e952e 8003935: Simplify the needed includes for using Thread::current() stefank parents: 6923 diff changeset	40 #include "runtime/thread.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	41 #include "runtime/vmThread.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7451 diff changeset	42 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7451 diff changeset	43 #if INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	44 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1888 diff changeset	45 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7451 diff changeset	46 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 // CollectorPolicy methods.
a61af66fc99e Initial load duke parents: diff changeset	49
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	50 CollectorPolicy::CollectorPolicy() :
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	51 _space_alignment(0),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	52 _heap_alignment(0),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	53 _initial_heap_byte_size(InitialHeapSize),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	54 _max_heap_byte_size(MaxHeapSize),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	55 _min_heap_byte_size(Arguments::min_heap_size()),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	56 _max_heap_size_cmdline(false),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	57 _size_policy(NULL),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	58 _should_clear_all_soft_refs(false),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	59 _all_soft_refs_clear(false)
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	60 {}
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	61
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	62 #ifdef ASSERT
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	63 void CollectorPolicy::assert_flags() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	64 assert(InitialHeapSize <= MaxHeapSize, "Ergonomics decided on incompatible initial and maximum heap sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	65 assert(InitialHeapSize % _heap_alignment == 0, "InitialHeapSize alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	66 assert(MaxHeapSize % _heap_alignment == 0, "MaxHeapSize alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	67 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	68
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	69 void CollectorPolicy::assert_size_info() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	70 assert(InitialHeapSize == _initial_heap_byte_size, "Discrepancy between InitialHeapSize flag and local storage");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	71 assert(MaxHeapSize == _max_heap_byte_size, "Discrepancy between MaxHeapSize flag and local storage");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	72 assert(_max_heap_byte_size >= _min_heap_byte_size, "Ergonomics decided on incompatible minimum and maximum heap sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	73 assert(_initial_heap_byte_size >= _min_heap_byte_size, "Ergonomics decided on incompatible initial and minimum heap sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	74 assert(_max_heap_byte_size >= _initial_heap_byte_size, "Ergonomics decided on incompatible initial and maximum heap sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	75 assert(_min_heap_byte_size % _heap_alignment == 0, "min_heap_byte_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	76 assert(_initial_heap_byte_size % _heap_alignment == 0, "initial_heap_byte_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	77 assert(_max_heap_byte_size % _heap_alignment == 0, "max_heap_byte_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	78 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	79 #endif // ASSERT
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	80
0 a61af66fc99e Initial load duke parents: diff changeset	81 void CollectorPolicy::initialize_flags() {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	82 assert(_space_alignment != 0, "Space alignment not set up properly");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	83 assert(_heap_alignment != 0, "Heap alignment not set up properly");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	84 assert(_heap_alignment >= _space_alignment,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	85 err_msg("heap_alignment: " SIZE_FORMAT " less than space_alignment: " SIZE_FORMAT,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	86 _heap_alignment, _space_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	87 assert(_heap_alignment % _space_alignment == 0,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	88 err_msg("heap_alignment: " SIZE_FORMAT " not aligned by space_alignment: " SIZE_FORMAT,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	89 _heap_alignment, _space_alignment));
10239 f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	90
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	91 if (FLAG_IS_CMDLINE(MaxHeapSize)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	92 if (FLAG_IS_CMDLINE(InitialHeapSize) && InitialHeapSize > MaxHeapSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	93 vm_exit_during_initialization("Initial heap size set to a larger value than the maximum heap size");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	94 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	95 if (_min_heap_byte_size != 0 && MaxHeapSize < _min_heap_byte_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	96 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	97 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	98 _max_heap_size_cmdline = true;
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	99 }
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	100
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	101 // Check heap parameter properties
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	102 if (InitialHeapSize < M) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	103 vm_exit_during_initialization("Too small initial heap");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	104 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	105 if (_min_heap_byte_size < M) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	106 vm_exit_during_initialization("Too small minimum heap");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	107 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	108
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	109 // User inputs from -Xmx and -Xms must be aligned
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	110 _min_heap_byte_size = align_size_up(_min_heap_byte_size, _heap_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	111 uintx aligned_initial_heap_size = align_size_up(InitialHeapSize, _heap_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	112 uintx aligned_max_heap_size = align_size_up(MaxHeapSize, _heap_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	113
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	114 // Write back to flags if the values changed
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	115 if (aligned_initial_heap_size != InitialHeapSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	116 FLAG_SET_ERGO(uintx, InitialHeapSize, aligned_initial_heap_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	117 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	118 if (aligned_max_heap_size != MaxHeapSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	119 FLAG_SET_ERGO(uintx, MaxHeapSize, aligned_max_heap_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	120 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	121
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	122 if (FLAG_IS_CMDLINE(InitialHeapSize) && _min_heap_byte_size != 0 &&
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	123 InitialHeapSize < _min_heap_byte_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	124 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	125 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	126 if (!FLAG_IS_DEFAULT(InitialHeapSize) && InitialHeapSize > MaxHeapSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	127 FLAG_SET_ERGO(uintx, MaxHeapSize, InitialHeapSize);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	128 } else if (!FLAG_IS_DEFAULT(MaxHeapSize) && InitialHeapSize > MaxHeapSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	129 FLAG_SET_ERGO(uintx, InitialHeapSize, MaxHeapSize);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	130 if (InitialHeapSize < _min_heap_byte_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	131 _min_heap_byte_size = InitialHeapSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	132 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	133 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	134
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	135 _initial_heap_byte_size = InitialHeapSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	136 _max_heap_byte_size = MaxHeapSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	137
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	138 FLAG_SET_ERGO(uintx, MinHeapDeltaBytes, align_size_up(MinHeapDeltaBytes, _space_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	139
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	140 DEBUG_ONLY(CollectorPolicy::assert_flags();)
0 a61af66fc99e Initial load duke parents: diff changeset	141 }
a61af66fc99e Initial load duke parents: diff changeset	142
a61af66fc99e Initial load duke parents: diff changeset	143 void CollectorPolicy::initialize_size_info() {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	144 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	145 gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	146 SIZE_FORMAT " Maximum heap " SIZE_FORMAT,
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	147 _min_heap_byte_size, _initial_heap_byte_size, _max_heap_byte_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	148 }
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	149
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	150 DEBUG_ONLY(CollectorPolicy::assert_size_info();)
0 a61af66fc99e Initial load duke parents: diff changeset	151 }
a61af66fc99e Initial load duke parents: diff changeset	152
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	153 bool CollectorPolicy::use_should_clear_all_soft_refs(bool v) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	154 bool result = _should_clear_all_soft_refs;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	155 set_should_clear_all_soft_refs(false);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	156 return result;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	157 }
0 a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap,
a61af66fc99e Initial load duke parents: diff changeset	160 int max_covered_regions) {
12350 ab68fc0101ce 8025855: Simplify GenRemSet code slightly jwilhelm parents: 12346 diff changeset	161 return new CardTableRS(whole_heap, max_covered_regions);
0 a61af66fc99e Initial load duke parents: diff changeset	162 }
a61af66fc99e Initial load duke parents: diff changeset	163
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	164 void CollectorPolicy::cleared_all_soft_refs() {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	165 // If near gc overhear limit, continue to clear SoftRefs. SoftRefs may
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	166 // have been cleared in the last collection but if the gc overhear
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	167 // limit continues to be near, SoftRefs should still be cleared.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	168 if (size_policy() != NULL) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	169 _should_clear_all_soft_refs = size_policy()->gc_overhead_limit_near();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	170 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	171 _all_soft_refs_clear = true;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	172 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	173
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	174 size_t CollectorPolicy::compute_heap_alignment() {
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	175 // The card marking array and the offset arrays for old generations are
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	176 // committed in os pages as well. Make sure they are entirely full (to
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	177 // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	178 // byte entry and the os page size is 4096, the maximum heap size should
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	179 // be 512*4096 = 2MB aligned.
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	180
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	181 // There is only the GenRemSet in Hotspot and only the GenRemSet::CardTable
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	182 // is supported.
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	183 // Requirements of any new remembered set implementations must be added here.
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	184 size_t alignment = GenRemSet::max_alignment_constraint(GenRemSet::CardTable);
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	185
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	186 // Parallel GC does its own alignment of the generations to avoid requiring a
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	187 // large page (256M on some platforms) for the permanent generation. The
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	188 // other collectors should also be updated to do their own alignment and then
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	189 // this use of lcm() should be removed.
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	190 if (UseLargePages && !UseParallelGC) {
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	191 // in presence of large pages we have to make sure that our
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	192 // alignment is large page aware
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	193 alignment = lcm(os::large_page_size(), alignment);
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	194 }
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	195
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	196 return alignment;
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	197 }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	198
0 a61af66fc99e Initial load duke parents: diff changeset	199 // GenCollectorPolicy methods.
a61af66fc99e Initial load duke parents: diff changeset	200
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	201 GenCollectorPolicy::GenCollectorPolicy() :
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	202 _min_gen0_size(0),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	203 _initial_gen0_size(0),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	204 _max_gen0_size(0),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	205 _gen_alignment(0),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	206 _generations(NULL)
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	207 {}
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	208
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	209 size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	210 return align_size_down_bounded(base_size / (NewRatio + 1), _gen_alignment);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	211 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	212
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	213 size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	214 size_t maximum_size) {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	215 size_t max_minus = maximum_size - _gen_alignment;
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	216 return desired_size < max_minus ? desired_size : max_minus;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	217 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	218
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	219
0 a61af66fc99e Initial load duke parents: diff changeset	220 void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	221 size_t init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	222 size_t init_survivor_size) {
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	223 const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0;
0 a61af66fc99e Initial load duke parents: diff changeset	224 _size_policy = new AdaptiveSizePolicy(init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	225 init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	226 init_survivor_size,
8072 fd7b3770c77e 8007764: Wrong initialized value of max_gc_pause_sec for an instance of class AdaptiveSizePolicy tamao parents: 8016 diff changeset	227 max_gc_pause_sec,
0 a61af66fc99e Initial load duke parents: diff changeset	228 GCTimeRatio);
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	231 size_t GenCollectorPolicy::young_gen_size_lower_bound() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	232 // The young generation must be aligned and have room for eden + two survivors
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	233 return align_size_up(3 * _space_alignment, _gen_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	234 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	235
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	236 #ifdef ASSERT
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	237 void GenCollectorPolicy::assert_flags() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	238 CollectorPolicy::assert_flags();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	239 assert(NewSize >= _min_gen0_size, "Ergonomics decided on a too small young gen size");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	240 assert(NewSize <= MaxNewSize, "Ergonomics decided on incompatible initial and maximum young gen sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	241 assert(FLAG_IS_DEFAULT(MaxNewSize) \|\| MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young gen and heap sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	242 assert(NewSize % _gen_alignment == 0, "NewSize alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	243 assert(FLAG_IS_DEFAULT(MaxNewSize) \|\| MaxNewSize % _gen_alignment == 0, "MaxNewSize alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	244 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	245
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	246 void TwoGenerationCollectorPolicy::assert_flags() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	247 GenCollectorPolicy::assert_flags();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	248 assert(OldSize + NewSize <= MaxHeapSize, "Ergonomics decided on incompatible generation and heap sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	249 assert(OldSize % _gen_alignment == 0, "OldSize alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	250 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	251
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	252 void GenCollectorPolicy::assert_size_info() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	253 CollectorPolicy::assert_size_info();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	254 // GenCollectorPolicy::initialize_size_info may update the MaxNewSize
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	255 assert(MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young and heap sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	256 assert(NewSize == _initial_gen0_size, "Discrepancy between NewSize flag and local storage");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	257 assert(MaxNewSize == _max_gen0_size, "Discrepancy between MaxNewSize flag and local storage");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	258 assert(_min_gen0_size <= _initial_gen0_size, "Ergonomics decided on incompatible minimum and initial young gen sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	259 assert(_initial_gen0_size <= _max_gen0_size, "Ergonomics decided on incompatible initial and maximum young gen sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	260 assert(_min_gen0_size % _gen_alignment == 0, "_min_gen0_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	261 assert(_initial_gen0_size % _gen_alignment == 0, "_initial_gen0_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	262 assert(_max_gen0_size % _gen_alignment == 0, "_max_gen0_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	263 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	264
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	265 void TwoGenerationCollectorPolicy::assert_size_info() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	266 GenCollectorPolicy::assert_size_info();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	267 assert(OldSize == _initial_gen1_size, "Discrepancy between OldSize flag and local storage");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	268 assert(_min_gen1_size <= _initial_gen1_size, "Ergonomics decided on incompatible minimum and initial old gen sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	269 assert(_initial_gen1_size <= _max_gen1_size, "Ergonomics decided on incompatible initial and maximum old gen sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	270 assert(_max_gen1_size % _gen_alignment == 0, "_max_gen1_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	271 assert(_initial_gen1_size % _gen_alignment == 0, "_initial_gen1_size alignment");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	272 assert(_max_heap_byte_size <= (_max_gen0_size + _max_gen1_size), "Total maximum heap sizes must be sum of generation maximum sizes");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	273 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	274 #endif // ASSERT
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	275
0 a61af66fc99e Initial load duke parents: diff changeset	276 void GenCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load duke parents: diff changeset	277 CollectorPolicy::initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	278
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	279 assert(_gen_alignment != 0, "Generation alignment not set up properly");
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	280 assert(_heap_alignment >= _gen_alignment,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	281 err_msg("heap_alignment: " SIZE_FORMAT " less than gen_alignment: " SIZE_FORMAT,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	282 _heap_alignment, _gen_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	283 assert(_gen_alignment % _space_alignment == 0,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	284 err_msg("gen_alignment: " SIZE_FORMAT " not aligned by space_alignment: " SIZE_FORMAT,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	285 _gen_alignment, _space_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	286 assert(_heap_alignment % _gen_alignment == 0,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	287 err_msg("heap_alignment: " SIZE_FORMAT " not aligned by gen_alignment: " SIZE_FORMAT,
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	288 _heap_alignment, _gen_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	289
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	290 // All generational heaps have a youngest gen; handle those flags here
0 a61af66fc99e Initial load duke parents: diff changeset	291
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	292 // Make sure the heap is large enough for two generations
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	293 uintx smallest_new_size = young_gen_size_lower_bound();
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	294 uintx smallest_heap_size = align_size_up(smallest_new_size + align_size_up(_space_alignment, _gen_alignment),
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	295 _heap_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	296 if (MaxHeapSize < smallest_heap_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	297 FLAG_SET_ERGO(uintx, MaxHeapSize, smallest_heap_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	298 _max_heap_byte_size = MaxHeapSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	299 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	300 // If needed, synchronize _min_heap_byte size and _initial_heap_byte_size
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	301 if (_min_heap_byte_size < smallest_heap_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	302 _min_heap_byte_size = smallest_heap_size;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	303 if (InitialHeapSize < _min_heap_byte_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	304 FLAG_SET_ERGO(uintx, InitialHeapSize, smallest_heap_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	305 _initial_heap_byte_size = smallest_heap_size;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	306 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	307 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	308
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	309 // Now take the actual NewSize into account. We will silently increase NewSize
17899 9eddc467297f 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line sjohanss parents: 17898 diff changeset	310 // if the user specified a smaller or unaligned value.
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	311 smallest_new_size = MAX2(smallest_new_size, (uintx)align_size_down(NewSize, _gen_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	312 if (smallest_new_size != NewSize) {
17899 9eddc467297f 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line sjohanss parents: 17898 diff changeset	313 // Do not use FLAG_SET_ERGO to update NewSize here, since this will override
9eddc467297f 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line sjohanss parents: 17898 diff changeset	314 // if NewSize was set on the command line or not. This information is needed
9eddc467297f 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line sjohanss parents: 17898 diff changeset	315 // later when setting the initial and minimum young generation size.
9eddc467297f 8035057: NewSize ergonomics wrong when setting small or unaligned size on command line sjohanss parents: 17898 diff changeset	316 NewSize = smallest_new_size;
0 a61af66fc99e Initial load duke parents: diff changeset	317 }
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	318 _initial_gen0_size = NewSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	319
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	320 if (!FLAG_IS_DEFAULT(MaxNewSize)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	321 uintx min_new_size = MAX2(_gen_alignment, _min_gen0_size);
0 a61af66fc99e Initial load duke parents: diff changeset	322
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	323 if (MaxNewSize >= MaxHeapSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	324 // Make sure there is room for an old generation
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	325 uintx smaller_max_new_size = MaxHeapSize - _gen_alignment;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	326 if (FLAG_IS_CMDLINE(MaxNewSize)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	327 warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or greater than the entire "
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	328 "heap (" SIZE_FORMAT "k). A new max generation size of " SIZE_FORMAT "k will be used.",
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	329 MaxNewSize/K, MaxHeapSize/K, smaller_max_new_size/K);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	330 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	331 FLAG_SET_ERGO(uintx, MaxNewSize, smaller_max_new_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	332 if (NewSize > MaxNewSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	333 FLAG_SET_ERGO(uintx, NewSize, MaxNewSize);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	334 _initial_gen0_size = NewSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	335 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	336 } else if (MaxNewSize < min_new_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	337 FLAG_SET_ERGO(uintx, MaxNewSize, min_new_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	338 } else if (!is_size_aligned(MaxNewSize, _gen_alignment)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	339 FLAG_SET_ERGO(uintx, MaxNewSize, align_size_down(MaxNewSize, _gen_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	340 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	341 _max_gen0_size = MaxNewSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	342 }
0 a61af66fc99e Initial load duke parents: diff changeset	343
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	344 if (NewSize > MaxNewSize) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	345 // At this point this should only happen if the user specifies a large NewSize and/or
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	346 // a small (but not too small) MaxNewSize.
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	347 if (FLAG_IS_CMDLINE(MaxNewSize)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	348 warning("NewSize (" SIZE_FORMAT "k) is greater than the MaxNewSize (" SIZE_FORMAT "k). "
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	349 "A new max generation size of " SIZE_FORMAT "k will be used.",
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	350 NewSize/K, MaxNewSize/K, NewSize/K);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	351 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	352 FLAG_SET_ERGO(uintx, MaxNewSize, NewSize);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	353 _max_gen0_size = MaxNewSize;
0 a61af66fc99e Initial load duke parents: diff changeset	354 }
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	355
0 a61af66fc99e Initial load duke parents: diff changeset	356 if (SurvivorRatio < 1 \|\| NewRatio < 1) {
12831 087f02e22fc2 8025854: Use "young gen" instead of "eden" jwilhelm parents: 12830 diff changeset	357 vm_exit_during_initialization("Invalid young gen ratio specified");
0 a61af66fc99e Initial load duke parents: diff changeset	358 }
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	359
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	360 DEBUG_ONLY(GenCollectorPolicy::assert_flags();)
0 a61af66fc99e Initial load duke parents: diff changeset	361 }
a61af66fc99e Initial load duke parents: diff changeset	362
a61af66fc99e Initial load duke parents: diff changeset	363 void TwoGenerationCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load duke parents: diff changeset	364 GenCollectorPolicy::initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	365
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	366 if (!is_size_aligned(OldSize, _gen_alignment)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	367 FLAG_SET_ERGO(uintx, OldSize, align_size_down(OldSize, _gen_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	368 }
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	369
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	370 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(MaxHeapSize)) {
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	371 // NewRatio will be used later to set the young generation size so we use
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	372 // it to calculate how big the heap should be based on the requested OldSize
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	373 // and NewRatio.
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	374 assert(NewRatio > 0, "NewRatio should have been set up earlier");
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	375 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	376
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	377 calculated_heapsize = align_size_up(calculated_heapsize, _heap_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	378 FLAG_SET_ERGO(uintx, MaxHeapSize, calculated_heapsize);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	379 _max_heap_byte_size = MaxHeapSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	380 FLAG_SET_ERGO(uintx, InitialHeapSize, calculated_heapsize);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	381 _initial_heap_byte_size = InitialHeapSize;
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	382 }
0 a61af66fc99e Initial load duke parents: diff changeset	383
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	384 // adjust max heap size if necessary
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	385 if (NewSize + OldSize > MaxHeapSize) {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	386 if (_max_heap_size_cmdline) {
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	387 // somebody set a maximum heap size with the intention that we should not
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	388 // exceed it. Adjust New/OldSize as necessary.
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	389 uintx calculated_size = NewSize + OldSize;
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	390 double shrink_factor = (double) MaxHeapSize / calculated_size;
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	391 uintx smaller_new_size = align_size_down((uintx)(NewSize * shrink_factor), _gen_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	392 FLAG_SET_ERGO(uintx, NewSize, MAX2(young_gen_size_lower_bound(), smaller_new_size));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	393 _initial_gen0_size = NewSize;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	394
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	395 // OldSize is already aligned because above we aligned MaxHeapSize to
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	396 // _heap_alignment, and we just made sure that NewSize is aligned to
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	397 // _gen_alignment. In initialize_flags() we verified that _heap_alignment
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	398 // is a multiple of _gen_alignment.
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	399 FLAG_SET_ERGO(uintx, OldSize, MaxHeapSize - NewSize);
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	400 } else {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	401 FLAG_SET_ERGO(uintx, MaxHeapSize, align_size_up(NewSize + OldSize, _heap_alignment));
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	402 _max_heap_byte_size = MaxHeapSize;
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	403 }
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	404 }
10284 7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	405
0 a61af66fc99e Initial load duke parents: diff changeset	406 always_do_update_barrier = UseConcMarkSweepGC;
a61af66fc99e Initial load duke parents: diff changeset	407
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	408 DEBUG_ONLY(TwoGenerationCollectorPolicy::assert_flags();)
0 a61af66fc99e Initial load duke parents: diff changeset	409 }
a61af66fc99e Initial load duke parents: diff changeset	410
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	411 // Values set on the command line win over any ergonomically
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	412 // set command line parameters.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	413 // Ergonomic choice of parameters are done before this
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	414 // method is called. Values for command line parameters such as NewSize
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	415 // and MaxNewSize feed those ergonomic choices into this method.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	416 // This method makes the final generation sizings consistent with
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	417 // themselves and with overall heap sizings.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	418 // In the absence of explicitly set command line flags, policies
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	419 // such as the use of NewRatio are used to size the generation.
0 a61af66fc99e Initial load duke parents: diff changeset	420 void GenCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load duke parents: diff changeset	421 CollectorPolicy::initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	422
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	423 // _space_alignment is used for alignment within a generation.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	424 // There is additional alignment done down stream for some
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	425 // collectors that sometimes causes unwanted rounding up of
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	426 // generations sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	427
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	428 // Determine maximum size of gen0
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	429
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	430 size_t max_new_size = 0;
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	431 if (!FLAG_IS_DEFAULT(MaxNewSize)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	432 max_new_size = MaxNewSize;
0 a61af66fc99e Initial load duke parents: diff changeset	433 } else {
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	434 max_new_size = scale_by_NewRatio_aligned(_max_heap_byte_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	435 // Bound the maximum size by NewSize below (since it historically
0 a61af66fc99e Initial load duke parents: diff changeset	436 // would have been NewSize and because the NewRatio calculation could
a61af66fc99e Initial load duke parents: diff changeset	437 // yield a size that is too small) and bound it by MaxNewSize above.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	438 // Ergonomics plays here by previously calculating the desired
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	439 // NewSize and MaxNewSize.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	440 max_new_size = MIN2(MAX2(max_new_size, NewSize), MaxNewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	441 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	442 assert(max_new_size > 0, "All paths should set max_new_size");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	443
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	444 // Given the maximum gen0 size, determine the initial and
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	445 // minimum gen0 sizes.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	446
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	447 if (_max_heap_byte_size == _min_heap_byte_size) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	448 // The maximum and minimum heap sizes are the same so
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	449 // the generations minimum and initial must be the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	450 // same as its maximum.
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	451 _min_gen0_size = max_new_size;
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	452 _initial_gen0_size = max_new_size;
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	453 _max_gen0_size = max_new_size;
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	454 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	455 size_t desired_new_size = 0;
17898 1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	456 if (FLAG_IS_CMDLINE(NewSize)) {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	457 // If NewSize is set on the command line, we must use it as
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	458 // the initial size and it also makes sense to use it as the
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	459 // lower limit.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	460 _min_gen0_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	461 desired_new_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	462 max_new_size = MAX2(max_new_size, NewSize);
17898 1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	463 } else if (FLAG_IS_ERGO(NewSize)) {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	464 // If NewSize is set ergonomically, we should use it as a lower
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	465 // limit, but use NewRatio to calculate the initial size.
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	466 _min_gen0_size = NewSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	467 desired_new_size =
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	468 MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	469 max_new_size = MAX2(max_new_size, NewSize);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	470 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	471 // For the case where NewSize is the default, use NewRatio
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	472 // to size the minimum and initial generation sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	473 // Use the default NewSize as the floor for these values. If
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	474 // NewRatio is overly large, the resulting sizes can be too
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	475 // small.
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	476 _min_gen0_size = MAX2(scale_by_NewRatio_aligned(_min_heap_byte_size), NewSize);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	477 desired_new_size =
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	478 MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	479 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	480
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	481 assert(_min_gen0_size > 0, "Sanity check");
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	482 _initial_gen0_size = desired_new_size;
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	483 _max_gen0_size = max_new_size;
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	484
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	485 // At this point the desirable initial and minimum sizes have been
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	486 // determined without regard to the maximum sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	487
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	488 // Bound the sizes by the corresponding overall heap sizes.
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	489 _min_gen0_size = bound_minus_alignment(_min_gen0_size, _min_heap_byte_size);
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	490 _initial_gen0_size = bound_minus_alignment(_initial_gen0_size, _initial_heap_byte_size);
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	491 _max_gen0_size = bound_minus_alignment(_max_gen0_size, _max_heap_byte_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	492
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	493 // At this point all three sizes have been checked against the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	494 // maximum sizes but have not been checked for consistency
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	495 // among the three.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	496
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	497 // Final check min <= initial <= max
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	498 _min_gen0_size = MIN2(_min_gen0_size, _max_gen0_size);
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	499 _initial_gen0_size = MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size);
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	500 _min_gen0_size = MIN2(_min_gen0_size, _initial_gen0_size);
0 a61af66fc99e Initial load duke parents: diff changeset	501 }
a61af66fc99e Initial load duke parents: diff changeset	502
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	503 // Write back to flags if necessary
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	504 if (NewSize != _initial_gen0_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	505 FLAG_SET_ERGO(uintx, NewSize, _initial_gen0_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	506 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	507
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	508 if (MaxNewSize != _max_gen0_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	509 FLAG_SET_ERGO(uintx, MaxNewSize, _max_gen0_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	510 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	511
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	512 if (PrintGCDetails && Verbose) {
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	513 gclog_or_tty->print_cr("1: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	514 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	515 _min_gen0_size, _initial_gen0_size, _max_gen0_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	516 }
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	517
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	518 DEBUG_ONLY(GenCollectorPolicy::assert_size_info();)
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	519 }
0 a61af66fc99e Initial load duke parents: diff changeset	520
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	521 // Call this method during the sizing of the gen1 to make
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	522 // adjustments to gen0 because of gen1 sizing policy. gen0 initially has
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	523 // the most freedom in sizing because it is done before the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	524 // policy for gen1 is applied. Once gen1 policies have been applied,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	525 // there may be conflicts in the shape of the heap and this method
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	526 // is used to make the needed adjustments. The application of the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	527 // policies could be more sophisticated (iterative for example) but
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	528 // keeping it simple also seems a worthwhile goal.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	529 bool TwoGenerationCollectorPolicy::adjust_gen0_sizes(size_t* gen0_size_ptr,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	530 size_t* gen1_size_ptr,
13066 236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	531 const size_t heap_size) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	532 bool result = false;
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	533
13066 236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	534 if ((gen0_size_ptr + gen1_size_ptr) > heap_size) {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	535 uintx smallest_new_size = young_gen_size_lower_bound();
13066 236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	536 if ((heap_size < (*gen0_size_ptr + _min_gen1_size)) &&
236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	537 (heap_size >= _min_gen1_size + smallest_new_size)) {
236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	538 // Adjust gen0 down to accommodate _min_gen1_size
236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	539 *gen0_size_ptr = align_size_down_bounded(heap_size - _min_gen1_size, _gen_alignment);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	540 result = true;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	541 } else {
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	542 gen1_size_ptr = align_size_down_bounded(heap_size - gen0_size_ptr, _gen_alignment);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	543 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	544 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	545 return result;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	546 }
0 a61af66fc99e Initial load duke parents: diff changeset	547
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	548 // Minimum sizes of the generations may be different than
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	549 // the initial sizes. An inconsistently is permitted here
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	550 // in the total size that can be specified explicitly by
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	551 // command line specification of OldSize and NewSize and
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	552 // also a command line specification of -Xms. Issue a warning
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	553 // but allow the values to pass.
0 a61af66fc99e Initial load duke parents: diff changeset	554
a61af66fc99e Initial load duke parents: diff changeset	555 void TwoGenerationCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load duke parents: diff changeset	556 GenCollectorPolicy::initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	557
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	558 // At this point the minimum, initial and maximum sizes
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	559 // of the overall heap and of gen0 have been determined.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	560 // The maximum gen1 size can be determined from the maximum gen0
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	561 // and maximum heap size since no explicit flags exits
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	562 // for setting the gen1 maximum.
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	563 _max_gen1_size = MAX2(_max_heap_byte_size - _max_gen0_size, _gen_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	564
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	565 // If no explicit command line flag has been set for the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	566 // gen1 size, use what is left for gen1.
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	567 if (!FLAG_IS_CMDLINE(OldSize)) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	568 // The user has not specified any value but the ergonomics
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	569 // may have chosen a value (which may or may not be consistent
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	570 // with the overall heap size). In either case make
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	571 // the minimum, maximum and initial sizes consistent
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	572 // with the gen0 sizes and the overall heap sizes.
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	573 _min_gen1_size = MAX2(_min_heap_byte_size - _min_gen0_size, _gen_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	574 _initial_gen1_size = MAX2(_initial_heap_byte_size - _initial_gen0_size, _gen_alignment);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	575 // _max_gen1_size has already been made consistent above
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	576 FLAG_SET_ERGO(uintx, OldSize, _initial_gen1_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	577 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	578 // It's been explicitly set on the command line. Use the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	579 // OldSize and then determine the consequences.
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	580 _min_gen1_size = MIN2(OldSize, _min_heap_byte_size - _min_gen0_size);
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	581 _initial_gen1_size = OldSize;
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	582
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	583 // If the user has explicitly set an OldSize that is inconsistent
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	584 // with other command line flags, issue a warning.
0 a61af66fc99e Initial load duke parents: diff changeset	585 // The generation minimums and the overall heap mimimum should
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	586 // be within one generation alignment.
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	587 if ((_min_gen1_size + _min_gen0_size + _gen_alignment) < _min_heap_byte_size) {
0 a61af66fc99e Initial load duke parents: diff changeset	588 warning("Inconsistency between minimum heap size and minimum "
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	589 "generation sizes: using minimum heap = " SIZE_FORMAT,
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	590 _min_heap_byte_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	591 }
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	592 if (OldSize > _max_gen1_size) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	593 warning("Inconsistency between maximum heap size and maximum "
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	594 "generation sizes: using maximum heap = " SIZE_FORMAT
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	595 " -XX:OldSize flag is being ignored",
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	596 _max_heap_byte_size);
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	597 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	598 // If there is an inconsistency between the OldSize and the minimum and/or
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	599 // initial size of gen0, since OldSize was explicitly set, OldSize wins.
13066 236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	600 if (adjust_gen0_sizes(&_min_gen0_size, &_min_gen1_size, _min_heap_byte_size)) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	601 if (PrintGCDetails && Verbose) {
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	602 gclog_or_tty->print_cr("2: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	603 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	604 _min_gen0_size, _initial_gen0_size, _max_gen0_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	605 }
0 a61af66fc99e Initial load duke parents: diff changeset	606 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	607 // Initial size
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	608 if (adjust_gen0_sizes(&_initial_gen0_size, &_initial_gen1_size,
13066 236cecd9ec97 8028093: Initial young size is smaller than minimum young size jwilhelm parents: 13065 diff changeset	609 _initial_heap_byte_size)) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	610 if (PrintGCDetails && Verbose) {
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	611 gclog_or_tty->print_cr("3: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	612 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	613 _min_gen0_size, _initial_gen0_size, _max_gen0_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	614 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	615 }
0 a61af66fc99e Initial load duke parents: diff changeset	616 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	617 // Enforce the maximum gen1 size.
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	618 _min_gen1_size = MIN2(_min_gen1_size, _max_gen1_size);
0 a61af66fc99e Initial load duke parents: diff changeset	619
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	620 // Check that min gen1 <= initial gen1 <= max gen1
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	621 _initial_gen1_size = MAX2(_initial_gen1_size, _min_gen1_size);
9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	622 _initial_gen1_size = MIN2(_initial_gen1_size, _max_gen1_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	623
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	624 // Write back to flags if necessary
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	625 if (NewSize != _initial_gen0_size) {
13065 3ad2b68d107e 8027911: Assertion in the collector policy when running gc/arguments/TestMaxNewSize.java jwilhelm parents: 13060 diff changeset	626 FLAG_SET_ERGO(uintx, NewSize, _initial_gen0_size);
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	627 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	628
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	629 if (MaxNewSize != _max_gen0_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	630 FLAG_SET_ERGO(uintx, MaxNewSize, _max_gen0_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	631 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	632
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	633 if (OldSize != _initial_gen1_size) {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	634 FLAG_SET_ERGO(uintx, OldSize, _initial_gen1_size);
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	635 }
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	636
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	637 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	638 gclog_or_tty->print_cr("Minimum gen1 " SIZE_FORMAT " Initial gen1 "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	639 SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT,
12830 9b4d0569f2f4 8025852: Remove unnecessary setters in collector policy classes jwilhelm parents: 12350 diff changeset	640 _min_gen1_size, _initial_gen1_size, _max_gen1_size);
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	641 }
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	642
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	643 DEBUG_ONLY(TwoGenerationCollectorPolicy::assert_size_info();)
0 a61af66fc99e Initial load duke parents: diff changeset	644 }
a61af66fc99e Initial load duke parents: diff changeset	645
a61af66fc99e Initial load duke parents: diff changeset	646 HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	647 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	648 bool* gc_overhead_limit_was_exceeded) {
a61af66fc99e Initial load duke parents: diff changeset	649 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 debug_only(gch->check_for_valid_allocation_state());
a61af66fc99e Initial load duke parents: diff changeset	652 assert(gch->no_gc_in_progress(), "Allocation during gc not allowed");
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	653
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	654 // In general gc_overhead_limit_was_exceeded should be false so
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	655 // set it so here and reset it to true only if the gc time
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	656 // limit is being exceeded as checked below.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	657 *gc_overhead_limit_was_exceeded = false;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	658
0 a61af66fc99e Initial load duke parents: diff changeset	659 HeapWord* result = NULL;
a61af66fc99e Initial load duke parents: diff changeset	660
a61af66fc99e Initial load duke parents: diff changeset	661 // Loop until the allocation is satisified,
a61af66fc99e Initial load duke parents: diff changeset	662 // or unsatisfied after GC.
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	663 for (int try_count = 1, gclocker_stalled_count = 0; /* return or throw */; try_count += 1) {
0 a61af66fc99e Initial load duke parents: diff changeset	664 HandleMark hm; // discard any handles allocated in each iteration
a61af66fc99e Initial load duke parents: diff changeset	665
a61af66fc99e Initial load duke parents: diff changeset	666 // First allocation attempt is lock-free.
a61af66fc99e Initial load duke parents: diff changeset	667 Generation *gen0 = gch->get_gen(0);
a61af66fc99e Initial load duke parents: diff changeset	668 assert(gen0->supports_inline_contig_alloc(),
a61af66fc99e Initial load duke parents: diff changeset	669 "Otherwise, must do alloc within heap lock");
a61af66fc99e Initial load duke parents: diff changeset	670 if (gen0->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load duke parents: diff changeset	671 result = gen0->par_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	672 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	673 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	674 return result;
a61af66fc99e Initial load duke parents: diff changeset	675 }
a61af66fc99e Initial load duke parents: diff changeset	676 }
a61af66fc99e Initial load duke parents: diff changeset	677 unsigned int gc_count_before; // read inside the Heap_lock locked region
a61af66fc99e Initial load duke parents: diff changeset	678 {
a61af66fc99e Initial load duke parents: diff changeset	679 MutexLocker ml(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	680 if (PrintGC && Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	681 gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:"
a61af66fc99e Initial load duke parents: diff changeset	682 " attempting locked slow path allocation");
a61af66fc99e Initial load duke parents: diff changeset	683 }
a61af66fc99e Initial load duke parents: diff changeset	684 // Note that only large objects get a shot at being
a61af66fc99e Initial load duke parents: diff changeset	685 // allocated in later generations.
a61af66fc99e Initial load duke parents: diff changeset	686 bool first_only = ! should_try_older_generation_allocation(size);
a61af66fc99e Initial load duke parents: diff changeset	687
a61af66fc99e Initial load duke parents: diff changeset	688 result = gch->attempt_allocation(size, is_tlab, first_only);
a61af66fc99e Initial load duke parents: diff changeset	689 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	690 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	691 return result;
a61af66fc99e Initial load duke parents: diff changeset	692 }
a61af66fc99e Initial load duke parents: diff changeset	693
a61af66fc99e Initial load duke parents: diff changeset	694 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	695 if (is_tlab) {
a61af66fc99e Initial load duke parents: diff changeset	696 return NULL; // Caller will retry allocating individual object
a61af66fc99e Initial load duke parents: diff changeset	697 }
a61af66fc99e Initial load duke parents: diff changeset	698 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	699 // Try and expand heap to satisfy request
a61af66fc99e Initial load duke parents: diff changeset	700 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	701 // result could be null if we are out of space
a61af66fc99e Initial load duke parents: diff changeset	702 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	703 return result;
a61af66fc99e Initial load duke parents: diff changeset	704 }
a61af66fc99e Initial load duke parents: diff changeset	705 }
a61af66fc99e Initial load duke parents: diff changeset	706
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	707 if (gclocker_stalled_count > GCLockerRetryAllocationCount) {
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	708 return NULL; // we didn't get to do a GC and we didn't get any memory
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	709 }
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	710
0 a61af66fc99e Initial load duke parents: diff changeset	711 // If this thread is not in a jni critical section, we stall
a61af66fc99e Initial load duke parents: diff changeset	712 // the requestor until the critical section has cleared and
a61af66fc99e Initial load duke parents: diff changeset	713 // GC allowed. When the critical section clears, a GC is
a61af66fc99e Initial load duke parents: diff changeset	714 // initiated by the last thread exiting the critical section; so
a61af66fc99e Initial load duke parents: diff changeset	715 // we retry the allocation sequence from the beginning of the loop,
a61af66fc99e Initial load duke parents: diff changeset	716 // rather than causing more, now probably unnecessary, GC attempts.
a61af66fc99e Initial load duke parents: diff changeset	717 JavaThread* jthr = JavaThread::current();
a61af66fc99e Initial load duke parents: diff changeset	718 if (!jthr->in_critical()) {
a61af66fc99e Initial load duke parents: diff changeset	719 MutexUnlocker mul(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	720 // Wait for JNI critical section to be exited
a61af66fc99e Initial load duke parents: diff changeset	721 GC_locker::stall_until_clear();
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	722 gclocker_stalled_count += 1;
0 a61af66fc99e Initial load duke parents: diff changeset	723 continue;
a61af66fc99e Initial load duke parents: diff changeset	724 } else {
a61af66fc99e Initial load duke parents: diff changeset	725 if (CheckJNICalls) {
a61af66fc99e Initial load duke parents: diff changeset	726 fatal("Possible deadlock due to allocating while"
a61af66fc99e Initial load duke parents: diff changeset	727 " in jni critical section");
a61af66fc99e Initial load duke parents: diff changeset	728 }
a61af66fc99e Initial load duke parents: diff changeset	729 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	730 }
a61af66fc99e Initial load duke parents: diff changeset	731 }
a61af66fc99e Initial load duke parents: diff changeset	732
a61af66fc99e Initial load duke parents: diff changeset	733 // Read the gc count while the heap lock is held.
a61af66fc99e Initial load duke parents: diff changeset	734 gc_count_before = Universe::heap()->total_collections();
a61af66fc99e Initial load duke parents: diff changeset	735 }
a61af66fc99e Initial load duke parents: diff changeset	736
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	737 VM_GenCollectForAllocation op(size, is_tlab, gc_count_before);
0 a61af66fc99e Initial load duke parents: diff changeset	738 VMThread::execute(&op);
a61af66fc99e Initial load duke parents: diff changeset	739 if (op.prologue_succeeded()) {
a61af66fc99e Initial load duke parents: diff changeset	740 result = op.result();
a61af66fc99e Initial load duke parents: diff changeset	741 if (op.gc_locked()) {
a61af66fc99e Initial load duke parents: diff changeset	742 assert(result == NULL, "must be NULL if gc_locked() is true");
a61af66fc99e Initial load duke parents: diff changeset	743 continue; // retry and/or stall as necessary
a61af66fc99e Initial load duke parents: diff changeset	744 }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	745
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	746 // Allocation has failed and a collection
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	747 // has been done. If the gc time limit was exceeded the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	748 // this time, return NULL so that an out-of-memory
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	749 // will be thrown. Clear gc_overhead_limit_exceeded
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	750 // so that the overhead exceeded does not persist.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	751
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	752 const bool limit_exceeded = size_policy()->gc_overhead_limit_exceeded();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	753 const bool softrefs_clear = all_soft_refs_clear();
8743 82657b6a8cc0 6976528: PS: assert(!limit_exceeded \|\| softrefs_clear) failed: Should have been cleared jmasa parents: 8072 diff changeset	754
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	755 if (limit_exceeded && softrefs_clear) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	756 *gc_overhead_limit_was_exceeded = true;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	757 size_policy()->set_gc_overhead_limit_exceeded(false);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	758 if (op.result() != NULL) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	759 CollectedHeap::fill_with_object(op.result(), size);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	760 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	761 return NULL;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	762 }
0 a61af66fc99e Initial load duke parents: diff changeset	763 assert(result == NULL \|\| gch->is_in_reserved(result),
a61af66fc99e Initial load duke parents: diff changeset	764 "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	765 return result;
a61af66fc99e Initial load duke parents: diff changeset	766 }
a61af66fc99e Initial load duke parents: diff changeset	767
a61af66fc99e Initial load duke parents: diff changeset	768 // Give a warning if we seem to be looping forever.
a61af66fc99e Initial load duke parents: diff changeset	769 if ((QueuedAllocationWarningCount > 0) &&
a61af66fc99e Initial load duke parents: diff changeset	770 (try_count % QueuedAllocationWarningCount == 0)) {
a61af66fc99e Initial load duke parents: diff changeset	771 warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t"
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17899 diff changeset	772 " size=" SIZE_FORMAT " %s", try_count, size, is_tlab ? "(TLAB)" : "");
0 a61af66fc99e Initial load duke parents: diff changeset	773 }
a61af66fc99e Initial load duke parents: diff changeset	774 }
a61af66fc99e Initial load duke parents: diff changeset	775 }
a61af66fc99e Initial load duke parents: diff changeset	776
a61af66fc99e Initial load duke parents: diff changeset	777 HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	778 bool is_tlab) {
a61af66fc99e Initial load duke parents: diff changeset	779 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	780 HeapWord* result = NULL;
a61af66fc99e Initial load duke parents: diff changeset	781 for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) {
a61af66fc99e Initial load duke parents: diff changeset	782 Generation *gen = gch->get_gen(i);
a61af66fc99e Initial load duke parents: diff changeset	783 if (gen->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load duke parents: diff changeset	784 result = gen->expand_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	785 }
a61af66fc99e Initial load duke parents: diff changeset	786 }
a61af66fc99e Initial load duke parents: diff changeset	787 assert(result == NULL \|\| gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	788 return result;
a61af66fc99e Initial load duke parents: diff changeset	789 }
a61af66fc99e Initial load duke parents: diff changeset	790
a61af66fc99e Initial load duke parents: diff changeset	791 HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	792 bool is_tlab) {
a61af66fc99e Initial load duke parents: diff changeset	793 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	794 GCCauseSetter x(gch, GCCause::_allocation_failure);
a61af66fc99e Initial load duke parents: diff changeset	795 HeapWord* result = NULL;
a61af66fc99e Initial load duke parents: diff changeset	796
a61af66fc99e Initial load duke parents: diff changeset	797 assert(size != 0, "Precondition violated");
a61af66fc99e Initial load duke parents: diff changeset	798 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	799 // GC locker is active; instead of a collection we will attempt
a61af66fc99e Initial load duke parents: diff changeset	800 // to expand the heap, if there's room for expansion.
a61af66fc99e Initial load duke parents: diff changeset	801 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	802 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	803 }
a61af66fc99e Initial load duke parents: diff changeset	804 return result; // could be null if we are out of space
1994 6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	805 } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) {
0 a61af66fc99e Initial load duke parents: diff changeset	806 // Do an incremental collection.
a61af66fc99e Initial load duke parents: diff changeset	807 gch->do_collection(false /* full */,
a61af66fc99e Initial load duke parents: diff changeset	808 false /* clear_all_soft_refs */,
a61af66fc99e Initial load duke parents: diff changeset	809 size /* size */,
a61af66fc99e Initial load duke parents: diff changeset	810 is_tlab /* is_tlab */,
a61af66fc99e Initial load duke parents: diff changeset	811 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load duke parents: diff changeset	812 } else {
1994 6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	813 if (Verbose && PrintGCDetails) {
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	814 gclog_or_tty->print(" :: Trying full because partial may fail :: ");
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	815 }
0 a61af66fc99e Initial load duke parents: diff changeset	816 // Try a full collection; see delta for bug id 6266275
a61af66fc99e Initial load duke parents: diff changeset	817 // for the original code and why this has been simplified
a61af66fc99e Initial load duke parents: diff changeset	818 // with from-space allocation criteria modified and
a61af66fc99e Initial load duke parents: diff changeset	819 // such allocation moved out of the safepoint path.
a61af66fc99e Initial load duke parents: diff changeset	820 gch->do_collection(true /* full */,
a61af66fc99e Initial load duke parents: diff changeset	821 false /* clear_all_soft_refs */,
a61af66fc99e Initial load duke parents: diff changeset	822 size /* size */,
a61af66fc99e Initial load duke parents: diff changeset	823 is_tlab /* is_tlab */,
a61af66fc99e Initial load duke parents: diff changeset	824 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load duke parents: diff changeset	825 }
a61af66fc99e Initial load duke parents: diff changeset	826
a61af66fc99e Initial load duke parents: diff changeset	827 result = gch->attempt_allocation(size, is_tlab, false /first_only/);
a61af66fc99e Initial load duke parents: diff changeset	828
a61af66fc99e Initial load duke parents: diff changeset	829 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	830 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	831 return result;
a61af66fc99e Initial load duke parents: diff changeset	832 }
a61af66fc99e Initial load duke parents: diff changeset	833
a61af66fc99e Initial load duke parents: diff changeset	834 // OK, collection failed, try expansion.
a61af66fc99e Initial load duke parents: diff changeset	835 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	836 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	837 return result;
a61af66fc99e Initial load duke parents: diff changeset	838 }
a61af66fc99e Initial load duke parents: diff changeset	839
a61af66fc99e Initial load duke parents: diff changeset	840 // If we reach this point, we're really out of memory. Try every trick
a61af66fc99e Initial load duke parents: diff changeset	841 // we can to reclaim memory. Force collection of soft references. Force
a61af66fc99e Initial load duke parents: diff changeset	842 // a complete compaction of the heap. Any additional methods for finding
a61af66fc99e Initial load duke parents: diff changeset	843 // free memory should be here, especially if they are expensive. If this
a61af66fc99e Initial load duke parents: diff changeset	844 // attempt fails, an OOM exception will be thrown.
a61af66fc99e Initial load duke parents: diff changeset	845 {
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10284 diff changeset	846 UIntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
0 a61af66fc99e Initial load duke parents: diff changeset	847
a61af66fc99e Initial load duke parents: diff changeset	848 gch->do_collection(true /* full */,
a61af66fc99e Initial load duke parents: diff changeset	849 true /* clear_all_soft_refs */,
a61af66fc99e Initial load duke parents: diff changeset	850 size /* size */,
a61af66fc99e Initial load duke parents: diff changeset	851 is_tlab /* is_tlab */,
a61af66fc99e Initial load duke parents: diff changeset	852 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load duke parents: diff changeset	853 }
a61af66fc99e Initial load duke parents: diff changeset	854
a61af66fc99e Initial load duke parents: diff changeset	855 result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
a61af66fc99e Initial load duke parents: diff changeset	856 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	857 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	858 return result;
a61af66fc99e Initial load duke parents: diff changeset	859 }
a61af66fc99e Initial load duke parents: diff changeset	860
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	861 assert(!should_clear_all_soft_refs(),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	862 "Flag should have been handled and cleared prior to this point");
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	863
0 a61af66fc99e Initial load duke parents: diff changeset	864 // What else? We might try synchronous finalization later. If the total
a61af66fc99e Initial load duke parents: diff changeset	865 // space available is large enough for the allocation, then a more
a61af66fc99e Initial load duke parents: diff changeset	866 // complete compaction phase than we've tried so far might be
a61af66fc99e Initial load duke parents: diff changeset	867 // appropriate.
a61af66fc99e Initial load duke parents: diff changeset	868 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	869 }
a61af66fc99e Initial load duke parents: diff changeset	870
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	871 MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	872 ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	873 size_t word_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	874 Metaspace::MetadataType mdtype) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	875 uint loop_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	876 uint gc_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	877 uint full_gc_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	878
6923 3fadc0e8cffe 8000988: VM deadlock when running btree006 on windows-i586 jmasa parents: 6753 diff changeset	879 assert(!Heap_lock->owned_by_self(), "Should not be holding the Heap_lock");
3fadc0e8cffe 8000988: VM deadlock when running btree006 on windows-i586 jmasa parents: 6753 diff changeset	880
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	881 do {
6753 8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	882 MetaWord* result = NULL;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	883 if (GC_locker::is_active_and_needs_gc()) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	884 // If the GC_locker is active, just expand and allocate.
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	885 // If that does not succeed, wait if this thread is not
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	886 // in a critical section itself.
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	887 result =
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	888 loader_data->metaspace_non_null()->expand_and_allocate(word_size,
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	889 mdtype);
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	890 if (result != NULL) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	891 return result;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	892 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	893 JavaThread* jthr = JavaThread::current();
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	894 if (!jthr->in_critical()) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	895 // Wait for JNI critical section to be exited
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	896 GC_locker::stall_until_clear();
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	897 // The GC invoked by the last thread leaving the critical
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	898 // section will be a young collection and a full collection
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	899 // is (currently) needed for unloading classes so continue
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	900 // to the next iteration to get a full GC.
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	901 continue;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	902 } else {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	903 if (CheckJNICalls) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	904 fatal("Possible deadlock due to allocating while"
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	905 " in jni critical section");
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	906 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	907 return NULL;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	908 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	909 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	910
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	911 { // Need lock to get self consistent gc_count's
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	912 MutexLocker ml(Heap_lock);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	913 gc_count = Universe::heap()->total_collections();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	914 full_gc_count = Universe::heap()->total_full_collections();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	915 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	916
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	917 // Generate a VM operation
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	918 VM_CollectForMetadataAllocation op(loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	919 word_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	920 mdtype,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	921 gc_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	922 full_gc_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	923 GCCause::_metadata_GC_threshold);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	924 VMThread::execute(&op);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	925
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	926 // If GC was locked out, try again. Check
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	927 // before checking success because the prologue
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	928 // could have succeeded and the GC still have
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	929 // been locked out.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	930 if (op.gc_locked()) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	931 continue;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	932 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	933
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	934 if (op.prologue_succeeded()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	935 return op.result();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	936 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	937 loop_count++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	938 if ((QueuedAllocationWarningCount > 0) &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	939 (loop_count % QueuedAllocationWarningCount == 0)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	940 warning("satisfy_failed_metadata_allocation() retries %d times \n\t"
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17899 diff changeset	941 " size=" SIZE_FORMAT, loop_count, word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	942 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	943 } while (true); // Until a GC is done
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	944 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	945
0 a61af66fc99e Initial load duke parents: diff changeset	946 // Return true if any of the following is true:
a61af66fc99e Initial load duke parents: diff changeset	947 // . the allocation won't fit into the current young gen heap
a61af66fc99e Initial load duke parents: diff changeset	948 // . gc locker is occupied (jni critical section)
a61af66fc99e Initial load duke parents: diff changeset	949 // . heap memory is tight -- the most recent previous collection
a61af66fc99e Initial load duke parents: diff changeset	950 // was a full collection because a partial collection (would
a61af66fc99e Initial load duke parents: diff changeset	951 // have) failed and is likely to fail again
a61af66fc99e Initial load duke parents: diff changeset	952 bool GenCollectorPolicy::should_try_older_generation_allocation(
a61af66fc99e Initial load duke parents: diff changeset	953 size_t word_size) const {
a61af66fc99e Initial load duke parents: diff changeset	954 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	955 size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
a61af66fc99e Initial load duke parents: diff changeset	956 return (word_size > heap_word_size(gen0_capacity))
1888 a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1795 diff changeset	957 \|\| GC_locker::is_active_and_needs_gc()
a7214d79fcf1 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data ysr parents: 1795 diff changeset	958 \|\| gch->incremental_collection_failed();
0 a61af66fc99e Initial load duke parents: diff changeset	959 }
a61af66fc99e Initial load duke parents: diff changeset	960
a61af66fc99e Initial load duke parents: diff changeset	961
a61af66fc99e Initial load duke parents: diff changeset	962 //
a61af66fc99e Initial load duke parents: diff changeset	963 // MarkSweepPolicy methods
a61af66fc99e Initial load duke parents: diff changeset	964 //
a61af66fc99e Initial load duke parents: diff changeset	965
13060 8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	966 void MarkSweepPolicy::initialize_alignments() {
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	967 _space_alignment = _gen_alignment = (uintx)Generation::GenGrain;
8f07aa079343 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking jwilhelm parents: 13059 diff changeset	968 _heap_alignment = compute_heap_alignment();
0 a61af66fc99e Initial load duke parents: diff changeset	969 }
a61af66fc99e Initial load duke parents: diff changeset	970
a61af66fc99e Initial load duke parents: diff changeset	971 void MarkSweepPolicy::initialize_generations() {
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17937 diff changeset	972 _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, CURRENT_PC,
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17937 diff changeset	973 AllocFailStrategy::RETURN_NULL);
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	974 if (_generations == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	975 vm_exit_during_initialization("Unable to allocate gen spec");
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	976 }
0 a61af66fc99e Initial load duke parents: diff changeset	977
7451 ca0a78017dc7 8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines brutisso parents: 7446 diff changeset	978 if (UseParNewGC) {
0 a61af66fc99e Initial load duke parents: diff changeset	979 _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load duke parents: diff changeset	980 } else {
a61af66fc99e Initial load duke parents: diff changeset	981 _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load duke parents: diff changeset	982 }
a61af66fc99e Initial load duke parents: diff changeset	983 _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
a61af66fc99e Initial load duke parents: diff changeset	984
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	985 if (_generations[0] == NULL \|\| _generations[1] == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	986 vm_exit_during_initialization("Unable to allocate gen spec");
13059 46d7652b223c 8026853: Prepare GC code for collector policy regression fix jwilhelm parents: 13058 diff changeset	987 }
0 a61af66fc99e Initial load duke parents: diff changeset	988 }
a61af66fc99e Initial load duke parents: diff changeset	989
a61af66fc99e Initial load duke parents: diff changeset	990 void MarkSweepPolicy::initialize_gc_policy_counters() {
a61af66fc99e Initial load duke parents: diff changeset	991 // initialize the policy counters - 2 collectors, 3 generations
7451 ca0a78017dc7 8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines brutisso parents: 7446 diff changeset	992 if (UseParNewGC) {
0 a61af66fc99e Initial load duke parents: diff changeset	993 _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3);
7451 ca0a78017dc7 8005396: Use ParNew with only one thread instead of DefNew as default for CMS on single CPU machines brutisso parents: 7446 diff changeset	994 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	995 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
a61af66fc99e Initial load duke parents: diff changeset	996 }
a61af66fc99e Initial load duke parents: diff changeset	997 }
17898 1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	998
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	999 /////////////// Unit tests ///////////////
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1000
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1001 #ifndef PRODUCT
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1002 // Testing that the NewSize flag is handled correct is hard because it
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1003 // depends on so many other configurable variables. This test only tries to
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1004 // verify that there are some basic rules for NewSize honored by the policies.
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1005 class TestGenCollectorPolicy {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1006 public:
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1007 static void test() {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1008 size_t flag_value;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1009
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1010 save_flags();
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1011
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1012 // Set some limits that makes the math simple.
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1013 FLAG_SET_ERGO(uintx, MaxHeapSize, 180 * M);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1014 FLAG_SET_ERGO(uintx, InitialHeapSize, 120 * M);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1015 Arguments::set_min_heap_size(40 * M);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1016
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1017 // If NewSize is set on the command line, it should be used
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1018 // for both min and initial young size if less than min heap.
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1019 flag_value = 20 * M;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1020 FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1021 verify_min(flag_value);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1022 verify_initial(flag_value);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1023
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1024 // If NewSize is set on command line, but is larger than the min
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1025 // heap size, it should only be used for initial young size.
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1026 flag_value = 80 * M;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1027 FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1028 verify_initial(flag_value);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1029
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1030 // If NewSize has been ergonomically set, the collector policy
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1031 // should use it for min but calculate the initial young size
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1032 // using NewRatio.
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1033 flag_value = 20 * M;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1034 FLAG_SET_ERGO(uintx, NewSize, flag_value);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1035 verify_min(flag_value);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1036 verify_scaled_initial(InitialHeapSize);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1037
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1038 restore_flags();
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1039
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1040 }
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1041
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1042 static void verify_min(size_t expected) {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1043 MarkSweepPolicy msp;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1044 msp.initialize_all();
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1045
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1046 assert(msp.min_gen0_size() <= expected, err_msg("%zu > %zu", msp.min_gen0_size(), expected));
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1047 }
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1048
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1049 static void verify_initial(size_t expected) {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1050 MarkSweepPolicy msp;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1051 msp.initialize_all();
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1052
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1053 assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1054 }
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1055
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1056 static void verify_scaled_initial(size_t initial_heap_size) {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1057 MarkSweepPolicy msp;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1058 msp.initialize_all();
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1059
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1060 size_t expected = msp.scale_by_NewRatio_aligned(initial_heap_size);
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1061 assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1062 assert(FLAG_IS_ERGO(NewSize) && NewSize == expected,
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1063 err_msg("NewSize should have been set ergonomically to %zu, but was %zu", expected, NewSize));
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1064 }
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1065
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1066 private:
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1067 static size_t original_InitialHeapSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1068 static size_t original_MaxHeapSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1069 static size_t original_MaxNewSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1070 static size_t original_MinHeapDeltaBytes;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1071 static size_t original_NewSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1072 static size_t original_OldSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1073
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1074 static void save_flags() {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1075 original_InitialHeapSize = InitialHeapSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1076 original_MaxHeapSize = MaxHeapSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1077 original_MaxNewSize = MaxNewSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1078 original_MinHeapDeltaBytes = MinHeapDeltaBytes;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1079 original_NewSize = NewSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1080 original_OldSize = OldSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1081 }
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1082
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1083 static void restore_flags() {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1084 InitialHeapSize = original_InitialHeapSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1085 MaxHeapSize = original_MaxHeapSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1086 MaxNewSize = original_MaxNewSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1087 MinHeapDeltaBytes = original_MinHeapDeltaBytes;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1088 NewSize = original_NewSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1089 OldSize = original_OldSize;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1090 }
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1091 };
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1092
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1093 size_t TestGenCollectorPolicy::original_InitialHeapSize = 0;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1094 size_t TestGenCollectorPolicy::original_MaxHeapSize = 0;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1095 size_t TestGenCollectorPolicy::original_MaxNewSize = 0;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1096 size_t TestGenCollectorPolicy::original_MinHeapDeltaBytes = 0;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1097 size_t TestGenCollectorPolicy::original_NewSize = 0;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1098 size_t TestGenCollectorPolicy::original_OldSize = 0;
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1099
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1100 void TestNewSize_test() {
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1101 TestGenCollectorPolicy::test();
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1102 }
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1103
1d01a7f3a336 8033426: Scale initial NewSize using NewRatio if not set on command line sjohanss parents: 13066 diff changeset	1104 #endif

Mercurial > hg > truffle

annotate src/share/vm/memory/collectorPolicy.cpp @ 20543:e7d0505c8a30