Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp @ 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 | c2bf0120ee5d |
| children | eda078b01c65 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2177
diff
changeset
|
2 * Copyright (c) 2005, 2011, 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:
989
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
989
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:
989
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PCTASKS_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PCTASKS_HPP | |
| 27 | |
| 28 #include "gc_implementation/parallelScavenge/gcTaskManager.hpp" | |
| 29 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp" | |
| 30 #include "gc_implementation/parallelScavenge/psTasks.hpp" | |
| 31 | |
| 0 | 32 |
| 33 // Tasks for parallel compaction of the old generation | |
| 34 // | |
| 35 // Tasks are created and enqueued on a task queue. The | |
| 36 // tasks for parallel old collector for marking objects | |
| 37 // are MarkFromRootsTask and ThreadRootsMarkingTask. | |
| 38 // | |
| 39 // MarkFromRootsTask's are created | |
| 40 // with a root group (e.g., jni_handles) and when the do_it() | |
| 41 // method of a MarkFromRootsTask is executed, it starts marking | |
| 42 // form it's root group. | |
| 43 // | |
| 44 // ThreadRootsMarkingTask's are created for each Java thread. When | |
| 45 // the do_it() method of a ThreadRootsMarkingTask is executed, it | |
| 46 // starts marking from the thread's roots. | |
| 47 // | |
| 48 // The enqueuing of the MarkFromRootsTask and ThreadRootsMarkingTask | |
| 49 // do little more than create the task and put it on a queue. The | |
| 50 // queue is a GCTaskQueue and threads steal tasks from this GCTaskQueue. | |
| 51 // | |
| 52 // In addition to the MarkFromRootsTask and ThreadRootsMarkingTask | |
| 53 // tasks there are StealMarkingTask tasks. The StealMarkingTask's | |
| 54 // steal a reference from the marking stack of another | |
| 55 // thread and transitively marks the object of the reference | |
| 56 // and internal references. After successfully stealing a reference | |
| 57 // and marking it, the StealMarkingTask drains its marking stack | |
| 58 // stack before attempting another steal. | |
| 59 // | |
| 60 // ThreadRootsMarkingTask | |
| 61 // | |
| 62 // This task marks from the roots of a single thread. This task | |
| 63 // enables marking of thread roots in parallel. | |
| 64 // | |
| 65 | |
| 66 class ParallelTaskTerminator; | |
| 67 | |
| 68 class ThreadRootsMarkingTask : public GCTask { | |
| 69 private: | |
| 70 JavaThread* _java_thread; | |
| 71 VMThread* _vm_thread; | |
| 72 public: | |
| 73 ThreadRootsMarkingTask(JavaThread* root) : _java_thread(root), _vm_thread(NULL) {} | |
| 74 ThreadRootsMarkingTask(VMThread* root) : _java_thread(NULL), _vm_thread(root) {} | |
| 75 | |
| 76 char* name() { return (char *)"thread-roots-marking-task"; } | |
| 77 | |
| 78 virtual void do_it(GCTaskManager* manager, uint which); | |
| 79 }; | |
| 80 | |
| 81 | |
| 82 // | |
| 83 // MarkFromRootsTask | |
| 84 // | |
| 85 // This task marks from all the roots to all live | |
| 86 // objects. | |
| 87 // | |
| 88 // | |
| 89 | |
| 90 class MarkFromRootsTask : public GCTask { | |
| 91 public: | |
| 92 enum RootType { | |
| 93 universe = 1, | |
| 94 jni_handles = 2, | |
| 95 threads = 3, | |
| 96 object_synchronizer = 4, | |
| 97 flat_profiler = 5, | |
| 98 management = 6, | |
| 99 jvmti = 7, | |
| 100 system_dictionary = 8, | |
|
3915
c2bf0120ee5d
7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents:
2426
diff
changeset
|
101 code_cache = 9 |
| 0 | 102 }; |
| 103 private: | |
| 104 RootType _root_type; | |
| 105 public: | |
| 106 MarkFromRootsTask(RootType value) : _root_type(value) {} | |
| 107 | |
| 108 char* name() { return (char *)"mark-from-roots-task"; } | |
| 109 | |
| 110 virtual void do_it(GCTaskManager* manager, uint which); | |
| 111 }; | |
| 112 | |
| 113 // | |
| 114 // RefProcTaskProxy | |
| 115 // | |
| 116 // This task is used as a proxy to parallel reference processing tasks . | |
| 117 // | |
| 118 | |
| 119 class RefProcTaskProxy : public GCTask { | |
| 120 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; | |
| 121 ProcessTask & _rp_task; | |
| 122 uint _work_id; | |
| 123 public: | |
| 124 RefProcTaskProxy(ProcessTask & rp_task, uint work_id) | |
| 125 : _rp_task(rp_task), | |
| 126 _work_id(work_id) | |
| 127 { } | |
| 128 | |
| 129 private: | |
| 130 virtual char* name() { return (char *)"Process referents by policy in parallel"; } | |
| 131 | |
| 132 virtual void do_it(GCTaskManager* manager, uint which); | |
| 133 }; | |
| 134 | |
| 135 | |
| 136 | |
| 137 // | |
| 138 // RefEnqueueTaskProxy | |
| 139 // | |
| 140 // This task is used as a proxy to parallel reference processing tasks . | |
| 141 // | |
| 142 | |
| 143 class RefEnqueueTaskProxy: public GCTask { | |
| 144 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; | |
| 145 EnqueueTask& _enq_task; | |
| 146 uint _work_id; | |
| 147 | |
| 148 public: | |
| 149 RefEnqueueTaskProxy(EnqueueTask& enq_task, uint work_id) | |
| 150 : _enq_task(enq_task), | |
| 151 _work_id(work_id) | |
| 152 { } | |
| 153 | |
| 154 virtual char* name() { return (char *)"Enqueue reference objects in parallel"; } | |
| 155 virtual void do_it(GCTaskManager* manager, uint which) | |
| 156 { | |
| 157 _enq_task.work(_work_id); | |
| 158 } | |
| 159 }; | |
| 160 | |
| 161 | |
| 162 // | |
| 163 // RefProcTaskExecutor | |
| 164 // | |
| 165 // Task executor is an interface for the reference processor to run | |
| 166 // tasks using GCTaskManager. | |
| 167 // | |
| 168 | |
| 169 class RefProcTaskExecutor: public AbstractRefProcTaskExecutor { | |
| 170 virtual void execute(ProcessTask& task); | |
| 171 virtual void execute(EnqueueTask& task); | |
| 172 }; | |
| 173 | |
| 174 | |
| 175 // | |
| 176 // StealMarkingTask | |
| 177 // | |
| 178 // This task is used to distribute work to idle threads. | |
| 179 // | |
| 180 | |
| 181 class StealMarkingTask : public GCTask { | |
| 182 private: | |
| 183 ParallelTaskTerminator* const _terminator; | |
| 184 private: | |
| 185 | |
| 186 public: | |
| 187 char* name() { return (char *)"steal-marking-task"; } | |
| 188 | |
| 189 StealMarkingTask(ParallelTaskTerminator* t); | |
| 190 | |
| 191 ParallelTaskTerminator* terminator() { return _terminator; } | |
| 192 | |
| 193 virtual void do_it(GCTaskManager* manager, uint which); | |
| 194 }; | |
| 195 | |
| 196 // | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
197 // StealRegionCompactionTask |
| 0 | 198 // |
| 199 // This task is used to distribute work to idle threads. | |
| 200 // | |
| 201 | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
202 class StealRegionCompactionTask : public GCTask { |
| 0 | 203 private: |
| 204 ParallelTaskTerminator* const _terminator; | |
| 205 public: | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
206 StealRegionCompactionTask(ParallelTaskTerminator* t); |
| 0 | 207 |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
208 char* name() { return (char *)"steal-region-task"; } |
| 0 | 209 ParallelTaskTerminator* terminator() { return _terminator; } |
| 210 | |
| 211 virtual void do_it(GCTaskManager* manager, uint which); | |
| 212 }; | |
| 213 | |
| 214 // | |
| 215 // UpdateDensePrefixTask | |
| 216 // | |
| 217 // This task is used to update the dense prefix | |
| 218 // of a space. | |
| 219 // | |
| 220 | |
| 221 class UpdateDensePrefixTask : public GCTask { | |
| 222 private: | |
| 223 PSParallelCompact::SpaceId _space_id; | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
224 size_t _region_index_start; |
|
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
225 size_t _region_index_end; |
| 0 | 226 |
| 227 public: | |
| 228 char* name() { return (char *)"update-dense_prefix-task"; } | |
| 229 | |
| 230 UpdateDensePrefixTask(PSParallelCompact::SpaceId space_id, | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
231 size_t region_index_start, |
|
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
232 size_t region_index_end); |
| 0 | 233 |
| 234 virtual void do_it(GCTaskManager* manager, uint which); | |
| 235 }; | |
| 236 | |
| 237 // | |
| 238 // DrainStacksCompactionTask | |
| 239 // | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
240 // This task processes regions that have been added to the stacks of each |
| 0 | 241 // compaction manager. |
| 242 // | |
| 243 // Trying to use one draining thread does not work because there are no | |
| 244 // guarantees about which task will be picked up by which thread. For example, | |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
245 // if thread A gets all the preloaded regions, thread A may not get a draining |
| 0 | 246 // task (they may all be done by other threads). |
| 247 // | |
| 248 | |
| 249 class DrainStacksCompactionTask : public GCTask { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
250 uint _stack_index; |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
251 uint stack_index() { return _stack_index; } |
| 0 | 252 public: |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
253 DrainStacksCompactionTask(uint stack_index) : GCTask(), |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
254 _stack_index(stack_index) {}; |
|
375
81cd571500b0
6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents:
0
diff
changeset
|
255 char* name() { return (char *)"drain-region-task"; } |
| 0 | 256 virtual void do_it(GCTaskManager* manager, uint which); |
| 257 }; | |
| 1972 | 258 |
| 259 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PCTASKS_HPP |