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

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

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

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	d0aa87f04bd5
children	92ef81e2f571

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

Mercurial > hg > graal-compiler

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