author | rkennke |
Wed, 25 Oct 2017 10:05:17 +0200 | |
changeset 47819 | ee36a8e36561 |
parent 47624 | b055cb5170f5 |
child 48168 | cb5d2d4453d0 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
2 |
* Copyright (c) 2000, 2017, 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 |
||
29200 | 81 |
// Collects the given generation. |
82 |
void collect_generation(Generation* gen, bool full, size_t size, bool is_tlab, |
|
83 |
bool run_verification, bool clear_soft_refs, |
|
84 |
bool restore_marks_for_biased_locking); |
|
85 |
||
47819
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
86 |
// Reserve aligned space for the heap as needed by the contained generations. |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
87 |
char* allocate(size_t alignment, ReservedSpace* heap_rs); |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
88 |
|
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
89 |
// Initialize ("weak") refs processing support |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
90 |
void ref_processing_init(); |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
91 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
92 |
protected: |
1 | 93 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
94 |
// The set of potentially parallel tasks in root scanning. |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
95 |
enum GCH_strong_roots_tasks { |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
96 |
GCH_PS_Universe_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
97 |
GCH_PS_JNIHandles_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
98 |
GCH_PS_ObjectSynchronizer_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
99 |
GCH_PS_FlatProfiler_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
100 |
GCH_PS_Management_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
101 |
GCH_PS_SystemDictionary_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
102 |
GCH_PS_ClassLoaderDataGraph_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
103 |
GCH_PS_jvmti_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
104 |
GCH_PS_CodeCache_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
105 |
GCH_PS_aot_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
106 |
GCH_PS_younger_gens, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
107 |
// Leave this one last. |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
108 |
GCH_PS_NumElements |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
109 |
}; |
30152 | 110 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
111 |
// Data structure for claiming the (potentially) parallel tasks in |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
112 |
// (gen-specific) roots processing. |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
113 |
SubTasksDone* _process_strong_tasks; |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
114 |
|
1 | 115 |
// Helper functions for allocation |
116 |
HeapWord* attempt_allocation(size_t size, |
|
117 |
bool is_tlab, |
|
118 |
bool first_only); |
|
119 |
||
120 |
// Helper function for two callbacks below. |
|
121 |
// 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
|
122 |
void do_collection(bool full, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
123 |
bool clear_all_soft_refs, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
124 |
size_t size, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
125 |
bool is_tlab, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
126 |
GenerationType max_generation); |
1 | 127 |
|
128 |
// Callback from VM_GenCollectForAllocation operation. |
|
129 |
// This function does everything necessary/possible to satisfy an |
|
130 |
// allocation request that failed in the youngest generation that should |
|
131 |
// have handled it (including collection, expansion, etc.) |
|
132 |
HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab); |
|
133 |
||
134 |
// Callback from VM_GenCollectFull operation. |
|
135 |
// 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
|
136 |
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
|
137 |
void do_full_collection(bool clear_all_soft_refs, GenerationType max_generation); |
1 | 138 |
|
139 |
// Does the "cause" of GC indicate that |
|
140 |
// we absolutely __must__ clear soft refs? |
|
141 |
bool must_clear_all_soft_refs(); |
|
142 |
||
47819
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
143 |
GenCollectedHeap(GenCollectorPolicy *policy); |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
144 |
|
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
145 |
virtual void check_gen_kinds() = 0; |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
146 |
|
1 | 147 |
public: |
148 |
||
149 |
// Returns JNI_OK on success |
|
150 |
virtual jint initialize(); |
|
28939 | 151 |
|
1 | 152 |
// Does operations required after initialization has been done. |
153 |
void post_initialize(); |
|
154 |
||
29794 | 155 |
Generation* young_gen() const { return _young_gen; } |
156 |
Generation* old_gen() const { return _old_gen; } |
|
29200 | 157 |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
158 |
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
|
159 |
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
|
160 |
|
1 | 161 |
// The generational collector policy. |
162 |
GenCollectorPolicy* gen_policy() const { return _gen_policy; } |
|
29200 | 163 |
|
32735
c6063d028c3c
8134797: Remove explicit casts in CollectorPolicy hierarchy
kbarrett
parents:
32623
diff
changeset
|
164 |
virtual CollectorPolicy* collector_policy() const { return gen_policy(); } |
1 | 165 |
|
166 |
// Adaptive size policy |
|
167 |
virtual AdaptiveSizePolicy* size_policy() { |
|
168 |
return gen_policy()->size_policy(); |
|
169 |
} |
|
170 |
||
19986
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
171 |
// Return the (conservative) maximum heap alignment |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
172 |
static size_t conservative_max_heap_alignment() { |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
173 |
return Generation::GenGrain; |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
174 |
} |
33d188c66ed9
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
19286
diff
changeset
|
175 |
|
1 | 176 |
size_t capacity() const; |
177 |
size_t used() const; |
|
178 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
179 |
// Save the "used_region" for both generations. |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
180 |
void save_used_regions(); |
1 | 181 |
|
182 |
size_t max_capacity() const; |
|
183 |
||
32623
390a27af5657
8134626: Misc cleanups after generation array removal
jwilhelm
parents:
32361
diff
changeset
|
184 |
HeapWord* mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded); |
1 | 185 |
|
186 |
// We may support a shared contiguous allocation area, if the youngest |
|
187 |
// generation does. |
|
188 |
bool supports_inline_contig_alloc() const; |
|
41283
2615c024f3eb
8033552: Fix missing missing volatile specifiers in CAS operations in GC code
eosterlund
parents:
40892
diff
changeset
|
189 |
HeapWord* volatile* top_addr() const; |
1 | 190 |
HeapWord** end_addr() const; |
191 |
||
192 |
// Perform a full collection of the heap; intended for use in implementing |
|
193 |
// "System.gc". This implies as full a collection as the CollectedHeap |
|
194 |
// supports. Caller does not hold the Heap_lock on entry. |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
195 |
virtual void collect(GCCause::Cause cause); |
1 | 196 |
|
197 |
// The same as above but assume that the caller holds the Heap_lock. |
|
198 |
void collect_locked(GCCause::Cause cause); |
|
199 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
200 |
// Perform a full collection of generations up to and including max_generation. |
1 | 201 |
// 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
|
202 |
void collect(GCCause::Cause cause, GenerationType max_generation); |
1 | 203 |
|
11247 | 204 |
// Returns "TRUE" iff "p" points into the committed areas of the heap. |
1 | 205 |
// The methods is_in(), is_in_closed_subset() and is_in_youngest() may |
206 |
// be expensive to compute in general, so, to prevent |
|
207 |
// their inadvertent use in product jvm's, we restrict their use to |
|
208 |
// assertion checking or verification only. |
|
209 |
bool is_in(const void* p) const; |
|
210 |
||
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
211 |
// 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
|
212 |
// for the young generation. |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
213 |
// 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
|
214 |
bool is_in_young(oop p); |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
215 |
|
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
216 |
#ifdef ASSERT |
29803 | 217 |
bool is_in_partial_collection(const void* p); |
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
218 |
#endif |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
219 |
|
47624
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
220 |
virtual bool is_scavengable(oop obj) { |
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
221 |
return is_in_young(obj); |
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
222 |
} |
1 | 223 |
|
47624
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
224 |
// Optimized nmethod scanning support routines |
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
225 |
virtual void register_nmethod(nmethod* nm); |
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
226 |
virtual void verify_nmethod(nmethod* nmethod); |
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
227 |
|
1 | 228 |
// Iteration functions. |
30152 | 229 |
void oop_iterate_no_header(OopClosure* cl); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
230 |
void oop_iterate(ExtendedOopClosure* cl); |
1 | 231 |
void object_iterate(ObjectClosure* cl); |
1893
c82e388e17c5
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
1388
diff
changeset
|
232 |
void safe_object_iterate(ObjectClosure* cl); |
1 | 233 |
Space* space_containing(const void* addr) const; |
234 |
||
235 |
// A CollectedHeap is divided into a dense sequence of "blocks"; that is, |
|
236 |
// each address in the (reserved) heap is a member of exactly |
|
237 |
// one block. The defining characteristic of a block is that it is |
|
238 |
// possible to find its size, and thus to progress forward to the next |
|
239 |
// block. (Blocks may be of different sizes.) Thus, blocks may |
|
240 |
// represent Java objects, or they might be free blocks in a |
|
241 |
// free-list-based heap (or subheap), as long as the two kinds are |
|
242 |
// distinguishable and the size of each is determinable. |
|
243 |
||
244 |
// Returns the address of the start of the "block" that contains the |
|
245 |
// address "addr". We say "blocks" instead of "object" since some heaps |
|
246 |
// may not pack objects densely; a chunk may either be an object or a |
|
247 |
// non-object. |
|
248 |
virtual HeapWord* block_start(const void* addr) const; |
|
249 |
||
250 |
// Requires "addr" to be the start of a chunk, and returns its size. |
|
251 |
// "addr + size" is required to be the start of a new chunk, or the end |
|
252 |
// of the active area of the heap. Assumes (and verifies in non-product |
|
253 |
// builds) that addr is in the allocated part of the heap and is |
|
254 |
// the start of a chunk. |
|
255 |
virtual size_t block_size(const HeapWord* addr) const; |
|
256 |
||
257 |
// Requires "addr" to be the start of a block, and returns "TRUE" iff |
|
258 |
// the block is an object. Assumes (and verifies in non-product |
|
259 |
// builds) that addr is in the allocated part of the heap and is |
|
260 |
// the start of a chunk. |
|
261 |
virtual bool block_is_obj(const HeapWord* addr) const; |
|
262 |
||
263 |
// Section on TLAB's. |
|
264 |
virtual bool supports_tlab_allocation() const; |
|
265 |
virtual size_t tlab_capacity(Thread* thr) const; |
|
22552 | 266 |
virtual size_t tlab_used(Thread* thr) const; |
1 | 267 |
virtual size_t unsafe_max_tlab_alloc(Thread* thr) const; |
268 |
virtual HeapWord* allocate_new_tlab(size_t size); |
|
269 |
||
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
270 |
// Can a compiler initialize a new object without store barriers? |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
271 |
// 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
|
272 |
// via a TLAB up to the first subsequent safepoint. |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
273 |
virtual bool can_elide_tlab_store_barriers() const { |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
274 |
return true; |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
275 |
} |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
389
diff
changeset
|
276 |
|
4030
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
277 |
// 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
|
278 |
// 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
|
279 |
// 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
|
280 |
// 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
|
281 |
// kinds of collectors are implemented in the future. |
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
282 |
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
|
283 |
return is_in_young(new_obj); |
4030
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
284 |
} |
4c471254865e
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
3908
diff
changeset
|
285 |
|
1 | 286 |
// The "requestor" generation is performing some garbage collection |
287 |
// action for which it would be useful to have scratch space. The |
|
288 |
// requestor promises to allocate no more than "max_alloc_words" in any |
|
289 |
// older generation (via promotion say.) Any blocks of space that can |
|
290 |
// be provided are returned as a list of ScratchBlocks, sorted by |
|
291 |
// decreasing size. |
|
292 |
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
|
293 |
// 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
|
294 |
// contributed as it needs. |
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
295 |
void release_scratch(); |
1 | 296 |
|
297 |
// Ensure parsability: override |
|
298 |
virtual void ensure_parsability(bool retire_tlabs); |
|
299 |
||
300 |
// Time in ms since the longest time a collector ran in |
|
301 |
// in any generation. |
|
302 |
virtual jlong millis_since_last_gc(); |
|
303 |
||
304 |
// Total number of full collections completed. |
|
305 |
unsigned int total_full_collections_completed() { |
|
306 |
assert(_full_collections_completed <= _total_full_collections, |
|
307 |
"Can't complete more collections than were started"); |
|
308 |
return _full_collections_completed; |
|
309 |
} |
|
310 |
||
311 |
// Update above counter, as appropriate, at the end of a stop-world GC cycle |
|
312 |
unsigned int update_full_collections_completed(); |
|
313 |
// Update above counter, as appropriate, at the end of a concurrent GC cycle |
|
314 |
unsigned int update_full_collections_completed(unsigned int count); |
|
315 |
||
29200 | 316 |
// Update "time of last gc" for all generations to "now". |
1 | 317 |
void update_time_of_last_gc(jlong now) { |
29200 | 318 |
_young_gen->update_time_of_last_gc(now); |
319 |
_old_gen->update_time_of_last_gc(now); |
|
1 | 320 |
} |
321 |
||
322 |
// Update the gc statistics for each generation. |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
323 |
void update_gc_stats(Generation* current_generation, bool full) { |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
324 |
_old_gen->update_gc_stats(current_generation, full); |
1 | 325 |
} |
326 |
||
327 |
bool no_gc_in_progress() { return !is_gc_active(); } |
|
328 |
||
329 |
// Override. |
|
330 |
void prepare_for_verify(); |
|
331 |
||
332 |
// Override. |
|
35061 | 333 |
void verify(VerifyOption option); |
1 | 334 |
|
335 |
// Override. |
|
10997
0be4b3be7197
7099849: G1: include heap region information in hs_err files
tonyp
parents:
9997
diff
changeset
|
336 |
virtual void print_on(outputStream* st) const; |
1 | 337 |
virtual void print_gc_threads_on(outputStream* st) const; |
338 |
virtual void gc_threads_do(ThreadClosure* tc) const; |
|
339 |
virtual void print_tracing_info() const; |
|
340 |
||
35061 | 341 |
void print_heap_change(size_t young_prev_used, size_t old_prev_used) const; |
1 | 342 |
|
343 |
// The functions below are helper functions that a subclass of |
|
344 |
// "CollectedHeap" can use in the implementation of its virtual |
|
345 |
// functions. |
|
346 |
||
347 |
class GenClosure : public StackObj { |
|
348 |
public: |
|
349 |
virtual void do_generation(Generation* gen) = 0; |
|
350 |
}; |
|
351 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
352 |
// 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
|
353 |
// If "old_to_young" determines the order. |
1 | 354 |
void generation_iterate(GenClosure* cl, bool old_to_young); |
355 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
356 |
// Return "true" if all generations have reached the |
1 | 357 |
// maximal committed limit that they can reach, without a garbage |
358 |
// collection. |
|
359 |
virtual bool is_maximal_no_gc() const; |
|
360 |
||
33212 | 361 |
// 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
|
362 |
// generations in a fully generational heap. |
33212 | 363 |
CardTableRS* rem_set() { return _rem_set; } |
28217
57791914628c
8067499: G1SATBCardTableModRefBS should not inherit from CardTableModRefBSForCTRS
kbarrett
parents:
27898
diff
changeset
|
364 |
|
1 | 365 |
// Convenience function to be used in situations where the heap type can be |
366 |
// asserted to be this type. |
|
367 |
static GenCollectedHeap* heap(); |
|
368 |
||
41682
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
369 |
// The ScanningOption determines which of the roots |
1 | 370 |
// the closure is applied to: |
371 |
// "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
|
372 |
enum ScanningOption { |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
373 |
SO_None = 0x0, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
374 |
SO_AllCodeCache = 0x8, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
375 |
SO_ScavengeCodeCache = 0x10 |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
376 |
}; |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
377 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
378 |
protected: |
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
379 |
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
|
380 |
ScanningOption so, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
381 |
OopClosure* strong_roots, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
382 |
OopClosure* weak_roots, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
383 |
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
|
384 |
CLDClosure* weak_cld_closure, |
36591
d0622cab5983
8150013: ParNew: Prune nmethods scavengable list.
cvarming
parents:
35061
diff
changeset
|
385 |
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
|
386 |
|
41683
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
387 |
void process_string_table_roots(StrongRootsScope* scope, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
388 |
OopClosure* root_closure); |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
389 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
390 |
// Accessor for memory state verification support |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
391 |
NOT_PRODUCT( |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
392 |
virtual size_t skip_header_HeapWords() { return 0; } |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
393 |
) |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
394 |
|
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
395 |
virtual void gc_prologue(bool full); |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
396 |
virtual void gc_epilogue(bool full); |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
397 |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
398 |
public: |
41682
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
399 |
void young_process_roots(StrongRootsScope* scope, |
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
400 |
OopsInGenClosure* root_closure, |
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
401 |
OopsInGenClosure* old_gen_closure, |
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
402 |
CLDClosure* cld_closure); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
403 |
|
41683
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
404 |
void full_process_roots(StrongRootsScope* scope, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
405 |
bool is_adjust_phase, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
406 |
ScanningOption so, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
407 |
bool only_strong_roots, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
408 |
OopsInGenClosure* root_closure, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
409 |
CLDClosure* cld_closure); |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
410 |
|
22882
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
411 |
// 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
|
412 |
// These include JNI weak roots, string table, |
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
413 |
// and referents of reachable weak refs. |
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
414 |
void gen_process_weak_roots(OopClosure* root_closure); |
1 | 415 |
|
416 |
// Set the saved marks of generations, if that makes sense. |
|
417 |
// In particular, if any generation might iterate over the oops |
|
418 |
// in other generations, it should call this method. |
|
419 |
void save_marks(); |
|
420 |
||
421 |
// Apply "cur->do_oop" or "older->do_oop" to all the oops in objects |
|
422 |
// 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
|
423 |
// "level". The "cur" closure is |
1 | 424 |
// 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
|
425 |
// closure to older generations. |
1 | 426 |
#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
|
427 |
void oop_since_save_marks_iterate(GenerationType start_gen, \ |
1 | 428 |
OopClosureType* cur, \ |
429 |
OopClosureType* older); |
|
430 |
||
431 |
ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DECL) |
|
432 |
||
433 |
#undef GCH_SINCE_SAVE_MARKS_ITERATE_DECL |
|
434 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
435 |
// Returns "true" iff no allocations have occurred since the last |
1 | 436 |
// call to "save_marks". |
31780 | 437 |
bool no_allocs_since_save_marks(); |
1 | 438 |
|
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
439 |
// 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
|
440 |
// 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
|
441 |
// 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
|
442 |
// 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
|
443 |
bool incremental_collection_will_fail(bool consult_young) { |
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
444 |
// 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
|
445 |
// 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
|
446 |
return incremental_collection_failed() || |
29684
a36d90acae41
8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents:
29200
diff
changeset
|
447 |
(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
|
448 |
} |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
449 |
|
1 | 450 |
// If a generation bails out of an incremental collection, |
451 |
// it sets this flag. |
|
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
452 |
bool incremental_collection_failed() const { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
453 |
return _incremental_collection_failed; |
1 | 454 |
} |
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
455 |
void set_incremental_collection_failed() { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
456 |
_incremental_collection_failed = true; |
1 | 457 |
} |
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
458 |
void clear_incremental_collection_failed() { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
459 |
_incremental_collection_failed = false; |
1 | 460 |
} |
461 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
462 |
// Promotion of obj into gen failed. Try to promote obj to higher |
1 | 463 |
// 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
|
464 |
// 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
|
465 |
// 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
|
466 |
oop handle_failed_promotion(Generation* old_gen, |
1 | 467 |
oop obj, |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
468 |
size_t obj_size); |
1 | 469 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
470 |
|
1 | 471 |
private: |
472 |
// Override |
|
473 |
void check_for_non_bad_heap_word_value(HeapWord* addr, |
|
474 |
size_t size) PRODUCT_RETURN; |
|
475 |
||
476 |
// For use by mark-sweep. As implemented, mark-sweep-compact is global |
|
477 |
// in an essential way: compaction is performed across generations, by |
|
478 |
// iterating over spaces. |
|
479 |
void prepare_for_compaction(); |
|
480 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
481 |
// Perform a full collection of the generations up to and including max_generation. |
1 | 482 |
// This is the low level interface used by the public versions of |
483 |
// 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
|
484 |
void collect_locked(GCCause::Cause cause, GenerationType max_generation); |
1 | 485 |
|
971
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
486 |
// 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
|
487 |
void record_gen_tops_before_GC() PRODUCT_RETURN; |
1 | 488 |
}; |
7397 | 489 |
|
30764 | 490 |
#endif // SHARE_VM_GC_SHARED_GENCOLLECTEDHEAP_HPP |