Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/parNew/parNewGeneration.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 | a30e7b564541 |
children | f2110083203d |
rev | line source |
---|---|
0 | 1 /* |
6595 | 2 * Copyright (c) 2001, 2012, 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:
1145
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1145
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:
1145
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARNEW_PARNEWGENERATION_HPP |
26 #define SHARE_VM_GC_IMPLEMENTATION_PARNEW_PARNEWGENERATION_HPP | |
27 | |
6595 | 28 #include "gc_implementation/shared/parGCAllocBuffer.hpp" |
1972 | 29 #include "memory/defNewGeneration.hpp" |
30 #include "utilities/taskqueue.hpp" | |
31 | |
0 | 32 class ChunkArray; |
33 class ParScanWithoutBarrierClosure; | |
34 class ParScanWithBarrierClosure; | |
35 class ParRootScanWithoutBarrierClosure; | |
36 class ParRootScanWithBarrierTwoGensClosure; | |
37 class ParEvacuateFollowersClosure; | |
38 | |
39 // It would be better if these types could be kept local to the .cpp file, | |
40 // but they must be here to allow ParScanClosure::do_oop_work to be defined | |
41 // in genOopClosures.inline.hpp. | |
42 | |
1665 | 43 typedef Padded<OopTaskQueue> ObjToScanQueue; |
6197 | 44 typedef GenericTaskQueueSet<ObjToScanQueue, mtGC> ObjToScanQueueSet; |
0 | 45 |
46 class ParKeepAliveClosure: public DefNewGeneration::KeepAliveClosure { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
47 private: |
0 | 48 ParScanWeakRefClosure* _par_cl; |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
49 protected: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
50 template <class T> void do_oop_work(T* p); |
0 | 51 public: |
52 ParKeepAliveClosure(ParScanWeakRefClosure* cl); | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
53 virtual void do_oop(oop* p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
54 virtual void do_oop(narrowOop* p); |
0 | 55 }; |
56 | |
57 // The state needed by thread performing parallel young-gen collection. | |
58 class ParScanThreadState { | |
59 friend class ParScanThreadStateSet; | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
60 private: |
0 | 61 ObjToScanQueue *_work_queue; |
6197 | 62 Stack<oop, mtGC>* const _overflow_stack; |
0 | 63 |
64 ParGCAllocBuffer _to_space_alloc_buffer; | |
65 | |
66 ParScanWithoutBarrierClosure _to_space_closure; // scan_without_gc_barrier | |
67 ParScanWithBarrierClosure _old_gen_closure; // scan_with_gc_barrier | |
68 ParRootScanWithoutBarrierClosure _to_space_root_closure; // scan_root_without_gc_barrier | |
69 // One of these two will be passed to process_strong_roots, which will | |
70 // set its generation. The first is for two-gen configs where the | |
71 // old gen collects the perm gen; the second is for arbitrary configs. | |
72 // The second isn't used right now (it used to be used for the train, an | |
73 // incremental collector) but the declaration has been left as a reminder. | |
74 ParRootScanWithBarrierTwoGensClosure _older_gen_closure; | |
75 // This closure will always be bound to the old gen; it will be used | |
76 // in evacuate_followers. | |
77 ParRootScanWithBarrierTwoGensClosure _old_gen_root_closure; // scan_old_root_with_gc_barrier | |
78 ParEvacuateFollowersClosure _evacuate_followers; | |
79 DefNewGeneration::IsAliveClosure _is_alive_closure; | |
80 ParScanWeakRefClosure _scan_weak_ref_closure; | |
81 ParKeepAliveClosure _keep_alive_closure; | |
82 | |
83 | |
84 Space* _to_space; | |
85 Space* to_space() { return _to_space; } | |
86 | |
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
87 ParNewGeneration* _young_gen; |
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
88 ParNewGeneration* young_gen() const { return _young_gen; } |
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
89 |
0 | 90 Generation* _old_gen; |
91 Generation* old_gen() { return _old_gen; } | |
92 | |
93 HeapWord *_young_old_boundary; | |
94 | |
95 int _hash_seed; | |
96 int _thread_num; | |
97 ageTable _ageTable; | |
98 | |
99 bool _to_space_full; | |
100 | |
1710 | 101 #if TASKQUEUE_STATS |
102 size_t _term_attempts; | |
103 size_t _overflow_refills; | |
104 size_t _overflow_refill_objs; | |
105 #endif // TASKQUEUE_STATS | |
0 | 106 |
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
107 // Stats for promotion failure |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
108 size_t _promotion_failure_size; |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
109 |
0 | 110 // Timing numbers. |
111 double _start; | |
112 double _start_strong_roots; | |
113 double _strong_roots_time; | |
114 double _start_term; | |
115 double _term_time; | |
116 | |
117 // Helper for trim_queues. Scans subset of an array and makes | |
118 // remainder available for work stealing. | |
119 void scan_partial_array_and_push_remainder(oop obj); | |
120 | |
121 // In support of CMS' parallel rescan of survivor space. | |
122 ChunkArray* _survivor_chunk_array; | |
123 ChunkArray* survivor_chunk_array() { return _survivor_chunk_array; } | |
124 | |
125 void record_survivor_plab(HeapWord* plab_start, size_t plab_word_size); | |
126 | |
127 ParScanThreadState(Space* to_space_, ParNewGeneration* gen_, | |
128 Generation* old_gen_, int thread_num_, | |
695 | 129 ObjToScanQueueSet* work_queue_set_, |
6197 | 130 Stack<oop, mtGC>* overflow_stacks_, |
695 | 131 size_t desired_plab_sz_, |
0 | 132 ParallelTaskTerminator& term_); |
133 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
134 public: |
0 | 135 ageTable* age_table() {return &_ageTable;} |
136 | |
137 ObjToScanQueue* work_queue() { return _work_queue; } | |
138 | |
139 ParGCAllocBuffer* to_space_alloc_buffer() { | |
140 return &_to_space_alloc_buffer; | |
141 } | |
142 | |
143 ParEvacuateFollowersClosure& evacuate_followers_closure() { return _evacuate_followers; } | |
144 DefNewGeneration::IsAliveClosure& is_alive_closure() { return _is_alive_closure; } | |
145 ParScanWeakRefClosure& scan_weak_ref_closure() { return _scan_weak_ref_closure; } | |
146 ParKeepAliveClosure& keep_alive_closure() { return _keep_alive_closure; } | |
147 ParScanClosure& older_gen_closure() { return _older_gen_closure; } | |
148 ParRootScanWithoutBarrierClosure& to_space_root_closure() { return _to_space_root_closure; }; | |
149 | |
150 // Decrease queue size below "max_size". | |
151 void trim_queues(int max_size); | |
152 | |
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
153 // Private overflow stack usage |
6197 | 154 Stack<oop, mtGC>* overflow_stack() { return _overflow_stack; } |
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
155 bool take_from_overflow_stack(); |
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
156 void push_on_overflow_stack(oop p); |
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
157 |
0 | 158 // Is new_obj a candidate for scan_partial_array_and_push_remainder method. |
159 inline bool should_be_partially_scanned(oop new_obj, oop old_obj) const; | |
160 | |
161 int* hash_seed() { return &_hash_seed; } | |
162 int thread_num() { return _thread_num; } | |
163 | |
164 // Allocate a to-space block of size "sz", or else return NULL. | |
165 HeapWord* alloc_in_to_space_slow(size_t word_sz); | |
166 | |
167 HeapWord* alloc_in_to_space(size_t word_sz) { | |
168 HeapWord* obj = to_space_alloc_buffer()->allocate(word_sz); | |
169 if (obj != NULL) return obj; | |
170 else return alloc_in_to_space_slow(word_sz); | |
171 } | |
172 | |
173 HeapWord* young_old_boundary() { return _young_old_boundary; } | |
174 | |
175 void set_young_old_boundary(HeapWord *boundary) { | |
176 _young_old_boundary = boundary; | |
177 } | |
178 | |
179 // Undo the most recent allocation ("obj", of "word_sz"). | |
180 void undo_alloc_in_to_space(HeapWord* obj, size_t word_sz); | |
181 | |
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
182 // Promotion failure stats |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
183 size_t promotion_failure_size() { return promotion_failure_size(); } |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
184 void log_promotion_failure(size_t sz) { |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
185 if (_promotion_failure_size == 0) { |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
186 _promotion_failure_size = sz; |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
187 } |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
188 } |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
189 void print_and_clear_promotion_failure_size(); |
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
695
diff
changeset
|
190 |
1710 | 191 #if TASKQUEUE_STATS |
192 TaskQueueStats & taskqueue_stats() const { return _work_queue->stats; } | |
193 | |
194 size_t term_attempts() const { return _term_attempts; } | |
195 size_t overflow_refills() const { return _overflow_refills; } | |
196 size_t overflow_refill_objs() const { return _overflow_refill_objs; } | |
0 | 197 |
1710 | 198 void note_term_attempt() { ++_term_attempts; } |
199 void note_overflow_refill(size_t objs) { | |
200 ++_overflow_refills; _overflow_refill_objs += objs; | |
0 | 201 } |
202 | |
1710 | 203 void reset_stats(); |
204 #endif // TASKQUEUE_STATS | |
205 | |
0 | 206 void start_strong_roots() { |
207 _start_strong_roots = os::elapsedTime(); | |
208 } | |
209 void end_strong_roots() { | |
210 _strong_roots_time += (os::elapsedTime() - _start_strong_roots); | |
211 } | |
1710 | 212 double strong_roots_time() const { return _strong_roots_time; } |
0 | 213 void start_term_time() { |
1710 | 214 TASKQUEUE_STATS_ONLY(note_term_attempt()); |
0 | 215 _start_term = os::elapsedTime(); |
216 } | |
217 void end_term_time() { | |
218 _term_time += (os::elapsedTime() - _start_term); | |
219 } | |
1710 | 220 double term_time() const { return _term_time; } |
0 | 221 |
1710 | 222 double elapsed_time() const { |
0 | 223 return os::elapsedTime() - _start; |
224 } | |
225 }; | |
226 | |
227 class ParNewGenTask: public AbstractGangTask { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
228 private: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
229 ParNewGeneration* _gen; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
230 Generation* _next_gen; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
231 HeapWord* _young_old_boundary; |
0 | 232 class ParScanThreadStateSet* _state_set; |
233 | |
234 public: | |
235 ParNewGenTask(ParNewGeneration* gen, | |
236 Generation* next_gen, | |
237 HeapWord* young_old_boundary, | |
238 ParScanThreadStateSet* state_set); | |
239 | |
240 HeapWord* young_old_boundary() { return _young_old_boundary; } | |
241 | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
242 void work(uint worker_id); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
1972
diff
changeset
|
243 |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
1972
diff
changeset
|
244 // Reset the terminator in ParScanThreadStateSet for |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
1972
diff
changeset
|
245 // "active_workers" threads. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
1972
diff
changeset
|
246 virtual void set_for_termination(int active_workers); |
0 | 247 }; |
248 | |
249 class KeepAliveClosure: public DefNewGeneration::KeepAliveClosure { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
250 protected: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
251 template <class T> void do_oop_work(T* p); |
0 | 252 public: |
253 KeepAliveClosure(ScanWeakRefClosure* cl); | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
254 virtual void do_oop(oop* p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
255 virtual void do_oop(narrowOop* p); |
0 | 256 }; |
257 | |
258 class EvacuateFollowersClosureGeneral: public VoidClosure { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
259 private: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
260 GenCollectedHeap* _gch; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
261 int _level; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
262 OopsInGenClosure* _scan_cur_or_nonheap; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
263 OopsInGenClosure* _scan_older; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
264 public: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
265 EvacuateFollowersClosureGeneral(GenCollectedHeap* gch, int level, |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
266 OopsInGenClosure* cur, |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
267 OopsInGenClosure* older); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
268 virtual void do_void(); |
0 | 269 }; |
270 | |
271 // Closure for scanning ParNewGeneration. | |
272 // Same as ScanClosure, except does parallel GC barrier. | |
273 class ScanClosureWithParBarrier: public ScanClosure { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
274 protected: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
275 template <class T> void do_oop_work(T* p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
276 public: |
0 | 277 ScanClosureWithParBarrier(ParNewGeneration* g, bool gc_barrier); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
278 virtual void do_oop(oop* p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
279 virtual void do_oop(narrowOop* p); |
0 | 280 }; |
281 | |
282 // Implements AbstractRefProcTaskExecutor for ParNew. | |
283 class ParNewRefProcTaskExecutor: public AbstractRefProcTaskExecutor { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
284 private: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
285 ParNewGeneration& _generation; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
286 ParScanThreadStateSet& _state_set; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
287 public: |
0 | 288 ParNewRefProcTaskExecutor(ParNewGeneration& generation, |
289 ParScanThreadStateSet& state_set) | |
290 : _generation(generation), _state_set(state_set) | |
291 { } | |
292 | |
293 // Executes a task using worker threads. | |
294 virtual void execute(ProcessTask& task); | |
295 virtual void execute(EnqueueTask& task); | |
296 // Switch to single threaded mode. | |
297 virtual void set_single_threaded_mode(); | |
298 }; | |
299 | |
300 | |
301 // A Generation that does parallel young-gen collection. | |
302 | |
303 class ParNewGeneration: public DefNewGeneration { | |
304 friend class ParNewGenTask; | |
305 friend class ParNewRefProcTask; | |
306 friend class ParNewRefProcTaskExecutor; | |
307 friend class ParScanThreadStateSet; | |
534 | 308 friend class ParEvacuateFollowersClosure; |
0 | 309 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
310 private: |
695 | 311 // The per-worker-thread work queues |
0 | 312 ObjToScanQueueSet* _task_queues; |
313 | |
695 | 314 // Per-worker-thread local overflow stacks |
6197 | 315 Stack<oop, mtGC>* _overflow_stacks; |
695 | 316 |
0 | 317 // Desired size of survivor space plab's |
318 PLABStats _plab_stats; | |
319 | |
320 // A list of from-space images of to-be-scanned objects, threaded through | |
321 // klass-pointers (klass information already copied to the forwarded | |
322 // image.) Manipulated with CAS. | |
323 oop _overflow_list; | |
534 | 324 NOT_PRODUCT(ssize_t _num_par_pushes;) |
0 | 325 |
326 // If true, older generation does not support promotion undo, so avoid. | |
327 static bool _avoid_promotion_undo; | |
328 | |
329 // This closure is used by the reference processor to filter out | |
330 // references to live referent. | |
331 DefNewGeneration::IsAliveClosure _is_alive_closure; | |
332 | |
333 static oop real_forwardee_slow(oop obj); | |
334 static void waste_some_time(); | |
335 | |
336 // Preserve the mark of "obj", if necessary, in preparation for its mark | |
337 // word being overwritten with a self-forwarding-pointer. | |
338 void preserve_mark_if_necessary(oop obj, markOop m); | |
339 | |
340 protected: | |
341 | |
342 bool _survivor_overflow; | |
343 | |
344 bool avoid_promotion_undo() { return _avoid_promotion_undo; } | |
345 void set_avoid_promotion_undo(bool v) { _avoid_promotion_undo = v; } | |
346 | |
347 bool survivor_overflow() { return _survivor_overflow; } | |
348 void set_survivor_overflow(bool v) { _survivor_overflow = v; } | |
349 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
350 public: |
0 | 351 ParNewGeneration(ReservedSpace rs, size_t initial_byte_size, int level); |
352 | |
353 ~ParNewGeneration() { | |
354 for (uint i = 0; i < ParallelGCThreads; i++) | |
355 delete _task_queues->queue(i); | |
356 | |
357 delete _task_queues; | |
358 } | |
359 | |
360 virtual void ref_processor_init(); | |
361 virtual Generation::Name kind() { return Generation::ParNew; } | |
362 virtual const char* name() const; | |
363 virtual const char* short_name() const { return "ParNew"; } | |
364 | |
365 // override | |
366 virtual bool refs_discovery_is_mt() const { | |
367 assert(UseParNewGC, "ParNewGeneration only when UseParNewGC"); | |
368 return ParallelGCThreads > 1; | |
369 } | |
370 | |
371 // Make the collection virtual. | |
372 virtual void collect(bool full, | |
373 bool clear_all_soft_refs, | |
374 size_t size, | |
375 bool is_tlab); | |
376 | |
377 // This needs to be visible to the closure function. | |
378 // "obj" is the object to be copied, "m" is a recent value of its mark | |
379 // that must not contain a forwarding pointer (though one might be | |
380 // inserted in "obj"s mark word by a parallel thread). | |
381 inline oop copy_to_survivor_space(ParScanThreadState* par_scan_state, | |
382 oop obj, size_t obj_sz, markOop m) { | |
383 if (_avoid_promotion_undo) { | |
384 return copy_to_survivor_space_avoiding_promotion_undo(par_scan_state, | |
385 obj, obj_sz, m); | |
386 } | |
387 | |
388 return copy_to_survivor_space_with_undo(par_scan_state, obj, obj_sz, m); | |
389 } | |
390 | |
391 oop copy_to_survivor_space_avoiding_promotion_undo(ParScanThreadState* par_scan_state, | |
392 oop obj, size_t obj_sz, markOop m); | |
393 | |
394 oop copy_to_survivor_space_with_undo(ParScanThreadState* par_scan_state, | |
395 oop obj, size_t obj_sz, markOop m); | |
396 | |
534 | 397 // in support of testing overflow code |
398 NOT_PRODUCT(int _overflow_counter;) | |
399 NOT_PRODUCT(bool should_simulate_overflow();) | |
400 | |
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
401 // Accessor for overflow list |
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
402 oop overflow_list() { return _overflow_list; } |
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
403 |
0 | 404 // Push the given (from-space) object on the global overflow list. |
534 | 405 void push_on_overflow_list(oop from_space_obj, ParScanThreadState* par_scan_state); |
0 | 406 |
407 // If the global overflow list is non-empty, move some tasks from it | |
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
408 // onto "work_q" (which need not be empty). No more than 1/4 of the |
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
409 // available space on "work_q" is used. |
0 | 410 bool take_from_overflow_list(ParScanThreadState* par_scan_state); |
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
411 bool take_from_overflow_list_work(ParScanThreadState* par_scan_state); |
0 | 412 |
413 // The task queues to be used by parallel GC threads. | |
414 ObjToScanQueueSet* task_queues() { | |
415 return _task_queues; | |
416 } | |
417 | |
418 PLABStats* plab_stats() { | |
419 return &_plab_stats; | |
420 } | |
421 | |
422 size_t desired_plab_sz() { | |
423 return _plab_stats.desired_plab_sz(); | |
424 } | |
425 | |
426 static oop real_forwardee(oop obj); | |
427 | |
428 DEBUG_ONLY(static bool is_legal_forward_ptr(oop p);) | |
429 }; | |
1972 | 430 |
431 #endif // SHARE_VM_GC_IMPLEMENTATION_PARNEW_PARNEWGENERATION_HPP |