author | kbarrett |
Tue, 30 Aug 2016 23:48:16 -0400 | |
changeset 40892 | 330a02d935ad |
parent 37129 | af29e306e50b |
child 41283 | 2615c024f3eb |
permissions | -rw-r--r-- |
1 | 1 |
/* |
37129
af29e306e50b
8151601: Cleanup locking of the Reference pending list
pliden
parents:
36591
diff
changeset
|
2 |
* Copyright (c) 2000, 2016, 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:
4637
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4637
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:
4637
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
30764 | 25 |
#ifndef SHARE_VM_GC_SHARED_GENCOLLECTEDHEAP_HPP |
26 |
#define SHARE_VM_GC_SHARED_GENCOLLECTEDHEAP_HPP |
|
7397 | 27 |
|
30764 | 28 |
#include "gc/shared/adaptiveSizePolicy.hpp" |
29 |
#include "gc/shared/collectedHeap.hpp" |
|
30 |
#include "gc/shared/collectorPolicy.hpp" |
|
31 |
#include "gc/shared/generation.hpp" |
|
7397 | 32 |
|
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
33 |
class StrongRootsScope; |
1 | 34 |
class SubTasksDone; |
32361
3de9a2e1e2d0
8087324: Use semaphores when starting and stopping GC task threads
stefank
parents:
32360
diff
changeset
|
35 |
class WorkGang; |
1 | 36 |
|
30154 | 37 |
// A "GenCollectedHeap" is a CollectedHeap that uses generational |
29200 | 38 |
// collection. It has two generations, young and old. |
30154 | 39 |
class GenCollectedHeap : public CollectedHeap { |
1 | 40 |
friend class GenCollectorPolicy; |
41 |
friend class Generation; |
|
42 |
friend class DefNewGeneration; |
|
43 |
friend class TenuredGeneration; |
|
44 |
friend class ConcurrentMarkSweepGeneration; |
|
45 |
friend class CMSCollector; |
|
46 |
friend class GenMarkSweep; |
|
47 |
friend class VM_GenCollectForAllocation; |
|
48 |
friend class VM_GenCollectFull; |
|
49 |
friend class VM_GenCollectFullConcurrent; |
|
50 |
friend class VM_GC_HeapInspection; |
|
51 |
friend class VM_HeapDumper; |
|
52 |
friend class HeapInspection; |
|
53 |
friend class GCCauseSetter; |
|
54 |
friend class VMStructs; |
|
55 |
public: |
|
56 |
friend class VM_PopulateDumpSharedSpace; |
|
57 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
58 |
enum GenerationType { |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
59 |
YoungGen, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
60 |
OldGen |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
61 |
}; |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
62 |
|
30258
413e15d1b146
8077415: Remove duplicate variables holding the CollectedHeap
pliden
parents:
30171
diff
changeset
|
63 |
private: |
29200 | 64 |
Generation* _young_gen; |
65 |
Generation* _old_gen; |
|
66 |
||
33212 | 67 |
// The singleton CardTable Remembered Set. |
68 |
CardTableRS* _rem_set; |
|
28217
57791914628c
8067499: G1SATBCardTableModRefBS should not inherit from CardTableModRefBSForCTRS
kbarrett
parents:
27898
diff
changeset
|
69 |
|
1 | 70 |
// The generational collector policy. |
71 |
GenCollectorPolicy* _gen_policy; |
|
72 |
||
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
73 |
// Indicates that the most recent previous incremental collection failed. |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
74 |
// The flag is cleared when an action is taken that might clear the |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
75 |
// condition that caused that incremental collection to fail. |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
76 |
bool _incremental_collection_failed; |
1 | 77 |
|
78 |
// In support of ExplicitGCInvokesConcurrent functionality |
|
79 |
unsigned int _full_collections_completed; |
|
80 |
||
81 |
// Data structure for claiming the (potentially) parallel tasks in |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
82 |
// (gen-specific) roots processing. |
29693
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
83 |
SubTasksDone* _process_strong_tasks; |
1 | 84 |
|
29200 | 85 |
// Collects the given generation. |
86 |
void collect_generation(Generation* gen, bool full, size_t size, bool is_tlab, |
|
87 |
bool run_verification, bool clear_soft_refs, |
|
88 |
bool restore_marks_for_biased_locking); |
|
89 |
||
1 | 90 |
// In block contents verification, the number of header words to skip |
91 |
NOT_PRODUCT(static size_t _skip_header_HeapWords;) |
|
92 |
||
32360 | 93 |
WorkGang* _workers; |
30152 | 94 |
|
1 | 95 |
protected: |
96 |
// Helper functions for allocation |
|
97 |
HeapWord* attempt_allocation(size_t size, |
|
98 |
bool is_tlab, |
|
99 |
bool first_only); |
|
100 |
||
101 |
// Helper function for two callbacks below. |
|
102 |
// Considers collection of the first max_level+1 generations. |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
103 |
void do_collection(bool full, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
104 |
bool clear_all_soft_refs, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
105 |
size_t size, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
106 |
bool is_tlab, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
107 |
GenerationType max_generation); |
1 | 108 |
|
109 |
// Callback from VM_GenCollectForAllocation operation. |
|
110 |
// This function does everything necessary/possible to satisfy an |
|
111 |
// allocation request that failed in the youngest generation that should |
|
112 |
// have handled it (including collection, expansion, etc.) |
|
113 |
HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab); |
|
114 |
||
115 |
// Callback from VM_GenCollectFull operation. |
|
116 |
// Perform a full collection of the first max_level+1 generations. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
117 |
virtual void do_full_collection(bool clear_all_soft_refs); |
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
118 |
void do_full_collection(bool clear_all_soft_refs, GenerationType max_generation); |
1 | 119 |
|
120 |
// Does the "cause" of GC indicate that |
|
121 |
// we absolutely __must__ clear soft refs? |
|
122 |
bool must_clear_all_soft_refs(); |
|
123 |
||
124 |
public: |
|
125 |
GenCollectedHeap(GenCollectorPolicy *policy); |
|
126 |
||
32360 | 127 |
WorkGang* workers() const { return _workers; } |
30152 | 128 |
|
1 | 129 |
// Returns JNI_OK on success |
130 |
virtual jint initialize(); |
|
28939 | 131 |
|
132 |
// Reserve aligned space for the heap as needed by the contained generations. |
|
133 |
char* allocate(size_t alignment, ReservedSpace* heap_rs); |
|
1 | 134 |
|
135 |
// Does operations required after initialization has been done. |
|
136 |
void post_initialize(); |
|
137 |
||
138 |
// Initialize ("weak") refs processing support |
|
139 |
virtual void ref_processing_init(); |
|
140 |
||
29808 | 141 |
virtual Name kind() const { |
1 | 142 |
return CollectedHeap::GenCollectedHeap; |
143 |
} |
|
144 |
||
35061 | 145 |
virtual const char* name() const { |
146 |
if (UseConcMarkSweepGC) { |
|
147 |
return "Concurrent Mark Sweep"; |
|
148 |
} else { |
|
149 |
return "Serial"; |
|
150 |
} |
|
151 |
} |
|
152 |
||
29794 | 153 |
Generation* young_gen() const { return _young_gen; } |
154 |
Generation* old_gen() const { return _old_gen; } |
|
29200 | 155 |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
156 |
bool is_young_gen(const Generation* gen) const { return gen == _young_gen; } |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
157 |
bool is_old_gen(const Generation* gen) const { return gen == _old_gen; } |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
158 |
|
1 | 159 |
// The generational collector policy. |
160 |
GenCollectorPolicy* gen_policy() const { return _gen_policy; } |
|
29200 | 161 |
|
32735
c6063d028c3c
8134797: Remove explicit casts in CollectorPolicy hierarchy
kbarrett
parents:
32623
diff
changeset
|
162 |
virtual CollectorPolicy* collector_policy() const { return gen_policy(); } |
1 | 163 |
|
164 |
// Adaptive size policy |
|
165 |
virtual AdaptiveSizePolicy* size_policy() { |
|
166 |
return gen_policy()->size_policy(); |
|
167 |
} |
|
168 |
||
19986
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
169 |
// Return the (conservative) maximum heap alignment |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
170 |
static size_t conservative_max_heap_alignment() { |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
171 |
return Generation::GenGrain; |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
172 |
} |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
173 |
|
1 | 174 |
size_t capacity() const; |
175 |
size_t used() const; |
|
176 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
177 |
// Save the "used_region" for both generations. |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
178 |
void save_used_regions(); |
1 | 179 |
|
180 |
size_t max_capacity() const; |
|
181 |
||
32623
390a27af5657
8134626: Misc cleanups after generation array removal
jwilhelm
parents:
32361
diff
changeset
|
182 |
HeapWord* mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded); |
1 | 183 |
|
184 |
// We may support a shared contiguous allocation area, if the youngest |
|
185 |
// generation does. |
|
186 |
bool supports_inline_contig_alloc() const; |
|
187 |
HeapWord** top_addr() const; |
|
188 |
HeapWord** end_addr() const; |
|
189 |
||
190 |
// Perform a full collection of the heap; intended for use in implementing |
|
191 |
// "System.gc". This implies as full a collection as the CollectedHeap |
|
192 |
// supports. Caller does not hold the Heap_lock on entry. |
|
193 |
void collect(GCCause::Cause cause); |
|
194 |
||
195 |
// The same as above but assume that the caller holds the Heap_lock. |
|
196 |
void collect_locked(GCCause::Cause cause); |
|
197 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
198 |
// Perform a full collection of generations up to and including max_generation. |
1 | 199 |
// Mostly used for testing purposes. Caller does not hold the Heap_lock on entry. |
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
200 |
void collect(GCCause::Cause cause, GenerationType max_generation); |
1 | 201 |
|
11247 | 202 |
// Returns "TRUE" iff "p" points into the committed areas of the heap. |
1 | 203 |
// The methods is_in(), is_in_closed_subset() and is_in_youngest() may |
204 |
// be expensive to compute in general, so, to prevent |
|
205 |
// their inadvertent use in product jvm's, we restrict their use to |
|
206 |
// assertion checking or verification only. |
|
207 |
bool is_in(const void* p) const; |
|
208 |
||
209 |
// override |
|
210 |
bool is_in_closed_subset(const void* p) const { |
|
211 |
if (UseConcMarkSweepGC) { |
|
212 |
return is_in_reserved(p); |
|
213 |
} else { |
|
214 |
return is_in(p); |
|
215 |
} |
|
216 |
} |
|
217 |
||
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
218 |
// Returns true if the reference is to an object in the reserved space |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
219 |
// for the young generation. |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
220 |
// Assumes the the young gen address range is less than that of the old gen. |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
221 |
bool is_in_young(oop p); |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
222 |
|
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
223 |
#ifdef ASSERT |
29803 | 224 |
bool is_in_partial_collection(const void* p); |
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
225 |
#endif |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
226 |
|
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
227 |
virtual bool is_scavengable(const void* addr) { |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
228 |
return is_in_young((oop)addr); |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
229 |
} |
1 | 230 |
|
231 |
// Iteration functions. |
|
30152 | 232 |
void oop_iterate_no_header(OopClosure* cl); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
233 |
void oop_iterate(ExtendedOopClosure* cl); |
1 | 234 |
void object_iterate(ObjectClosure* cl); |
1893
c82e388e17c5
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
1388
diff
changeset
|
235 |
void safe_object_iterate(ObjectClosure* cl); |
1 | 236 |
Space* space_containing(const void* addr) const; |
237 |
||
238 |
// A CollectedHeap is divided into a dense sequence of "blocks"; that is, |
|
239 |
// each address in the (reserved) heap is a member of exactly |
|
240 |
// one block. The defining characteristic of a block is that it is |
|
241 |
// possible to find its size, and thus to progress forward to the next |
|
242 |
// block. (Blocks may be of different sizes.) Thus, blocks may |
|
243 |
// represent Java objects, or they might be free blocks in a |
|
244 |
// free-list-based heap (or subheap), as long as the two kinds are |
|
245 |
// distinguishable and the size of each is determinable. |
|
246 |
||
247 |
// Returns the address of the start of the "block" that contains the |
|
248 |
// address "addr". We say "blocks" instead of "object" since some heaps |
|
249 |
// may not pack objects densely; a chunk may either be an object or a |
|
250 |
// non-object. |
|
251 |
virtual HeapWord* block_start(const void* addr) const; |
|
252 |
||
253 |
// Requires "addr" to be the start of a chunk, and returns its size. |
|
254 |
// "addr + size" is required to be the start of a new chunk, or the end |
|
255 |
// of the active area of the heap. Assumes (and verifies in non-product |
|
256 |
// builds) that addr is in the allocated part of the heap and is |
|
257 |
// the start of a chunk. |
|
258 |
virtual size_t block_size(const HeapWord* addr) const; |
|
259 |
||
260 |
// Requires "addr" to be the start of a block, and returns "TRUE" iff |
|
261 |
// the block is an object. Assumes (and verifies in non-product |
|
262 |
// builds) that addr is in the allocated part of the heap and is |
|
263 |
// the start of a chunk. |
|
264 |
virtual bool block_is_obj(const HeapWord* addr) const; |
|
265 |
||
266 |
// Section on TLAB's. |
|
267 |
virtual bool supports_tlab_allocation() const; |
|
268 |
virtual size_t tlab_capacity(Thread* thr) const; |
|
22552 | 269 |
virtual size_t tlab_used(Thread* thr) const; |
1 | 270 |
virtual size_t unsafe_max_tlab_alloc(Thread* thr) const; |
271 |
virtual HeapWord* allocate_new_tlab(size_t size); |
|
272 |
||
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
273 |
// Can a compiler initialize a new object without store barriers? |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
274 |
// This permission only extends from the creation of a new object |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
275 |
// via a TLAB up to the first subsequent safepoint. |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
276 |
virtual bool can_elide_tlab_store_barriers() const { |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
277 |
return true; |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
278 |
} |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
279 |
|
4637 | 280 |
virtual bool card_mark_must_follow_store() const { |
281 |
return UseConcMarkSweepGC; |
|
282 |
} |
|
283 |
||
4030
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
284 |
// We don't need barriers for stores to objects in the |
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
285 |
// young gen and, a fortiori, for initializing stores to |
27898
813ad96387b3
8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents:
27687
diff
changeset
|
286 |
// objects therein. This applies to DefNew+Tenured and ParNew+CMS |
4030
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
287 |
// only and may need to be re-examined in case other |
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
288 |
// kinds of collectors are implemented in the future. |
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
289 |
virtual bool can_elide_initializing_store_barrier(oop new_obj) { |
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
290 |
return is_in_young(new_obj); |
4030
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
291 |
} |
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
292 |
|
1 | 293 |
// The "requestor" generation is performing some garbage collection |
294 |
// action for which it would be useful to have scratch space. The |
|
295 |
// requestor promises to allocate no more than "max_alloc_words" in any |
|
296 |
// older generation (via promotion say.) Any blocks of space that can |
|
297 |
// be provided are returned as a list of ScratchBlocks, sorted by |
|
298 |
// decreasing size. |
|
299 |
ScratchBlock* gather_scratch(Generation* requestor, size_t max_alloc_words); |
|
971
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
300 |
// Allow each generation to reset any scratch space that it has |
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
301 |
// contributed as it needs. |
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
302 |
void release_scratch(); |
1 | 303 |
|
304 |
// Ensure parsability: override |
|
305 |
virtual void ensure_parsability(bool retire_tlabs); |
|
306 |
||
307 |
// Time in ms since the longest time a collector ran in |
|
308 |
// in any generation. |
|
309 |
virtual jlong millis_since_last_gc(); |
|
310 |
||
311 |
// Total number of full collections completed. |
|
312 |
unsigned int total_full_collections_completed() { |
|
313 |
assert(_full_collections_completed <= _total_full_collections, |
|
314 |
"Can't complete more collections than were started"); |
|
315 |
return _full_collections_completed; |
|
316 |
} |
|
317 |
||
318 |
// Update above counter, as appropriate, at the end of a stop-world GC cycle |
|
319 |
unsigned int update_full_collections_completed(); |
|
320 |
// Update above counter, as appropriate, at the end of a concurrent GC cycle |
|
321 |
unsigned int update_full_collections_completed(unsigned int count); |
|
322 |
||
29200 | 323 |
// Update "time of last gc" for all generations to "now". |
1 | 324 |
void update_time_of_last_gc(jlong now) { |
29200 | 325 |
_young_gen->update_time_of_last_gc(now); |
326 |
_old_gen->update_time_of_last_gc(now); |
|
1 | 327 |
} |
328 |
||
329 |
// Update the gc statistics for each generation. |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
330 |
void update_gc_stats(Generation* current_generation, bool full) { |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
331 |
_old_gen->update_gc_stats(current_generation, full); |
1 | 332 |
} |
333 |
||
334 |
bool no_gc_in_progress() { return !is_gc_active(); } |
|
335 |
||
336 |
// Override. |
|
337 |
void prepare_for_verify(); |
|
338 |
||
339 |
// Override. |
|
35061 | 340 |
void verify(VerifyOption option); |
1 | 341 |
|
342 |
// Override. |
|
10997
0be4b3be7197
7099849: G1: include heap region information in hs_err files
tonyp
parents:
9997
diff
changeset
|
343 |
virtual void print_on(outputStream* st) const; |
1 | 344 |
virtual void print_gc_threads_on(outputStream* st) const; |
345 |
virtual void gc_threads_do(ThreadClosure* tc) const; |
|
346 |
virtual void print_tracing_info() const; |
|
16685
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
13728
diff
changeset
|
347 |
virtual void print_on_error(outputStream* st) const; |
1 | 348 |
|
35061 | 349 |
void print_heap_change(size_t young_prev_used, size_t old_prev_used) const; |
1 | 350 |
|
351 |
// The functions below are helper functions that a subclass of |
|
352 |
// "CollectedHeap" can use in the implementation of its virtual |
|
353 |
// functions. |
|
354 |
||
355 |
class GenClosure : public StackObj { |
|
356 |
public: |
|
357 |
virtual void do_generation(Generation* gen) = 0; |
|
358 |
}; |
|
359 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
360 |
// Apply "cl.do_generation" to all generations in the heap |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
361 |
// If "old_to_young" determines the order. |
1 | 362 |
void generation_iterate(GenClosure* cl, bool old_to_young); |
363 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
364 |
// Return "true" if all generations have reached the |
1 | 365 |
// maximal committed limit that they can reach, without a garbage |
366 |
// collection. |
|
367 |
virtual bool is_maximal_no_gc() const; |
|
368 |
||
33212 | 369 |
// This function returns the CardTableRS object that allows us to scan |
28217
57791914628c
8067499: G1SATBCardTableModRefBS should not inherit from CardTableModRefBSForCTRS
kbarrett
parents:
27898
diff
changeset
|
370 |
// generations in a fully generational heap. |
33212 | 371 |
CardTableRS* rem_set() { return _rem_set; } |
28217
57791914628c
8067499: G1SATBCardTableModRefBS should not inherit from CardTableModRefBSForCTRS
kbarrett
parents:
27898
diff
changeset
|
372 |
|
1 | 373 |
// Convenience function to be used in situations where the heap type can be |
374 |
// asserted to be this type. |
|
375 |
static GenCollectedHeap* heap(); |
|
376 |
||
377 |
// Invoke the "do_oop" method of one of the closures "not_older_gens" |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
378 |
// or "older_gens" on root locations for the generations depending on |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
379 |
// the type. (The "older_gens" closure is used for scanning references |
1 | 380 |
// from older generations; "not_older_gens" is used everywhere else.) |
381 |
// If "younger_gens_as_roots" is false, younger generations are |
|
382 |
// not scanned as roots; in this case, the caller must be arranging to |
|
383 |
// scan the younger generations itself. (For example, a generation might |
|
384 |
// explicitly mark reachable objects in younger generations, to avoid |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
385 |
// excess storage retention.) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
386 |
// The "so" argument determines which of the roots |
1 | 387 |
// the closure is applied to: |
388 |
// "SO_None" does none; |
|
29693
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
389 |
enum ScanningOption { |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
390 |
SO_None = 0x0, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
391 |
SO_AllCodeCache = 0x8, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
392 |
SO_ScavengeCodeCache = 0x10 |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
393 |
}; |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
394 |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
395 |
private: |
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
396 |
void process_roots(StrongRootsScope* scope, |
29693
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
397 |
ScanningOption so, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
398 |
OopClosure* strong_roots, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
399 |
OopClosure* weak_roots, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
400 |
CLDClosure* strong_cld_closure, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
401 |
CLDClosure* weak_cld_closure, |
36591
d0622cab5983
8150013: ParNew: Prune nmethods scavengable list.
cvarming
parents:
35061
diff
changeset
|
402 |
CodeBlobToOopClosure* code_roots); |
29693
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
403 |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
404 |
public: |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
405 |
static const bool StrongAndWeakRoots = false; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
406 |
static const bool StrongRootsOnly = true; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
407 |
|
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
408 |
void gen_process_roots(StrongRootsScope* scope, |
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
409 |
GenerationType type, |
32623
390a27af5657
8134626: Misc cleanups after generation array removal
jwilhelm
parents:
32361
diff
changeset
|
410 |
bool young_gen_as_roots, |
29693
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
411 |
ScanningOption so, |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
412 |
bool only_strong_roots, |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
413 |
OopsInGenClosure* not_older_gens, |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
414 |
OopsInGenClosure* older_gens, |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
415 |
CLDClosure* cld_closure); |
1 | 416 |
|
22882
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
417 |
// Apply "root_closure" to all the weak roots of the system. |
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
418 |
// These include JNI weak roots, string table, |
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
419 |
// and referents of reachable weak refs. |
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
420 |
void gen_process_weak_roots(OopClosure* root_closure); |
1 | 421 |
|
422 |
// Set the saved marks of generations, if that makes sense. |
|
423 |
// In particular, if any generation might iterate over the oops |
|
424 |
// in other generations, it should call this method. |
|
425 |
void save_marks(); |
|
426 |
||
427 |
// Apply "cur->do_oop" or "older->do_oop" to all the oops in objects |
|
428 |
// allocated since the last call to save_marks in generations at or above |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
429 |
// "level". The "cur" closure is |
1 | 430 |
// applied to references in the generation at "level", and the "older" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
431 |
// closure to older generations. |
1 | 432 |
#define GCH_SINCE_SAVE_MARKS_ITERATE_DECL(OopClosureType, nv_suffix) \ |
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
433 |
void oop_since_save_marks_iterate(GenerationType start_gen, \ |
1 | 434 |
OopClosureType* cur, \ |
435 |
OopClosureType* older); |
|
436 |
||
437 |
ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DECL) |
|
438 |
||
439 |
#undef GCH_SINCE_SAVE_MARKS_ITERATE_DECL |
|
440 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
441 |
// Returns "true" iff no allocations have occurred since the last |
1 | 442 |
// call to "save_marks". |
31780 | 443 |
bool no_allocs_since_save_marks(); |
1 | 444 |
|
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
445 |
// Returns true if an incremental collection is likely to fail. |
7419
263dd4e89b9d
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
7397
diff
changeset
|
446 |
// We optionally consult the young gen, if asked to do so; |
263dd4e89b9d
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
7397
diff
changeset
|
447 |
// otherwise we base our answer on whether the previous incremental |
263dd4e89b9d
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
7397
diff
changeset
|
448 |
// collection attempt failed with no corrective action as of yet. |
263dd4e89b9d
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
7397
diff
changeset
|
449 |
bool incremental_collection_will_fail(bool consult_young) { |
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
450 |
// The first disjunct remembers if an incremental collection failed, even |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
451 |
// when we thought (second disjunct) that it would not. |
7419
263dd4e89b9d
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
7397
diff
changeset
|
452 |
return incremental_collection_failed() || |
29684
a36d90acae41
8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents:
29200
diff
changeset
|
453 |
(consult_young && !_young_gen->collection_attempt_is_safe()); |
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
454 |
} |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
455 |
|
1 | 456 |
// If a generation bails out of an incremental collection, |
457 |
// it sets this flag. |
|
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
458 |
bool incremental_collection_failed() const { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
459 |
return _incremental_collection_failed; |
1 | 460 |
} |
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
461 |
void set_incremental_collection_failed() { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
462 |
_incremental_collection_failed = true; |
1 | 463 |
} |
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
464 |
void clear_incremental_collection_failed() { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
465 |
_incremental_collection_failed = false; |
1 | 466 |
} |
467 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
468 |
// Promotion of obj into gen failed. Try to promote obj to higher |
1 | 469 |
// gens in ascending order; return the new location of obj if successful. |
19286
48394008c803
8022800: Use specific generations rather than generation iteration
brutisso
parents:
18687
diff
changeset
|
470 |
// Otherwise, try expand-and-allocate for obj in both the young and old |
48394008c803
8022800: Use specific generations rather than generation iteration
brutisso
parents:
18687
diff
changeset
|
471 |
// generation; return the new location of obj if successful. Otherwise, return NULL. |
48394008c803
8022800: Use specific generations rather than generation iteration
brutisso
parents:
18687
diff
changeset
|
472 |
oop handle_failed_promotion(Generation* old_gen, |
1 | 473 |
oop obj, |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
474 |
size_t obj_size); |
1 | 475 |
|
476 |
private: |
|
477 |
// Accessor for memory state verification support |
|
478 |
NOT_PRODUCT( |
|
479 |
static size_t skip_header_HeapWords() { return _skip_header_HeapWords; } |
|
480 |
) |
|
481 |
||
482 |
// Override |
|
483 |
void check_for_non_bad_heap_word_value(HeapWord* addr, |
|
484 |
size_t size) PRODUCT_RETURN; |
|
485 |
||
486 |
// For use by mark-sweep. As implemented, mark-sweep-compact is global |
|
487 |
// in an essential way: compaction is performed across generations, by |
|
488 |
// iterating over spaces. |
|
489 |
void prepare_for_compaction(); |
|
490 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
491 |
// Perform a full collection of the generations up to and including max_generation. |
1 | 492 |
// This is the low level interface used by the public versions of |
493 |
// collect() and collect_locked(). Caller holds the Heap_lock on entry. |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
494 |
void collect_locked(GCCause::Cause cause, GenerationType max_generation); |
1 | 495 |
|
496 |
// Returns success or failure. |
|
497 |
bool create_cms_collector(); |
|
498 |
||
499 |
// In support of ExplicitGCInvokesConcurrent functionality |
|
500 |
bool should_do_concurrent_full_gc(GCCause::Cause cause); |
|
501 |
void collect_mostly_concurrent(GCCause::Cause cause); |
|
502 |
||
971
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
503 |
// Save the tops of the spaces in all generations |
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
504 |
void record_gen_tops_before_GC() PRODUCT_RETURN; |
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
505 |
|
1 | 506 |
protected: |
30152 | 507 |
void gc_prologue(bool full); |
508 |
void gc_epilogue(bool full); |
|
34133
5d761539ac2c
8141356: Explicitly stop CMS threads during VM termination.
jwha
parents:
33580
diff
changeset
|
509 |
|
5d761539ac2c
8141356: Explicitly stop CMS threads during VM termination.
jwha
parents:
33580
diff
changeset
|
510 |
public: |
5d761539ac2c
8141356: Explicitly stop CMS threads during VM termination.
jwha
parents:
33580
diff
changeset
|
511 |
void stop(); |
1 | 512 |
}; |
7397 | 513 |
|
30764 | 514 |
#endif // SHARE_VM_GC_SHARED_GENCOLLECTEDHEAP_HPP |