truffle: src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp annotate

annotate src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	d2a62e0f25eb
children

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: 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 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	28 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	29 #include "utilities/stack.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	30 #include "utilities/taskqueue.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	31
0 a61af66fc99e Initial load duke parents: diff changeset	32 // Move to some global location
a61af66fc99e Initial load duke parents: diff changeset	33 #define HAS_BEEN_MOVED 0x1501d01d
a61af66fc99e Initial load duke parents: diff changeset	34 // End move to some global location
a61af66fc99e Initial load duke parents: diff changeset	35
a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 class MutableSpace;
a61af66fc99e Initial load duke parents: diff changeset	38 class PSOldGen;
a61af66fc99e Initial load duke parents: diff changeset	39 class ParCompactionManager;
a61af66fc99e Initial load duke parents: diff changeset	40 class ObjectStartArray;
a61af66fc99e Initial load duke parents: diff changeset	41 class ParallelCompactData;
a61af66fc99e Initial load duke parents: diff changeset	42 class ParMarkBitMap;
a61af66fc99e Initial load duke parents: diff changeset	43
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	44 class ParCompactionManager : public CHeapObj<mtGC> {
0 a61af66fc99e Initial load duke parents: diff changeset	45 friend class ParallelTaskTerminator;
a61af66fc99e Initial load duke parents: diff changeset	46 friend class ParMarkBitMap;
a61af66fc99e Initial load duke parents: diff changeset	47 friend class PSParallelCompact;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	48 friend class StealRegionCompactionTask;
0 a61af66fc99e Initial load duke parents: diff changeset	49 friend class UpdateAndFillClosure;
a61af66fc99e Initial load duke parents: diff changeset	50 friend class RefProcTaskExecutor;
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	51 friend class IdleGCTask;
0 a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 public:
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 // ------------------------ Don't putback if not needed
a61af66fc99e Initial load duke parents: diff changeset	56 // Actions that the compaction manager should take.
a61af66fc99e Initial load duke parents: diff changeset	57 enum Action {
a61af66fc99e Initial load duke parents: diff changeset	58 Update,
a61af66fc99e Initial load duke parents: diff changeset	59 Copy,
a61af66fc99e Initial load duke parents: diff changeset	60 UpdateAndCopy,
a61af66fc99e Initial load duke parents: diff changeset	61 CopyAndUpdate,
a61af66fc99e Initial load duke parents: diff changeset	62 NotValid
a61af66fc99e Initial load duke parents: diff changeset	63 };
a61af66fc99e Initial load duke parents: diff changeset	64 // ------------------------ End don't putback if not needed
a61af66fc99e Initial load duke parents: diff changeset	65
a61af66fc99e Initial load duke parents: diff changeset	66 private:
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	67 // 32-bit: 4K * 8 = 32KiB; 64-bit: 8K * 16 = 128KiB
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	68 #define QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13))
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	69 typedef OverflowTaskQueue<ObjArrayTask, mtGC, QUEUE_SIZE> ObjArrayTaskQueue;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	70 typedef GenericTaskQueueSet<ObjArrayTaskQueue, mtGC> ObjArrayTaskQueueSet;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	71 #undef QUEUE_SIZE
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	72
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	73 static ParCompactionManager** _manager_array;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	74 static OopTaskQueueSet* _stack_array;
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	75 static ObjArrayTaskQueueSet* _objarray_queues;
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	76 static ObjectStartArray* _start_array;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	77 static RegionTaskQueueSet* _region_array;
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	78 static PSOldGen* _old_gen;
0 a61af66fc99e Initial load duke parents: diff changeset	79
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	80 private:
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	81 OverflowTaskQueue<oop, mtGC> _marking_stack;
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	82 ObjArrayTaskQueue _objarray_stack;
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	83
0 a61af66fc99e Initial load duke parents: diff changeset	84 // Is there a way to reuse the _marking_stack for the
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	85 // saving empty regions? For now just create a different
0 a61af66fc99e Initial load duke parents: diff changeset	86 // type of TaskQueue.
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	87 RegionTaskQueue* _region_stack;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	88
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	89 static RegionTaskQueue** _region_list;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	90 // Index in _region_list for current _region_stack.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	91 uint _region_stack_index;
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 // Indexes of recycled region stacks/overflow stacks
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	94 // Stacks of regions to be compacted are embedded in the tasks doing
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	95 // the compaction. A thread that executes the task extracts the
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	96 // region stack and drains it. These threads keep these region
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	97 // stacks for use during compaction task stealing. If a thread
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	98 // gets a second draining task, it pushed its current region stack
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	99 // index into the array _recycled_stack_index and gets a new
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	100 // region stack from the task. A thread that is executing a
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	101 // compaction stealing task without ever having executing a
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	102 // draining task, will get a region stack from _recycled_stack_index.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	103 //
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	104 // Array of indexes into the array of region stacks.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	105 static uint* _recycled_stack_index;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	106 // The index into _recycled_stack_index of the last region stack index
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	107 // pushed. If -1, there are no entries into _recycled_stack_index.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	108 static int _recycled_top;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	109 // The index into _recycled_stack_index of the last region stack index
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	110 // popped. If -1, there has not been any entry popped.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	111 static int _recycled_bottom;
0 a61af66fc99e Initial load duke parents: diff changeset	112
a61af66fc99e Initial load duke parents: diff changeset	113 static ParMarkBitMap* _mark_bitmap;
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 Action _action;
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 static PSOldGen* old_gen() { return _old_gen; }
a61af66fc99e Initial load duke parents: diff changeset	118 static ObjectStartArray* start_array() { return _start_array; }
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	119 static OopTaskQueueSet* stack_array() { return _stack_array; }
0 a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 static void initialize(ParMarkBitMap* mbm);
a61af66fc99e Initial load duke parents: diff changeset	122
a61af66fc99e Initial load duke parents: diff changeset	123 protected:
a61af66fc99e Initial load duke parents: diff changeset	124 // Array of tasks. Needed by the ParallelTaskTerminator.
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	125 static RegionTaskQueueSet* region_array() { return _region_array; }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4099 diff changeset	126 OverflowTaskQueue<oop, mtGC>* marking_stack() { return &_marking_stack; }
0 a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 // Pushes onto the marking stack. If the marking stack is full,
a61af66fc99e Initial load duke parents: diff changeset	129 // pushes onto the overflow stack.
a61af66fc99e Initial load duke parents: diff changeset	130 void stack_push(oop obj);
a61af66fc99e Initial load duke parents: diff changeset	131 // Do not implement an equivalent stack_pop. Deal with the
a61af66fc99e Initial load duke parents: diff changeset	132 // marking stack and overflow stack directly.
a61af66fc99e Initial load duke parents: diff changeset	133
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	134 public:
0 a61af66fc99e Initial load duke parents: diff changeset	135 Action action() { return _action; }
a61af66fc99e Initial load duke parents: diff changeset	136 void set_action(Action v) { _action = v; }
a61af66fc99e Initial load duke parents: diff changeset	137
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	138 RegionTaskQueue* region_stack() { return _region_stack; }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	139 void set_region_stack(RegionTaskQueue* v) { _region_stack = v; }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	140
0 a61af66fc99e Initial load duke parents: diff changeset	141 inline static ParCompactionManager* manager_array(int index);
a61af66fc99e Initial load duke parents: diff changeset	142
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	143 inline static RegionTaskQueue* region_list(int index) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	144 return _region_list[index];
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
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	147 uint region_stack_index() { return _region_stack_index; }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	148 void set_region_stack_index(uint v) { _region_stack_index = v; }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	149
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	150 // Pop and push unique reusable stack index
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	151 static int pop_recycled_stack_index();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	152 static void push_recycled_stack_index(uint v);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	153 static void reset_recycled_stack_index() {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	154 _recycled_bottom = _recycled_top = -1;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	155 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	156
0 a61af66fc99e Initial load duke parents: diff changeset	157 ParCompactionManager();
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	158 ~ParCompactionManager();
0 a61af66fc99e Initial load duke parents: diff changeset	159
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	160 // Pushes onto the region stack at the given index. If the
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	161 // region stack is full,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	162 // pushes onto the region overflow stack.
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	163 static void region_list_push(uint stack_index, size_t region_index);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 1972 diff changeset	164 static void verify_region_list_empty(uint stack_index);
0 a61af66fc99e Initial load duke parents: diff changeset	165 ParMarkBitMap* mark_bitmap() { return _mark_bitmap; }
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 // void drain_stacks();
a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169 bool should_update();
a61af66fc99e Initial load duke parents: diff changeset	170 bool should_copy();
a61af66fc99e Initial load duke parents: diff changeset	171
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	172 // Save for later processing. Must not fail.
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	173 inline void push(oop obj) { _marking_stack.push(obj); }
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	174 inline void push_objarray(oop objarray, size_t index);
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	175 inline void push_region(size_t index);
0 a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 // Access function for compaction managers
a61af66fc99e Initial load duke parents: diff changeset	178 static ParCompactionManager* gc_thread_compaction_manager(int index);
a61af66fc99e Initial load duke parents: diff changeset	179
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	180 static bool steal(int queue_num, int* seed, oop& t) {
0 a61af66fc99e Initial load duke parents: diff changeset	181 return stack_array()->steal(queue_num, seed, t);
a61af66fc99e Initial load duke parents: diff changeset	182 }
a61af66fc99e Initial load duke parents: diff changeset	183
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	184 static bool steal_objarray(int queue_num, int* seed, ObjArrayTask& t) {
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	185 return _objarray_queues->steal(queue_num, seed, t);
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	186 }
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	187
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	188 static bool steal(int queue_num, int* seed, size_t& region) {
b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	189 return region_array()->steal(queue_num, seed, region);
0 a61af66fc99e Initial load duke parents: diff changeset	190 }
a61af66fc99e Initial load duke parents: diff changeset	191
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	192 // Process tasks remaining on any marking stack
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	193 void follow_marking_stacks();
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	194 inline bool marking_stacks_empty() const;
0 a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 // Process tasks remaining on any stack
375 81cd571500b0 6725697: par compact - rename class ChunkData to RegionData jcoomes parents: 0 diff changeset	197 void drain_region_stacks();
0 a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 };
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 inline ParCompactionManager* ParCompactionManager::manager_array(int index) {
a61af66fc99e Initial load duke parents: diff changeset	202 assert(_manager_array != NULL, "access of NULL manager_array");
a61af66fc99e Initial load duke parents: diff changeset	203 assert(index >= 0 && index <= (int)ParallelGCThreads,
a61af66fc99e Initial load duke parents: diff changeset	204 "out of range manager_array access");
a61af66fc99e Initial load duke parents: diff changeset	205 return _manager_array[index];
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
2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	208 bool ParCompactionManager::marking_stacks_empty() const {
1638 b2a00dd3117c 6957084: simplify TaskQueue overflow handling jcoomes parents: 1552 diff changeset	209 return _marking_stack.is_empty() && _objarray_stack.is_empty();
1311 2a1472c30599 4396719: Mark Sweep stack overflow on deeply nested Object arrays jcoomes parents: 948 diff changeset	210 }
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	211
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	212 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp @ 6725:da91efe96a93