graal-compiler: src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp annotate

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	7b835924c31c
children	f2110083203d

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	2 * Copyright (c) 2001, 2012, 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: 1907 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	26 #include "gc_implementation/parallelScavenge/adjoiningGenerations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	27 #include "gc_implementation/parallelScavenge/adjoiningVirtualSpaces.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	28 #include "gc_implementation/parallelScavenge/cardTableExtension.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	29 #include "gc_implementation/parallelScavenge/gcTaskManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	30 #include "gc_implementation/parallelScavenge/generationSizer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	31 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	32 #include "gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	33 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	34 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	35 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	36 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	37 #include "gc_implementation/parallelScavenge/vmPSOperations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	38 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	39 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	40 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	41 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	42 #include "runtime/vmThread.hpp"
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6008 diff changeset	43 #include "services/memTracker.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1907 diff changeset	44 #include "utilities/vmError.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 PSYoungGen* ParallelScavengeHeap::_young_gen = NULL;
a61af66fc99e Initial load duke parents: diff changeset	47 PSOldGen* ParallelScavengeHeap::_old_gen = NULL;
a61af66fc99e Initial load duke parents: diff changeset	48 PSAdaptiveSizePolicy* ParallelScavengeHeap::_size_policy = NULL;
a61af66fc99e Initial load duke parents: diff changeset	49 PSGCAdaptivePolicyCounters* ParallelScavengeHeap::_gc_policy_counters = NULL;
a61af66fc99e Initial load duke parents: diff changeset	50 ParallelScavengeHeap* ParallelScavengeHeap::_psh = NULL;
a61af66fc99e Initial load duke parents: diff changeset	51 GCTaskManager* ParallelScavengeHeap::_gc_task_manager = NULL;
a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 static void trace_gen_sizes(const char* const str,
a61af66fc99e Initial load duke parents: diff changeset	54 size_t og_min, size_t og_max,
a61af66fc99e Initial load duke parents: diff changeset	55 size_t yg_min, size_t yg_max)
a61af66fc99e Initial load duke parents: diff changeset	56 {
a61af66fc99e Initial load duke parents: diff changeset	57 if (TracePageSizes) {
a61af66fc99e Initial load duke parents: diff changeset	58 tty->print_cr("%s: " SIZE_FORMAT "," SIZE_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	59 SIZE_FORMAT "," SIZE_FORMAT " "
a61af66fc99e Initial load duke parents: diff changeset	60 SIZE_FORMAT,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	61 str,
0 a61af66fc99e Initial load duke parents: diff changeset	62 og_min / K, og_max / K,
a61af66fc99e Initial load duke parents: diff changeset	63 yg_min / K, yg_max / K,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	64 (og_max + yg_max) / K);
0 a61af66fc99e Initial load duke parents: diff changeset	65 }
a61af66fc99e Initial load duke parents: diff changeset	66 }
a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68 jint ParallelScavengeHeap::initialize() {
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1027 diff changeset	69 CollectedHeap::pre_initialize();
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1027 diff changeset	70
0 a61af66fc99e Initial load duke parents: diff changeset	71 // Cannot be initialized until after the flags are parsed
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	72 // GenerationSizer flag_parser;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	73 _collector_policy = new GenerationSizer();
0 a61af66fc99e Initial load duke parents: diff changeset	74
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	75 size_t yg_min_size = _collector_policy->min_young_gen_size();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	76 size_t yg_max_size = _collector_policy->max_young_gen_size();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	77 size_t og_min_size = _collector_policy->min_old_gen_size();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	78 size_t og_max_size = _collector_policy->max_old_gen_size();
0 a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 trace_gen_sizes("ps heap raw",
a61af66fc99e Initial load duke parents: diff changeset	81 og_min_size, og_max_size,
a61af66fc99e Initial load duke parents: diff changeset	82 yg_min_size, yg_max_size);
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 const size_t og_page_sz = os::page_size_for_region(yg_min_size + og_min_size,
a61af66fc99e Initial load duke parents: diff changeset	85 yg_max_size + og_max_size,
a61af66fc99e Initial load duke parents: diff changeset	86 8);
a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 const size_t og_align = set_alignment(_old_gen_alignment, og_page_sz);
a61af66fc99e Initial load duke parents: diff changeset	89 const size_t yg_align = set_alignment(_young_gen_alignment, og_page_sz);
a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 // Update sizes to reflect the selected page size(s).
a61af66fc99e Initial load duke parents: diff changeset	92 //
a61af66fc99e Initial load duke parents: diff changeset	93 // NEEDS_CLEANUP. The default TwoGenerationCollectorPolicy uses NewRatio; it
a61af66fc99e Initial load duke parents: diff changeset	94 // should check UseAdaptiveSizePolicy. Changes from generationSizer could
a61af66fc99e Initial load duke parents: diff changeset	95 // move to the common code.
a61af66fc99e Initial load duke parents: diff changeset	96 yg_min_size = align_size_up(yg_min_size, yg_align);
a61af66fc99e Initial load duke parents: diff changeset	97 yg_max_size = align_size_up(yg_max_size, yg_align);
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	98 size_t yg_cur_size =
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	99 align_size_up(_collector_policy->young_gen_size(), yg_align);
0 a61af66fc99e Initial load duke parents: diff changeset	100 yg_cur_size = MAX2(yg_cur_size, yg_min_size);
a61af66fc99e Initial load duke parents: diff changeset	101
a61af66fc99e Initial load duke parents: diff changeset	102 og_min_size = align_size_up(og_min_size, og_align);
2251 336d17dff7cc 7014874: Incorrect COOPs modes on solaris-{sparcv9,amd64} with ParallelGC kvn parents: 1972 diff changeset	103 // Align old gen size down to preserve specified heap size.
336d17dff7cc 7014874: Incorrect COOPs modes on solaris-{sparcv9,amd64} with ParallelGC kvn parents: 1972 diff changeset	104 assert(og_align == yg_align, "sanity");
336d17dff7cc 7014874: Incorrect COOPs modes on solaris-{sparcv9,amd64} with ParallelGC kvn parents: 1972 diff changeset	105 og_max_size = align_size_down(og_max_size, og_align);
336d17dff7cc 7014874: Incorrect COOPs modes on solaris-{sparcv9,amd64} with ParallelGC kvn parents: 1972 diff changeset	106 og_max_size = MAX2(og_max_size, og_min_size);
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	107 size_t og_cur_size =
2251 336d17dff7cc 7014874: Incorrect COOPs modes on solaris-{sparcv9,amd64} with ParallelGC kvn parents: 1972 diff changeset	108 align_size_down(_collector_policy->old_gen_size(), og_align);
0 a61af66fc99e Initial load duke parents: diff changeset	109 og_cur_size = MAX2(og_cur_size, og_min_size);
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 trace_gen_sizes("ps heap rnd",
a61af66fc99e Initial load duke parents: diff changeset	112 og_min_size, og_max_size,
a61af66fc99e Initial load duke parents: diff changeset	113 yg_min_size, yg_max_size);
a61af66fc99e Initial load duke parents: diff changeset	114
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	115 const size_t heap_size = og_max_size + yg_max_size;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 374 diff changeset	116
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	117 ReservedSpace heap_rs = Universe::reserve_heap(heap_size, og_align);
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 374 diff changeset	118
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6008 diff changeset	119 MemTracker::record_virtual_memory_type((address)heap_rs.base(), mtJavaHeap);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6008 diff changeset	120
0 a61af66fc99e Initial load duke parents: diff changeset	121 os::trace_page_sizes("ps main", og_min_size + yg_min_size,
a61af66fc99e Initial load duke parents: diff changeset	122 og_max_size + yg_max_size, og_page_sz,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	123 heap_rs.base(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	124 heap_rs.size());
0 a61af66fc99e Initial load duke parents: diff changeset	125 if (!heap_rs.is_reserved()) {
a61af66fc99e Initial load duke parents: diff changeset	126 vm_shutdown_during_initialization(
a61af66fc99e Initial load duke parents: diff changeset	127 "Could not reserve enough space for object heap");
a61af66fc99e Initial load duke parents: diff changeset	128 return JNI_ENOMEM;
a61af66fc99e Initial load duke parents: diff changeset	129 }
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 _reserved = MemRegion((HeapWord*)heap_rs.base(),
a61af66fc99e Initial load duke parents: diff changeset	132 (HeapWord*)(heap_rs.base() + heap_rs.size()));
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 CardTableExtension* const barrier_set = new CardTableExtension(_reserved, 3);
a61af66fc99e Initial load duke parents: diff changeset	135 _barrier_set = barrier_set;
a61af66fc99e Initial load duke parents: diff changeset	136 oopDesc::set_bs(_barrier_set);
a61af66fc99e Initial load duke parents: diff changeset	137 if (_barrier_set == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	138 vm_shutdown_during_initialization(
a61af66fc99e Initial load duke parents: diff changeset	139 "Could not reserve enough space for barrier set");
a61af66fc99e Initial load duke parents: diff changeset	140 return JNI_ENOMEM;
a61af66fc99e Initial load duke parents: diff changeset	141 }
a61af66fc99e Initial load duke parents: diff changeset	142
a61af66fc99e Initial load duke parents: diff changeset	143 // Initial young gen size is 4 Mb
a61af66fc99e Initial load duke parents: diff changeset	144 //
a61af66fc99e Initial load duke parents: diff changeset	145 // XXX - what about flag_parser.young_gen_size()?
a61af66fc99e Initial load duke parents: diff changeset	146 const size_t init_young_size = align_size_up(4 * M, yg_align);
a61af66fc99e Initial load duke parents: diff changeset	147 yg_cur_size = MAX2(MIN2(init_young_size, yg_max_size), yg_cur_size);
a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 // Make up the generations
a61af66fc99e Initial load duke parents: diff changeset	150 // Calculate the maximum size that a generation can grow. This
a61af66fc99e Initial load duke parents: diff changeset	151 // includes growth into the other generation. Note that the
a61af66fc99e Initial load duke parents: diff changeset	152 // parameter _max_gen_size is kept as the maximum
a61af66fc99e Initial load duke parents: diff changeset	153 // size of the generation as the boundaries currently stand.
a61af66fc99e Initial load duke parents: diff changeset	154 // _max_gen_size is still used as that value.
a61af66fc99e Initial load duke parents: diff changeset	155 double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
a61af66fc99e Initial load duke parents: diff changeset	156 double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
a61af66fc99e Initial load duke parents: diff changeset	157
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	158 _gens = new AdjoiningGenerations(heap_rs,
0 a61af66fc99e Initial load duke parents: diff changeset	159 og_cur_size,
a61af66fc99e Initial load duke parents: diff changeset	160 og_min_size,
a61af66fc99e Initial load duke parents: diff changeset	161 og_max_size,
a61af66fc99e Initial load duke parents: diff changeset	162 yg_cur_size,
a61af66fc99e Initial load duke parents: diff changeset	163 yg_min_size,
a61af66fc99e Initial load duke parents: diff changeset	164 yg_max_size,
a61af66fc99e Initial load duke parents: diff changeset	165 yg_align);
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 _old_gen = _gens->old_gen();
a61af66fc99e Initial load duke parents: diff changeset	168 _young_gen = _gens->young_gen();
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 const size_t eden_capacity = _young_gen->eden_space()->capacity_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	171 const size_t old_capacity = _old_gen->capacity_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	172 const size_t initial_promo_size = MIN2(eden_capacity, old_capacity);
a61af66fc99e Initial load duke parents: diff changeset	173 _size_policy =
a61af66fc99e Initial load duke parents: diff changeset	174 new PSAdaptiveSizePolicy(eden_capacity,
a61af66fc99e Initial load duke parents: diff changeset	175 initial_promo_size,
a61af66fc99e Initial load duke parents: diff changeset	176 young_gen()->to_space()->capacity_in_bytes(),
13 183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO jmasa parents: 0 diff changeset	177 intra_heap_alignment(),
0 a61af66fc99e Initial load duke parents: diff changeset	178 max_gc_pause_sec,
a61af66fc99e Initial load duke parents: diff changeset	179 max_gc_minor_pause_sec,
a61af66fc99e Initial load duke parents: diff changeset	180 GCTimeRatio
a61af66fc99e Initial load duke parents: diff changeset	181 );
a61af66fc99e Initial load duke parents: diff changeset	182
a61af66fc99e Initial load duke parents: diff changeset	183 assert(!UseAdaptiveGCBoundary \|\|
a61af66fc99e Initial load duke parents: diff changeset	184 (old_gen()->virtual_space()->high_boundary() ==
a61af66fc99e Initial load duke parents: diff changeset	185 young_gen()->virtual_space()->low_boundary()),
a61af66fc99e Initial load duke parents: diff changeset	186 "Boundaries must meet");
a61af66fc99e Initial load duke parents: diff changeset	187 // initialize the policy counters - 2 collectors, 3 generations
a61af66fc99e Initial load duke parents: diff changeset	188 _gc_policy_counters =
a61af66fc99e Initial load duke parents: diff changeset	189 new PSGCAdaptivePolicyCounters("ParScav:MSC", 2, 3, _size_policy);
a61af66fc99e Initial load duke parents: diff changeset	190 _psh = this;
a61af66fc99e Initial load duke parents: diff changeset	191
a61af66fc99e Initial load duke parents: diff changeset	192 // Set up the GCTaskManager
a61af66fc99e Initial load duke parents: diff changeset	193 _gc_task_manager = GCTaskManager::create(ParallelGCThreads);
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195 if (UseParallelOldGC && !PSParallelCompact::initialize()) {
a61af66fc99e Initial load duke parents: diff changeset	196 return JNI_ENOMEM;
a61af66fc99e Initial load duke parents: diff changeset	197 }
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 return JNI_OK;
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 ParallelScavengeHeap::post_initialize() {
a61af66fc99e Initial load duke parents: diff changeset	203 // Need to init the tenuring threshold
a61af66fc99e Initial load duke parents: diff changeset	204 PSScavenge::initialize();
a61af66fc99e Initial load duke parents: diff changeset	205 if (UseParallelOldGC) {
a61af66fc99e Initial load duke parents: diff changeset	206 PSParallelCompact::post_initialize();
a61af66fc99e Initial load duke parents: diff changeset	207 } else {
a61af66fc99e Initial load duke parents: diff changeset	208 PSMarkSweep::initialize();
a61af66fc99e Initial load duke parents: diff changeset	209 }
a61af66fc99e Initial load duke parents: diff changeset	210 PSPromotionManager::initialize();
a61af66fc99e Initial load duke parents: diff changeset	211 }
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213 void ParallelScavengeHeap::update_counters() {
a61af66fc99e Initial load duke parents: diff changeset	214 young_gen()->update_counters();
a61af66fc99e Initial load duke parents: diff changeset	215 old_gen()->update_counters();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	216 MetaspaceCounters::update_performance_counters();
0 a61af66fc99e Initial load duke parents: diff changeset	217 }
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 size_t ParallelScavengeHeap::capacity() const {
a61af66fc99e Initial load duke parents: diff changeset	220 size_t value = young_gen()->capacity_in_bytes() + old_gen()->capacity_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	221 return value;
a61af66fc99e Initial load duke parents: diff changeset	222 }
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 size_t ParallelScavengeHeap::used() const {
a61af66fc99e Initial load duke parents: diff changeset	225 size_t value = young_gen()->used_in_bytes() + old_gen()->used_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	226 return value;
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 bool ParallelScavengeHeap::is_maximal_no_gc() const {
a61af66fc99e Initial load duke parents: diff changeset	230 return old_gen()->is_maximal_no_gc() && young_gen()->is_maximal_no_gc();
a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232
a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 size_t ParallelScavengeHeap::max_capacity() const {
a61af66fc99e Initial load duke parents: diff changeset	235 size_t estimated = reserved_region().byte_size();
a61af66fc99e Initial load duke parents: diff changeset	236 if (UseAdaptiveSizePolicy) {
a61af66fc99e Initial load duke parents: diff changeset	237 estimated -= _size_policy->max_survivor_size(young_gen()->max_size());
a61af66fc99e Initial load duke parents: diff changeset	238 } else {
a61af66fc99e Initial load duke parents: diff changeset	239 estimated -= young_gen()->to_space()->capacity_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	240 }
a61af66fc99e Initial load duke parents: diff changeset	241 return MAX2(estimated, capacity());
a61af66fc99e Initial load duke parents: diff changeset	242 }
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 bool ParallelScavengeHeap::is_in(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	245 if (young_gen()->is_in(p)) {
a61af66fc99e Initial load duke parents: diff changeset	246 return true;
a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 if (old_gen()->is_in(p)) {
a61af66fc99e Initial load duke parents: diff changeset	250 return true;
a61af66fc99e Initial load duke parents: diff changeset	251 }
a61af66fc99e Initial load duke parents: diff changeset	252
a61af66fc99e Initial load duke parents: diff changeset	253 return false;
a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 bool ParallelScavengeHeap::is_in_reserved(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	257 if (young_gen()->is_in_reserved(p)) {
a61af66fc99e Initial load duke parents: diff changeset	258 return true;
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260
a61af66fc99e Initial load duke parents: diff changeset	261 if (old_gen()->is_in_reserved(p)) {
a61af66fc99e Initial load duke parents: diff changeset	262 return true;
a61af66fc99e Initial load duke parents: diff changeset	263 }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 return false;
a61af66fc99e Initial load duke parents: diff changeset	266 }
a61af66fc99e Initial load duke parents: diff changeset	267
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	268 bool ParallelScavengeHeap::is_scavengable(const void* addr) {
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	269 return is_in_young((oop)addr);
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	270 }
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	271
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	272 #ifdef ASSERT
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	273 // Don't implement this by using is_in_young(). This method is used
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	274 // in some cases to check that is_in_young() is correct.
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	275 bool ParallelScavengeHeap::is_in_partial_collection(const void *p) {
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	276 assert(is_in_reserved(p) \|\| p == NULL,
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	277 "Does not work if address is non-null and outside of the heap");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	278 // The order of the generations is old (low addr), young (high addr)
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	279 return p >= old_gen()->reserved().end();
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	280 }
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	281 #endif
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2251 diff changeset	282
0 a61af66fc99e Initial load duke parents: diff changeset	283 // There are two levels of allocation policy here.
a61af66fc99e Initial load duke parents: diff changeset	284 //
a61af66fc99e Initial load duke parents: diff changeset	285 // When an allocation request fails, the requesting thread must invoke a VM
a61af66fc99e Initial load duke parents: diff changeset	286 // operation, transfer control to the VM thread, and await the results of a
a61af66fc99e Initial load duke parents: diff changeset	287 // garbage collection. That is quite expensive, and we should avoid doing it
a61af66fc99e Initial load duke parents: diff changeset	288 // multiple times if possible.
a61af66fc99e Initial load duke parents: diff changeset	289 //
a61af66fc99e Initial load duke parents: diff changeset	290 // To accomplish this, we have a basic allocation policy, and also a
a61af66fc99e Initial load duke parents: diff changeset	291 // failed allocation policy.
a61af66fc99e Initial load duke parents: diff changeset	292 //
a61af66fc99e Initial load duke parents: diff changeset	293 // The basic allocation policy controls how you allocate memory without
a61af66fc99e Initial load duke parents: diff changeset	294 // attempting garbage collection. It is okay to grab locks and
a61af66fc99e Initial load duke parents: diff changeset	295 // expand the heap, if that can be done without coming to a safepoint.
a61af66fc99e Initial load duke parents: diff changeset	296 // It is likely that the basic allocation policy will not be very
a61af66fc99e Initial load duke parents: diff changeset	297 // aggressive.
a61af66fc99e Initial load duke parents: diff changeset	298 //
a61af66fc99e Initial load duke parents: diff changeset	299 // The failed allocation policy is invoked from the VM thread after
a61af66fc99e Initial load duke parents: diff changeset	300 // the basic allocation policy is unable to satisfy a mem_allocate
a61af66fc99e Initial load duke parents: diff changeset	301 // request. This policy needs to cover the entire range of collection,
a61af66fc99e Initial load duke parents: diff changeset	302 // heap expansion, and out-of-memory conditions. It should make every
a61af66fc99e Initial load duke parents: diff changeset	303 // attempt to allocate the requested memory.
a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 // Basic allocation policy. Should never be called at a safepoint, or
a61af66fc99e Initial load duke parents: diff changeset	306 // from the VM thread.
a61af66fc99e Initial load duke parents: diff changeset	307 //
a61af66fc99e Initial load duke parents: diff changeset	308 // This method must handle cases where many mem_allocate requests fail
a61af66fc99e Initial load duke parents: diff changeset	309 // simultaneously. When that happens, only one VM operation will succeed,
a61af66fc99e Initial load duke parents: diff changeset	310 // and the rest will not be executed. For that reason, this method loops
a61af66fc99e Initial load duke parents: diff changeset	311 // during failed allocation attempts. If the java heap becomes exhausted,
a61af66fc99e Initial load duke parents: diff changeset	312 // we rely on the size_policy object to force a bail out.
a61af66fc99e Initial load duke parents: diff changeset	313 HeapWord* ParallelScavengeHeap::mem_allocate(
a61af66fc99e Initial load duke parents: diff changeset	314 size_t size,
a61af66fc99e Initial load duke parents: diff changeset	315 bool* gc_overhead_limit_was_exceeded) {
a61af66fc99e Initial load duke parents: diff changeset	316 assert(!SafepointSynchronize::is_at_safepoint(), "should not be at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	317 assert(Thread::current() != (Thread*)VMThread::vm_thread(), "should not be in vm thread");
a61af66fc99e Initial load duke parents: diff changeset	318 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
a61af66fc99e Initial load duke parents: diff changeset	319
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	320 // 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: 1166 diff changeset	321 // 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: 1166 diff changeset	322 // limit is being exceeded as checked below.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	323 *gc_overhead_limit_was_exceeded = false;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	324
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	325 HeapWord* result = young_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327 uint loop_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	328 uint gc_count = 0;
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8785 diff changeset	329 int gclocker_stalled_count = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	330
a61af66fc99e Initial load duke parents: diff changeset	331 while (result == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	332 // We don't want to have multiple collections for a single filled generation.
a61af66fc99e Initial load duke parents: diff changeset	333 // To prevent this, each thread tracks the total_collections() value, and if
a61af66fc99e Initial load duke parents: diff changeset	334 // the count has changed, does not do a new collection.
a61af66fc99e Initial load duke parents: diff changeset	335 //
a61af66fc99e Initial load duke parents: diff changeset	336 // The collection count must be read only while holding the heap lock. VM
a61af66fc99e Initial load duke parents: diff changeset	337 // operations also hold the heap lock during collections. There is a lock
a61af66fc99e Initial load duke parents: diff changeset	338 // contention case where thread A blocks waiting on the Heap_lock, while
a61af66fc99e Initial load duke parents: diff changeset	339 // thread B is holding it doing a collection. When thread A gets the lock,
a61af66fc99e Initial load duke parents: diff changeset	340 // the collection count has already changed. To prevent duplicate collections,
a61af66fc99e Initial load duke parents: diff changeset	341 // The policy MUST attempt allocations during the same period it reads the
a61af66fc99e Initial load duke parents: diff changeset	342 // total_collections() value!
a61af66fc99e Initial load duke parents: diff changeset	343 {
a61af66fc99e Initial load duke parents: diff changeset	344 MutexLocker ml(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	345 gc_count = Universe::heap()->total_collections();
a61af66fc99e Initial load duke parents: diff changeset	346
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	347 result = young_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	348 if (result != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	349 return result;
a61af66fc99e Initial load duke parents: diff changeset	350 }
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	351
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	352 // If certain conditions hold, try allocating from the old gen.
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	353 result = mem_allocate_old_gen(size);
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	354 if (result != NULL) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	355 return result;
0 a61af66fc99e Initial load duke parents: diff changeset	356 }
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	357
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8785 diff changeset	358 if (gclocker_stalled_count > GCLockerRetryAllocationCount) {
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8785 diff changeset	359 return NULL;
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8785 diff changeset	360 }
2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8785 diff changeset	361
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	362 // Failed to allocate without a gc.
0 a61af66fc99e Initial load duke parents: diff changeset	363 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	364 // If this thread is not in a jni critical section, we stall
a61af66fc99e Initial load duke parents: diff changeset	365 // the requestor until the critical section has cleared and
a61af66fc99e Initial load duke parents: diff changeset	366 // GC allowed. When the critical section clears, a GC is
a61af66fc99e Initial load duke parents: diff changeset	367 // initiated by the last thread exiting the critical section; so
a61af66fc99e Initial load duke parents: diff changeset	368 // we retry the allocation sequence from the beginning of the loop,
a61af66fc99e Initial load duke parents: diff changeset	369 // rather than causing more, now probably unnecessary, GC attempts.
a61af66fc99e Initial load duke parents: diff changeset	370 JavaThread* jthr = JavaThread::current();
a61af66fc99e Initial load duke parents: diff changeset	371 if (!jthr->in_critical()) {
a61af66fc99e Initial load duke parents: diff changeset	372 MutexUnlocker mul(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	373 GC_locker::stall_until_clear();
8853 2e093b564241 7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine mgerdin parents: 8785 diff changeset	374 gclocker_stalled_count += 1;
0 a61af66fc99e Initial load duke parents: diff changeset	375 continue;
a61af66fc99e Initial load duke parents: diff changeset	376 } else {
a61af66fc99e Initial load duke parents: diff changeset	377 if (CheckJNICalls) {
a61af66fc99e Initial load duke parents: diff changeset	378 fatal("Possible deadlock due to allocating while"
a61af66fc99e Initial load duke parents: diff changeset	379 " in jni critical section");
a61af66fc99e Initial load duke parents: diff changeset	380 }
a61af66fc99e Initial load duke parents: diff changeset	381 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	382 }
a61af66fc99e Initial load duke parents: diff changeset	383 }
a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385
a61af66fc99e Initial load duke parents: diff changeset	386 if (result == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	387 // Generate a VM operation
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	388 VM_ParallelGCFailedAllocation op(size, gc_count);
0 a61af66fc99e Initial load duke parents: diff changeset	389 VMThread::execute(&op);
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 // Did the VM operation execute? If so, return the result directly.
a61af66fc99e Initial load duke parents: diff changeset	392 // This prevents us from looping until time out on requests that can
a61af66fc99e Initial load duke parents: diff changeset	393 // not be satisfied.
a61af66fc99e Initial load duke parents: diff changeset	394 if (op.prologue_succeeded()) {
a61af66fc99e Initial load duke parents: diff changeset	395 assert(Universe::heap()->is_in_or_null(op.result()),
a61af66fc99e Initial load duke parents: diff changeset	396 "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	397
a61af66fc99e Initial load duke parents: diff changeset	398 // If GC was locked out during VM operation then retry allocation
a61af66fc99e Initial load duke parents: diff changeset	399 // and/or stall as necessary.
a61af66fc99e Initial load duke parents: diff changeset	400 if (op.gc_locked()) {
a61af66fc99e Initial load duke parents: diff changeset	401 assert(op.result() == NULL, "must be NULL if gc_locked() is true");
a61af66fc99e Initial load duke parents: diff changeset	402 continue; // retry and/or stall as necessary
a61af66fc99e Initial load duke parents: diff changeset	403 }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	404
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	405 // Exit the loop if the gc time limit has been exceeded.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	406 // The allocation must have failed above ("result" guarding
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	407 // this path is NULL) and the most recent collection has exceeded the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	408 // gc overhead limit (although enough may have been collected to
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	409 // satisfy the allocation). Exit the loop so that an out-of-memory
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	410 // will be thrown (return a NULL ignoring the contents of
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	411 // op.result()),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	412 // but clear gc_overhead_limit_exceeded so that the next collection
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	413 // starts with a clean slate (i.e., forgets about previous overhead
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	414 // excesses). Fill op.result() with a filler object so that the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	415 // heap remains parsable.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	416 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: 1166 diff changeset	417 const bool softrefs_clear = collector_policy()->all_soft_refs_clear();
8743 82657b6a8cc0 6976528: PS: assert(!limit_exceeded \|\| softrefs_clear) failed: Should have been cleared jmasa parents: 6725 diff changeset	418
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	419 if (limit_exceeded && softrefs_clear) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	420 *gc_overhead_limit_was_exceeded = true;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	421 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: 1166 diff changeset	422 if (PrintGCDetails && Verbose) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	423 gclog_or_tty->print_cr("ParallelScavengeHeap::mem_allocate: "
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	424 "return NULL because gc_overhead_limit_exceeded is set");
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	425 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	426 if (op.result() != NULL) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	427 CollectedHeap::fill_with_object(op.result(), size);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	428 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	429 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	430 }
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	431
0 a61af66fc99e Initial load duke parents: diff changeset	432 return op.result();
a61af66fc99e Initial load duke parents: diff changeset	433 }
a61af66fc99e Initial load duke parents: diff changeset	434 }
a61af66fc99e Initial load duke parents: diff changeset	435
a61af66fc99e Initial load duke parents: diff changeset	436 // The policy object will prevent us from looping forever. If the
a61af66fc99e Initial load duke parents: diff changeset	437 // time spent in gc crosses a threshold, we will bail out.
a61af66fc99e Initial load duke parents: diff changeset	438 loop_count++;
a61af66fc99e Initial load duke parents: diff changeset	439 if ((result == NULL) && (QueuedAllocationWarningCount > 0) &&
a61af66fc99e Initial load duke parents: diff changeset	440 (loop_count % QueuedAllocationWarningCount == 0)) {
a61af66fc99e Initial load duke parents: diff changeset	441 warning("ParallelScavengeHeap::mem_allocate retries %d times \n\t"
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	442 " size=%d", loop_count, size);
0 a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445
a61af66fc99e Initial load duke parents: diff changeset	446 return result;
a61af66fc99e Initial load duke parents: diff changeset	447 }
a61af66fc99e Initial load duke parents: diff changeset	448
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	449 // A "death march" is a series of ultra-slow allocations in which a full gc is
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	450 // done before each allocation, and after the full gc the allocation still
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	451 // cannot be satisfied from the young gen. This routine detects that condition;
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	452 // it should be called after a full gc has been done and the allocation
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	453 // attempted from the young gen. The parameter 'addr' should be the result of
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	454 // that young gen allocation attempt.
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	455 void
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	456 ParallelScavengeHeap::death_march_check(HeapWord* const addr, size_t size) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	457 if (addr != NULL) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	458 _death_march_count = 0; // death march has ended
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	459 } else if (_death_march_count == 0) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	460 if (should_alloc_in_eden(size)) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	461 _death_march_count = 1; // death march has started
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	462 }
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	463 }
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	464 }
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	465
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	466 HeapWord* ParallelScavengeHeap::mem_allocate_old_gen(size_t size) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	467 if (!should_alloc_in_eden(size) \|\| GC_locker::is_active_and_needs_gc()) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	468 // Size is too big for eden, or gc is locked out.
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	469 return old_gen()->allocate(size);
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	470 }
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	471
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	472 // If a "death march" is in progress, allocate from the old gen a limited
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	473 // number of times before doing a GC.
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	474 if (_death_march_count > 0) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	475 if (_death_march_count < 64) {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	476 ++_death_march_count;
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	477 return old_gen()->allocate(size);
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	478 } else {
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	479 _death_march_count = 0;
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	480 }
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	481 }
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	482 return NULL;
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	483 }
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	484
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	485 void ParallelScavengeHeap::do_full_collection(bool clear_all_soft_refs) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	486 if (UseParallelOldGC) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	487 // The do_full_collection() parameter clear_all_soft_refs
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	488 // is interpreted here as maximum_compaction which will
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	489 // cause SoftRefs to be cleared.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	490 bool maximum_compaction = clear_all_soft_refs;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	491 PSParallelCompact::invoke(maximum_compaction);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	492 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	493 PSMarkSweep::invoke(clear_all_soft_refs);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	494 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	495 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	496
0 a61af66fc99e Initial load duke parents: diff changeset	497 // Failed allocation policy. Must be called from the VM thread, and
a61af66fc99e Initial load duke parents: diff changeset	498 // only at a safepoint! Note that this method has policy for allocation
a61af66fc99e Initial load duke parents: diff changeset	499 // flow, and NOT collection policy. So we do not check for gc collection
a61af66fc99e Initial load duke parents: diff changeset	500 // time over limit here, that is the responsibility of the heap specific
a61af66fc99e Initial load duke parents: diff changeset	501 // collection methods. This method decides where to attempt allocations,
a61af66fc99e Initial load duke parents: diff changeset	502 // and when to attempt collections, but no collection specific policy.
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	503 HeapWord* ParallelScavengeHeap::failed_mem_allocate(size_t size) {
0 a61af66fc99e Initial load duke parents: diff changeset	504 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	505 assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
a61af66fc99e Initial load duke parents: diff changeset	506 assert(!Universe::heap()->is_gc_active(), "not reentrant");
a61af66fc99e Initial load duke parents: diff changeset	507 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
a61af66fc99e Initial load duke parents: diff changeset	508
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	509 // We assume that allocation in eden will fail unless we collect.
0 a61af66fc99e Initial load duke parents: diff changeset	510
a61af66fc99e Initial load duke parents: diff changeset	511 // First level allocation failure, scavenge and allocate in young gen.
a61af66fc99e Initial load duke parents: diff changeset	512 GCCauseSetter gccs(this, GCCause::_allocation_failure);
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	513 const bool invoked_full_gc = PSScavenge::invoke();
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	514 HeapWord* result = young_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	515
a61af66fc99e Initial load duke parents: diff changeset	516 // Second level allocation failure.
a61af66fc99e Initial load duke parents: diff changeset	517 // Mark sweep and allocate in young generation.
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	518 if (result == NULL && !invoked_full_gc) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	519 do_full_collection(false);
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	520 result = young_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	521 }
a61af66fc99e Initial load duke parents: diff changeset	522
4914 23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	523 death_march_check(result, size);
23c0eb012d6f 6330863: vm/gc/InfiniteList.java fails intermittently due to timeout jcoomes parents: 4073 diff changeset	524
0 a61af66fc99e Initial load duke parents: diff changeset	525 // Third level allocation failure.
a61af66fc99e Initial load duke parents: diff changeset	526 // After mark sweep and young generation allocation failure,
a61af66fc99e Initial load duke parents: diff changeset	527 // allocate in old generation.
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	528 if (result == NULL) {
c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	529 result = old_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	530 }
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532 // Fourth level allocation failure. We're running out of memory.
a61af66fc99e Initial load duke parents: diff changeset	533 // More complete mark sweep and allocate in young generation.
a61af66fc99e Initial load duke parents: diff changeset	534 if (result == NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	535 do_full_collection(true);
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	536 result = young_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 // Fifth level allocation failure.
a61af66fc99e Initial load duke parents: diff changeset	540 // After more complete mark sweep, allocate in old generation.
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	541 if (result == NULL) {
c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	542 result = old_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	543 }
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545 return result;
a61af66fc99e Initial load duke parents: diff changeset	546 }
a61af66fc99e Initial load duke parents: diff changeset	547
a61af66fc99e Initial load duke parents: diff changeset	548 void ParallelScavengeHeap::ensure_parsability(bool retire_tlabs) {
a61af66fc99e Initial load duke parents: diff changeset	549 CollectedHeap::ensure_parsability(retire_tlabs);
a61af66fc99e Initial load duke parents: diff changeset	550 young_gen()->eden_space()->ensure_parsability();
a61af66fc99e Initial load duke parents: diff changeset	551 }
a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553 size_t ParallelScavengeHeap::unsafe_max_alloc() {
a61af66fc99e Initial load duke parents: diff changeset	554 return young_gen()->eden_space()->free_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	555 }
a61af66fc99e Initial load duke parents: diff changeset	556
a61af66fc99e Initial load duke parents: diff changeset	557 size_t ParallelScavengeHeap::tlab_capacity(Thread* thr) const {
a61af66fc99e Initial load duke parents: diff changeset	558 return young_gen()->eden_space()->tlab_capacity(thr);
a61af66fc99e Initial load duke parents: diff changeset	559 }
a61af66fc99e Initial load duke parents: diff changeset	560
a61af66fc99e Initial load duke parents: diff changeset	561 size_t ParallelScavengeHeap::unsafe_max_tlab_alloc(Thread* thr) const {
a61af66fc99e Initial load duke parents: diff changeset	562 return young_gen()->eden_space()->unsafe_max_tlab_alloc(thr);
a61af66fc99e Initial load duke parents: diff changeset	563 }
a61af66fc99e Initial load duke parents: diff changeset	564
a61af66fc99e Initial load duke parents: diff changeset	565 HeapWord* ParallelScavengeHeap::allocate_new_tlab(size_t size) {
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	566 return young_gen()->allocate(size);
0 a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569 void ParallelScavengeHeap::accumulate_statistics_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	570 CollectedHeap::accumulate_statistics_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
a61af66fc99e Initial load duke parents: diff changeset	573 void ParallelScavengeHeap::resize_all_tlabs() {
a61af66fc99e Initial load duke parents: diff changeset	574 CollectedHeap::resize_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	575 }
a61af66fc99e Initial load duke parents: diff changeset	576
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	577 bool ParallelScavengeHeap::can_elide_initializing_store_barrier(oop new_obj) {
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	578 // We don't need barriers for stores to objects in the
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	579 // young gen and, a fortiori, for initializing stores to
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	580 // objects therein.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	581 return is_in_young(new_obj);
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	582 }
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 989 diff changeset	583
0 a61af66fc99e Initial load duke parents: diff changeset	584 // This method is used by System.gc() and JVMTI.
a61af66fc99e Initial load duke parents: diff changeset	585 void ParallelScavengeHeap::collect(GCCause::Cause cause) {
a61af66fc99e Initial load duke parents: diff changeset	586 assert(!Heap_lock->owned_by_self(),
a61af66fc99e Initial load duke parents: diff changeset	587 "this thread should not own the Heap_lock");
a61af66fc99e Initial load duke parents: diff changeset	588
a61af66fc99e Initial load duke parents: diff changeset	589 unsigned int gc_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	590 unsigned int full_gc_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	591 {
a61af66fc99e Initial load duke parents: diff changeset	592 MutexLocker ml(Heap_lock);
a61af66fc99e Initial load duke parents: diff changeset	593 // This value is guarded by the Heap_lock
a61af66fc99e Initial load duke parents: diff changeset	594 gc_count = Universe::heap()->total_collections();
a61af66fc99e Initial load duke parents: diff changeset	595 full_gc_count = Universe::heap()->total_full_collections();
a61af66fc99e Initial load duke parents: diff changeset	596 }
a61af66fc99e Initial load duke parents: diff changeset	597
a61af66fc99e Initial load duke parents: diff changeset	598 VM_ParallelGCSystemGC op(gc_count, full_gc_count, cause);
a61af66fc99e Initial load duke parents: diff changeset	599 VMThread::execute(&op);
a61af66fc99e Initial load duke parents: diff changeset	600 }
a61af66fc99e Initial load duke parents: diff changeset	601
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	602 void ParallelScavengeHeap::oop_iterate(ExtendedOopClosure* cl) {
0 a61af66fc99e Initial load duke parents: diff changeset	603 Unimplemented();
a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605
a61af66fc99e Initial load duke parents: diff changeset	606 void ParallelScavengeHeap::object_iterate(ObjectClosure* cl) {
a61af66fc99e Initial load duke parents: diff changeset	607 young_gen()->object_iterate(cl);
a61af66fc99e Initial load duke parents: diff changeset	608 old_gen()->object_iterate(cl);
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610
a61af66fc99e Initial load duke parents: diff changeset	611
a61af66fc99e Initial load duke parents: diff changeset	612 HeapWord* ParallelScavengeHeap::block_start(const void* addr) const {
a61af66fc99e Initial load duke parents: diff changeset	613 if (young_gen()->is_in_reserved(addr)) {
a61af66fc99e Initial load duke parents: diff changeset	614 assert(young_gen()->is_in(addr),
a61af66fc99e Initial load duke parents: diff changeset	615 "addr should be in allocated part of young gen");
1907 1e9a9d2e6509 6970683: improvements to hs_err output never parents: 1552 diff changeset	616 // called from os::print_location by find or VMError
1e9a9d2e6509 6970683: improvements to hs_err output never parents: 1552 diff changeset	617 if (Debugging \|\| VMError::fatal_error_in_progress()) return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	618 Unimplemented();
a61af66fc99e Initial load duke parents: diff changeset	619 } else if (old_gen()->is_in_reserved(addr)) {
a61af66fc99e Initial load duke parents: diff changeset	620 assert(old_gen()->is_in(addr),
a61af66fc99e Initial load duke parents: diff changeset	621 "addr should be in allocated part of old gen");
a61af66fc99e Initial load duke parents: diff changeset	622 return old_gen()->start_array()->object_start((HeapWord*)addr);
a61af66fc99e Initial load duke parents: diff changeset	623 }
a61af66fc99e Initial load duke parents: diff changeset	624 return 0;
a61af66fc99e Initial load duke parents: diff changeset	625 }
a61af66fc99e Initial load duke parents: diff changeset	626
a61af66fc99e Initial load duke parents: diff changeset	627 size_t ParallelScavengeHeap::block_size(const HeapWord* addr) const {
a61af66fc99e Initial load duke parents: diff changeset	628 return oop(addr)->size();
a61af66fc99e Initial load duke parents: diff changeset	629 }
a61af66fc99e Initial load duke parents: diff changeset	630
a61af66fc99e Initial load duke parents: diff changeset	631 bool ParallelScavengeHeap::block_is_obj(const HeapWord* addr) const {
a61af66fc99e Initial load duke parents: diff changeset	632 return block_start(addr) == addr;
a61af66fc99e Initial load duke parents: diff changeset	633 }
a61af66fc99e Initial load duke parents: diff changeset	634
a61af66fc99e Initial load duke parents: diff changeset	635 jlong ParallelScavengeHeap::millis_since_last_gc() {
a61af66fc99e Initial load duke parents: diff changeset	636 return UseParallelOldGC ?
a61af66fc99e Initial load duke parents: diff changeset	637 PSParallelCompact::millis_since_last_gc() :
a61af66fc99e Initial load duke parents: diff changeset	638 PSMarkSweep::millis_since_last_gc();
a61af66fc99e Initial load duke parents: diff changeset	639 }
a61af66fc99e Initial load duke parents: diff changeset	640
a61af66fc99e Initial load duke parents: diff changeset	641 void ParallelScavengeHeap::prepare_for_verify() {
a61af66fc99e Initial load duke parents: diff changeset	642 ensure_parsability(false); // no need to retire TLABs for verification
a61af66fc99e Initial load duke parents: diff changeset	643 }
a61af66fc99e Initial load duke parents: diff changeset	644
a61af66fc99e Initial load duke parents: diff changeset	645 void ParallelScavengeHeap::print_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	646 young_gen()->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	647 old_gen()->print_on(st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	648 MetaspaceAux::print_on(st);
0 a61af66fc99e Initial load duke parents: diff changeset	649 }
a61af66fc99e Initial load duke parents: diff changeset	650
9076 7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	651 void ParallelScavengeHeap::print_on_error(outputStream* st) const {
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	652 this->CollectedHeap::print_on_error(st);
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	653
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	654 if (UseParallelOldGC) {
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	655 st->cr();
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	656 PSParallelCompact::print_on_error(st);
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	657 }
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	658 }
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 8853 diff changeset	659
0 a61af66fc99e Initial load duke parents: diff changeset	660 void ParallelScavengeHeap::gc_threads_do(ThreadClosure* tc) const {
a61af66fc99e Initial load duke parents: diff changeset	661 PSScavenge::gc_task_manager()->threads_do(tc);
a61af66fc99e Initial load duke parents: diff changeset	662 }
a61af66fc99e Initial load duke parents: diff changeset	663
a61af66fc99e Initial load duke parents: diff changeset	664 void ParallelScavengeHeap::print_gc_threads_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	665 PSScavenge::gc_task_manager()->print_threads_on(st);
a61af66fc99e Initial load duke parents: diff changeset	666 }
a61af66fc99e Initial load duke parents: diff changeset	667
a61af66fc99e Initial load duke parents: diff changeset	668 void ParallelScavengeHeap::print_tracing_info() const {
a61af66fc99e Initial load duke parents: diff changeset	669 if (TraceGen0Time) {
a61af66fc99e Initial load duke parents: diff changeset	670 double time = PSScavenge::accumulated_time()->seconds();
a61af66fc99e Initial load duke parents: diff changeset	671 tty->print_cr("[Accumulated GC generation 0 time %3.7f secs]", time);
a61af66fc99e Initial load duke parents: diff changeset	672 }
a61af66fc99e Initial load duke parents: diff changeset	673 if (TraceGen1Time) {
8785 3c226052f7dc 6733980: par compact - TraceGen1Time always shows 0.0000 seconds tschatzl parents: 8743 diff changeset	674 double time = UseParallelOldGC ? PSParallelCompact::accumulated_time()->seconds() : PSMarkSweep::accumulated_time()->seconds();
0 a61af66fc99e Initial load duke parents: diff changeset	675 tty->print_cr("[Accumulated GC generation 1 time %3.7f secs]", time);
a61af66fc99e Initial load duke parents: diff changeset	676 }
a61af66fc99e Initial load duke parents: diff changeset	677 }
a61af66fc99e Initial load duke parents: diff changeset	678
a61af66fc99e Initial load duke parents: diff changeset	679
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso parents: 4914 diff changeset	680 void ParallelScavengeHeap::verify(bool silent, VerifyOption option /* ignored */) {
0 a61af66fc99e Initial load duke parents: diff changeset	681 // Why do we need the total_collections()-filter below?
a61af66fc99e Initial load duke parents: diff changeset	682 if (total_collections() > 0) {
a61af66fc99e Initial load duke parents: diff changeset	683 if (!silent) {
a61af66fc99e Initial load duke parents: diff changeset	684 gclog_or_tty->print("tenured ");
a61af66fc99e Initial load duke parents: diff changeset	685 }
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso parents: 4914 diff changeset	686 old_gen()->verify();
0 a61af66fc99e Initial load duke parents: diff changeset	687
a61af66fc99e Initial load duke parents: diff changeset	688 if (!silent) {
a61af66fc99e Initial load duke parents: diff changeset	689 gclog_or_tty->print("eden ");
a61af66fc99e Initial load duke parents: diff changeset	690 }
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso parents: 4914 diff changeset	691 young_gen()->verify();
0 a61af66fc99e Initial load duke parents: diff changeset	692 }
a61af66fc99e Initial load duke parents: diff changeset	693 }
a61af66fc99e Initial load duke parents: diff changeset	694
a61af66fc99e Initial load duke parents: diff changeset	695 void ParallelScavengeHeap::print_heap_change(size_t prev_used) {
a61af66fc99e Initial load duke parents: diff changeset	696 if (PrintGCDetails && Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	697 gclog_or_tty->print(" " SIZE_FORMAT
a61af66fc99e Initial load duke parents: diff changeset	698 "->" SIZE_FORMAT
a61af66fc99e Initial load duke parents: diff changeset	699 "(" SIZE_FORMAT ")",
a61af66fc99e Initial load duke parents: diff changeset	700 prev_used, used(), capacity());
a61af66fc99e Initial load duke parents: diff changeset	701 } else {
a61af66fc99e Initial load duke parents: diff changeset	702 gclog_or_tty->print(" " SIZE_FORMAT "K"
a61af66fc99e Initial load duke parents: diff changeset	703 "->" SIZE_FORMAT "K"
a61af66fc99e Initial load duke parents: diff changeset	704 "(" SIZE_FORMAT "K)",
a61af66fc99e Initial load duke parents: diff changeset	705 prev_used / K, used() / K, capacity() / K);
a61af66fc99e Initial load duke parents: diff changeset	706 }
a61af66fc99e Initial load duke parents: diff changeset	707 }
a61af66fc99e Initial load duke parents: diff changeset	708
a61af66fc99e Initial load duke parents: diff changeset	709 ParallelScavengeHeap* ParallelScavengeHeap::heap() {
a61af66fc99e Initial load duke parents: diff changeset	710 assert(_psh != NULL, "Uninitialized access to ParallelScavengeHeap::heap()");
a61af66fc99e Initial load duke parents: diff changeset	711 assert(_psh->kind() == CollectedHeap::ParallelScavengeHeap, "not a parallel scavenge heap");
a61af66fc99e Initial load duke parents: diff changeset	712 return _psh;
a61af66fc99e Initial load duke parents: diff changeset	713 }
a61af66fc99e Initial load duke parents: diff changeset	714
a61af66fc99e Initial load duke parents: diff changeset	715 // Before delegating the resize to the young generation,
a61af66fc99e Initial load duke parents: diff changeset	716 // the reserved space for the young and old generations
a61af66fc99e Initial load duke parents: diff changeset	717 // may be changed to accomodate the desired resize.
a61af66fc99e Initial load duke parents: diff changeset	718 void ParallelScavengeHeap::resize_young_gen(size_t eden_size,
a61af66fc99e Initial load duke parents: diff changeset	719 size_t survivor_size) {
a61af66fc99e Initial load duke parents: diff changeset	720 if (UseAdaptiveGCBoundary) {
a61af66fc99e Initial load duke parents: diff changeset	721 if (size_policy()->bytes_absorbed_from_eden() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	722 size_policy()->reset_bytes_absorbed_from_eden();
a61af66fc99e Initial load duke parents: diff changeset	723 return; // The generation changed size already.
a61af66fc99e Initial load duke parents: diff changeset	724 }
a61af66fc99e Initial load duke parents: diff changeset	725 gens()->adjust_boundary_for_young_gen_needs(eden_size, survivor_size);
a61af66fc99e Initial load duke parents: diff changeset	726 }
a61af66fc99e Initial load duke parents: diff changeset	727
a61af66fc99e Initial load duke parents: diff changeset	728 // Delegate the resize to the generation.
a61af66fc99e Initial load duke parents: diff changeset	729 _young_gen->resize(eden_size, survivor_size);
a61af66fc99e Initial load duke parents: diff changeset	730 }
a61af66fc99e Initial load duke parents: diff changeset	731
a61af66fc99e Initial load duke parents: diff changeset	732 // Before delegating the resize to the old generation,
a61af66fc99e Initial load duke parents: diff changeset	733 // the reserved space for the young and old generations
a61af66fc99e Initial load duke parents: diff changeset	734 // may be changed to accomodate the desired resize.
a61af66fc99e Initial load duke parents: diff changeset	735 void ParallelScavengeHeap::resize_old_gen(size_t desired_free_space) {
a61af66fc99e Initial load duke parents: diff changeset	736 if (UseAdaptiveGCBoundary) {
a61af66fc99e Initial load duke parents: diff changeset	737 if (size_policy()->bytes_absorbed_from_eden() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	738 size_policy()->reset_bytes_absorbed_from_eden();
a61af66fc99e Initial load duke parents: diff changeset	739 return; // The generation changed size already.
a61af66fc99e Initial load duke parents: diff changeset	740 }
a61af66fc99e Initial load duke parents: diff changeset	741 gens()->adjust_boundary_for_old_gen_needs(desired_free_space);
a61af66fc99e Initial load duke parents: diff changeset	742 }
a61af66fc99e Initial load duke parents: diff changeset	743
a61af66fc99e Initial load duke parents: diff changeset	744 // Delegate the resize to the generation.
a61af66fc99e Initial load duke parents: diff changeset	745 _old_gen->resize(desired_free_space);
a61af66fc99e Initial load duke parents: diff changeset	746 }
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	747
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	748 ParallelScavengeHeap::ParStrongRootsScope::ParStrongRootsScope() {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	749 // nothing particular
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	750 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	751
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	752 ParallelScavengeHeap::ParStrongRootsScope::~ParStrongRootsScope() {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	753 // nothing particular
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	754 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	755
263 12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	756 #ifndef PRODUCT
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	757 void ParallelScavengeHeap::record_gen_tops_before_GC() {
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	758 if (ZapUnusedHeapArea) {
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	759 young_gen()->record_spaces_top();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	760 old_gen()->record_spaces_top();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	761 }
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	762 }
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	763
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	764 void ParallelScavengeHeap::gen_mangle_unused_area() {
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	765 if (ZapUnusedHeapArea) {
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	766 young_gen()->eden_space()->mangle_unused_area();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	767 young_gen()->to_space()->mangle_unused_area();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	768 young_gen()->from_space()->mangle_unused_area();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	769 old_gen()->object_space()->mangle_unused_area();
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	770 }
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	771 }
12eea04c8b06 6672698: mangle_unused_area() should not remangle the entire heap at each collection. jmasa parents: 139 diff changeset	772 #endif

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp @ 10185:d50cc62e94ff