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

annotate src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.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	d8ce2825b193
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: 6197 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: 1315 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1315 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: 1315 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 "gc_implementation/parallelScavenge/gcTaskManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	28 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	29 #include "gc_implementation/parallelScavenge/parMarkBitMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	30 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	31 #include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	32 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	33 #include "gc_implementation/parallelScavenge/psParallelCompact.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 "utilities/stack.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	38
a61af66fc99e Initial load duke parents: diff changeset	39 PSOldGen* ParCompactionManager::_old_gen = NULL;
a61af66fc99e Initial load duke parents: diff changeset	40 ParCompactionManager** ParCompactionManager::_manager_array = NULL;
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	41
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	42 RegionTaskQueue** ParCompactionManager::_region_list = NULL;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	43
0 a61af66fc99e Initial load duke parents: diff changeset	44 OopTaskQueueSet* ParCompactionManager::_stack_array = NULL;
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	45 ParCompactionManager::ObjArrayTaskQueueSet*
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	46 ParCompactionManager::_objarray_queues = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	47 ObjectStartArray* ParCompactionManager::_start_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	48 ParMarkBitMap* ParCompactionManager::_mark_bitmap = NULL;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	49 RegionTaskQueueSet* ParCompactionManager::_region_array = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	50
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	51 uint* ParCompactionManager::_recycled_stack_index = NULL;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	52 int ParCompactionManager::_recycled_top = -1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	53 int ParCompactionManager::_recycled_bottom = -1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	54
0 a61af66fc99e Initial load duke parents: diff changeset	55 ParCompactionManager::ParCompactionManager() :
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	56 _action(CopyAndUpdate),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	57 _region_stack(NULL),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	58 _region_stack_index((uint)max_uintx) {
0 a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
a61af66fc99e Initial load duke parents: diff changeset	61 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	62
a61af66fc99e Initial load duke parents: diff changeset	63 _old_gen = heap->old_gen();
a61af66fc99e Initial load duke parents: diff changeset	64 _start_array = old_gen()->start_array();
a61af66fc99e Initial load duke parents: diff changeset	65
a61af66fc99e Initial load duke parents: diff changeset	66 marking_stack()->initialize();
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	67 _objarray_stack.initialize();
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	68 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	69
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	70 ParCompactionManager::~ParCompactionManager() {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	71 delete _recycled_stack_index;
0 a61af66fc99e Initial load duke parents: diff changeset	72 }
a61af66fc99e Initial load duke parents: diff changeset	73
a61af66fc99e Initial load duke parents: diff changeset	74 void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
a61af66fc99e Initial load duke parents: diff changeset	75 assert(PSParallelCompact::gc_task_manager() != NULL,
a61af66fc99e Initial load duke parents: diff changeset	76 "Needed for initialization");
a61af66fc99e Initial load duke parents: diff changeset	77
a61af66fc99e Initial load duke parents: diff changeset	78 _mark_bitmap = mbm;
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 uint parallel_gc_threads = PSParallelCompact::gc_task_manager()->workers();
a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82 assert(_manager_array == NULL, "Attempt to initialize twice");
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	83 _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads+1, mtGC);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	84 guarantee(_manager_array != NULL, "Could not allocate manager_array");
0 a61af66fc99e Initial load duke parents: diff changeset	85
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	86 _region_list = NEW_C_HEAP_ARRAY(RegionTaskQueue*,
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	87 parallel_gc_threads+1, mtGC);
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	88 guarantee(_region_list != NULL, "Could not initialize promotion manager");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	89
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	90 _recycled_stack_index = NEW_C_HEAP_ARRAY(uint, parallel_gc_threads, mtGC);
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	91
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	92 // parallel_gc-threads + 1 to be consistent with the number of
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	93 // compaction managers.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	94 for(uint i=0; i<parallel_gc_threads + 1; i++) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	95 _region_list[i] = new RegionTaskQueue();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	96 region_list(i)->initialize();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	97 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	98
0 a61af66fc99e Initial load duke parents: diff changeset	99 _stack_array = new OopTaskQueueSet(parallel_gc_threads);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	100 guarantee(_stack_array != NULL, "Could not allocate stack_array");
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	101 _objarray_queues = new ObjArrayTaskQueueSet(parallel_gc_threads);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	102 guarantee(_objarray_queues != NULL, "Could not allocate objarray_queues");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	103 _region_array = new RegionTaskQueueSet(parallel_gc_threads);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	104 guarantee(_region_array != NULL, "Could not allocate region_array");
0 a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106 // Create and register the ParCompactionManager(s) for the worker threads.
a61af66fc99e Initial load duke parents: diff changeset	107 for(uint i=0; i<parallel_gc_threads; i++) {
a61af66fc99e Initial load duke parents: diff changeset	108 _manager_array[i] = new ParCompactionManager();
a61af66fc99e Initial load duke parents: diff changeset	109 guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
a61af66fc99e Initial load duke parents: diff changeset	110 stack_array()->register_queue(i, _manager_array[i]->marking_stack());
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	111 _objarray_queues->register_queue(i, &_manager_array[i]->_objarray_stack);
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	112 region_array()->register_queue(i, region_list(i));
0 a61af66fc99e Initial load duke parents: diff changeset	113 }
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 // The VMThread gets its own ParCompactionManager, which is not available
a61af66fc99e Initial load duke parents: diff changeset	116 // for work stealing.
a61af66fc99e Initial load duke parents: diff changeset	117 _manager_array[parallel_gc_threads] = new ParCompactionManager();
a61af66fc99e Initial load duke parents: diff changeset	118 guarantee(_manager_array[parallel_gc_threads] != NULL,
a61af66fc99e Initial load duke parents: diff changeset	119 "Could not create ParCompactionManager");
a61af66fc99e Initial load duke parents: diff changeset	120 assert(PSParallelCompact::gc_task_manager()->workers() != 0,
a61af66fc99e Initial load duke parents: diff changeset	121 "Not initialized?");
a61af66fc99e Initial load duke parents: diff changeset	122 }
a61af66fc99e Initial load duke parents: diff changeset	123
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	124 int ParCompactionManager::pop_recycled_stack_index() {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	125 assert(_recycled_bottom <= _recycled_top, "list is empty");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	126 // Get the next available index
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	127 if (_recycled_bottom < _recycled_top) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	128 uint cur, next, last;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	129 do {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	130 cur = _recycled_bottom;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	131 next = cur + 1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	132 last = Atomic::cmpxchg(next, &_recycled_bottom, cur);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	133 } while (cur != last);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	134 return _recycled_stack_index[next];
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	135 } else {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	136 return -1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	137 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	138 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	139
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	140 void ParCompactionManager::push_recycled_stack_index(uint v) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	141 // Get the next available index
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	142 int cur = Atomic::add(1, &_recycled_top);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	143 _recycled_stack_index[cur] = v;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	144 assert(_recycled_bottom <= _recycled_top, "list top and bottom are wrong");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	145 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	146
0 a61af66fc99e Initial load duke parents: diff changeset	147 bool ParCompactionManager::should_update() {
a61af66fc99e Initial load duke parents: diff changeset	148 assert(action() != NotValid, "Action is not set");
a61af66fc99e Initial load duke parents: diff changeset	149 return (action() == ParCompactionManager::Update) \|\|
a61af66fc99e Initial load duke parents: diff changeset	150 (action() == ParCompactionManager::CopyAndUpdate) \|\|
a61af66fc99e Initial load duke parents: diff changeset	151 (action() == ParCompactionManager::UpdateAndCopy);
a61af66fc99e Initial load duke parents: diff changeset	152 }
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 bool ParCompactionManager::should_copy() {
a61af66fc99e Initial load duke parents: diff changeset	155 assert(action() != NotValid, "Action is not set");
a61af66fc99e Initial load duke parents: diff changeset	156 return (action() == ParCompactionManager::Copy) \|\|
a61af66fc99e Initial load duke parents: diff changeset	157 (action() == ParCompactionManager::CopyAndUpdate) \|\|
a61af66fc99e Initial load duke parents: diff changeset	158 (action() == ParCompactionManager::UpdateAndCopy);
a61af66fc99e Initial load duke parents: diff changeset	159 }
a61af66fc99e Initial load duke parents: diff changeset	160
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	161 void ParCompactionManager::region_list_push(uint list_index,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	162 size_t region_index) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	163 region_list(list_index)->push(region_index);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	164 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	165
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	166 void ParCompactionManager::verify_region_list_empty(uint list_index) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	167 assert(region_list(list_index)->is_empty(), "Not empty");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	168 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	169
0 a61af66fc99e Initial load duke parents: diff changeset	170 ParCompactionManager*
a61af66fc99e Initial load duke parents: diff changeset	171 ParCompactionManager::gc_thread_compaction_manager(int index) {
a61af66fc99e Initial load duke parents: diff changeset	172 assert(index >= 0 && index < (int)ParallelGCThreads, "index out of range");
a61af66fc99e Initial load duke parents: diff changeset	173 assert(_manager_array != NULL, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	174 return _manager_array[index];
a61af66fc99e Initial load duke parents: diff changeset	175 }
a61af66fc99e Initial load duke parents: diff changeset	176
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	177 void ParCompactionManager::follow_marking_stacks() {
0 a61af66fc99e Initial load duke parents: diff changeset	178 do {
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	179 // Drain the overflow stack first, to allow stealing from the marking stack.
1315 c385bf94cfb8 6935839: excessive marking stack growth during full gcs jcoomes parents: 1311 diff changeset	180 oop obj;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	181 while (marking_stack()->pop_overflow(obj)) {
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	182 obj->follow_contents(this);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	183 }
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	184 while (marking_stack()->pop_local(obj)) {
0 a61af66fc99e Initial load duke parents: diff changeset	185 obj->follow_contents(this);
a61af66fc99e Initial load duke parents: diff changeset	186 }
a61af66fc99e Initial load duke parents: diff changeset	187
1315 c385bf94cfb8 6935839: excessive marking stack growth during full gcs jcoomes parents: 1311 diff changeset	188 // Process ObjArrays one at a time to avoid marking stack bloat.
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	189 ObjArrayTask task;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	190 if (_objarray_stack.pop_overflow(task)) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	191 ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	192 k->oop_follow_contents(this, task.obj(), task.index());
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	193 } else if (_objarray_stack.pop_local(task)) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	194 ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	195 k->oop_follow_contents(this, task.obj(), task.index());
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	196 }
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	197 } while (!marking_stacks_empty());
0 a61af66fc99e Initial load duke parents: diff changeset	198
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	199 assert(marking_stacks_empty(), "Sanity");
0 a61af66fc99e Initial load duke parents: diff changeset	200 }
a61af66fc99e Initial load duke parents: diff changeset	201
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	202 void ParCompactionManager::drain_region_stacks() {
0 a61af66fc99e Initial load duke parents: diff changeset	203 do {
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	204 // Drain overflow stack first so other threads can steal.
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	205 size_t region_index;
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	206 while (region_stack()->pop_overflow(region_index)) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	207 PSParallelCompact::fill_and_update_region(this, region_index);
0 a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	210 while (region_stack()->pop_local(region_index)) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	211 PSParallelCompact::fill_and_update_region(this, region_index);
0 a61af66fc99e Initial load duke parents: diff changeset	212 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	213 } while (!region_stack()->is_empty());
0 a61af66fc99e Initial load duke parents: diff changeset	214 }

Mercurial > hg > graal-compiler

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