author | stefank |
Mon, 25 May 2015 11:41:34 +0200 | |
changeset 30881 | 7a3899d7cea0 |
parent 30868 | c1b24f26deed |
child 31358 | 693058672cc6 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
29684
a36d90acae41
8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents:
28940
diff
changeset
|
2 |
* Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4574
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4574
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4574
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
30764 | 25 |
#ifndef SHARE_VM_GC_CMS_PARNEWGENERATION_HPP |
26 |
#define SHARE_VM_GC_CMS_PARNEWGENERATION_HPP |
|
7397 | 27 |
|
30764 | 28 |
#include "gc/cms/parOopClosures.hpp" |
29 |
#include "gc/serial/defNewGeneration.hpp" |
|
30 |
#include "gc/shared/copyFailedInfo.hpp" |
|
31 |
#include "gc/shared/gcTrace.hpp" |
|
32 |
#include "gc/shared/plab.hpp" |
|
33 |
#include "gc/shared/taskqueue.hpp" |
|
19285
0a3b3f115402
8022880: False sharing between PSPromotionManager instances
stefank
parents:
18025
diff
changeset
|
34 |
#include "memory/padded.hpp" |
7397 | 35 |
|
1 | 36 |
class ChunkArray; |
37 |
class ParScanWithoutBarrierClosure; |
|
38 |
class ParScanWithBarrierClosure; |
|
39 |
class ParRootScanWithoutBarrierClosure; |
|
40 |
class ParRootScanWithBarrierTwoGensClosure; |
|
41 |
class ParEvacuateFollowersClosure; |
|
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
42 |
class StrongRootsScope; |
1 | 43 |
|
44 |
// It would be better if these types could be kept local to the .cpp file, |
|
45 |
// but they must be here to allow ParScanClosure::do_oop_work to be defined |
|
46 |
// in genOopClosures.inline.hpp. |
|
47 |
||
6067 | 48 |
typedef Padded<OopTaskQueue> ObjToScanQueue; |
13195 | 49 |
typedef GenericTaskQueueSet<ObjToScanQueue, mtGC> ObjToScanQueueSet; |
1 | 50 |
|
51 |
class ParKeepAliveClosure: public DefNewGeneration::KeepAliveClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
52 |
private: |
1 | 53 |
ParScanWeakRefClosure* _par_cl; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
54 |
protected: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
55 |
template <class T> void do_oop_work(T* p); |
1 | 56 |
public: |
57 |
ParKeepAliveClosure(ParScanWeakRefClosure* cl); |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
58 |
virtual void do_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
59 |
virtual void do_oop(narrowOop* p); |
1 | 60 |
}; |
61 |
||
62 |
// The state needed by thread performing parallel young-gen collection. |
|
63 |
class ParScanThreadState { |
|
64 |
friend class ParScanThreadStateSet; |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
65 |
private: |
1 | 66 |
ObjToScanQueue *_work_queue; |
13195 | 67 |
Stack<oop, mtGC>* const _overflow_stack; |
1 | 68 |
|
30275
41fef3a62cc8
8074546: Rename and clean up the ParGCAllocBuffer class
jprovino
parents:
30274
diff
changeset
|
69 |
PLAB _to_space_alloc_buffer; |
1 | 70 |
|
71 |
ParScanWithoutBarrierClosure _to_space_closure; // scan_without_gc_barrier |
|
72 |
ParScanWithBarrierClosure _old_gen_closure; // scan_with_gc_barrier |
|
73 |
ParRootScanWithoutBarrierClosure _to_space_root_closure; // scan_root_without_gc_barrier |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
74 |
// One of these two will be passed to process_roots, which will |
1 | 75 |
// set its generation. The first is for two-gen configs where the |
76 |
// old gen collects the perm gen; the second is for arbitrary configs. |
|
77 |
// The second isn't used right now (it used to be used for the train, an |
|
78 |
// incremental collector) but the declaration has been left as a reminder. |
|
79 |
ParRootScanWithBarrierTwoGensClosure _older_gen_closure; |
|
80 |
// This closure will always be bound to the old gen; it will be used |
|
81 |
// in evacuate_followers. |
|
82 |
ParRootScanWithBarrierTwoGensClosure _old_gen_root_closure; // scan_old_root_with_gc_barrier |
|
83 |
ParEvacuateFollowersClosure _evacuate_followers; |
|
84 |
DefNewGeneration::IsAliveClosure _is_alive_closure; |
|
85 |
ParScanWeakRefClosure _scan_weak_ref_closure; |
|
86 |
ParKeepAliveClosure _keep_alive_closure; |
|
87 |
||
88 |
||
89 |
Space* _to_space; |
|
90 |
Space* to_space() { return _to_space; } |
|
91 |
||
2346
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
92 |
ParNewGeneration* _young_gen; |
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
93 |
ParNewGeneration* young_gen() const { return _young_gen; } |
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
94 |
|
1 | 95 |
Generation* _old_gen; |
96 |
Generation* old_gen() { return _old_gen; } |
|
97 |
||
98 |
HeapWord *_young_old_boundary; |
|
99 |
||
100 |
int _hash_seed; |
|
101 |
int _thread_num; |
|
102 |
ageTable _ageTable; |
|
103 |
||
104 |
bool _to_space_full; |
|
105 |
||
6252 | 106 |
#if TASKQUEUE_STATS |
107 |
size_t _term_attempts; |
|
108 |
size_t _overflow_refills; |
|
109 |
size_t _overflow_refill_objs; |
|
110 |
#endif // TASKQUEUE_STATS |
|
1 | 111 |
|
4574
b2d5b0975515
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
2362
diff
changeset
|
112 |
// Stats for promotion failure |
18025 | 113 |
PromotionFailedInfo _promotion_failed_info; |
4574
b2d5b0975515
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
2362
diff
changeset
|
114 |
|
1 | 115 |
// Timing numbers. |
116 |
double _start; |
|
117 |
double _start_strong_roots; |
|
118 |
double _strong_roots_time; |
|
119 |
double _start_term; |
|
120 |
double _term_time; |
|
121 |
||
122 |
// Helper for trim_queues. Scans subset of an array and makes |
|
123 |
// remainder available for work stealing. |
|
124 |
void scan_partial_array_and_push_remainder(oop obj); |
|
125 |
||
126 |
// In support of CMS' parallel rescan of survivor space. |
|
127 |
ChunkArray* _survivor_chunk_array; |
|
128 |
ChunkArray* survivor_chunk_array() { return _survivor_chunk_array; } |
|
129 |
||
130 |
void record_survivor_plab(HeapWord* plab_start, size_t plab_word_size); |
|
131 |
||
132 |
ParScanThreadState(Space* to_space_, ParNewGeneration* gen_, |
|
133 |
Generation* old_gen_, int thread_num_, |
|
2362
5e1bfddf919e
6824570: ParNew: Fix memory leak introduced in 6819891
ysr
parents:
2346
diff
changeset
|
134 |
ObjToScanQueueSet* work_queue_set_, |
13195 | 135 |
Stack<oop, mtGC>* overflow_stacks_, |
2362
5e1bfddf919e
6824570: ParNew: Fix memory leak introduced in 6819891
ysr
parents:
2346
diff
changeset
|
136 |
size_t desired_plab_sz_, |
1 | 137 |
ParallelTaskTerminator& term_); |
138 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
139 |
public: |
1 | 140 |
ageTable* age_table() {return &_ageTable;} |
141 |
||
142 |
ObjToScanQueue* work_queue() { return _work_queue; } |
|
143 |
||
30275
41fef3a62cc8
8074546: Rename and clean up the ParGCAllocBuffer class
jprovino
parents:
30274
diff
changeset
|
144 |
PLAB* to_space_alloc_buffer() { |
1 | 145 |
return &_to_space_alloc_buffer; |
146 |
} |
|
147 |
||
148 |
ParEvacuateFollowersClosure& evacuate_followers_closure() { return _evacuate_followers; } |
|
149 |
DefNewGeneration::IsAliveClosure& is_alive_closure() { return _is_alive_closure; } |
|
150 |
ParScanWeakRefClosure& scan_weak_ref_closure() { return _scan_weak_ref_closure; } |
|
151 |
ParKeepAliveClosure& keep_alive_closure() { return _keep_alive_closure; } |
|
152 |
ParScanClosure& older_gen_closure() { return _older_gen_closure; } |
|
153 |
ParRootScanWithoutBarrierClosure& to_space_root_closure() { return _to_space_root_closure; }; |
|
154 |
||
155 |
// Decrease queue size below "max_size". |
|
156 |
void trim_queues(int max_size); |
|
157 |
||
2346
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
158 |
// Private overflow stack usage |
13195 | 159 |
Stack<oop, mtGC>* overflow_stack() { return _overflow_stack; } |
2346
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
160 |
bool take_from_overflow_stack(); |
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
161 |
void push_on_overflow_stack(oop p); |
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
162 |
|
1 | 163 |
// Is new_obj a candidate for scan_partial_array_and_push_remainder method. |
164 |
inline bool should_be_partially_scanned(oop new_obj, oop old_obj) const; |
|
165 |
||
166 |
int* hash_seed() { return &_hash_seed; } |
|
167 |
int thread_num() { return _thread_num; } |
|
168 |
||
169 |
// Allocate a to-space block of size "sz", or else return NULL. |
|
170 |
HeapWord* alloc_in_to_space_slow(size_t word_sz); |
|
171 |
||
172 |
HeapWord* alloc_in_to_space(size_t word_sz) { |
|
25905
04a3d83cc752
8031323: Optionally align objects copied to survivor spaces
jmasa
parents:
25492
diff
changeset
|
173 |
HeapWord* obj = to_space_alloc_buffer()->allocate_aligned(word_sz, SurvivorAlignmentInBytes); |
1 | 174 |
if (obj != NULL) return obj; |
175 |
else return alloc_in_to_space_slow(word_sz); |
|
176 |
} |
|
177 |
||
178 |
HeapWord* young_old_boundary() { return _young_old_boundary; } |
|
179 |
||
180 |
void set_young_old_boundary(HeapWord *boundary) { |
|
181 |
_young_old_boundary = boundary; |
|
182 |
} |
|
183 |
||
184 |
// Undo the most recent allocation ("obj", of "word_sz"). |
|
185 |
void undo_alloc_in_to_space(HeapWord* obj, size_t word_sz); |
|
186 |
||
4574
b2d5b0975515
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
2362
diff
changeset
|
187 |
// Promotion failure stats |
18025 | 188 |
void register_promotion_failure(size_t sz) { |
189 |
_promotion_failed_info.register_copy_failure(sz); |
|
4574
b2d5b0975515
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
2362
diff
changeset
|
190 |
} |
18025 | 191 |
PromotionFailedInfo& promotion_failed_info() { |
192 |
return _promotion_failed_info; |
|
193 |
} |
|
194 |
bool promotion_failed() { |
|
195 |
return _promotion_failed_info.has_failed(); |
|
196 |
} |
|
197 |
void print_promotion_failure_size(); |
|
4574
b2d5b0975515
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
2362
diff
changeset
|
198 |
|
6252 | 199 |
#if TASKQUEUE_STATS |
200 |
TaskQueueStats & taskqueue_stats() const { return _work_queue->stats; } |
|
201 |
||
202 |
size_t term_attempts() const { return _term_attempts; } |
|
203 |
size_t overflow_refills() const { return _overflow_refills; } |
|
204 |
size_t overflow_refill_objs() const { return _overflow_refill_objs; } |
|
1 | 205 |
|
6252 | 206 |
void note_term_attempt() { ++_term_attempts; } |
207 |
void note_overflow_refill(size_t objs) { |
|
208 |
++_overflow_refills; _overflow_refill_objs += objs; |
|
1 | 209 |
} |
210 |
||
6252 | 211 |
void reset_stats(); |
212 |
#endif // TASKQUEUE_STATS |
|
213 |
||
1 | 214 |
void start_strong_roots() { |
215 |
_start_strong_roots = os::elapsedTime(); |
|
216 |
} |
|
217 |
void end_strong_roots() { |
|
218 |
_strong_roots_time += (os::elapsedTime() - _start_strong_roots); |
|
219 |
} |
|
6252 | 220 |
double strong_roots_time() const { return _strong_roots_time; } |
1 | 221 |
void start_term_time() { |
6252 | 222 |
TASKQUEUE_STATS_ONLY(note_term_attempt()); |
1 | 223 |
_start_term = os::elapsedTime(); |
224 |
} |
|
225 |
void end_term_time() { |
|
226 |
_term_time += (os::elapsedTime() - _start_term); |
|
227 |
} |
|
6252 | 228 |
double term_time() const { return _term_time; } |
1 | 229 |
|
6252 | 230 |
double elapsed_time() const { |
1 | 231 |
return os::elapsedTime() - _start; |
232 |
} |
|
233 |
}; |
|
234 |
||
235 |
class ParNewGenTask: public AbstractGangTask { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
236 |
private: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
237 |
ParNewGeneration* _gen; |
29684
a36d90acae41
8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents:
28940
diff
changeset
|
238 |
Generation* _old_gen; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
239 |
HeapWord* _young_old_boundary; |
1 | 240 |
class ParScanThreadStateSet* _state_set; |
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
241 |
StrongRootsScope* _strong_roots_scope; |
1 | 242 |
|
243 |
public: |
|
244 |
ParNewGenTask(ParNewGeneration* gen, |
|
29684
a36d90acae41
8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents:
28940
diff
changeset
|
245 |
Generation* old_gen, |
1 | 246 |
HeapWord* young_old_boundary, |
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
247 |
ParScanThreadStateSet* state_set, |
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
248 |
StrongRootsScope* strong_roots_scope); |
1 | 249 |
|
250 |
HeapWord* young_old_boundary() { return _young_old_boundary; } |
|
251 |
||
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11174
diff
changeset
|
252 |
void work(uint worker_id); |
1 | 253 |
}; |
254 |
||
255 |
class KeepAliveClosure: public DefNewGeneration::KeepAliveClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
256 |
protected: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
257 |
template <class T> void do_oop_work(T* p); |
1 | 258 |
public: |
259 |
KeepAliveClosure(ScanWeakRefClosure* cl); |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
260 |
virtual void do_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
261 |
virtual void do_oop(narrowOop* p); |
1 | 262 |
}; |
263 |
||
264 |
class EvacuateFollowersClosureGeneral: public VoidClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
265 |
private: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
266 |
GenCollectedHeap* _gch; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
267 |
int _level; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
268 |
OopsInGenClosure* _scan_cur_or_nonheap; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
269 |
OopsInGenClosure* _scan_older; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
270 |
public: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
271 |
EvacuateFollowersClosureGeneral(GenCollectedHeap* gch, int level, |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
272 |
OopsInGenClosure* cur, |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
273 |
OopsInGenClosure* older); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
274 |
virtual void do_void(); |
1 | 275 |
}; |
276 |
||
277 |
// Closure for scanning ParNewGeneration. |
|
278 |
// Same as ScanClosure, except does parallel GC barrier. |
|
279 |
class ScanClosureWithParBarrier: public ScanClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
280 |
protected: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
281 |
template <class T> void do_oop_work(T* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
282 |
public: |
1 | 283 |
ScanClosureWithParBarrier(ParNewGeneration* g, bool gc_barrier); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
284 |
virtual void do_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
285 |
virtual void do_oop(narrowOop* p); |
1 | 286 |
}; |
287 |
||
288 |
// Implements AbstractRefProcTaskExecutor for ParNew. |
|
289 |
class ParNewRefProcTaskExecutor: public AbstractRefProcTaskExecutor { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
290 |
private: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
291 |
ParNewGeneration& _generation; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
292 |
ParScanThreadStateSet& _state_set; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
293 |
public: |
1 | 294 |
ParNewRefProcTaskExecutor(ParNewGeneration& generation, |
295 |
ParScanThreadStateSet& state_set) |
|
296 |
: _generation(generation), _state_set(state_set) |
|
297 |
{ } |
|
298 |
||
299 |
// Executes a task using worker threads. |
|
300 |
virtual void execute(ProcessTask& task); |
|
301 |
virtual void execute(EnqueueTask& task); |
|
302 |
// Switch to single threaded mode. |
|
303 |
virtual void set_single_threaded_mode(); |
|
304 |
}; |
|
305 |
||
306 |
||
307 |
// A Generation that does parallel young-gen collection. |
|
308 |
||
309 |
class ParNewGeneration: public DefNewGeneration { |
|
310 |
friend class ParNewGenTask; |
|
311 |
friend class ParNewRefProcTask; |
|
312 |
friend class ParNewRefProcTaskExecutor; |
|
313 |
friend class ParScanThreadStateSet; |
|
1910 | 314 |
friend class ParEvacuateFollowersClosure; |
1 | 315 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
316 |
private: |
2362
5e1bfddf919e
6824570: ParNew: Fix memory leak introduced in 6819891
ysr
parents:
2346
diff
changeset
|
317 |
// The per-worker-thread work queues |
1 | 318 |
ObjToScanQueueSet* _task_queues; |
319 |
||
2362
5e1bfddf919e
6824570: ParNew: Fix memory leak introduced in 6819891
ysr
parents:
2346
diff
changeset
|
320 |
// Per-worker-thread local overflow stacks |
13195 | 321 |
Stack<oop, mtGC>* _overflow_stacks; |
2362
5e1bfddf919e
6824570: ParNew: Fix memory leak introduced in 6819891
ysr
parents:
2346
diff
changeset
|
322 |
|
1 | 323 |
// Desired size of survivor space plab's |
324 |
PLABStats _plab_stats; |
|
325 |
||
326 |
// A list of from-space images of to-be-scanned objects, threaded through |
|
327 |
// klass-pointers (klass information already copied to the forwarded |
|
328 |
// image.) Manipulated with CAS. |
|
329 |
oop _overflow_list; |
|
1910 | 330 |
NOT_PRODUCT(ssize_t _num_par_pushes;) |
1 | 331 |
|
332 |
// This closure is used by the reference processor to filter out |
|
333 |
// references to live referent. |
|
334 |
DefNewGeneration::IsAliveClosure _is_alive_closure; |
|
335 |
||
28940
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
336 |
// GC tracer that should be used during collection. |
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
337 |
ParNewTracer _gc_tracer; |
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
338 |
|
1 | 339 |
static oop real_forwardee_slow(oop obj); |
340 |
static void waste_some_time(); |
|
341 |
||
342 |
// Preserve the mark of "obj", if necessary, in preparation for its mark |
|
343 |
// word being overwritten with a self-forwarding-pointer. |
|
344 |
void preserve_mark_if_necessary(oop obj, markOop m); |
|
345 |
||
28940
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
346 |
void handle_promotion_failed(GenCollectedHeap* gch, ParScanThreadStateSet& thread_state_set); |
18025 | 347 |
|
1 | 348 |
protected: |
349 |
||
350 |
bool _survivor_overflow; |
|
351 |
||
352 |
bool survivor_overflow() { return _survivor_overflow; } |
|
353 |
void set_survivor_overflow(bool v) { _survivor_overflow = v; } |
|
354 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
355 |
public: |
1 | 356 |
ParNewGeneration(ReservedSpace rs, size_t initial_byte_size, int level); |
357 |
||
358 |
~ParNewGeneration() { |
|
359 |
for (uint i = 0; i < ParallelGCThreads; i++) |
|
360 |
delete _task_queues->queue(i); |
|
361 |
||
362 |
delete _task_queues; |
|
363 |
} |
|
364 |
||
365 |
virtual void ref_processor_init(); |
|
366 |
virtual Generation::Name kind() { return Generation::ParNew; } |
|
367 |
virtual const char* name() const; |
|
368 |
virtual const char* short_name() const { return "ParNew"; } |
|
369 |
||
370 |
// override |
|
371 |
virtual bool refs_discovery_is_mt() const { |
|
372 |
return ParallelGCThreads > 1; |
|
373 |
} |
|
374 |
||
375 |
// Make the collection virtual. |
|
376 |
virtual void collect(bool full, |
|
377 |
bool clear_all_soft_refs, |
|
378 |
size_t size, |
|
379 |
bool is_tlab); |
|
380 |
||
381 |
// This needs to be visible to the closure function. |
|
382 |
// "obj" is the object to be copied, "m" is a recent value of its mark |
|
383 |
// that must not contain a forwarding pointer (though one might be |
|
384 |
// inserted in "obj"s mark word by a parallel thread). |
|
27899
17754211a7ab
8066133: Fix missing reivew changes for JDK-8065972
brutisso
parents:
27898
diff
changeset
|
385 |
oop copy_to_survivor_space(ParScanThreadState* par_scan_state, |
1 | 386 |
oop obj, size_t obj_sz, markOop m); |
387 |
||
1910 | 388 |
// in support of testing overflow code |
389 |
NOT_PRODUCT(int _overflow_counter;) |
|
390 |
NOT_PRODUCT(bool should_simulate_overflow();) |
|
391 |
||
2346
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
392 |
// Accessor for overflow list |
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
393 |
oop overflow_list() { return _overflow_list; } |
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
394 |
|
1 | 395 |
// Push the given (from-space) object on the global overflow list. |
1910 | 396 |
void push_on_overflow_list(oop from_space_obj, ParScanThreadState* par_scan_state); |
1 | 397 |
|
398 |
// If the global overflow list is non-empty, move some tasks from it |
|
2346
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
399 |
// onto "work_q" (which need not be empty). No more than 1/4 of the |
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
400 |
// available space on "work_q" is used. |
1 | 401 |
bool take_from_overflow_list(ParScanThreadState* par_scan_state); |
2346
3aa355016e90
6819891: ParNew: Fix work queue overflow code to deal correctly with +UseCompressedOops
ysr
parents:
2105
diff
changeset
|
402 |
bool take_from_overflow_list_work(ParScanThreadState* par_scan_state); |
1 | 403 |
|
404 |
// The task queues to be used by parallel GC threads. |
|
405 |
ObjToScanQueueSet* task_queues() { |
|
406 |
return _task_queues; |
|
407 |
} |
|
408 |
||
409 |
PLABStats* plab_stats() { |
|
410 |
return &_plab_stats; |
|
411 |
} |
|
412 |
||
30586
23e6e981e89c
8079556: BACKOUT - Determining the desired PLAB size adjusts to the the number of threads at the wrong place
tschatzl
parents:
30585
diff
changeset
|
413 |
size_t desired_plab_sz() { |
23e6e981e89c
8079556: BACKOUT - Determining the desired PLAB size adjusts to the the number of threads at the wrong place
tschatzl
parents:
30585
diff
changeset
|
414 |
return _plab_stats.desired_plab_sz(); |
23e6e981e89c
8079556: BACKOUT - Determining the desired PLAB size adjusts to the the number of threads at the wrong place
tschatzl
parents:
30585
diff
changeset
|
415 |
} |
1 | 416 |
|
28940
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
417 |
const ParNewTracer* gc_tracer() const { |
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
418 |
return &_gc_tracer; |
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
419 |
} |
c314cf1db3fa
8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents:
27899
diff
changeset
|
420 |
|
1 | 421 |
static oop real_forwardee(oop obj); |
422 |
}; |
|
7397 | 423 |
|
30764 | 424 |
#endif // SHARE_VM_GC_CMS_PARNEWGENERATION_HPP |