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

annotate src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp @ 6197:d2a62e0f25eb

6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain

author	zgu
date	Thu, 28 Jun 2012 17:03:16 -0400
parents	7913e93dca52
children	da91efe96a93

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
4099 7913e93dca52 7112997: Remove obsolete code ResetObjectsClosure and VerifyUpdateClosure jmasa parents: 4095 diff changeset	2 * Copyright (c) 2005, 2011, 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.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	36 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	37 #include "oops/oop.pcgc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	38 #include "utilities/stack.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 PSOldGen* ParCompactionManager::_old_gen = NULL;
a61af66fc99e Initial load duke parents: diff changeset	41 ParCompactionManager** ParCompactionManager::_manager_array = NULL;
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	42
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	43 RegionTaskQueue** ParCompactionManager::_region_list = NULL;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	44
0 a61af66fc99e Initial load duke parents: diff changeset	45 OopTaskQueueSet* ParCompactionManager::_stack_array = NULL;
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	46 ParCompactionManager::ObjArrayTaskQueueSet*
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	47 ParCompactionManager::_objarray_queues = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	48 ObjectStartArray* ParCompactionManager::_start_array = NULL;
a61af66fc99e Initial load duke parents: diff changeset	49 ParMarkBitMap* ParCompactionManager::_mark_bitmap = NULL;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	50 RegionTaskQueueSet* ParCompactionManager::_region_array = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	51
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	52 uint* ParCompactionManager::_recycled_stack_index = NULL;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	53 int ParCompactionManager::_recycled_top = -1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	54 int ParCompactionManager::_recycled_bottom = -1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	55
0 a61af66fc99e Initial load duke parents: diff changeset	56 ParCompactionManager::ParCompactionManager() :
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	57 _action(CopyAndUpdate),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	58 _region_stack(NULL),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	59 _region_stack_index((uint)max_uintx) {
0 a61af66fc99e Initial load duke parents: diff changeset	60
a61af66fc99e Initial load duke parents: diff changeset	61 ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
a61af66fc99e Initial load duke parents: diff changeset	62 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	63
a61af66fc99e Initial load duke parents: diff changeset	64 _old_gen = heap->old_gen();
a61af66fc99e Initial load duke parents: diff changeset	65 _start_array = old_gen()->start_array();
a61af66fc99e Initial load duke parents: diff changeset	66
a61af66fc99e Initial load duke parents: diff changeset	67 marking_stack()->initialize();
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	68 _objarray_stack.initialize();
4095 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
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	71 ParCompactionManager::~ParCompactionManager() {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	72 delete _recycled_stack_index;
0 a61af66fc99e Initial load duke parents: diff changeset	73 }
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
a61af66fc99e Initial load duke parents: diff changeset	76 assert(PSParallelCompact::gc_task_manager() != NULL,
a61af66fc99e Initial load duke parents: diff changeset	77 "Needed for initialization");
a61af66fc99e Initial load duke parents: diff changeset	78
a61af66fc99e Initial load duke parents: diff changeset	79 _mark_bitmap = mbm;
a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81 uint parallel_gc_threads = PSParallelCompact::gc_task_manager()->workers();
a61af66fc99e Initial load duke parents: diff changeset	82
a61af66fc99e Initial load duke parents: diff changeset	83 assert(_manager_array == NULL, "Attempt to initialize twice");
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	84 _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	85 guarantee(_manager_array != NULL, "Could not allocate manager_array");
0 a61af66fc99e Initial load duke parents: diff changeset	86
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	87 _region_list = NEW_C_HEAP_ARRAY(RegionTaskQueue*,
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	88 parallel_gc_threads+1, mtGC);
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	89 guarantee(_region_list != NULL, "Could not initialize promotion manager");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	90
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	91 _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	92
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	93 // 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	94 // compaction managers.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	95 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	96 _region_list[i] = new RegionTaskQueue();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	97 region_list(i)->initialize();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	98 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	99
0 a61af66fc99e Initial load duke parents: diff changeset	100 _stack_array = new OopTaskQueueSet(parallel_gc_threads);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	101 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	102 _objarray_queues = new ObjArrayTaskQueueSet(parallel_gc_threads);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	103 guarantee(_objarray_queues != NULL, "Could not allocate objarray_queues");
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	104 _region_array = new RegionTaskQueueSet(parallel_gc_threads);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	105 guarantee(_region_array != NULL, "Could not allocate region_array");
0 a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 // Create and register the ParCompactionManager(s) for the worker threads.
a61af66fc99e Initial load duke parents: diff changeset	108 for(uint i=0; i<parallel_gc_threads; i++) {
a61af66fc99e Initial load duke parents: diff changeset	109 _manager_array[i] = new ParCompactionManager();
a61af66fc99e Initial load duke parents: diff changeset	110 guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
a61af66fc99e Initial load duke parents: diff changeset	111 stack_array()->register_queue(i, _manager_array[i]->marking_stack());
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	112 _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	113 region_array()->register_queue(i, region_list(i));
0 a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115
a61af66fc99e Initial load duke parents: diff changeset	116 // The VMThread gets its own ParCompactionManager, which is not available
a61af66fc99e Initial load duke parents: diff changeset	117 // for work stealing.
a61af66fc99e Initial load duke parents: diff changeset	118 _manager_array[parallel_gc_threads] = new ParCompactionManager();
a61af66fc99e Initial load duke parents: diff changeset	119 guarantee(_manager_array[parallel_gc_threads] != NULL,
a61af66fc99e Initial load duke parents: diff changeset	120 "Could not create ParCompactionManager");
a61af66fc99e Initial load duke parents: diff changeset	121 assert(PSParallelCompact::gc_task_manager()->workers() != 0,
a61af66fc99e Initial load duke parents: diff changeset	122 "Not initialized?");
a61af66fc99e Initial load duke parents: diff changeset	123 }
a61af66fc99e Initial load duke parents: diff changeset	124
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	125 int ParCompactionManager::pop_recycled_stack_index() {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	126 assert(_recycled_bottom <= _recycled_top, "list is empty");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	127 // Get the next available index
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	128 if (_recycled_bottom < _recycled_top) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	129 uint cur, next, last;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	130 do {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	131 cur = _recycled_bottom;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	132 next = cur + 1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	133 last = Atomic::cmpxchg(next, &_recycled_bottom, cur);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	134 } while (cur != last);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	135 return _recycled_stack_index[next];
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	136 } else {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	137 return -1;
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
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	141 void ParCompactionManager::push_recycled_stack_index(uint v) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	142 // Get the next available index
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	143 int cur = Atomic::add(1, &_recycled_top);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	144 _recycled_stack_index[cur] = v;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	145 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	146 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	147
0 a61af66fc99e Initial load duke parents: diff changeset	148 bool ParCompactionManager::should_update() {
a61af66fc99e Initial load duke parents: diff changeset	149 assert(action() != NotValid, "Action is not set");
a61af66fc99e Initial load duke parents: diff changeset	150 return (action() == ParCompactionManager::Update) \|\|
a61af66fc99e Initial load duke parents: diff changeset	151 (action() == ParCompactionManager::CopyAndUpdate) \|\|
a61af66fc99e Initial load duke parents: diff changeset	152 (action() == ParCompactionManager::UpdateAndCopy);
a61af66fc99e Initial load duke parents: diff changeset	153 }
a61af66fc99e Initial load duke parents: diff changeset	154
a61af66fc99e Initial load duke parents: diff changeset	155 bool ParCompactionManager::should_copy() {
a61af66fc99e Initial load duke parents: diff changeset	156 assert(action() != NotValid, "Action is not set");
a61af66fc99e Initial load duke parents: diff changeset	157 return (action() == ParCompactionManager::Copy) \|\|
a61af66fc99e Initial load duke parents: diff changeset	158 (action() == ParCompactionManager::CopyAndUpdate) \|\|
a61af66fc99e Initial load duke parents: diff changeset	159 (action() == ParCompactionManager::UpdateAndCopy);
a61af66fc99e Initial load duke parents: diff changeset	160 }
a61af66fc99e Initial load duke parents: diff changeset	161
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	162 void ParCompactionManager::region_list_push(uint list_index,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	163 size_t region_index) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	164 region_list(list_index)->push(region_index);
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
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	167 void ParCompactionManager::verify_region_list_empty(uint list_index) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	168 assert(region_list(list_index)->is_empty(), "Not empty");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	169 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	170
0 a61af66fc99e Initial load duke parents: diff changeset	171 ParCompactionManager*
a61af66fc99e Initial load duke parents: diff changeset	172 ParCompactionManager::gc_thread_compaction_manager(int index) {
a61af66fc99e Initial load duke parents: diff changeset	173 assert(index >= 0 && index < (int)ParallelGCThreads, "index out of range");
a61af66fc99e Initial load duke parents: diff changeset	174 assert(_manager_array != NULL, "Sanity");
a61af66fc99e Initial load duke parents: diff changeset	175 return _manager_array[index];
a61af66fc99e Initial load duke parents: diff changeset	176 }
a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 void ParCompactionManager::reset() {
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1638 diff changeset	179 for(uint i = 0; i < ParallelGCThreads + 1; i++) {
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1638 diff changeset	180 assert(manager_array(i)->revisit_klass_stack()->is_empty(), "sanity");
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1638 diff changeset	181 assert(manager_array(i)->revisit_mdo_stack()->is_empty(), "sanity");
0 a61af66fc99e Initial load duke parents: diff changeset	182 }
a61af66fc99e Initial load duke parents: diff changeset	183 }
a61af66fc99e Initial load duke parents: diff changeset	184
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	185 void ParCompactionManager::follow_marking_stacks() {
0 a61af66fc99e Initial load duke parents: diff changeset	186 do {
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	187 // 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	188 oop obj;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	189 while (marking_stack()->pop_overflow(obj)) {
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	190 obj->follow_contents(this);
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	191 }
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	192 while (marking_stack()->pop_local(obj)) {
0 a61af66fc99e Initial load duke parents: diff changeset	193 obj->follow_contents(this);
a61af66fc99e Initial load duke parents: diff changeset	194 }
a61af66fc99e Initial load duke parents: diff changeset	195
1315 c385bf94cfb8 6935839: excessive marking stack growth during full gcs jcoomes parents: 1311 diff changeset	196 // 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	197 ObjArrayTask task;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	198 if (_objarray_stack.pop_overflow(task)) {
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	199 objArrayKlass* const k = (objArrayKlass*)task.obj()->blueprint();
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	200 k->oop_follow_contents(this, task.obj(), task.index());
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	201 } else if (_objarray_stack.pop_local(task)) {
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	202 objArrayKlass* const k = (objArrayKlass*)task.obj()->blueprint();
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	203 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	204 }
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	205 } while (!marking_stacks_empty());
0 a61af66fc99e Initial load duke parents: diff changeset	206
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	207 assert(marking_stacks_empty(), "Sanity");
0 a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	210 void ParCompactionManager::drain_region_stacks() {
0 a61af66fc99e Initial load duke parents: diff changeset	211 do {
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	212 // Drain overflow stack first so other threads can steal.
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	213 size_t region_index;
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	214 while (region_stack()->pop_overflow(region_index)) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	215 PSParallelCompact::fill_and_update_region(this, region_index);
0 a61af66fc99e Initial load duke parents: diff changeset	216 }
a61af66fc99e Initial load duke parents: diff changeset	217
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	218 while (region_stack()->pop_local(region_index)) {
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	219 PSParallelCompact::fill_and_update_region(this, region_index);
0 a61af66fc99e Initial load duke parents: diff changeset	220 }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	221 } while (!region_stack()->is_empty());
0 a61af66fc99e Initial load duke parents: diff changeset	222 }

Mercurial > hg > graal-compiler

annotate src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp @ 6197:d2a62e0f25eb