Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp @ 2149:7e37af9d69ef
7011379: G1: overly long concurrent marking cycles
Summary: This changeset introduces filtering of SATB buffers at the point when they are about to be enqueued. If this filtering clears enough entries on each buffer, the buffer can then be re-used and not enqueued. This cuts down the number of SATB buffers that need to be processed by the concurrent marking threads.
Reviewed-by: johnc, ysr
| author | tonyp |
|---|---|
| date | Wed, 19 Jan 2011 09:35:17 -0500 |
| parents | f95d63e2154a |
| children | bca17e38de00 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1638 | 2 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "utilities/stack.hpp" | |
| 30 #include "utilities/taskqueue.hpp" | |
| 31 | |
| 0 | 32 // Move to some global location |
| 33 #define HAS_BEEN_MOVED 0x1501d01d | |
| 34 // End move to some global location | |
| 35 | |
| 36 | |
| 37 class MutableSpace; | |
| 38 class PSOldGen; | |
| 39 class ParCompactionManager; | |
| 40 class ObjectStartArray; | |
| 41 class ParallelCompactData; | |
| 42 class ParMarkBitMap; | |
| 43 | |
| 44 class ParCompactionManager : public CHeapObj { | |
| 45 friend class ParallelTaskTerminator; | |
| 46 friend class ParMarkBitMap; | |
| 47 friend class PSParallelCompact; | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
48 friend class StealRegionCompactionTask; |
| 0 | 49 friend class UpdateAndFillClosure; |
| 50 friend class RefProcTaskExecutor; | |
| 51 | |
| 52 public: | |
| 53 | |
| 54 // ------------------------ Don't putback if not needed | |
| 55 // Actions that the compaction manager should take. | |
| 56 enum Action { | |
| 57 Update, | |
| 58 Copy, | |
| 59 UpdateAndCopy, | |
| 60 CopyAndUpdate, | |
| 61 VerifyUpdate, | |
| 62 ResetObjects, | |
| 63 NotValid | |
| 64 }; | |
| 65 // ------------------------ End don't putback if not needed | |
| 66 | |
| 67 private: | |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
68 // 32-bit: 4K * 8 = 32KiB; 64-bit: 8K * 16 = 128KiB |
| 1638 | 69 #define QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13)) |
| 70 typedef OverflowTaskQueue<ObjArrayTask, QUEUE_SIZE> ObjArrayTaskQueue; | |
| 71 typedef GenericTaskQueueSet<ObjArrayTaskQueue> ObjArrayTaskQueueSet; | |
| 72 #undef QUEUE_SIZE | |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
73 |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
74 static ParCompactionManager** _manager_array; |
|
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
75 static OopTaskQueueSet* _stack_array; |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
76 static ObjArrayTaskQueueSet* _objarray_queues; |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
77 static ObjectStartArray* _start_array; |
|
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
78 static RegionTaskQueueSet* _region_array; |
|
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
79 static PSOldGen* _old_gen; |
| 0 | 80 |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
81 private: |
| 1638 | 82 OverflowTaskQueue<oop> _marking_stack; |
| 83 ObjArrayTaskQueue _objarray_stack; | |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
84 |
| 0 | 85 // 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
|
86 // saving empty regions? For now just create a different |
| 0 | 87 // type of TaskQueue. |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
88 RegionTaskQueue _region_stack; |
| 0 | 89 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1638
diff
changeset
|
90 Stack<Klass*> _revisit_klass_stack; |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1638
diff
changeset
|
91 Stack<DataLayout*> _revisit_mdo_stack; |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1638
diff
changeset
|
92 |
| 0 | 93 static ParMarkBitMap* _mark_bitmap; |
| 94 | |
| 95 Action _action; | |
| 96 | |
| 97 static PSOldGen* old_gen() { return _old_gen; } | |
| 98 static ObjectStartArray* start_array() { return _start_array; } | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
99 static OopTaskQueueSet* stack_array() { return _stack_array; } |
| 0 | 100 |
| 101 static void initialize(ParMarkBitMap* mbm); | |
| 102 | |
| 103 protected: | |
| 104 // Array of tasks. Needed by the ParallelTaskTerminator. | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
105 static RegionTaskQueueSet* region_array() { return _region_array; } |
| 1638 | 106 OverflowTaskQueue<oop>* marking_stack() { return &_marking_stack; } |
| 107 RegionTaskQueue* region_stack() { return &_region_stack; } | |
| 0 | 108 |
| 109 // Pushes onto the marking stack. If the marking stack is full, | |
| 110 // pushes onto the overflow stack. | |
| 111 void stack_push(oop obj); | |
| 112 // Do not implement an equivalent stack_pop. Deal with the | |
| 113 // marking stack and overflow stack directly. | |
| 114 | |
| 1638 | 115 public: |
| 0 | 116 Action action() { return _action; } |
| 117 void set_action(Action v) { _action = v; } | |
| 118 | |
| 119 inline static ParCompactionManager* manager_array(int index); | |
| 120 | |
| 121 ParCompactionManager(); | |
| 122 | |
| 123 ParMarkBitMap* mark_bitmap() { return _mark_bitmap; } | |
| 124 | |
| 125 // Take actions in preparation for a compaction. | |
| 126 static void reset(); | |
| 127 | |
| 128 // void drain_stacks(); | |
| 129 | |
| 130 bool should_update(); | |
| 131 bool should_copy(); | |
| 132 bool should_verify_only(); | |
| 133 bool should_reset_only(); | |
| 134 | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1638
diff
changeset
|
135 Stack<Klass*>* revisit_klass_stack() { return &_revisit_klass_stack; } |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1638
diff
changeset
|
136 Stack<DataLayout*>* revisit_mdo_stack() { return &_revisit_mdo_stack; } |
| 0 | 137 |
| 1638 | 138 // Save for later processing. Must not fail. |
| 139 inline void push(oop obj) { _marking_stack.push(obj); } | |
| 140 inline void push_objarray(oop objarray, size_t index); | |
| 141 inline void push_region(size_t index); | |
| 0 | 142 |
| 143 // Access function for compaction managers | |
| 144 static ParCompactionManager* gc_thread_compaction_manager(int index); | |
| 145 | |
| 1638 | 146 static bool steal(int queue_num, int* seed, oop& t) { |
| 0 | 147 return stack_array()->steal(queue_num, seed, t); |
| 148 } | |
| 149 | |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
150 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
|
151 return _objarray_queues->steal(queue_num, seed, t); |
|
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
152 } |
|
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
153 |
| 1638 | 154 static bool steal(int queue_num, int* seed, size_t& region) { |
| 155 return region_array()->steal(queue_num, seed, region); | |
| 0 | 156 } |
| 157 | |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
158 // Process tasks remaining on any marking stack |
|
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
159 void follow_marking_stacks(); |
|
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
160 inline bool marking_stacks_empty() const; |
| 0 | 161 |
| 162 // Process tasks remaining on any stack | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
163 void drain_region_stacks(); |
| 0 | 164 |
| 165 }; | |
| 166 | |
| 167 inline ParCompactionManager* ParCompactionManager::manager_array(int index) { | |
| 168 assert(_manager_array != NULL, "access of NULL manager_array"); | |
| 169 assert(index >= 0 && index <= (int)ParallelGCThreads, | |
| 170 "out of range manager_array access"); | |
| 171 return _manager_array[index]; | |
| 172 } | |
|
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
173 |
|
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
948
diff
changeset
|
174 bool ParCompactionManager::marking_stacks_empty() const { |
| 1638 | 175 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
|
176 } |
| 1972 | 177 |
| 178 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP |