Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/parNew/parNewGeneration.hpp @ 3762:5c0a3c1858b1
7048782: CMS: assert(last_chunk_index_to_check<= last_chunk_index) failed: parCardTableModRefBS.cpp:359
Summary: The LNC array is sized before the start of a scavenge, while the heap may expand during a scavenge. With CMS, the last block of an arbitrary suffice of the LNC array may expand due to coalition with the expansion delta. We now take care not to attempt access past the end of the LNC array. LNC array code will be cleaned up and suitably encapsulated as part of the forthcoming performance RFE 7043675.
Reviewed-by: brutisso
| author | ysr |
|---|---|
| date | Thu, 02 Jun 2011 10:23:36 -0700 |
| parents | f95d63e2154a |
| children | bca17e38de00 |
| 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 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARNEW_PARNEWGENERATION_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_PARNEW_PARNEWGENERATION_HPP | |
| 27 | |
| 28 #include "gc_implementation/parNew/parGCAllocBuffer.hpp" | |
| 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; |
| 44 typedef GenericTaskQueueSet<ObjToScanQueue> 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; |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
62 Stack<oop>* 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_, |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
130 Stack<oop>* 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 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
154 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
|
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 | |
| 242 void work(int i); | |
| 243 }; | |
| 244 | |
| 245 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
|
246 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
247 template <class T> void do_oop_work(T* p); |
| 0 | 248 public: |
| 249 KeepAliveClosure(ScanWeakRefClosure* cl); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
250 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
|
251 virtual void do_oop(narrowOop* p); |
| 0 | 252 }; |
| 253 | |
| 254 class EvacuateFollowersClosureGeneral: public VoidClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
255 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
256 GenCollectedHeap* _gch; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
257 int _level; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
258 OopsInGenClosure* _scan_cur_or_nonheap; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
259 OopsInGenClosure* _scan_older; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
260 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
261 EvacuateFollowersClosureGeneral(GenCollectedHeap* gch, int level, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
262 OopsInGenClosure* cur, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
263 OopsInGenClosure* older); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
264 virtual void do_void(); |
| 0 | 265 }; |
| 266 | |
| 267 // Closure for scanning ParNewGeneration. | |
| 268 // Same as ScanClosure, except does parallel GC barrier. | |
| 269 class ScanClosureWithParBarrier: public ScanClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
270 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
271 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
|
272 public: |
| 0 | 273 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
|
274 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
|
275 virtual void do_oop(narrowOop* p); |
| 0 | 276 }; |
| 277 | |
| 278 // Implements AbstractRefProcTaskExecutor for ParNew. | |
| 279 class ParNewRefProcTaskExecutor: public AbstractRefProcTaskExecutor { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
280 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
281 ParNewGeneration& _generation; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
282 ParScanThreadStateSet& _state_set; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
283 public: |
| 0 | 284 ParNewRefProcTaskExecutor(ParNewGeneration& generation, |
| 285 ParScanThreadStateSet& state_set) | |
| 286 : _generation(generation), _state_set(state_set) | |
| 287 { } | |
| 288 | |
| 289 // Executes a task using worker threads. | |
| 290 virtual void execute(ProcessTask& task); | |
| 291 virtual void execute(EnqueueTask& task); | |
| 292 // Switch to single threaded mode. | |
| 293 virtual void set_single_threaded_mode(); | |
| 294 }; | |
| 295 | |
| 296 | |
| 297 // A Generation that does parallel young-gen collection. | |
| 298 | |
| 299 class ParNewGeneration: public DefNewGeneration { | |
| 300 friend class ParNewGenTask; | |
| 301 friend class ParNewRefProcTask; | |
| 302 friend class ParNewRefProcTaskExecutor; | |
| 303 friend class ParScanThreadStateSet; | |
| 534 | 304 friend class ParEvacuateFollowersClosure; |
| 0 | 305 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
306 private: |
| 695 | 307 // The per-worker-thread work queues |
| 0 | 308 ObjToScanQueueSet* _task_queues; |
| 309 | |
| 695 | 310 // Per-worker-thread local overflow stacks |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1833
diff
changeset
|
311 Stack<oop>* _overflow_stacks; |
| 695 | 312 |
| 0 | 313 // Desired size of survivor space plab's |
| 314 PLABStats _plab_stats; | |
| 315 | |
| 316 // A list of from-space images of to-be-scanned objects, threaded through | |
| 317 // klass-pointers (klass information already copied to the forwarded | |
| 318 // image.) Manipulated with CAS. | |
| 319 oop _overflow_list; | |
| 534 | 320 NOT_PRODUCT(ssize_t _num_par_pushes;) |
| 0 | 321 |
| 322 // If true, older generation does not support promotion undo, so avoid. | |
| 323 static bool _avoid_promotion_undo; | |
| 324 | |
| 325 // This closure is used by the reference processor to filter out | |
| 326 // references to live referent. | |
| 327 DefNewGeneration::IsAliveClosure _is_alive_closure; | |
| 328 | |
| 329 static oop real_forwardee_slow(oop obj); | |
| 330 static void waste_some_time(); | |
| 331 | |
| 332 // Preserve the mark of "obj", if necessary, in preparation for its mark | |
| 333 // word being overwritten with a self-forwarding-pointer. | |
| 334 void preserve_mark_if_necessary(oop obj, markOop m); | |
| 335 | |
| 336 protected: | |
| 337 | |
| 338 bool _survivor_overflow; | |
| 339 | |
| 340 bool avoid_promotion_undo() { return _avoid_promotion_undo; } | |
| 341 void set_avoid_promotion_undo(bool v) { _avoid_promotion_undo = v; } | |
| 342 | |
| 343 bool survivor_overflow() { return _survivor_overflow; } | |
| 344 void set_survivor_overflow(bool v) { _survivor_overflow = v; } | |
| 345 | |
| 346 // Adjust the tenuring threshold. See the implementation for | |
| 347 // the details of the policy. | |
| 348 virtual void adjust_desired_tenuring_threshold(); | |
| 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 | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1710
diff
changeset
|
360 static bool in_use(); |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1710
diff
changeset
|
361 |
| 0 | 362 virtual void ref_processor_init(); |
| 363 virtual Generation::Name kind() { return Generation::ParNew; } | |
| 364 virtual const char* name() const; | |
| 365 virtual const char* short_name() const { return "ParNew"; } | |
| 366 | |
| 367 // override | |
| 368 virtual bool refs_discovery_is_mt() const { | |
| 369 assert(UseParNewGC, "ParNewGeneration only when UseParNewGC"); | |
| 370 return ParallelGCThreads > 1; | |
| 371 } | |
| 372 | |
| 373 // Make the collection virtual. | |
| 374 virtual void collect(bool full, | |
| 375 bool clear_all_soft_refs, | |
| 376 size_t size, | |
| 377 bool is_tlab); | |
| 378 | |
| 379 // This needs to be visible to the closure function. | |
| 380 // "obj" is the object to be copied, "m" is a recent value of its mark | |
| 381 // that must not contain a forwarding pointer (though one might be | |
| 382 // inserted in "obj"s mark word by a parallel thread). | |
| 383 inline oop copy_to_survivor_space(ParScanThreadState* par_scan_state, | |
| 384 oop obj, size_t obj_sz, markOop m) { | |
| 385 if (_avoid_promotion_undo) { | |
| 386 return copy_to_survivor_space_avoiding_promotion_undo(par_scan_state, | |
| 387 obj, obj_sz, m); | |
| 388 } | |
| 389 | |
| 390 return copy_to_survivor_space_with_undo(par_scan_state, obj, obj_sz, m); | |
| 391 } | |
| 392 | |
| 393 oop copy_to_survivor_space_avoiding_promotion_undo(ParScanThreadState* par_scan_state, | |
| 394 oop obj, size_t obj_sz, markOop m); | |
| 395 | |
| 396 oop copy_to_survivor_space_with_undo(ParScanThreadState* par_scan_state, | |
| 397 oop obj, size_t obj_sz, markOop m); | |
| 398 | |
| 534 | 399 // in support of testing overflow code |
| 400 NOT_PRODUCT(int _overflow_counter;) | |
| 401 NOT_PRODUCT(bool should_simulate_overflow();) | |
| 402 | |
|
679
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
403 // Accessor for overflow list |
|
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
404 oop overflow_list() { return _overflow_list; } |
|
cea947c8a988
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
579
diff
changeset
|
405 |
| 0 | 406 // Push the given (from-space) object on the global overflow list. |
| 534 | 407 void push_on_overflow_list(oop from_space_obj, ParScanThreadState* par_scan_state); |
| 0 | 408 |
| 409 // 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
|
410 // 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
|
411 // available space on "work_q" is used. |
| 0 | 412 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
|
413 bool take_from_overflow_list_work(ParScanThreadState* par_scan_state); |
| 0 | 414 |
| 415 // The task queues to be used by parallel GC threads. | |
| 416 ObjToScanQueueSet* task_queues() { | |
| 417 return _task_queues; | |
| 418 } | |
| 419 | |
| 420 PLABStats* plab_stats() { | |
| 421 return &_plab_stats; | |
| 422 } | |
| 423 | |
| 424 size_t desired_plab_sz() { | |
| 425 return _plab_stats.desired_plab_sz(); | |
| 426 } | |
| 427 | |
| 428 static oop real_forwardee(oop obj); | |
| 429 | |
| 430 DEBUG_ONLY(static bool is_legal_forward_ptr(oop p);) | |
| 431 }; | |
| 1972 | 432 |
| 433 #endif // SHARE_VM_GC_IMPLEMENTATION_PARNEW_PARNEWGENERATION_HPP |