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