truffle: src/share/vm/gc_implementation/shared/vmGCOperations.cpp annotate

annotate src/share/vm/gc_implementation/shared/vmGCOperations.cpp @ 20280:bac98749fe00

8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off Reviewed-by: brutisso, tschatzl, ehelin, jmasa, dfazunen

author	stefank
date	Fri, 11 Jul 2014 09:07:23 +0200
parents	2c6ef90f030a
children	f3aeae1f9fc5

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
20280 bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	2 * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1547 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1547 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: 1547 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #include "classfile/classLoader.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "gc_implementation/shared/vmGCOperations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "oops/instanceRefKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "runtime/init.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 #include "utilities/dtrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	38 #include "utilities/preserveException.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6820 diff changeset	39 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6820 diff changeset	40 #if INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	41 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6820 diff changeset	42 #endif // INCLUDE_ALL_GCS
2125 7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent kamg parents: 1972 diff changeset	43
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	44 #ifndef USDT2
0 a61af66fc99e Initial load duke parents: diff changeset	45 HS_DTRACE_PROBE_DECL1(hotspot, gc__begin, bool);
a61af66fc99e Initial load duke parents: diff changeset	46 HS_DTRACE_PROBE_DECL(hotspot, gc__end);
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	47 #endif /* !USDT2 */
0 a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49 // The same dtrace probe can't be inserted in two different files, so we
a61af66fc99e Initial load duke parents: diff changeset	50 // have to call it here, so it's only in one file. Can't create new probes
a61af66fc99e Initial load duke parents: diff changeset	51 // for the other file anymore. The dtrace probes have to remain stable.
a61af66fc99e Initial load duke parents: diff changeset	52 void VM_GC_Operation::notify_gc_begin(bool full) {
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	53 #ifndef USDT2
0 a61af66fc99e Initial load duke parents: diff changeset	54 HS_DTRACE_PROBE1(hotspot, gc__begin, full);
1547 fb1a39993f69 6951319: enable solaris builds using Sun Studio 12 update 1 jcoomes parents: 1392 diff changeset	55 HS_DTRACE_WORKAROUND_TAIL_CALL_BUG();
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	56 #else /* USDT2 */
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	57 HOTSPOT_GC_BEGIN(
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	58 full);
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	59 #endif /* USDT2 */
0 a61af66fc99e Initial load duke parents: diff changeset	60 }
a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 void VM_GC_Operation::notify_gc_end() {
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	63 #ifndef USDT2
0 a61af66fc99e Initial load duke parents: diff changeset	64 HS_DTRACE_PROBE(hotspot, gc__end);
1547 fb1a39993f69 6951319: enable solaris builds using Sun Studio 12 update 1 jcoomes parents: 1392 diff changeset	65 HS_DTRACE_WORKAROUND_TAIL_CALL_BUG();
4006 436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	66 #else /* USDT2 */
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	67 HOTSPOT_GC_END(
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	68 );
436b4a3231bf 7098194: integrate macosx-port changes dcubed parents: 2225 diff changeset	69 #endif /* USDT2 */
0 a61af66fc99e Initial load duke parents: diff changeset	70 }
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 void VM_GC_Operation::acquire_pending_list_lock() {
a61af66fc99e Initial load duke parents: diff changeset	73 // we may enter this with pending exception set
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	74 InstanceRefKlass::acquire_pending_list_lock(&_pending_list_basic_lock);
0 a61af66fc99e Initial load duke parents: diff changeset	75 }
a61af66fc99e Initial load duke parents: diff changeset	76
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 void VM_GC_Operation::release_and_notify_pending_list_lock() {
a61af66fc99e Initial load duke parents: diff changeset	79
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6725 diff changeset	80 InstanceRefKlass::release_and_notify_pending_list_lock(&_pending_list_basic_lock);
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 // Allocations may fail in several threads at about the same time,
a61af66fc99e Initial load duke parents: diff changeset	84 // resulting in multiple gc requests. We only want to do one of them.
a61af66fc99e Initial load duke parents: diff changeset	85 // In case a GC locker is active and the need for a GC is already signalled,
a61af66fc99e Initial load duke parents: diff changeset	86 // we want to skip this GC attempt altogether, without doing a futile
a61af66fc99e Initial load duke parents: diff changeset	87 // safepoint operation.
a61af66fc99e Initial load duke parents: diff changeset	88 bool VM_GC_Operation::skip_operation() const {
a61af66fc99e Initial load duke parents: diff changeset	89 bool skip = (_gc_count_before != Universe::heap()->total_collections());
a61af66fc99e Initial load duke parents: diff changeset	90 if (_full && skip) {
a61af66fc99e Initial load duke parents: diff changeset	91 skip = (_full_gc_count_before != Universe::heap()->total_full_collections());
a61af66fc99e Initial load duke parents: diff changeset	92 }
a61af66fc99e Initial load duke parents: diff changeset	93 if (!skip && GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	94 skip = Universe::heap()->is_maximal_no_gc();
a61af66fc99e Initial load duke parents: diff changeset	95 assert(!(skip && (_gc_cause == GCCause::_gc_locker)),
a61af66fc99e Initial load duke parents: diff changeset	96 "GC_locker cannot be active when initiating GC");
a61af66fc99e Initial load duke parents: diff changeset	97 }
a61af66fc99e Initial load duke parents: diff changeset	98 return skip;
a61af66fc99e Initial load duke parents: diff changeset	99 }
a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 bool VM_GC_Operation::doit_prologue() {
a61af66fc99e Initial load duke parents: diff changeset	102 assert(Thread::current()->is_Java_thread(), "just checking");
2225 c798c277ddd1 7015169: GC Cause not always set brutisso parents: 2125 diff changeset	103 assert(((_gc_cause != GCCause::_no_gc) &&
c798c277ddd1 7015169: GC Cause not always set brutisso parents: 2125 diff changeset	104 (_gc_cause != GCCause::_no_cause_specified)), "Illegal GCCause");
0 a61af66fc99e Initial load duke parents: diff changeset	105
17876 9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	106 // To be able to handle a GC the VM initialization needs to be completed.
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	107 if (!is_init_completed()) {
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	108 vm_exit_during_initialization(
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	109 err_msg("GC triggered before VM initialization completed. Try increasing "
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	110 "NewSize, current value " UINTX_FORMAT "%s.",
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	111 byte_size_in_proper_unit(NewSize),
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	112 proper_unit_for_byte_size(NewSize)));
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	113 }
9c3dc501b5eb 8028498: runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java asserts in RT_Baseline sjohanss parents: 12907 diff changeset	114
0 a61af66fc99e Initial load duke parents: diff changeset	115 acquire_pending_list_lock();
a61af66fc99e Initial load duke parents: diff changeset	116 // If the GC count has changed someone beat us to the collection
a61af66fc99e Initial load duke parents: diff changeset	117 // Get the Heap_lock after the pending_list_lock.
a61af66fc99e Initial load duke parents: diff changeset	118 Heap_lock->lock();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	119
0 a61af66fc99e Initial load duke parents: diff changeset	120 // Check invocations
a61af66fc99e Initial load duke parents: diff changeset	121 if (skip_operation()) {
a61af66fc99e Initial load duke parents: diff changeset	122 // skip collection
a61af66fc99e Initial load duke parents: diff changeset	123 Heap_lock->unlock();
a61af66fc99e Initial load duke parents: diff changeset	124 release_and_notify_pending_list_lock();
a61af66fc99e Initial load duke parents: diff changeset	125 _prologue_succeeded = false;
a61af66fc99e Initial load duke parents: diff changeset	126 } else {
a61af66fc99e Initial load duke parents: diff changeset	127 _prologue_succeeded = true;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	128 SharedHeap* sh = SharedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	129 if (sh != NULL) sh->_thread_holds_heap_lock_for_gc = true;
0 a61af66fc99e Initial load duke parents: diff changeset	130 }
a61af66fc99e Initial load duke parents: diff changeset	131 return _prologue_succeeded;
a61af66fc99e Initial load duke parents: diff changeset	132 }
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134
a61af66fc99e Initial load duke parents: diff changeset	135 void VM_GC_Operation::doit_epilogue() {
a61af66fc99e Initial load duke parents: diff changeset	136 assert(Thread::current()->is_Java_thread(), "just checking");
a61af66fc99e Initial load duke parents: diff changeset	137 // Release the Heap_lock first.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	138 SharedHeap* sh = SharedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	139 if (sh != NULL) sh->_thread_holds_heap_lock_for_gc = false;
0 a61af66fc99e Initial load duke parents: diff changeset	140 Heap_lock->unlock();
a61af66fc99e Initial load duke parents: diff changeset	141 release_and_notify_pending_list_lock();
a61af66fc99e Initial load duke parents: diff changeset	142 }
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144 bool VM_GC_HeapInspection::doit_prologue() {
a61af66fc99e Initial load duke parents: diff changeset	145 if (Universe::heap()->supports_heap_inspection()) {
a61af66fc99e Initial load duke parents: diff changeset	146 return VM_GC_Operation::doit_prologue();
a61af66fc99e Initial load duke parents: diff changeset	147 } else {
a61af66fc99e Initial load duke parents: diff changeset	148 return false;
a61af66fc99e Initial load duke parents: diff changeset	149 }
a61af66fc99e Initial load duke parents: diff changeset	150 }
a61af66fc99e Initial load duke parents: diff changeset	151
a61af66fc99e Initial load duke parents: diff changeset	152 bool VM_GC_HeapInspection::skip_operation() const {
a61af66fc99e Initial load duke parents: diff changeset	153 assert(Universe::heap()->supports_heap_inspection(), "huh?");
a61af66fc99e Initial load duke parents: diff changeset	154 return false;
a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	157 bool VM_GC_HeapInspection::collect() {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	158 if (GC_locker::is_active()) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	159 return false;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	160 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	161 Universe::heap()->collect_as_vm_thread(GCCause::_heap_inspection);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	162 return true;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	163 }
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	164
0 a61af66fc99e Initial load duke parents: diff changeset	165 void VM_GC_HeapInspection::doit() {
a61af66fc99e Initial load duke parents: diff changeset	166 HandleMark hm;
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	167 Universe::heap()->ensure_parsability(false); // must happen, even if collection does
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	168 // not happen (e.g. due to GC_locker)
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	169 // or _full_gc being false
0 a61af66fc99e Initial load duke parents: diff changeset	170 if (_full_gc) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	171 if (!collect()) {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	172 // The collection attempt was skipped because the gc locker is held.
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	173 // The following dump may then be a tad misleading to someone expecting
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	174 // only live objects to show up in the dump (see CR 6944195). Just issue
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	175 // a suitable warning in that case and do not attempt to do a collection.
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	176 // The latter is a subtle point, because even a failed attempt
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	177 // to GC will, in fact, induce one in the future, which we
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	178 // probably want to avoid in this case because the GC that we may
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	179 // be about to attempt holds value for us only
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	180 // if it happens now and not if it happens in the eventual
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	181 // future.
1392 bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	182 warning("GC locker is held; pre-dump GC was skipped");
bdb5361c461c 6897143: Stress test crashes during HeapInspection using ParallelGC. kevinw parents: 615 diff changeset	183 }
0 a61af66fc99e Initial load duke parents: diff changeset	184 }
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6820 diff changeset	185 HeapInspection inspect(_csv_format, _print_help, _print_class_stats,
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 6820 diff changeset	186 _columns);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10183 diff changeset	187 inspect.heap_inspection(_out);
0 a61af66fc99e Initial load duke parents: diff changeset	188 }
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190
a61af66fc99e Initial load duke parents: diff changeset	191 void VM_GenCollectForAllocation::doit() {
2125 7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent kamg parents: 1972 diff changeset	192 SvcGCMarker sgcm(SvcGCMarker::MINOR);
0 a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	195 GCCauseSetter gccs(gch, _gc_cause);
a61af66fc99e Initial load duke parents: diff changeset	196 _res = gch->satisfy_failed_allocation(_size, _tlab);
a61af66fc99e Initial load duke parents: diff changeset	197 assert(gch->is_in_reserved_or_null(_res), "result not in heap");
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 if (_res == NULL && GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load duke parents: diff changeset	200 set_gc_locked();
a61af66fc99e Initial load duke parents: diff changeset	201 }
a61af66fc99e Initial load duke parents: diff changeset	202 }
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204 void VM_GenCollectFull::doit() {
2125 7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent kamg parents: 1972 diff changeset	205 SvcGCMarker sgcm(SvcGCMarker::FULL);
0 a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load duke parents: diff changeset	208 GCCauseSetter gccs(gch, _gc_cause);
a61af66fc99e Initial load duke parents: diff changeset	209 gch->do_full_collection(gch->must_clear_all_soft_refs(), _max_level);
a61af66fc99e Initial load duke parents: diff changeset	210 }
139 c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	211
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	212 bool VM_CollectForMetadataAllocation::initiate_concurrent_GC() {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	213 #if INCLUDE_ALL_GCS
20280 bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	214 if (UseConcMarkSweepGC && CMSClassUnloadingEnabled) {
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	215 MetaspaceGC::set_should_concurrent_collect(true);
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	216 return true;
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	217 }
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	218
20280 bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	219 if (UseG1GC) {
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	220 G1CollectedHeap* g1h = G1CollectedHeap::heap();
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	221 g1h->g1_policy()->set_initiate_conc_mark_if_possible();
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	222
20280 bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	223 GCCauseSetter x(g1h, _gc_cause);
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	224
20280 bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	225 // At this point we are supposed to start a concurrent cycle. We
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	226 // will do so if one is not already in progress.
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	227 bool should_start = g1h->g1_policy()->force_initial_mark_if_outside_cycle(_gc_cause);
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	228
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	229 if (should_start) {
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	230 double pause_target = g1h->g1_policy()->max_pause_time_ms();
bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	231 g1h->do_collection_pause_at_safepoint(pause_target);
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	232 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	233 return true;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	234 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	235 #endif
20280 bac98749fe00 8049831: Metadata Full GCs are not triggered when CMSClassUnloadingEnabled is turned off stefank parents: 20278 diff changeset	236
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	237 return false;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	238 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	239
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	240 static void log_metaspace_alloc_failure_for_concurrent_GC() {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	241 if (Verbose && PrintGCDetails) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	242 if (UseConcMarkSweepGC) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	243 gclog_or_tty->print_cr("\nCMS full GC for Metaspace");
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	244 } else if (UseG1GC) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	245 gclog_or_tty->print_cr("\nG1 full GC for Metaspace");
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	246 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	247 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	248 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	249
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	250 void VM_CollectForMetadataAllocation::doit() {
2125 7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent kamg parents: 1972 diff changeset	251 SvcGCMarker sgcm(SvcGCMarker::FULL);
7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent kamg parents: 1972 diff changeset	252
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	253 CollectedHeap* heap = Universe::heap();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	254 GCCauseSetter gccs(heap, _gc_cause);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	255
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	256 // Check again if the space is available. Another thread
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	257 // may have similarly failed a metadata allocation and induced
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	258 // a GC that freed space for the allocation.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	259 if (!MetadataAllocationFailALot) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	260 _result = _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	261 if (_result != NULL) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	262 return;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	263 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 139 diff changeset	264 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4006 diff changeset	265
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	266 if (initiate_concurrent_GC()) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	267 // For CMS and G1 expand since the collection is going to be concurrent.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	268 _result = _loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	269 if (_result != NULL) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	270 return;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	271 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	272
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	273 log_metaspace_alloc_failure_for_concurrent_GC();
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	274 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	275
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	276 // Don't clear the soft refs yet.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	277 heap->collect_as_vm_thread(GCCause::_metadata_GC_threshold);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	278 // After a GC try to allocate without expanding. Could fail
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	279 // and expansion will be tried below.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	280 _result = _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	281 if (_result != NULL) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	282 return;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	283 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	284
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	285 // If still failing, allow the Metaspace to expand.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	286 // See delta_capacity_until_GC() for explanation of the
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	287 // amount of the expansion.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	288 // This should work unless there really is no more space
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	289 // or a MaxMetaspaceSize has been specified on the command line.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	290 _result = _loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	291 if (_result != NULL) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	292 return;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	293 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	294
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	295 // If expansion failed, do a last-ditch collection and try allocating
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	296 // again. A last-ditch collection will clear softrefs. This
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	297 // behavior is similar to the last-ditch collection done for perm
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	298 // gen when it was full and a collection for failed allocation
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	299 // did not free perm gen space.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	300 heap->collect_as_vm_thread(GCCause::_last_ditch_collection);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	301 _result = _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	302 if (_result != NULL) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	303 return;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	304 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	305
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	306 if (Verbose && PrintGCDetails) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	307 gclog_or_tty->print_cr("\nAfter Metaspace GC failed to allocate size "
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	308 SIZE_FORMAT, _size);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	309 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	310
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17876 diff changeset	311 if (GC_locker::is_active_and_needs_gc()) {
139 c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	312 set_gc_locked();
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	313 }
c0492d52d55b 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen apetrusenko parents: 0 diff changeset	314 }

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/shared/vmGCOperations.cpp @ 20280:bac98749fe00