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

annotate src/share/vm/memory/collectorPolicy.cpp @ 12233:40136aa2cdb1

8010722: assert: failed: heap size is too big for compressed oops Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation. Reviewed-by: stefank, dholmes

author	tschatzl
date	Wed, 11 Sep 2013 16:25:02 +0200
parents	4c84d351cca9
children	9e11762cee52

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 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
a61af66fc99e Initial load duke parents: diff changeset	50 void CollectorPolicy::initialize_flags() {
10239 f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	51 assert(max_alignment() >= min_alignment(),
f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	52 err_msg("max_alignment: " SIZE_FORMAT " less than min_alignment: " SIZE_FORMAT,
f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	53 max_alignment(), min_alignment()));
f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	54 assert(max_alignment() % min_alignment() == 0,
f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	55 err_msg("max_alignment: " SIZE_FORMAT " not aligned by min_alignment: " SIZE_FORMAT,
f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	56 max_alignment(), min_alignment()));
f14063dcd52a 8013791: G1: G1CollectorPolicy::initialize_flags() may set min_alignment > max_alignment brutisso parents: 10135 diff changeset	57
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	58 if (MaxHeapSize < InitialHeapSize) {
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	59 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	60 }
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	61
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	62 if (MetaspaceSize > MaxMetaspaceSize) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	63 MaxMetaspaceSize = MetaspaceSize;
0 a61af66fc99e Initial load duke parents: diff changeset	64 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	65 MetaspaceSize = MAX2(min_alignment(), align_size_down_(MetaspaceSize, min_alignment()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	66 // Don't increase Metaspace size limit above specified.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	67 MaxMetaspaceSize = align_size_down(MaxMetaspaceSize, max_alignment());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	68 if (MetaspaceSize > MaxMetaspaceSize) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	69 MetaspaceSize = MaxMetaspaceSize;
1795 a8b66e00933b 6984368: Large default heap size does not allow to use zero based compressed oops kvn parents: 1552 diff changeset	70 }
0 a61af66fc99e Initial load duke parents: diff changeset	71
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	72 MinMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MinMetaspaceExpansion, min_alignment()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	73 MaxMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MaxMetaspaceExpansion, min_alignment()));
0 a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment());
a61af66fc99e Initial load duke parents: diff changeset	76
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	77 assert(MetaspaceSize % min_alignment() == 0, "metapace alignment");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	78 assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	79 if (MetaspaceSize < 256*K) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	80 vm_exit_during_initialization("Too small initial Metaspace size");
0 a61af66fc99e Initial load duke parents: diff changeset	81 }
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 void CollectorPolicy::initialize_size_info() {
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	85 // User inputs from -mx and ms must be aligned
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	86 set_min_heap_byte_size(align_size_up(Arguments::min_heap_size(), min_alignment()));
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	87 set_initial_heap_byte_size(align_size_up(InitialHeapSize, min_alignment()));
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	88 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment()));
0 a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90 // Check heap parameter properties
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	91 if (initial_heap_byte_size() < M) {
0 a61af66fc99e Initial load duke parents: diff changeset	92 vm_exit_during_initialization("Too small initial heap");
a61af66fc99e Initial load duke parents: diff changeset	93 }
a61af66fc99e Initial load duke parents: diff changeset	94 // Check heap parameter properties
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	95 if (min_heap_byte_size() < M) {
0 a61af66fc99e Initial load duke parents: diff changeset	96 vm_exit_during_initialization("Too small minimum heap");
a61af66fc99e Initial load duke parents: diff changeset	97 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	98 if (initial_heap_byte_size() <= NewSize) {
0 a61af66fc99e Initial load duke parents: diff changeset	99 // make sure there is at least some room in old space
a61af66fc99e Initial load duke parents: diff changeset	100 vm_exit_during_initialization("Too small initial heap for new size specified");
a61af66fc99e Initial load duke parents: diff changeset	101 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	102 if (max_heap_byte_size() < min_heap_byte_size()) {
0 a61af66fc99e Initial load duke parents: diff changeset	103 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
a61af66fc99e Initial load duke parents: diff changeset	104 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	105 if (initial_heap_byte_size() < min_heap_byte_size()) {
0 a61af66fc99e Initial load duke parents: diff changeset	106 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
a61af66fc99e Initial load duke parents: diff changeset	107 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	108 if (max_heap_byte_size() < initial_heap_byte_size()) {
0 a61af66fc99e Initial load duke parents: diff changeset	109 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
a61af66fc99e Initial load duke parents: diff changeset	110 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	111
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	112 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	113 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	114 SIZE_FORMAT " Maximum heap " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	115 min_heap_byte_size(), initial_heap_byte_size(), max_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	116 }
0 a61af66fc99e Initial load duke parents: diff changeset	117 }
a61af66fc99e Initial load duke parents: diff changeset	118
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	119 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	120 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	121 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	122 return result;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	123 }
0 a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap,
a61af66fc99e Initial load duke parents: diff changeset	126 int max_covered_regions) {
a61af66fc99e Initial load duke parents: diff changeset	127 switch (rem_set_name()) {
a61af66fc99e Initial load duke parents: diff changeset	128 case GenRemSet::CardTable: {
a61af66fc99e Initial load duke parents: diff changeset	129 CardTableRS* res = new CardTableRS(whole_heap, max_covered_regions);
a61af66fc99e Initial load duke parents: diff changeset	130 return res;
a61af66fc99e Initial load duke parents: diff changeset	131 }
a61af66fc99e Initial load duke parents: diff changeset	132 default:
a61af66fc99e Initial load duke parents: diff changeset	133 guarantee(false, "unrecognized GenRemSet::Name");
a61af66fc99e Initial load duke parents: diff changeset	134 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	135 }
a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	138 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	139 // 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	140 // 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	141 // 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	142 if (size_policy() != NULL) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	143 _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	144 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	145 _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	146 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	147
12233 40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	148 size_t CollectorPolicy::compute_max_alignment() {
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	149 // 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	150 // 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	151 // 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	152 // 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	153 // be 512*4096 = 2MB aligned.
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	154
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	155 // 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	156 // is supported.
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	157 // 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	158 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	159
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	160 // 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	161 // 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	162 // 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	163 // this use of lcm() should be removed.
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	164 if (UseLargePages && !UseParallelGC) {
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	165 // 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	166 // alignment is large page aware
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	167 alignment = lcm(os::large_page_size(), alignment);
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	168 }
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	169
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	170 return alignment;
40136aa2cdb1 8010722: assert: failed: heap size is too big for compressed oops tschatzl parents: 12110 diff changeset	171 }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	172
0 a61af66fc99e Initial load duke parents: diff changeset	173 // GenCollectorPolicy methods.
a61af66fc99e Initial load duke parents: diff changeset	174
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	175 size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	176 size_t x = base_size / (NewRatio+1);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	177 size_t new_gen_size = x > min_alignment() ?
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	178 align_size_down(x, min_alignment()) :
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	179 min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	180 return new_gen_size;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	181 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	182
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	183 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	184 size_t maximum_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	185 size_t alignment = min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	186 size_t max_minus = maximum_size - alignment;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	187 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	188 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	189
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	190
0 a61af66fc99e Initial load duke parents: diff changeset	191 void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	192 size_t init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	193 size_t 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	194 const double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
0 a61af66fc99e Initial load duke parents: diff changeset	195 _size_policy = new AdaptiveSizePolicy(init_eden_size,
a61af66fc99e Initial load duke parents: diff changeset	196 init_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	197 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	198 max_gc_pause_sec,
0 a61af66fc99e Initial load duke parents: diff changeset	199 GCTimeRatio);
a61af66fc99e Initial load duke parents: diff changeset	200 }
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 void GenCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load duke parents: diff changeset	203 // All sizes must be multiples of the generation granularity.
a61af66fc99e Initial load duke parents: diff changeset	204 set_min_alignment((uintx) Generation::GenGrain);
a61af66fc99e Initial load duke parents: diff changeset	205 set_max_alignment(compute_max_alignment());
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 CollectorPolicy::initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	208
a61af66fc99e Initial load duke parents: diff changeset	209 // All generational heaps have a youngest gen; handle those flags here.
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 // Adjust max size parameters
a61af66fc99e Initial load duke parents: diff changeset	212 if (NewSize > MaxNewSize) {
a61af66fc99e Initial load duke parents: diff changeset	213 MaxNewSize = NewSize;
a61af66fc99e Initial load duke parents: diff changeset	214 }
a61af66fc99e Initial load duke parents: diff changeset	215 NewSize = align_size_down(NewSize, min_alignment());
a61af66fc99e Initial load duke parents: diff changeset	216 MaxNewSize = align_size_down(MaxNewSize, min_alignment());
a61af66fc99e Initial load duke parents: diff changeset	217
a61af66fc99e Initial load duke parents: diff changeset	218 // Check validity of heap flags
a61af66fc99e Initial load duke parents: diff changeset	219 assert(NewSize % min_alignment() == 0, "eden space alignment");
a61af66fc99e Initial load duke parents: diff changeset	220 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment");
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 if (NewSize < 3*min_alignment()) {
a61af66fc99e Initial load duke parents: diff changeset	223 // make sure there room for eden and two survivor spaces
a61af66fc99e Initial load duke parents: diff changeset	224 vm_exit_during_initialization("Too small new size specified");
a61af66fc99e Initial load duke parents: diff changeset	225 }
a61af66fc99e Initial load duke parents: diff changeset	226 if (SurvivorRatio < 1 \|\| NewRatio < 1) {
a61af66fc99e Initial load duke parents: diff changeset	227 vm_exit_during_initialization("Invalid heap ratio specified");
a61af66fc99e Initial load duke parents: diff changeset	228 }
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230
a61af66fc99e Initial load duke parents: diff changeset	231 void TwoGenerationCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load duke parents: diff changeset	232 GenCollectorPolicy::initialize_flags();
a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 OldSize = align_size_down(OldSize, min_alignment());
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	235
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	236 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) {
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	237 // 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	238 // 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	239 // and NewRatio.
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	240 assert(NewRatio > 0, "NewRatio should have been set up earlier");
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	241 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	242
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	243 calculated_heapsize = align_size_up(calculated_heapsize, max_alignment());
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	244 MaxHeapSize = calculated_heapsize;
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	245 InitialHeapSize = calculated_heapsize;
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	246 }
0 a61af66fc99e Initial load duke parents: diff changeset	247 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
a61af66fc99e Initial load duke parents: diff changeset	248
10241 d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	249 // adjust max heap size if necessary
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	250 if (NewSize + OldSize > MaxHeapSize) {
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	251 if (FLAG_IS_CMDLINE(MaxHeapSize)) {
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	252 // 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	253 // exceed it. Adjust New/OldSize as necessary.
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	254 uintx calculated_size = NewSize + OldSize;
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	255 double shrink_factor = (double) MaxHeapSize / calculated_size;
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	256 // align
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	257 NewSize = align_size_down((uintx) (NewSize * shrink_factor), min_alignment());
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	258 // OldSize is already aligned because above we aligned MaxHeapSize to
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	259 // max_alignment(), and we just made sure that NewSize is aligned to
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	260 // min_alignment(). In initialize_flags() we verified that max_alignment()
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	261 // is a multiple of min_alignment().
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	262 OldSize = MaxHeapSize - NewSize;
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	263 } else {
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	264 MaxHeapSize = NewSize + OldSize;
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	265 }
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	266 }
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	267 // need to do this again
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	268 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
d17700c82d7d 8006088: Incompatible heap size flags accepted by VM tschatzl parents: 10239 diff changeset	269
10284 7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	270 // adjust max heap size if necessary
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	271 if (NewSize + OldSize > MaxHeapSize) {
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	272 if (FLAG_IS_CMDLINE(MaxHeapSize)) {
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	273 // somebody set a maximum heap size with the intention that we should not
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	274 // exceed it. Adjust New/OldSize as necessary.
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	275 uintx calculated_size = NewSize + OldSize;
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	276 double shrink_factor = (double) MaxHeapSize / calculated_size;
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	277 // align
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	278 NewSize = align_size_down((uintx) (NewSize * shrink_factor), min_alignment());
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	279 // OldSize is already aligned because above we aligned MaxHeapSize to
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	280 // max_alignment(), and we just made sure that NewSize is aligned to
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	281 // min_alignment(). In initialize_flags() we verified that max_alignment()
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	282 // is a multiple of min_alignment().
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	283 OldSize = MaxHeapSize - NewSize;
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	284 } else {
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	285 MaxHeapSize = NewSize + OldSize;
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	286 }
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	287 }
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	288 // need to do this again
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	289 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
7a95933197d0 8014058: Regression tests for 8006088 tschatzl parents: 10241 diff changeset	290
0 a61af66fc99e Initial load duke parents: diff changeset	291 always_do_update_barrier = UseConcMarkSweepGC;
a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 // Check validity of heap flags
a61af66fc99e Initial load duke parents: diff changeset	294 assert(OldSize % min_alignment() == 0, "old space alignment");
a61af66fc99e Initial load duke parents: diff changeset	295 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment");
a61af66fc99e Initial load duke parents: diff changeset	296 }
a61af66fc99e Initial load duke parents: diff changeset	297
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	298 // 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	299 // set command line parameters.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	300 // 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	301 // 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	302 // 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	303 // 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	304 // themselves and with overall heap sizings.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	305 // 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	306 // such as the use of NewRatio are used to size the generation.
0 a61af66fc99e Initial load duke parents: diff changeset	307 void GenCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load duke parents: diff changeset	308 CollectorPolicy::initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	309
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	310 // min_alignment() is used for alignment within a generation.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	311 // 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	312 // 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	313 // generations sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	314
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	315 // Determine maximum size of gen0
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	316
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	317 size_t max_new_size = 0;
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	318 if (FLAG_IS_CMDLINE(MaxNewSize) \|\| FLAG_IS_ERGO(MaxNewSize)) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	319 if (MaxNewSize < min_alignment()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	320 max_new_size = min_alignment();
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	321 }
dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	322 if (MaxNewSize >= max_heap_byte_size()) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	323 max_new_size = align_size_down(max_heap_byte_size() - min_alignment(),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	324 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	325 warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	326 "greater than the entire heap (" SIZE_FORMAT "k). A "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	327 "new generation size of " SIZE_FORMAT "k will be used.",
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	328 MaxNewSize/K, max_heap_byte_size()/K, max_new_size/K);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	329 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	330 max_new_size = align_size_down(MaxNewSize, min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	331 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	332
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	333 // The case for FLAG_IS_ERGO(MaxNewSize) could be treated
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	334 // specially at this point to just use an ergonomically set
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	335 // MaxNewSize to set max_new_size. For cases with small
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	336 // heaps such a policy often did not work because the MaxNewSize
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	337 // was larger than the entire heap. The interpretation given
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	338 // to ergonomically set flags is that the flags are set
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	339 // by different collectors for their own special needs but
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	340 // are not allowed to badly shape the heap. This allows the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	341 // different collectors to decide what's best for themselves
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	342 // without having to factor in the overall heap shape. It
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	343 // can be the case in the future that the collectors would
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	344 // only make "wise" ergonomics choices and this policy could
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	345 // just accept those choices. The choices currently made are
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	346 // not always "wise".
0 a61af66fc99e Initial load duke parents: diff changeset	347 } else {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	348 max_new_size = scale_by_NewRatio_aligned(max_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	349 // Bound the maximum size by NewSize below (since it historically
0 a61af66fc99e Initial load duke parents: diff changeset	350 // would have been NewSize and because the NewRatio calculation could
a61af66fc99e Initial load duke parents: diff changeset	351 // 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	352 // 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	353 // NewSize and MaxNewSize.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	354 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	355 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	356 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	357
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	358 // 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	359 // minimum gen0 sizes.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	360
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	361 if (max_heap_byte_size() == min_heap_byte_size()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	362 // 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	363 // 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	364 // same as its maximum.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	365 set_min_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	366 set_initial_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	367 set_max_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	368 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	369 size_t desired_new_size = 0;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	370 if (!FLAG_IS_DEFAULT(NewSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	371 // If NewSize is set ergonomically (for example by cms), it
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	372 // would make sense to use it. If it is used, also use it
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	373 // to set the initial size. Although there is no reason
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	374 // the minimum size and the initial size have to be the same,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	375 // the current implementation gets into trouble during the calculation
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	376 // of the tenured generation sizes if they are different.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	377 // Note that this makes the initial size and the minimum size
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	378 // generally small compared to the NewRatio calculation.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	379 _min_gen0_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	380 desired_new_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	381 max_new_size = MAX2(max_new_size, NewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	382 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	383 // 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	384 // 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	385 // 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	386 // 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	387 // small.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	388 _min_gen0_size = MAX2(scale_by_NewRatio_aligned(min_heap_byte_size()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	389 NewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	390 desired_new_size =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	391 MAX2(scale_by_NewRatio_aligned(initial_heap_byte_size()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	392 NewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	393 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	394
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	395 assert(_min_gen0_size > 0, "Sanity check");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	396 set_initial_gen0_size(desired_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	397 set_max_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	398
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	399 // 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	400 // determined without regard to the maximum sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	401
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	402 // Bound the sizes by the corresponding overall heap sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	403 set_min_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	404 bound_minus_alignment(_min_gen0_size, min_heap_byte_size()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	405 set_initial_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	406 bound_minus_alignment(_initial_gen0_size, initial_heap_byte_size()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	407 set_max_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	408 bound_minus_alignment(_max_gen0_size, max_heap_byte_size()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	409
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	410 // 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	411 // maximum sizes but have not been checked for consistency
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 13 diff changeset	412 // among the three.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	413
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	414 // Final check min <= initial <= max
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	415 set_min_gen0_size(MIN2(_min_gen0_size, _max_gen0_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	416 set_initial_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	417 MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	418 set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size));
0 a61af66fc99e Initial load duke parents: diff changeset	419 }
a61af66fc99e Initial load duke parents: diff changeset	420
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	421 if (PrintGCDetails && Verbose) {
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	422 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	423 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	424 min_gen0_size(), initial_gen0_size(), max_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	425 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	426 }
0 a61af66fc99e Initial load duke parents: diff changeset	427
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	428 // 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	429 // 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	430 // 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	431 // 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	432 // 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	433 // 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	434 // 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	435 // 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	436 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	437 size_t* gen1_size_ptr,
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	438 const size_t heap_size,
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	439 const size_t min_gen1_size) {
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	440 bool result = false;
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	441
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	442 if ((gen1_size_ptr + gen0_size_ptr) > heap_size) {
8013 95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	443 if ((heap_size < (*gen0_size_ptr + min_gen1_size)) &&
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	444 (heap_size >= min_gen1_size + min_alignment())) {
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	445 // Adjust gen0 down to accommodate min_gen1_size
95ccff9eee8e 6348447: Specifying -XX:OldSize crashes 64-bit VMs jwilhelm parents: 7451 diff changeset	446 *gen0_size_ptr = heap_size - min_gen1_size;
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	447 *gen0_size_ptr =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	448 MAX2((uintx)align_size_down(*gen0_size_ptr, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	449 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	450 assert(*gen0_size_ptr > 0, "Min gen0 is too large");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	451 result = true;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	452 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	453 gen1_size_ptr = heap_size - gen0_size_ptr;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	454 *gen1_size_ptr =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	455 MAX2((uintx)align_size_down(*gen1_size_ptr, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	456 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	457 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	458 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	459 return result;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	460 }
0 a61af66fc99e Initial load duke parents: diff changeset	461
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	462 // 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	463 // 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	464 // 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	465 // 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	466 // 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	467 // but allow the values to pass.
0 a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 void TwoGenerationCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load duke parents: diff changeset	470 GenCollectorPolicy::initialize_size_info();
a61af66fc99e Initial load duke parents: diff changeset	471
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	472 // 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	473 // 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	474 // 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	475 // 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	476 // for setting the gen1 maximum.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	477 _max_gen1_size = max_heap_byte_size() - _max_gen0_size;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	478 _max_gen1_size =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	479 MAX2((uintx)align_size_down(_max_gen1_size, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	480 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	481 // 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	482 // gen1 size, use what is left for gen1.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	483 if (FLAG_IS_DEFAULT(OldSize) \|\| FLAG_IS_ERGO(OldSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	484 // The user has not specified any value or ergonomics
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	485 // has chosen a value (which may or may not be consistent
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	486 // 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	487 // the minimum, maximum and initial sizes consistent
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	488 // with the gen0 sizes and the overall heap sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	489 assert(min_heap_byte_size() > _min_gen0_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	490 "gen0 has an unexpected minimum size");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	491 set_min_gen1_size(min_heap_byte_size() - min_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	492 set_min_gen1_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	493 MAX2((uintx)align_size_down(_min_gen1_size, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	494 min_alignment()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	495 set_initial_gen1_size(initial_heap_byte_size() - initial_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	496 set_initial_gen1_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	497 MAX2((uintx)align_size_down(_initial_gen1_size, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	498 min_alignment()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	499
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	500 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	501 // 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	502 // OldSize and then determine the consequences.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	503 set_min_gen1_size(OldSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	504 set_initial_gen1_size(OldSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	505
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	506 // 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	507 // with other command line flags, issue a warning.
0 a61af66fc99e Initial load duke parents: diff changeset	508 // The generation minimums and the overall heap mimimum should
a61af66fc99e Initial load duke parents: diff changeset	509 // be within one heap alignment.
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	510 if ((_min_gen1_size + _min_gen0_size + min_alignment()) <
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	511 min_heap_byte_size()) {
0 a61af66fc99e Initial load duke parents: diff changeset	512 warning("Inconsistency between minimum heap size and minimum "
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	513 "generation sizes: using minimum heap = " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	514 min_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	515 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	516 if ((OldSize > _max_gen1_size)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	517 warning("Inconsistency between maximum heap size and maximum "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	518 "generation sizes: using maximum heap = " SIZE_FORMAT
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	519 " -XX:OldSize flag is being ignored",
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	520 max_heap_byte_size());
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	521 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	522 // 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	523 // initial size of gen0, since OldSize was explicitly set, OldSize wins.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	524 if (adjust_gen0_sizes(&_min_gen0_size, &_min_gen1_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	525 min_heap_byte_size(), OldSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	526 if (PrintGCDetails && Verbose) {
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	527 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	528 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	529 min_gen0_size(), initial_gen0_size(), max_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	530 }
0 a61af66fc99e Initial load duke parents: diff changeset	531 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	532 // Initial size
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	533 if (adjust_gen0_sizes(&_initial_gen0_size, &_initial_gen1_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	534 initial_heap_byte_size(), OldSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	535 if (PrintGCDetails && Verbose) {
2368 dde920245681 6896099: Integrate CMS heap ergo with default heap sizing ergo ysr parents: 1994 diff changeset	536 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	537 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	538 min_gen0_size(), initial_gen0_size(), max_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	539 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	540 }
0 a61af66fc99e Initial load duke parents: diff changeset	541 }
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	542 // Enforce the maximum gen1 size.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	543 set_min_gen1_size(MIN2(_min_gen1_size, _max_gen1_size));
0 a61af66fc99e Initial load duke parents: diff changeset	544
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	545 // Check that min gen1 <= initial gen1 <= max gen1
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	546 set_initial_gen1_size(MAX2(_initial_gen1_size, _min_gen1_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	547 set_initial_gen1_size(MIN2(_initial_gen1_size, _max_gen1_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	548
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	549 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	550 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	551 SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	552 min_gen1_size(), initial_gen1_size(), max_gen1_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	553 }
0 a61af66fc99e Initial load duke parents: diff changeset	554 }
a61af66fc99e Initial load duke parents: diff changeset	555
a61af66fc99e Initial load duke parents: diff changeset	556 HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	557 bool is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	558 bool* gc_overhead_limit_was_exceeded) {
a61af66fc99e Initial load duke parents: diff changeset	559 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	560
a61af66fc99e Initial load duke parents: diff changeset	561 debug_only(gch->check_for_valid_allocation_state());
a61af66fc99e Initial load duke parents: diff changeset	562 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	563
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	564 // 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	565 // 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	566 // 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	567 *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	568
0 a61af66fc99e Initial load duke parents: diff changeset	569 HeapWord* result = NULL;
a61af66fc99e Initial load duke parents: diff changeset	570
a61af66fc99e Initial load duke parents: diff changeset	571 // Loop until the allocation is satisified,
a61af66fc99e Initial load duke parents: diff changeset	572 // or unsatisfied after GC.
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	573 for (int try_count = 1, gclocker_stalled_count = 0; /* return or throw */; try_count += 1) {
0 a61af66fc99e Initial load duke parents: diff changeset	574 HandleMark hm; // discard any handles allocated in each iteration
a61af66fc99e Initial load duke parents: diff changeset	575
a61af66fc99e Initial load duke parents: diff changeset	576 // First allocation attempt is lock-free.
a61af66fc99e Initial load duke parents: diff changeset	577 Generation *gen0 = gch->get_gen(0);
a61af66fc99e Initial load duke parents: diff changeset	578 assert(gen0->supports_inline_contig_alloc(),
a61af66fc99e Initial load duke parents: diff changeset	579 "Otherwise, must do alloc within heap lock");
a61af66fc99e Initial load duke parents: diff changeset	580 if (gen0->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load duke parents: diff changeset	581 result = gen0->par_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	582 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	583 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	584 return result;
a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586 }
a61af66fc99e Initial load duke parents: diff changeset	587 unsigned int gc_count_before; // read inside the Heap_lock locked region
a61af66fc99e Initial load duke parents: diff changeset	588 {
a61af66fc99e Initial load duke parents: diff changeset	589 MutexLocker ml(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	590 if (PrintGC && Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	591 gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:"
a61af66fc99e Initial load duke parents: diff changeset	592 " attempting locked slow path allocation");
a61af66fc99e Initial load duke parents: diff changeset	593 }
a61af66fc99e Initial load duke parents: diff changeset	594 // Note that only large objects get a shot at being
a61af66fc99e Initial load duke parents: diff changeset	595 // allocated in later generations.
a61af66fc99e Initial load duke parents: diff changeset	596 bool first_only = ! should_try_older_generation_allocation(size);
a61af66fc99e Initial load duke parents: diff changeset	597
a61af66fc99e Initial load duke parents: diff changeset	598 result = gch->attempt_allocation(size, is_tlab, first_only);
a61af66fc99e Initial load duke parents: diff changeset	599 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	600 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	601 return result;
a61af66fc99e Initial load duke parents: diff changeset	602 }
a61af66fc99e Initial load duke parents: diff changeset	603
a61af66fc99e Initial load duke parents: diff changeset	604 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	605 if (is_tlab) {
a61af66fc99e Initial load duke parents: diff changeset	606 return NULL; // Caller will retry allocating individual object
a61af66fc99e Initial load duke parents: diff changeset	607 }
a61af66fc99e Initial load duke parents: diff changeset	608 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	609 // Try and expand heap to satisfy request
a61af66fc99e Initial load duke parents: diff changeset	610 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	611 // result could be null if we are out of space
a61af66fc99e Initial load duke parents: diff changeset	612 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	613 return result;
a61af66fc99e Initial load duke parents: diff changeset	614 }
a61af66fc99e Initial load duke parents: diff changeset	615 }
a61af66fc99e Initial load duke parents: diff changeset	616
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	617 if (gclocker_stalled_count > GCLockerRetryAllocationCount) {
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	618 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	619 }
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	620
0 a61af66fc99e Initial load duke parents: diff changeset	621 // If this thread is not in a jni critical section, we stall
a61af66fc99e Initial load duke parents: diff changeset	622 // the requestor until the critical section has cleared and
a61af66fc99e Initial load duke parents: diff changeset	623 // GC allowed. When the critical section clears, a GC is
a61af66fc99e Initial load duke parents: diff changeset	624 // initiated by the last thread exiting the critical section; so
a61af66fc99e Initial load duke parents: diff changeset	625 // we retry the allocation sequence from the beginning of the loop,
a61af66fc99e Initial load duke parents: diff changeset	626 // rather than causing more, now probably unnecessary, GC attempts.
a61af66fc99e Initial load duke parents: diff changeset	627 JavaThread* jthr = JavaThread::current();
a61af66fc99e Initial load duke parents: diff changeset	628 if (!jthr->in_critical()) {
a61af66fc99e Initial load duke parents: diff changeset	629 MutexUnlocker mul(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	630 // Wait for JNI critical section to be exited
a61af66fc99e Initial load duke parents: diff changeset	631 GC_locker::stall_until_clear();
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8743 diff changeset	632 gclocker_stalled_count += 1;
0 a61af66fc99e Initial load duke parents: diff changeset	633 continue;
a61af66fc99e Initial load duke parents: diff changeset	634 } else {
a61af66fc99e Initial load duke parents: diff changeset	635 if (CheckJNICalls) {
a61af66fc99e Initial load duke parents: diff changeset	636 fatal("Possible deadlock due to allocating while"
a61af66fc99e Initial load duke parents: diff changeset	637 " in jni critical section");
a61af66fc99e Initial load duke parents: diff changeset	638 }
a61af66fc99e Initial load duke parents: diff changeset	639 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	640 }
a61af66fc99e Initial load duke parents: diff changeset	641 }
a61af66fc99e Initial load duke parents: diff changeset	642
a61af66fc99e Initial load duke parents: diff changeset	643 // Read the gc count while the heap lock is held.
a61af66fc99e Initial load duke parents: diff changeset	644 gc_count_before = Universe::heap()->total_collections();
a61af66fc99e Initial load duke parents: diff changeset	645 }
a61af66fc99e Initial load duke parents: diff changeset	646
a61af66fc99e Initial load duke parents: diff changeset	647 VM_GenCollectForAllocation op(size,
a61af66fc99e Initial load duke parents: diff changeset	648 is_tlab,
a61af66fc99e Initial load duke parents: diff changeset	649 gc_count_before);
a61af66fc99e Initial load duke parents: diff changeset	650 VMThread::execute(&op);
a61af66fc99e Initial load duke parents: diff changeset	651 if (op.prologue_succeeded()) {
a61af66fc99e Initial load duke parents: diff changeset	652 result = op.result();
a61af66fc99e Initial load duke parents: diff changeset	653 if (op.gc_locked()) {
a61af66fc99e Initial load duke parents: diff changeset	654 assert(result == NULL, "must be NULL if gc_locked() is true");
a61af66fc99e Initial load duke parents: diff changeset	655 continue; // retry and/or stall as necessary
a61af66fc99e Initial load duke parents: diff changeset	656 }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	657
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	658 // 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	659 // 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	660 // 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	661 // 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	662 // 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	663
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	664 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	665 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	666
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	667 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	668 *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	669 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	670 if (op.result() != NULL) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	671 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	672 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	673 return NULL;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	674 }
0 a61af66fc99e Initial load duke parents: diff changeset	675 assert(result == NULL \|\| gch->is_in_reserved(result),
a61af66fc99e Initial load duke parents: diff changeset	676 "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	677 return result;
a61af66fc99e Initial load duke parents: diff changeset	678 }
a61af66fc99e Initial load duke parents: diff changeset	679
a61af66fc99e Initial load duke parents: diff changeset	680 // Give a warning if we seem to be looping forever.
a61af66fc99e Initial load duke parents: diff changeset	681 if ((QueuedAllocationWarningCount > 0) &&
a61af66fc99e Initial load duke parents: diff changeset	682 (try_count % QueuedAllocationWarningCount == 0)) {
a61af66fc99e Initial load duke parents: diff changeset	683 warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t"
a61af66fc99e Initial load duke parents: diff changeset	684 " size=%d %s", try_count, size, is_tlab ? "(TLAB)" : "");
a61af66fc99e Initial load duke parents: diff changeset	685 }
a61af66fc99e Initial load duke parents: diff changeset	686 }
a61af66fc99e Initial load duke parents: diff changeset	687 }
a61af66fc99e Initial load duke parents: diff changeset	688
a61af66fc99e Initial load duke parents: diff changeset	689 HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	690 bool is_tlab) {
a61af66fc99e Initial load duke parents: diff changeset	691 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	692 HeapWord* result = NULL;
a61af66fc99e Initial load duke parents: diff changeset	693 for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) {
a61af66fc99e Initial load duke parents: diff changeset	694 Generation *gen = gch->get_gen(i);
a61af66fc99e Initial load duke parents: diff changeset	695 if (gen->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load duke parents: diff changeset	696 result = gen->expand_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	697 }
a61af66fc99e Initial load duke parents: diff changeset	698 }
a61af66fc99e Initial load duke parents: diff changeset	699 assert(result == NULL \|\| gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	700 return result;
a61af66fc99e Initial load duke parents: diff changeset	701 }
a61af66fc99e Initial load duke parents: diff changeset	702
a61af66fc99e Initial load duke parents: diff changeset	703 HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	704 bool is_tlab) {
a61af66fc99e Initial load duke parents: diff changeset	705 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	706 GCCauseSetter x(gch, GCCause::_allocation_failure);
a61af66fc99e Initial load duke parents: diff changeset	707 HeapWord* result = NULL;
a61af66fc99e Initial load duke parents: diff changeset	708
a61af66fc99e Initial load duke parents: diff changeset	709 assert(size != 0, "Precondition violated");
a61af66fc99e Initial load duke parents: diff changeset	710 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	711 // GC locker is active; instead of a collection we will attempt
a61af66fc99e Initial load duke parents: diff changeset	712 // to expand the heap, if there's room for expansion.
a61af66fc99e Initial load duke parents: diff changeset	713 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	714 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	715 }
a61af66fc99e Initial load duke parents: diff changeset	716 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	717 } else if (!gch->incremental_collection_will_fail(false /* don't consult_young */)) {
0 a61af66fc99e Initial load duke parents: diff changeset	718 // Do an incremental collection.
a61af66fc99e Initial load duke parents: diff changeset	719 gch->do_collection(false /* full */,
a61af66fc99e Initial load duke parents: diff changeset	720 false /* clear_all_soft_refs */,
a61af66fc99e Initial load duke parents: diff changeset	721 size /* size */,
a61af66fc99e Initial load duke parents: diff changeset	722 is_tlab /* is_tlab */,
a61af66fc99e Initial load duke parents: diff changeset	723 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load duke parents: diff changeset	724 } else {
1994 6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	725 if (Verbose && PrintGCDetails) {
6cd6d394f280 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot \|\| !gch->incremental_collection_failed()) ysr parents: 1972 diff changeset	726 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	727 }
0 a61af66fc99e Initial load duke parents: diff changeset	728 // Try a full collection; see delta for bug id 6266275
a61af66fc99e Initial load duke parents: diff changeset	729 // for the original code and why this has been simplified
a61af66fc99e Initial load duke parents: diff changeset	730 // with from-space allocation criteria modified and
a61af66fc99e Initial load duke parents: diff changeset	731 // such allocation moved out of the safepoint path.
a61af66fc99e Initial load duke parents: diff changeset	732 gch->do_collection(true /* full */,
a61af66fc99e Initial load duke parents: diff changeset	733 false /* clear_all_soft_refs */,
a61af66fc99e Initial load duke parents: diff changeset	734 size /* size */,
a61af66fc99e Initial load duke parents: diff changeset	735 is_tlab /* is_tlab */,
a61af66fc99e Initial load duke parents: diff changeset	736 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load duke parents: diff changeset	737 }
a61af66fc99e Initial load duke parents: diff changeset	738
a61af66fc99e Initial load duke parents: diff changeset	739 result = gch->attempt_allocation(size, is_tlab, false /first_only/);
a61af66fc99e Initial load duke parents: diff changeset	740
a61af66fc99e Initial load duke parents: diff changeset	741 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	742 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	743 return result;
a61af66fc99e Initial load duke parents: diff changeset	744 }
a61af66fc99e Initial load duke parents: diff changeset	745
a61af66fc99e Initial load duke parents: diff changeset	746 // OK, collection failed, try expansion.
a61af66fc99e Initial load duke parents: diff changeset	747 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load duke parents: diff changeset	748 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	749 return result;
a61af66fc99e Initial load duke parents: diff changeset	750 }
a61af66fc99e Initial load duke parents: diff changeset	751
a61af66fc99e Initial load duke parents: diff changeset	752 // If we reach this point, we're really out of memory. Try every trick
a61af66fc99e Initial load duke parents: diff changeset	753 // we can to reclaim memory. Force collection of soft references. Force
a61af66fc99e Initial load duke parents: diff changeset	754 // a complete compaction of the heap. Any additional methods for finding
a61af66fc99e Initial load duke parents: diff changeset	755 // free memory should be here, especially if they are expensive. If this
a61af66fc99e Initial load duke parents: diff changeset	756 // attempt fails, an OOM exception will be thrown.
a61af66fc99e Initial load duke parents: diff changeset	757 {
10287 12f651e29f6b 6843347: Boundary values in some public GC options cause crashes tschatzl parents: 10284 diff changeset	758 UIntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
0 a61af66fc99e Initial load duke parents: diff changeset	759
a61af66fc99e Initial load duke parents: diff changeset	760 gch->do_collection(true /* full */,
a61af66fc99e Initial load duke parents: diff changeset	761 true /* clear_all_soft_refs */,
a61af66fc99e Initial load duke parents: diff changeset	762 size /* size */,
a61af66fc99e Initial load duke parents: diff changeset	763 is_tlab /* is_tlab */,
a61af66fc99e Initial load duke parents: diff changeset	764 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load duke parents: diff changeset	765 }
a61af66fc99e Initial load duke parents: diff changeset	766
a61af66fc99e Initial load duke parents: diff changeset	767 result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
a61af66fc99e Initial load duke parents: diff changeset	768 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	769 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	770 return result;
a61af66fc99e Initial load duke parents: diff changeset	771 }
a61af66fc99e Initial load duke parents: diff changeset	772
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1064 diff changeset	773 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	774 "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	775
0 a61af66fc99e Initial load duke parents: diff changeset	776 // What else? We might try synchronous finalization later. If the total
a61af66fc99e Initial load duke parents: diff changeset	777 // space available is large enough for the allocation, then a more
a61af66fc99e Initial load duke parents: diff changeset	778 // complete compaction phase than we've tried so far might be
a61af66fc99e Initial load duke parents: diff changeset	779 // appropriate.
a61af66fc99e Initial load duke parents: diff changeset	780 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	781 }
a61af66fc99e Initial load duke parents: diff changeset	782
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	783 MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	784 ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	785 size_t word_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	786 Metaspace::MetadataType mdtype) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	787 uint loop_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	788 uint gc_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	789 uint full_gc_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	790
6923 3fadc0e8cffe 8000988: VM deadlock when running btree006 on windows-i586 jmasa parents: 6753 diff changeset	791 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	792
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	793 do {
6753 8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	794 MetaWord* result = NULL;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	795 if (GC_locker::is_active_and_needs_gc()) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	796 // 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	797 // 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	798 // in a critical section itself.
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	799 result =
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	800 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	801 mdtype);
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	802 if (result != NULL) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	803 return result;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	804 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	805 JavaThread* jthr = JavaThread::current();
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	806 if (!jthr->in_critical()) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	807 // Wait for JNI critical section to be exited
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	808 GC_locker::stall_until_clear();
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	809 // 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	810 // 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	811 // is (currently) needed for unloading classes so continue
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	812 // 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	813 continue;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	814 } else {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	815 if (CheckJNICalls) {
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	816 fatal("Possible deadlock due to allocating while"
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	817 " in jni critical section");
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	818 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	819 return NULL;
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	820 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	821 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6725 diff changeset	822
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	823 { // 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	824 MutexLocker ml(Heap_lock);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	825 gc_count = Universe::heap()->total_collections();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	826 full_gc_count = Universe::heap()->total_full_collections();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	827 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	828
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	829 // Generate a VM operation
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	830 VM_CollectForMetadataAllocation op(loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	831 word_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	832 mdtype,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	833 gc_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	834 full_gc_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	835 GCCause::_metadata_GC_threshold);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	836 VMThread::execute(&op);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	837
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	838 // 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	839 // before checking success because the prologue
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	840 // 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	841 // been locked out.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	842 if (op.gc_locked()) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	843 continue;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	844 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7180 diff changeset	845
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	846 if (op.prologue_succeeded()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	847 return op.result();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	848 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	849 loop_count++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	850 if ((QueuedAllocationWarningCount > 0) &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	851 (loop_count % QueuedAllocationWarningCount == 0)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	852 warning("satisfy_failed_metadata_allocation() retries %d times \n\t"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	853 " size=%d", loop_count, word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	854 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	855 } while (true); // Until a GC is done
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	856 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3960 diff changeset	857
0 a61af66fc99e Initial load duke parents: diff changeset	858 // Return true if any of the following is true:
a61af66fc99e Initial load duke parents: diff changeset	859 // . the allocation won't fit into the current young gen heap
a61af66fc99e Initial load duke parents: diff changeset	860 // . gc locker is occupied (jni critical section)
a61af66fc99e Initial load duke parents: diff changeset	861 // . heap memory is tight -- the most recent previous collection
a61af66fc99e Initial load duke parents: diff changeset	862 // was a full collection because a partial collection (would
a61af66fc99e Initial load duke parents: diff changeset	863 // have) failed and is likely to fail again
a61af66fc99e Initial load duke parents: diff changeset	864 bool GenCollectorPolicy::should_try_older_generation_allocation(
a61af66fc99e Initial load duke parents: diff changeset	865 size_t word_size) const {
a61af66fc99e Initial load duke parents: diff changeset	866 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	867 size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
a61af66fc99e Initial load duke parents: diff changeset	868 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	869 \|\| 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	870 \|\| gch->incremental_collection_failed();
0 a61af66fc99e Initial load duke parents: diff changeset	871 }
a61af66fc99e Initial load duke parents: diff changeset	872
a61af66fc99e Initial load duke parents: diff changeset	873
a61af66fc99e Initial load duke parents: diff changeset	874 //
a61af66fc99e Initial load duke parents: diff changeset	875 // MarkSweepPolicy methods
a61af66fc99e Initial load duke parents: diff changeset	876 //
a61af66fc99e Initial load duke parents: diff changeset	877
a61af66fc99e Initial load duke parents: diff changeset	878 MarkSweepPolicy::MarkSweepPolicy() {
a61af66fc99e Initial load duke parents: diff changeset	879 initialize_all();
a61af66fc99e Initial load duke parents: diff changeset	880 }
a61af66fc99e Initial load duke parents: diff changeset	881
a61af66fc99e Initial load duke parents: diff changeset	882 void MarkSweepPolicy::initialize_generations() {
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10241 diff changeset	883 _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, 0, AllocFailStrategy::RETURN_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	884 if (_generations == NULL)
a61af66fc99e Initial load duke parents: diff changeset	885 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load duke parents: diff changeset	886
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	887 if (UseParNewGC) {
0 a61af66fc99e Initial load duke parents: diff changeset	888 _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load duke parents: diff changeset	889 } else {
a61af66fc99e Initial load duke parents: diff changeset	890 _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load duke parents: diff changeset	891 }
a61af66fc99e Initial load duke parents: diff changeset	892 _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
a61af66fc99e Initial load duke parents: diff changeset	893
a61af66fc99e Initial load duke parents: diff changeset	894 if (_generations[0] == NULL \|\| _generations[1] == NULL)
a61af66fc99e Initial load duke parents: diff changeset	895 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load duke parents: diff changeset	896 }
a61af66fc99e Initial load duke parents: diff changeset	897
a61af66fc99e Initial load duke parents: diff changeset	898 void MarkSweepPolicy::initialize_gc_policy_counters() {
a61af66fc99e Initial load duke parents: diff changeset	899 // 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	900 if (UseParNewGC) {
0 a61af66fc99e Initial load duke parents: diff changeset	901 _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	902 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	903 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
a61af66fc99e Initial load duke parents: diff changeset	904 }
a61af66fc99e Initial load duke parents: diff changeset	905 }

Mercurial > hg > truffle

annotate src/share/vm/memory/collectorPolicy.cpp @ 12233:40136aa2cdb1