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

annotate src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp @ 10405:f2110083203d

8005849: JEP 167: Event-Based JVM Tracing Reviewed-by: acorn, coleenp, sla Contributed-by: Karen Kinnear <karen.kinnear@oracle.com>, Bengt Rutisson <bengt.rutisson@oracle.com>, Calvin Cheung <calvin.cheung@oracle.com>, Erik Gahlin <erik.gahlin@oracle.com>, Erik Helin <erik.helin@oracle.com>, Jesper Wilhelmsson <jesper.wilhelmsson@oracle.com>, Keith McGuigan <keith.mcguigan@oracle.com>, Mattias Tobiasson <mattias.tobiasson@oracle.com>, Markus Gronlund <markus.gronlund@oracle.com>, Mikael Auno <mikael.auno@oracle.com>, Nils Eliasson <nils.eliasson@oracle.com>, Nils Loodin <nils.loodin@oracle.com>, Rickard Backman <rickard.backman@oracle.com>, Staffan Larsen <staffan.larsen@oracle.com>, Stefan Karlsson <stefan.karlsson@oracle.com>, Yekaterina Kantserova <yekaterina.kantserova@oracle.com>

author	sla
date	Mon, 10 Jun 2013 11:30:51 +0200
parents	eda078b01c65
children	78bbf4d43a14

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 7179 diff changeset	2 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1311 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: 1311 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: 1836 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	27 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	28 #include "gc_implementation/parallelScavenge/pcTasks.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	29 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	30 #include "gc_implementation/shared/gcTimer.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	31 #include "gc_implementation/shared/gcTraceTime.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	32 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	33 #include "memory/universe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	34 #include "oops/objArrayKlass.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	35 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	36 #include "oops/oop.pcgc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	37 #include "prims/jvmtiExport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	38 #include "runtime/fprofiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	39 #include "runtime/jniHandles.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	40 #include "runtime/thread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	41 #include "runtime/vmThread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	42 #include "services/management.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	43
a61af66fc99e Initial load duke parents: diff changeset	44 //
a61af66fc99e Initial load duke parents: diff changeset	45 // ThreadRootsMarkingTask
a61af66fc99e Initial load duke parents: diff changeset	46 //
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 void ThreadRootsMarkingTask::do_it(GCTaskManager* manager, uint which) {
a61af66fc99e Initial load duke parents: diff changeset	49 assert(Universe::heap()->is_gc_active(), "called outside gc");
a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	52
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	53 NOT_PRODUCT(GCTraceTime tm("ThreadRootsMarkingTask",
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	54 PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
0 a61af66fc99e Initial load duke parents: diff changeset	55 ParCompactionManager* cm =
a61af66fc99e Initial load duke parents: diff changeset	56 ParCompactionManager::gc_thread_compaction_manager(which);
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	57
0 a61af66fc99e Initial load duke parents: diff changeset	58 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	59 CLDToOopClosure mark_and_push_from_clds(&mark_and_push_closure, true);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 375 diff changeset	60 CodeBlobToOopClosure mark_and_push_in_blobs(&mark_and_push_closure, /do_marking=/ true);
0 a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 if (_java_thread != NULL)
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	63 _java_thread->oops_do(
d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	64 &mark_and_push_closure,
d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	65 &mark_and_push_from_clds,
d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	66 &mark_and_push_in_blobs);
0 a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68 if (_vm_thread != NULL)
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	69 _vm_thread->oops_do(
d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	70 &mark_and_push_closure,
d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	71 &mark_and_push_from_clds,
d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	72 &mark_and_push_in_blobs);
0 a61af66fc99e Initial load duke parents: diff changeset	73
a61af66fc99e Initial load duke parents: diff changeset	74 // Do the real work
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	75 cm->follow_marking_stacks();
0 a61af66fc99e Initial load duke parents: diff changeset	76 }
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78
a61af66fc99e Initial load duke parents: diff changeset	79 void MarkFromRootsTask::do_it(GCTaskManager* manager, uint which) {
a61af66fc99e Initial load duke parents: diff changeset	80 assert(Universe::heap()->is_gc_active(), "called outside gc");
a61af66fc99e Initial load duke parents: diff changeset	81
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	82 NOT_PRODUCT(GCTraceTime tm("MarkFromRootsTask",
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	83 PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
0 a61af66fc99e Initial load duke parents: diff changeset	84 ParCompactionManager* cm =
a61af66fc99e Initial load duke parents: diff changeset	85 ParCompactionManager::gc_thread_compaction_manager(which);
a61af66fc99e Initial load duke parents: diff changeset	86 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4095 diff changeset	87 PSParallelCompact::FollowKlassClosure follow_klass_closure(&mark_and_push_closure);
0 a61af66fc99e Initial load duke parents: diff changeset	88
a61af66fc99e Initial load duke parents: diff changeset	89 switch (_root_type) {
a61af66fc99e Initial load duke parents: diff changeset	90 case universe:
a61af66fc99e Initial load duke parents: diff changeset	91 Universe::oops_do(&mark_and_push_closure);
a61af66fc99e Initial load duke parents: diff changeset	92 break;
a61af66fc99e Initial load duke parents: diff changeset	93
a61af66fc99e Initial load duke parents: diff changeset	94 case jni_handles:
a61af66fc99e Initial load duke parents: diff changeset	95 JNIHandles::oops_do(&mark_and_push_closure);
a61af66fc99e Initial load duke parents: diff changeset	96 break;
a61af66fc99e Initial load duke parents: diff changeset	97
a61af66fc99e Initial load duke parents: diff changeset	98 case threads:
a61af66fc99e Initial load duke parents: diff changeset	99 {
a61af66fc99e Initial load duke parents: diff changeset	100 ResourceMark rm;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 375 diff changeset	101 CodeBlobToOopClosure each_active_code_blob(&mark_and_push_closure, /do_marking=/ true);
7179 d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	102 CLDToOopClosure mark_and_push_from_cld(&mark_and_push_closure);
d0aa87f04bd5 8003720: NPG: Method in interpreter stack frame can be deallocated stefank parents: 6831 diff changeset	103 Threads::oops_do(&mark_and_push_closure, &mark_and_push_from_cld, &each_active_code_blob);
0 a61af66fc99e Initial load duke parents: diff changeset	104 }
a61af66fc99e Initial load duke parents: diff changeset	105 break;
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 case object_synchronizer:
a61af66fc99e Initial load duke parents: diff changeset	108 ObjectSynchronizer::oops_do(&mark_and_push_closure);
a61af66fc99e Initial load duke parents: diff changeset	109 break;
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 case flat_profiler:
a61af66fc99e Initial load duke parents: diff changeset	112 FlatProfiler::oops_do(&mark_and_push_closure);
a61af66fc99e Initial load duke parents: diff changeset	113 break;
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 case management:
a61af66fc99e Initial load duke parents: diff changeset	116 Management::oops_do(&mark_and_push_closure);
a61af66fc99e Initial load duke parents: diff changeset	117 break;
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119 case jvmti:
a61af66fc99e Initial load duke parents: diff changeset	120 JvmtiExport::oops_do(&mark_and_push_closure);
a61af66fc99e Initial load duke parents: diff changeset	121 break;
a61af66fc99e Initial load duke parents: diff changeset	122
a61af66fc99e Initial load duke parents: diff changeset	123 case system_dictionary:
a61af66fc99e Initial load duke parents: diff changeset	124 SystemDictionary::always_strong_oops_do(&mark_and_push_closure);
10361 eda078b01c65 8015268: NPG: 2.5% regression in young GC times on CRM Sales Opty stefank parents: 10265 diff changeset	125 break;
eda078b01c65 8015268: NPG: 2.5% regression in young GC times on CRM Sales Opty stefank parents: 10265 diff changeset	126
eda078b01c65 8015268: NPG: 2.5% regression in young GC times on CRM Sales Opty stefank parents: 10265 diff changeset	127 case class_loader_data:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4095 diff changeset	128 ClassLoaderDataGraph::always_strong_oops_do(&mark_and_push_closure, &follow_klass_closure, true);
0 a61af66fc99e Initial load duke parents: diff changeset	129 break;
a61af66fc99e Initial load duke parents: diff changeset	130
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 375 diff changeset	131 case code_cache:
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 375 diff changeset	132 // Do not treat nmethods as strong roots for mark/sweep, since we can unload them.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 375 diff changeset	133 //CodeCache::scavenge_root_nmethods_do(CodeBlobToOopClosure(&mark_and_push_closure));
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 375 diff changeset	134 break;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 375 diff changeset	135
0 a61af66fc99e Initial load duke parents: diff changeset	136 default:
a61af66fc99e Initial load duke parents: diff changeset	137 fatal("Unknown root type");
a61af66fc99e Initial load duke parents: diff changeset	138 }
a61af66fc99e Initial load duke parents: diff changeset	139
a61af66fc99e Initial load duke parents: diff changeset	140 // Do the real work
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	141 cm->follow_marking_stacks();
0 a61af66fc99e Initial load duke parents: diff changeset	142 }
a61af66fc99e Initial load duke parents: diff changeset	143
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 //
a61af66fc99e Initial load duke parents: diff changeset	146 // RefProcTaskProxy
a61af66fc99e Initial load duke parents: diff changeset	147 //
a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 void RefProcTaskProxy::do_it(GCTaskManager* manager, uint which)
a61af66fc99e Initial load duke parents: diff changeset	150 {
a61af66fc99e Initial load duke parents: diff changeset	151 assert(Universe::heap()->is_gc_active(), "called outside gc");
a61af66fc99e Initial load duke parents: diff changeset	152
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	153 NOT_PRODUCT(GCTraceTime tm("RefProcTask",
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	154 PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
0 a61af66fc99e Initial load duke parents: diff changeset	155 ParCompactionManager* cm =
a61af66fc99e Initial load duke parents: diff changeset	156 ParCompactionManager::gc_thread_compaction_manager(which);
a61af66fc99e Initial load duke parents: diff changeset	157 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
a61af66fc99e Initial load duke parents: diff changeset	158 PSParallelCompact::FollowStackClosure follow_stack_closure(cm);
a61af66fc99e Initial load duke parents: diff changeset	159 _rp_task.work(_work_id, *PSParallelCompact::is_alive_closure(),
a61af66fc99e Initial load duke parents: diff changeset	160 mark_and_push_closure, follow_stack_closure);
a61af66fc99e Initial load duke parents: diff changeset	161 }
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 //
a61af66fc99e Initial load duke parents: diff changeset	164 // RefProcTaskExecutor
a61af66fc99e Initial load duke parents: diff changeset	165 //
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 void RefProcTaskExecutor::execute(ProcessTask& task)
a61af66fc99e Initial load duke parents: diff changeset	168 {
a61af66fc99e Initial load duke parents: diff changeset	169 ParallelScavengeHeap* heap = PSParallelCompact::gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	170 uint parallel_gc_threads = heap->gc_task_manager()->workers();
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	171 uint active_gc_threads = heap->gc_task_manager()->active_workers();
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	172 RegionTaskQueueSet* qset = ParCompactionManager::region_array();
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	173 ParallelTaskTerminator terminator(active_gc_threads, qset);
0 a61af66fc99e Initial load duke parents: diff changeset	174 GCTaskQueue* q = GCTaskQueue::create();
a61af66fc99e Initial load duke parents: diff changeset	175 for(uint i=0; i<parallel_gc_threads; i++) {
a61af66fc99e Initial load duke parents: diff changeset	176 q->enqueue(new RefProcTaskProxy(task, i));
a61af66fc99e Initial load duke parents: diff changeset	177 }
a61af66fc99e Initial load duke parents: diff changeset	178 if (task.marks_oops_alive()) {
a61af66fc99e Initial load duke parents: diff changeset	179 if (parallel_gc_threads>1) {
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	180 for (uint j=0; j<active_gc_threads; j++) {
0 a61af66fc99e Initial load duke parents: diff changeset	181 q->enqueue(new StealMarkingTask(&terminator));
a61af66fc99e Initial load duke parents: diff changeset	182 }
a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185 PSParallelCompact::gc_task_manager()->execute_and_wait(q);
a61af66fc99e Initial load duke parents: diff changeset	186 }
a61af66fc99e Initial load duke parents: diff changeset	187
a61af66fc99e Initial load duke parents: diff changeset	188 void RefProcTaskExecutor::execute(EnqueueTask& task)
a61af66fc99e Initial load duke parents: diff changeset	189 {
a61af66fc99e Initial load duke parents: diff changeset	190 ParallelScavengeHeap* heap = PSParallelCompact::gc_heap();
a61af66fc99e Initial load duke parents: diff changeset	191 uint parallel_gc_threads = heap->gc_task_manager()->workers();
a61af66fc99e Initial load duke parents: diff changeset	192 GCTaskQueue* q = GCTaskQueue::create();
a61af66fc99e Initial load duke parents: diff changeset	193 for(uint i=0; i<parallel_gc_threads; i++) {
a61af66fc99e Initial load duke parents: diff changeset	194 q->enqueue(new RefEnqueueTaskProxy(task, i));
a61af66fc99e Initial load duke parents: diff changeset	195 }
a61af66fc99e Initial load duke parents: diff changeset	196 PSParallelCompact::gc_task_manager()->execute_and_wait(q);
a61af66fc99e Initial load duke parents: diff changeset	197 }
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 //
a61af66fc99e Initial load duke parents: diff changeset	200 // StealMarkingTask
a61af66fc99e Initial load duke parents: diff changeset	201 //
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 StealMarkingTask::StealMarkingTask(ParallelTaskTerminator* t) :
a61af66fc99e Initial load duke parents: diff changeset	204 _terminator(t) {}
a61af66fc99e Initial load duke parents: diff changeset	205
a61af66fc99e Initial load duke parents: diff changeset	206 void StealMarkingTask::do_it(GCTaskManager* manager, uint which) {
a61af66fc99e Initial load duke parents: diff changeset	207 assert(Universe::heap()->is_gc_active(), "called outside gc");
a61af66fc99e Initial load duke parents: diff changeset	208
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	209 NOT_PRODUCT(GCTraceTime tm("StealMarkingTask",
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	210 PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
0 a61af66fc99e Initial load duke parents: diff changeset	211
a61af66fc99e Initial load duke parents: diff changeset	212 ParCompactionManager* cm =
a61af66fc99e Initial load duke parents: diff changeset	213 ParCompactionManager::gc_thread_compaction_manager(which);
a61af66fc99e Initial load duke parents: diff changeset	214 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
a61af66fc99e Initial load duke parents: diff changeset	215
a61af66fc99e Initial load duke parents: diff changeset	216 oop obj = NULL;
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	217 ObjArrayTask task;
0 a61af66fc99e Initial load duke parents: diff changeset	218 int random_seed = 17;
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	219 do {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	220 while (ParCompactionManager::steal_objarray(which, &random_seed, task)) {
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 7179 diff changeset	221 ObjArrayKlass* k = (ObjArrayKlass*)task.obj()->klass();
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	222 k->oop_follow_contents(cm, task.obj(), task.index());
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	223 cm->follow_marking_stacks();
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	224 }
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	225 while (ParCompactionManager::steal(which, &random_seed, obj)) {
0 a61af66fc99e Initial load duke parents: diff changeset	226 obj->follow_contents(cm);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	227 cm->follow_marking_stacks();
0 a61af66fc99e Initial load duke parents: diff changeset	228 }
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 1000 diff changeset	229 } while (!terminator()->offer_termination());
0 a61af66fc99e Initial load duke parents: diff changeset	230 }
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 //
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	233 // StealRegionCompactionTask
0 a61af66fc99e Initial load duke parents: diff changeset	234 //
a61af66fc99e Initial load duke parents: diff changeset	235
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	236 StealRegionCompactionTask::StealRegionCompactionTask(ParallelTaskTerminator* t):
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	237 _terminator(t) {}
0 a61af66fc99e Initial load duke parents: diff changeset	238
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	239 void StealRegionCompactionTask::do_it(GCTaskManager* manager, uint which) {
0 a61af66fc99e Initial load duke parents: diff changeset	240 assert(Universe::heap()->is_gc_active(), "called outside gc");
a61af66fc99e Initial load duke parents: diff changeset	241
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	242 NOT_PRODUCT(GCTraceTime tm("StealRegionCompactionTask",
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	243 PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
0 a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 ParCompactionManager* cm =
a61af66fc99e Initial load duke parents: diff changeset	246 ParCompactionManager::gc_thread_compaction_manager(which);
a61af66fc99e Initial load duke parents: diff changeset	247
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	248
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	249 // If not all threads are active, get a draining stack
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	250 // from the list. Else, just use this threads draining stack.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	251 uint which_stack_index;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	252 bool use_all_workers = manager->all_workers_active();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	253 if (use_all_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	254 which_stack_index = which;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	255 assert(manager->active_workers() == ParallelGCThreads,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	256 err_msg("all_workers_active has been incorrectly set: "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	257 " active %d ParallelGCThreads %d", manager->active_workers(),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	258 ParallelGCThreads));
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	259 } else {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	260 which_stack_index = ParCompactionManager::pop_recycled_stack_index();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	261 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	262
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	263 cm->set_region_stack_index(which_stack_index);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	264 cm->set_region_stack(ParCompactionManager::region_list(which_stack_index));
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	265 if (TraceDynamicGCThreads) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	266 gclog_or_tty->print_cr("StealRegionCompactionTask::do_it "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	267 "region_stack_index %d region_stack = 0x%x "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	268 " empty (%d) use all workers %d",
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	269 which_stack_index, ParCompactionManager::region_list(which_stack_index),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	270 cm->region_stack()->is_empty(),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	271 use_all_workers);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	272 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	273
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	274 // Has to drain stacks first because there may be regions on
0 a61af66fc99e Initial load duke parents: diff changeset	275 // preloaded onto the stack and this thread may never have
a61af66fc99e Initial load duke parents: diff changeset	276 // done a draining task. Are the draining tasks needed?
a61af66fc99e Initial load duke parents: diff changeset	277
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	278 cm->drain_region_stacks();
0 a61af66fc99e Initial load duke parents: diff changeset	279
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	280 size_t region_index = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	281 int random_seed = 17;
a61af66fc99e Initial load duke parents: diff changeset	282
a61af66fc99e Initial load duke parents: diff changeset	283 // If we're the termination task, try 10 rounds of stealing before
a61af66fc99e Initial load duke parents: diff changeset	284 // setting the termination flag
a61af66fc99e Initial load duke parents: diff changeset	285
a61af66fc99e Initial load duke parents: diff changeset	286 while(true) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	287 if (ParCompactionManager::steal(which, &random_seed, region_index)) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	288 PSParallelCompact::fill_and_update_region(cm, region_index);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	289 cm->drain_region_stacks();
0 a61af66fc99e Initial load duke parents: diff changeset	290 } else {
a61af66fc99e Initial load duke parents: diff changeset	291 if (terminator()->offer_termination()) {
a61af66fc99e Initial load duke parents: diff changeset	292 break;
a61af66fc99e Initial load duke parents: diff changeset	293 }
a61af66fc99e Initial load duke parents: diff changeset	294 // Go around again.
a61af66fc99e Initial load duke parents: diff changeset	295 }
a61af66fc99e Initial load duke parents: diff changeset	296 }
a61af66fc99e Initial load duke parents: diff changeset	297 return;
a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300 UpdateDensePrefixTask::UpdateDensePrefixTask(
a61af66fc99e Initial load duke parents: diff changeset	301 PSParallelCompact::SpaceId space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	302 size_t region_index_start,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	303 size_t region_index_end) :
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	304 _space_id(space_id), _region_index_start(region_index_start),
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	305 _region_index_end(region_index_end) {}
0 a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 void UpdateDensePrefixTask::do_it(GCTaskManager* manager, uint which) {
a61af66fc99e Initial load duke parents: diff changeset	308
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	309 NOT_PRODUCT(GCTraceTime tm("UpdateDensePrefixTask",
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	310 PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
0 a61af66fc99e Initial load duke parents: diff changeset	311
a61af66fc99e Initial load duke parents: diff changeset	312 ParCompactionManager* cm =
a61af66fc99e Initial load duke parents: diff changeset	313 ParCompactionManager::gc_thread_compaction_manager(which);
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 PSParallelCompact::update_and_deadwood_in_dense_prefix(cm,
a61af66fc99e Initial load duke parents: diff changeset	316 _space_id,
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	317 _region_index_start,
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	318 _region_index_end);
0 a61af66fc99e Initial load duke parents: diff changeset	319 }
a61af66fc99e Initial load duke parents: diff changeset	320
a61af66fc99e Initial load duke parents: diff changeset	321 void DrainStacksCompactionTask::do_it(GCTaskManager* manager, uint which) {
a61af66fc99e Initial load duke parents: diff changeset	322 assert(Universe::heap()->is_gc_active(), "called outside gc");
a61af66fc99e Initial load duke parents: diff changeset	323
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	324 NOT_PRODUCT(GCTraceTime tm("DrainStacksCompactionTask",
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10361 diff changeset	325 PrintGCDetails && TraceParallelOldGCTasks, true, NULL));
0 a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327 ParCompactionManager* cm =
a61af66fc99e Initial load duke parents: diff changeset	328 ParCompactionManager::gc_thread_compaction_manager(which);
a61af66fc99e Initial load duke parents: diff changeset	329
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	330 uint which_stack_index;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	331 bool use_all_workers = manager->all_workers_active();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	332 if (use_all_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	333 which_stack_index = which;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	334 assert(manager->active_workers() == ParallelGCThreads,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	335 err_msg("all_workers_active has been incorrectly set: "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	336 " active %d ParallelGCThreads %d", manager->active_workers(),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	337 ParallelGCThreads));
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	338 } else {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	339 which_stack_index = stack_index();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	340 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	341
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	342 cm->set_region_stack(ParCompactionManager::region_list(which_stack_index));
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	343 if (TraceDynamicGCThreads) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	344 gclog_or_tty->print_cr("DrainStacksCompactionTask::do_it which = %d "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	345 "which_stack_index = %d/empty(%d) "
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	346 "use all workers %d",
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	347 which, which_stack_index,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	348 cm->region_stack()->is_empty(),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	349 use_all_workers);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	350 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	351
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	352 cm->set_region_stack_index(which_stack_index);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	353
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	354 // Process any regions already in the compaction managers stacks.
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 196 diff changeset	355 cm->drain_region_stacks();
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	356
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	357 assert(cm->region_stack()->is_empty(), "Not empty");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	358
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	359 if (!use_all_workers) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	360 // Always give up the region stack.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	361 assert(cm->region_stack() ==
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	362 ParCompactionManager::region_list(cm->region_stack_index()),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	363 "region_stack and region_stack_index are inconsistent");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	364 ParCompactionManager::push_recycled_stack_index(cm->region_stack_index());
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	365
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	366 if (TraceDynamicGCThreads) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	367 void* old_region_stack = (void*) cm->region_stack();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	368 int old_region_stack_index = cm->region_stack_index();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	369 gclog_or_tty->print_cr("Pushing region stack 0x%x/%d",
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	370 old_region_stack, old_region_stack_index);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	371 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	372
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	373 cm->set_region_stack(NULL);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	374 cm->set_region_stack_index((uint)max_uintx);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3915 diff changeset	375 }
0 a61af66fc99e Initial load duke parents: diff changeset	376 }

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp @ 10405:f2110083203d