graal-jvmci-8: src/share/vm/memory/sharedHeap.cpp annotate

annotate src/share/vm/memory/sharedHeap.cpp @ 2368:dde920245681

6896099: Integrate CMS heap ergo with default heap sizing ergo 6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m 7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification 7027529: CMS: retire CMSUseOldDefaults flag Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago. Reviewed-by: brutisso, poonam

author	ysr
date	Wed, 16 Mar 2011 10:37:08 -0700
parents	3582bf76420e
children	b099aaf51bf8

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	2 * Copyright (c) 2000, 2010, 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: 989 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 989 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: 989 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: 1833 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	26 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	28 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	29 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	30 #include "memory/sharedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	31 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	32 #include "runtime/fprofiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	33 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	34 #include "services/management.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	35 #include "utilities/copy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	36 #include "utilities/workgroup.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	37
a61af66fc99e Initial load duke parents: diff changeset	38 SharedHeap* SharedHeap::_sh;
a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 // The set of potentially parallel tasks in strong root scanning.
a61af66fc99e Initial load duke parents: diff changeset	41 enum SH_process_strong_roots_tasks {
a61af66fc99e Initial load duke parents: diff changeset	42 SH_PS_Universe_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	43 SH_PS_JNIHandles_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	44 SH_PS_ObjectSynchronizer_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	45 SH_PS_FlatProfiler_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	46 SH_PS_Management_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	47 SH_PS_SystemDictionary_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	48 SH_PS_jvmti_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	49 SH_PS_SymbolTable_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	50 SH_PS_StringTable_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	51 SH_PS_CodeCache_oops_do,
a61af66fc99e Initial load duke parents: diff changeset	52 // Leave this one last.
a61af66fc99e Initial load duke parents: diff changeset	53 SH_PS_NumElements
a61af66fc99e Initial load duke parents: diff changeset	54 };
a61af66fc99e Initial load duke parents: diff changeset	55
a61af66fc99e Initial load duke parents: diff changeset	56 SharedHeap::SharedHeap(CollectorPolicy* policy_) :
a61af66fc99e Initial load duke parents: diff changeset	57 CollectedHeap(),
a61af66fc99e Initial load duke parents: diff changeset	58 _collector_policy(policy_),
a61af66fc99e Initial load duke parents: diff changeset	59 _perm_gen(NULL), _rem_set(NULL),
a61af66fc99e Initial load duke parents: diff changeset	60 _strong_roots_parity(0),
a61af66fc99e Initial load duke parents: diff changeset	61 _process_strong_tasks(new SubTasksDone(SH_PS_NumElements)),
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	62 _n_par_threads(0),
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	63 _workers(NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	64 {
a61af66fc99e Initial load duke parents: diff changeset	65 if (_process_strong_tasks == NULL \|\| !_process_strong_tasks->valid()) {
a61af66fc99e Initial load duke parents: diff changeset	66 vm_exit_during_initialization("Failed necessary allocation.");
a61af66fc99e Initial load duke parents: diff changeset	67 }
a61af66fc99e Initial load duke parents: diff changeset	68 _sh = this; // ch is static, should be set only once.
a61af66fc99e Initial load duke parents: diff changeset	69 if ((UseParNewGC \|\|
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	70 (UseConcMarkSweepGC && CMSParallelRemarkEnabled) \|\|
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	71 UseG1GC) &&
0 a61af66fc99e Initial load duke parents: diff changeset	72 ParallelGCThreads > 0) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	73 _workers = new FlexibleWorkGang("Parallel GC Threads", ParallelGCThreads,
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	74 /* are_GC_task_threads */true,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	75 /* are_ConcurrentGC_threads */false);
0 a61af66fc99e Initial load duke parents: diff changeset	76 if (_workers == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	77 vm_exit_during_initialization("Failed necessary allocation.");
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	78 } else {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	79 _workers->initialize_workers();
0 a61af66fc99e Initial load duke parents: diff changeset	80 }
a61af66fc99e Initial load duke parents: diff changeset	81 }
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	84 bool SharedHeap::heap_lock_held_for_gc() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	85 Thread* t = Thread::current();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	86 return Heap_lock->owned_by_self()
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	87 \|\| ( (t->is_GC_task_thread() \|\| t->is_VM_thread())
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	88 && _thread_holds_heap_lock_for_gc);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	89 }
0 a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 void SharedHeap::set_par_threads(int t) {
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	92 assert(t == 0 \|\| !UseSerialGC, "Cannot have parallel threads");
0 a61af66fc99e Initial load duke parents: diff changeset	93 _n_par_threads = t;
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	94 _process_strong_tasks->set_n_threads(t);
0 a61af66fc99e Initial load duke parents: diff changeset	95 }
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 class AssertIsPermClosure: public OopClosure {
a61af66fc99e Initial load duke parents: diff changeset	98 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	99 virtual void do_oop(oop* p) {
0 a61af66fc99e Initial load duke parents: diff changeset	100 assert((p) == NULL \|\| (p)->is_perm(), "Referent should be perm.");
a61af66fc99e Initial load duke parents: diff changeset	101 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	102 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
0 a61af66fc99e Initial load duke parents: diff changeset	103 };
a61af66fc99e Initial load duke parents: diff changeset	104 static AssertIsPermClosure assert_is_perm_closure;
a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106 void SharedHeap::change_strong_roots_parity() {
a61af66fc99e Initial load duke parents: diff changeset	107 // Also set the new collection parity.
a61af66fc99e Initial load duke parents: diff changeset	108 assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2,
a61af66fc99e Initial load duke parents: diff changeset	109 "Not in range.");
a61af66fc99e Initial load duke parents: diff changeset	110 _strong_roots_parity++;
a61af66fc99e Initial load duke parents: diff changeset	111 if (_strong_roots_parity == 3) _strong_roots_parity = 1;
a61af66fc99e Initial load duke parents: diff changeset	112 assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2,
a61af66fc99e Initial load duke parents: diff changeset	113 "Not in range.");
a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	116 SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* outer, bool activate)
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	117 : MarkScope(activate)
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	118 {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	119 if (_active) {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	120 outer->change_strong_roots_parity();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	121 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	122 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	123
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	124 SharedHeap::StrongRootsScope::~StrongRootsScope() {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	125 // nothing particular
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	126 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	127
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	128 void SharedHeap::process_strong_roots(bool activate_scope,
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	129 bool collecting_perm_gen,
0 a61af66fc99e Initial load duke parents: diff changeset	130 ScanningOption so,
a61af66fc99e Initial load duke parents: diff changeset	131 OopClosure* roots,
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	132 CodeBlobClosure* code_roots,
0 a61af66fc99e Initial load duke parents: diff changeset	133 OopsInGenClosure* perm_blk) {
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	134 StrongRootsScope srs(this, activate_scope);
0 a61af66fc99e Initial load duke parents: diff changeset	135 // General strong roots.
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	136 assert(_strong_roots_parity != 0, "must have called prologue code");
0 a61af66fc99e Initial load duke parents: diff changeset	137 if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) {
a61af66fc99e Initial load duke parents: diff changeset	138 Universe::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	139 ReferenceProcessor::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	140 // Consider perm-gen discovered lists to be strong.
a61af66fc99e Initial load duke parents: diff changeset	141 perm_gen()->ref_processor()->weak_oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	142 }
a61af66fc99e Initial load duke parents: diff changeset	143 // Global (strong) JNI handles
a61af66fc99e Initial load duke parents: diff changeset	144 if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
a61af66fc99e Initial load duke parents: diff changeset	145 JNIHandles::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	146 // All threads execute this; the individual threads are task groups.
a61af66fc99e Initial load duke parents: diff changeset	147 if (ParallelGCThreads > 0) {
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	148 Threads::possibly_parallel_oops_do(roots, code_roots);
0 a61af66fc99e Initial load duke parents: diff changeset	149 } else {
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	150 Threads::oops_do(roots, code_roots);
0 a61af66fc99e Initial load duke parents: diff changeset	151 }
a61af66fc99e Initial load duke parents: diff changeset	152 if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
a61af66fc99e Initial load duke parents: diff changeset	153 ObjectSynchronizer::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	154 if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
a61af66fc99e Initial load duke parents: diff changeset	155 FlatProfiler::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	156 if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
a61af66fc99e Initial load duke parents: diff changeset	157 Management::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	158 if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
a61af66fc99e Initial load duke parents: diff changeset	159 JvmtiExport::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
a61af66fc99e Initial load duke parents: diff changeset	162 if (so & SO_AllClasses) {
a61af66fc99e Initial load duke parents: diff changeset	163 SystemDictionary::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	164 } else
a61af66fc99e Initial load duke parents: diff changeset	165 if (so & SO_SystemClasses) {
a61af66fc99e Initial load duke parents: diff changeset	166 SystemDictionary::always_strong_oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	167 }
a61af66fc99e Initial load duke parents: diff changeset	168 }
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 if (!_process_strong_tasks->is_task_claimed(SH_PS_SymbolTable_oops_do)) {
a61af66fc99e Initial load duke parents: diff changeset	171 }
a61af66fc99e Initial load duke parents: diff changeset	172
a61af66fc99e Initial load duke parents: diff changeset	173 if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
a61af66fc99e Initial load duke parents: diff changeset	174 if (so & SO_Strings) {
a61af66fc99e Initial load duke parents: diff changeset	175 StringTable::oops_do(roots);
a61af66fc99e Initial load duke parents: diff changeset	176 }
a61af66fc99e Initial load duke parents: diff changeset	177 // Verify if the string table contents are in the perm gen
a61af66fc99e Initial load duke parents: diff changeset	178 NOT_PRODUCT(StringTable::oops_do(&assert_is_perm_closure));
a61af66fc99e Initial load duke parents: diff changeset	179 }
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	182 if (so & SO_CodeCache) {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	183 // (Currently, CMSCollector uses this to do intermediate-strength collections.)
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	184 assert(collecting_perm_gen, "scanning all of code cache");
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	185 assert(code_roots != NULL, "must supply closure for code cache");
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	186 if (code_roots != NULL) {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	187 CodeCache::blobs_do(code_roots);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	188 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	189 } else if (so & (SO_SystemClasses\|SO_AllClasses)) {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	190 if (!collecting_perm_gen) {
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	191 // If we are collecting from class statics, but we are not going to
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	192 // visit all of the CodeCache, collect from the non-perm roots if any.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	193 // This makes the code cache function temporarily as a source of strong
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	194 // roots for oops, until the next major collection.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	195 //
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	196 // If collecting_perm_gen is true, we require that this phase will call
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	197 // CodeCache::do_unloading. This will kill off nmethods with expired
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	198 // weak references, such as stale invokedynamic targets.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	199 CodeCache::scavenge_root_nmethods_do(code_roots);
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	200 }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	201 }
0 a61af66fc99e Initial load duke parents: diff changeset	202 // Verify if the code cache contents are in the perm gen
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	203 NOT_PRODUCT(CodeBlobToOopClosure assert_code_is_perm(&assert_is_perm_closure, /do_marking=/ false));
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	204 NOT_PRODUCT(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_perm));
0 a61af66fc99e Initial load duke parents: diff changeset	205 }
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 if (!collecting_perm_gen) {
a61af66fc99e Initial load duke parents: diff changeset	208 // All threads perform this; coordination is handled internally.
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210 rem_set()->younger_refs_iterate(perm_gen(), perm_blk);
a61af66fc99e Initial load duke parents: diff changeset	211 }
a61af66fc99e Initial load duke parents: diff changeset	212 _process_strong_tasks->all_tasks_completed();
a61af66fc99e Initial load duke parents: diff changeset	213 }
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 class AlwaysTrueClosure: public BoolObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	216 public:
a61af66fc99e Initial load duke parents: diff changeset	217 void do_object(oop p) { ShouldNotReachHere(); }
a61af66fc99e Initial load duke parents: diff changeset	218 bool do_object_b(oop p) { return true; }
a61af66fc99e Initial load duke parents: diff changeset	219 };
a61af66fc99e Initial load duke parents: diff changeset	220 static AlwaysTrueClosure always_true;
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 class SkipAdjustingSharedStrings: public OopClosure {
a61af66fc99e Initial load duke parents: diff changeset	223 OopClosure* _clo;
a61af66fc99e Initial load duke parents: diff changeset	224 public:
a61af66fc99e Initial load duke parents: diff changeset	225 SkipAdjustingSharedStrings(OopClosure* clo) : _clo(clo) {}
a61af66fc99e Initial load duke parents: diff changeset	226
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	227 virtual void do_oop(oop* p) {
0 a61af66fc99e Initial load duke parents: diff changeset	228 oop o = (*p);
a61af66fc99e Initial load duke parents: diff changeset	229 if (!o->is_shared_readwrite()) {
a61af66fc99e Initial load duke parents: diff changeset	230 _clo->do_oop(p);
a61af66fc99e Initial load duke parents: diff changeset	231 }
a61af66fc99e Initial load duke parents: diff changeset	232 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	233 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
0 a61af66fc99e Initial load duke parents: diff changeset	234 };
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 // Unmarked shared Strings in the StringTable (which got there due to
a61af66fc99e Initial load duke parents: diff changeset	237 // being in the constant pools of as-yet unloaded shared classes) were
a61af66fc99e Initial load duke parents: diff changeset	238 // not marked and therefore did not have their mark words preserved.
a61af66fc99e Initial load duke parents: diff changeset	239 // These entries are also deliberately not purged from the string
a61af66fc99e Initial load duke parents: diff changeset	240 // table during unloading of unmarked strings. If an identity hash
a61af66fc99e Initial load duke parents: diff changeset	241 // code was computed for any of these objects, it will not have been
a61af66fc99e Initial load duke parents: diff changeset	242 // cleared to zero during the forwarding process or by the
a61af66fc99e Initial load duke parents: diff changeset	243 // RecursiveAdjustSharedObjectClosure, and will be confused by the
a61af66fc99e Initial load duke parents: diff changeset	244 // adjusting process as a forwarding pointer. We need to skip
a61af66fc99e Initial load duke parents: diff changeset	245 // forwarding StringTable entries which contain unmarked shared
a61af66fc99e Initial load duke parents: diff changeset	246 // Strings. Actually, since shared strings won't be moving, we can
a61af66fc99e Initial load duke parents: diff changeset	247 // just skip adjusting any shared entries in the string table.
a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 void SharedHeap::process_weak_roots(OopClosure* root_closure,
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	250 CodeBlobClosure* code_roots,
0 a61af66fc99e Initial load duke parents: diff changeset	251 OopClosure* non_root_closure) {
a61af66fc99e Initial load duke parents: diff changeset	252 // Global (weak) JNI handles
a61af66fc99e Initial load duke parents: diff changeset	253 JNIHandles::weak_oops_do(&always_true, root_closure);
a61af66fc99e Initial load duke parents: diff changeset	254
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 579 diff changeset	255 CodeCache::blobs_do(code_roots);
0 a61af66fc99e Initial load duke parents: diff changeset	256 if (UseSharedSpaces && !DumpSharedSpaces) {
a61af66fc99e Initial load duke parents: diff changeset	257 SkipAdjustingSharedStrings skip_closure(root_closure);
a61af66fc99e Initial load duke parents: diff changeset	258 StringTable::oops_do(&skip_closure);
a61af66fc99e Initial load duke parents: diff changeset	259 } else {
a61af66fc99e Initial load duke parents: diff changeset	260 StringTable::oops_do(root_closure);
a61af66fc99e Initial load duke parents: diff changeset	261 }
a61af66fc99e Initial load duke parents: diff changeset	262 }
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 void SharedHeap::set_barrier_set(BarrierSet* bs) {
a61af66fc99e Initial load duke parents: diff changeset	265 _barrier_set = bs;
a61af66fc99e Initial load duke parents: diff changeset	266 // Cached barrier set for fast access in oops
a61af66fc99e Initial load duke parents: diff changeset	267 oopDesc::set_bs(bs);
a61af66fc99e Initial load duke parents: diff changeset	268 }
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 void SharedHeap::post_initialize() {
a61af66fc99e Initial load duke parents: diff changeset	271 ref_processing_init();
a61af66fc99e Initial load duke parents: diff changeset	272 }
a61af66fc99e Initial load duke parents: diff changeset	273
a61af66fc99e Initial load duke parents: diff changeset	274 void SharedHeap::ref_processing_init() {
a61af66fc99e Initial load duke parents: diff changeset	275 perm_gen()->ref_processor_init();
a61af66fc99e Initial load duke parents: diff changeset	276 }
a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 // Some utilities.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	279 void SharedHeap::print_size_transition(outputStream* out,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	280 size_t bytes_before,
0 a61af66fc99e Initial load duke parents: diff changeset	281 size_t bytes_after,
a61af66fc99e Initial load duke parents: diff changeset	282 size_t capacity) {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	283 out->print(" %d%s->%d%s(%d%s)",
0 a61af66fc99e Initial load duke parents: diff changeset	284 byte_size_in_proper_unit(bytes_before),
a61af66fc99e Initial load duke parents: diff changeset	285 proper_unit_for_byte_size(bytes_before),
a61af66fc99e Initial load duke parents: diff changeset	286 byte_size_in_proper_unit(bytes_after),
a61af66fc99e Initial load duke parents: diff changeset	287 proper_unit_for_byte_size(bytes_after),
a61af66fc99e Initial load duke parents: diff changeset	288 byte_size_in_proper_unit(capacity),
a61af66fc99e Initial load duke parents: diff changeset	289 proper_unit_for_byte_size(capacity));
a61af66fc99e Initial load duke parents: diff changeset	290 }

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/sharedHeap.cpp @ 2368:dde920245681