author | stefank |
Mon, 15 Apr 2019 11:47:46 +0200 | |
changeset 54678 | 93f09ca4a7f8 |
parent 54669 | ad45b3802d4e |
child 55740 | b3ff56f955c8 |
child 58678 | 9cf78a70fa4f |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
50800
diff
changeset
|
2 |
* Copyright (c) 2000, 2019, 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 |
||
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
50800
diff
changeset
|
25 |
#ifndef SHARE_GC_SHARED_GENCOLLECTEDHEAP_HPP |
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
50800
diff
changeset
|
26 |
#define SHARE_GC_SHARED_GENCOLLECTEDHEAP_HPP |
7397 | 27 |
|
30764 | 28 |
#include "gc/shared/collectedHeap.hpp" |
29 |
#include "gc/shared/generation.hpp" |
|
50445
bd6b78feb6a3
8195097: Make it possible to process StringTable outside safepoint
rehn
parents:
50297
diff
changeset
|
30 |
#include "gc/shared/oopStorageParState.hpp" |
49047
8f004146e407
8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents:
49046
diff
changeset
|
31 |
#include "gc/shared/softRefGenPolicy.hpp" |
7397 | 32 |
|
49048
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
33 |
class AdaptiveSizePolicy; |
54678
93f09ca4a7f8
8198505: Remove CollectorPolicy and its subclasses
stefank
parents:
54669
diff
changeset
|
34 |
class CardTableRS; |
49050
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
35 |
class GCPolicyCounters; |
49049
effb50eeea4e
8198528: Move GenerationSpecs from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49048
diff
changeset
|
36 |
class GenerationSpec; |
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
37 |
class StrongRootsScope; |
1 | 38 |
class SubTasksDone; |
32361
3de9a2e1e2d0
8087324: Use semaphores when starting and stopping GC task threads
stefank
parents:
32360
diff
changeset
|
39 |
class WorkGang; |
1 | 40 |
|
30154 | 41 |
// A "GenCollectedHeap" is a CollectedHeap that uses generational |
29200 | 42 |
// collection. It has two generations, young and old. |
30154 | 43 |
class GenCollectedHeap : public CollectedHeap { |
1 | 44 |
friend class Generation; |
45 |
friend class DefNewGeneration; |
|
46 |
friend class TenuredGeneration; |
|
47 |
friend class ConcurrentMarkSweepGeneration; |
|
48 |
friend class CMSCollector; |
|
49 |
friend class GenMarkSweep; |
|
50 |
friend class VM_GenCollectForAllocation; |
|
51 |
friend class VM_GenCollectFull; |
|
52 |
friend class VM_GenCollectFullConcurrent; |
|
53 |
friend class VM_GC_HeapInspection; |
|
54 |
friend class VM_HeapDumper; |
|
55 |
friend class HeapInspection; |
|
56 |
friend class GCCauseSetter; |
|
57 |
friend class VMStructs; |
|
58 |
public: |
|
59 |
friend class VM_PopulateDumpSharedSpace; |
|
60 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
61 |
enum GenerationType { |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
62 |
YoungGen, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
63 |
OldGen |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
64 |
}; |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
65 |
|
50033
000c697c81db
8202639: Use concrete Generation classes in SerialHeap and CMSHeap
stefank
parents:
49982
diff
changeset
|
66 |
protected: |
29200 | 67 |
Generation* _young_gen; |
68 |
Generation* _old_gen; |
|
69 |
||
50033
000c697c81db
8202639: Use concrete Generation classes in SerialHeap and CMSHeap
stefank
parents:
49982
diff
changeset
|
70 |
private: |
49049
effb50eeea4e
8198528: Move GenerationSpecs from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49048
diff
changeset
|
71 |
GenerationSpec* _young_gen_spec; |
effb50eeea4e
8198528: Move GenerationSpecs from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49048
diff
changeset
|
72 |
GenerationSpec* _old_gen_spec; |
effb50eeea4e
8198528: Move GenerationSpecs from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49048
diff
changeset
|
73 |
|
33212 | 74 |
// The singleton CardTable Remembered Set. |
75 |
CardTableRS* _rem_set; |
|
28217
57791914628c
8067499: G1SATBCardTableModRefBS should not inherit from CardTableModRefBSForCTRS
kbarrett
parents:
27898
diff
changeset
|
76 |
|
49047
8f004146e407
8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents:
49046
diff
changeset
|
77 |
SoftRefGenPolicy _soft_ref_gen_policy; |
8f004146e407
8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents:
49046
diff
changeset
|
78 |
|
49048
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
79 |
// The sizing of the heap is controlled by a sizing policy. |
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
80 |
AdaptiveSizePolicy* _size_policy; |
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
81 |
|
49050
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
82 |
GCPolicyCounters* _gc_policy_counters; |
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
83 |
|
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
84 |
// 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
|
85 |
// 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
|
86 |
// 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
|
87 |
bool _incremental_collection_failed; |
1 | 88 |
|
89 |
// In support of ExplicitGCInvokesConcurrent functionality |
|
90 |
unsigned int _full_collections_completed; |
|
91 |
||
29200 | 92 |
// Collects the given generation. |
93 |
void collect_generation(Generation* gen, bool full, size_t size, bool is_tlab, |
|
94 |
bool run_verification, bool clear_soft_refs, |
|
95 |
bool restore_marks_for_biased_locking); |
|
96 |
||
47819
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
97 |
// 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
|
98 |
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
|
99 |
|
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
100 |
// Initialize ("weak") refs processing support |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
101 |
void ref_processing_init(); |
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
102 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
103 |
protected: |
1 | 104 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
105 |
// 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
|
106 |
enum GCH_strong_roots_tasks { |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
107 |
GCH_PS_Universe_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
108 |
GCH_PS_JNIHandles_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
109 |
GCH_PS_ObjectSynchronizer_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
110 |
GCH_PS_FlatProfiler_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
111 |
GCH_PS_Management_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
112 |
GCH_PS_SystemDictionary_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
113 |
GCH_PS_ClassLoaderDataGraph_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
114 |
GCH_PS_jvmti_oops_do, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
115 |
GCH_PS_CodeCache_oops_do, |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54375
diff
changeset
|
116 |
AOT_ONLY(GCH_PS_aot_oops_do COMMA) |
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54375
diff
changeset
|
117 |
JVMCI_ONLY(GCH_PS_jvmci_oops_do COMMA) |
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
118 |
GCH_PS_younger_gens, |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
119 |
// Leave this one last. |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
120 |
GCH_PS_NumElements |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
121 |
}; |
30152 | 122 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
123 |
// 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
|
124 |
// (gen-specific) roots processing. |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
125 |
SubTasksDone* _process_strong_tasks; |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
126 |
|
48168
cb5d2d4453d0
8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents:
47819
diff
changeset
|
127 |
GCMemoryManager* _young_manager; |
cb5d2d4453d0
8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents:
47819
diff
changeset
|
128 |
GCMemoryManager* _old_manager; |
cb5d2d4453d0
8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents:
47819
diff
changeset
|
129 |
|
1 | 130 |
// Helper functions for allocation |
131 |
HeapWord* attempt_allocation(size_t size, |
|
132 |
bool is_tlab, |
|
133 |
bool first_only); |
|
134 |
||
135 |
// Helper function for two callbacks below. |
|
136 |
// 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
|
137 |
void do_collection(bool full, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
138 |
bool clear_all_soft_refs, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
139 |
size_t size, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
140 |
bool is_tlab, |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
141 |
GenerationType max_generation); |
1 | 142 |
|
143 |
// Callback from VM_GenCollectForAllocation operation. |
|
144 |
// This function does everything necessary/possible to satisfy an |
|
145 |
// allocation request that failed in the youngest generation that should |
|
146 |
// have handled it (including collection, expansion, etc.) |
|
147 |
HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab); |
|
148 |
||
149 |
// Callback from VM_GenCollectFull operation. |
|
150 |
// 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
|
151 |
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
|
152 |
void do_full_collection(bool clear_all_soft_refs, GenerationType max_generation); |
1 | 153 |
|
154 |
// Does the "cause" of GC indicate that |
|
155 |
// we absolutely __must__ clear soft refs? |
|
156 |
bool must_clear_all_soft_refs(); |
|
157 |
||
54678
93f09ca4a7f8
8198505: Remove CollectorPolicy and its subclasses
stefank
parents:
54669
diff
changeset
|
158 |
GenCollectedHeap(Generation::Name young, |
49050
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
159 |
Generation::Name old, |
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
160 |
const char* policy_counters_name); |
47819
ee36a8e36561
8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47624
diff
changeset
|
161 |
|
1 | 162 |
public: |
163 |
||
164 |
// Returns JNI_OK on success |
|
165 |
virtual jint initialize(); |
|
49733
6f0a3ea5ab75
8201209: Separate out CMS specific functions into CMSCardTable
stefank
parents:
49050
diff
changeset
|
166 |
virtual CardTableRS* create_rem_set(const MemRegion& reserved_region); |
28939 | 167 |
|
49048
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
168 |
void initialize_size_policy(size_t init_eden_size, |
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
169 |
size_t init_promo_size, |
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
170 |
size_t init_survivor_size); |
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
171 |
|
1 | 172 |
// Does operations required after initialization has been done. |
173 |
void post_initialize(); |
|
174 |
||
29794 | 175 |
Generation* young_gen() const { return _young_gen; } |
176 |
Generation* old_gen() const { return _old_gen; } |
|
29200 | 177 |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
178 |
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
|
179 |
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
|
180 |
|
49049
effb50eeea4e
8198528: Move GenerationSpecs from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49048
diff
changeset
|
181 |
GenerationSpec* young_gen_spec() const; |
effb50eeea4e
8198528: Move GenerationSpecs from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49048
diff
changeset
|
182 |
GenerationSpec* old_gen_spec() const; |
effb50eeea4e
8198528: Move GenerationSpecs from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49048
diff
changeset
|
183 |
|
49047
8f004146e407
8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents:
49046
diff
changeset
|
184 |
virtual SoftRefPolicy* soft_ref_policy() { return &_soft_ref_gen_policy; } |
8f004146e407
8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents:
49046
diff
changeset
|
185 |
|
1 | 186 |
// Adaptive size policy |
187 |
virtual AdaptiveSizePolicy* size_policy() { |
|
49048
4e8c86b75428
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap
stefank
parents:
49047
diff
changeset
|
188 |
return _size_policy; |
1 | 189 |
} |
190 |
||
49050
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
191 |
// Performance Counter support |
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
192 |
GCPolicyCounters* counters() { return _gc_policy_counters; } |
170c7b36aea6
8198530: Move _gc_policy_counters from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
49049
diff
changeset
|
193 |
|
1 | 194 |
size_t capacity() const; |
195 |
size_t used() const; |
|
196 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
197 |
// Save the "used_region" for both generations. |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
198 |
void save_used_regions(); |
1 | 199 |
|
200 |
size_t max_capacity() const; |
|
201 |
||
32623
390a27af5657
8134626: Misc cleanups after generation array removal
jwilhelm
parents:
32361
diff
changeset
|
202 |
HeapWord* mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded); |
1 | 203 |
|
204 |
// We may support a shared contiguous allocation area, if the youngest |
|
205 |
// generation does. |
|
206 |
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
|
207 |
HeapWord* volatile* top_addr() const; |
1 | 208 |
HeapWord** end_addr() const; |
209 |
||
210 |
// Perform a full collection of the heap; intended for use in implementing |
|
211 |
// "System.gc". This implies as full a collection as the CollectedHeap |
|
212 |
// 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
|
213 |
virtual void collect(GCCause::Cause cause); |
1 | 214 |
|
215 |
// The same as above but assume that the caller holds the Heap_lock. |
|
216 |
void collect_locked(GCCause::Cause cause); |
|
217 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
218 |
// Perform a full collection of generations up to and including max_generation. |
1 | 219 |
// 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
|
220 |
void collect(GCCause::Cause cause, GenerationType max_generation); |
1 | 221 |
|
11247 | 222 |
// Returns "TRUE" iff "p" points into the committed areas of the heap. |
54375
a5ce9300462f
8221648: Remove CollectedHeap::is_in_closed_subset()
pliden
parents:
54178
diff
changeset
|
223 |
// The methods is_in() and is_in_youngest() may be expensive to compute |
a5ce9300462f
8221648: Remove CollectedHeap::is_in_closed_subset()
pliden
parents:
54178
diff
changeset
|
224 |
// in general, so, to prevent their inadvertent use in product jvm's, we |
a5ce9300462f
8221648: Remove CollectedHeap::is_in_closed_subset()
pliden
parents:
54178
diff
changeset
|
225 |
// restrict their use to assertion checking or verification only. |
1 | 226 |
bool is_in(const void* p) const; |
227 |
||
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
228 |
// 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
|
229 |
// for the young generation. |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
230 |
// 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
|
231 |
bool is_in_young(oop p); |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
232 |
|
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
233 |
#ifdef ASSERT |
29803 | 234 |
bool is_in_partial_collection(const void* p); |
9935
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
235 |
#endif |
51267b5e1a3d
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
9342
diff
changeset
|
236 |
|
47624
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
237 |
// Optimized nmethod scanning support routines |
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
238 |
virtual void register_nmethod(nmethod* nm); |
54122
4b1426ed1c44
8220343: Move scavenge_root_nmethods from shared code
stefank
parents:
54093
diff
changeset
|
239 |
virtual void unregister_nmethod(nmethod* nm); |
4b1426ed1c44
8220343: Move scavenge_root_nmethods from shared code
stefank
parents:
54093
diff
changeset
|
240 |
virtual void verify_nmethod(nmethod* nm); |
4b1426ed1c44
8220343: Move scavenge_root_nmethods from shared code
stefank
parents:
54093
diff
changeset
|
241 |
virtual void flush_nmethod(nmethod* nm); |
4b1426ed1c44
8220343: Move scavenge_root_nmethods from shared code
stefank
parents:
54093
diff
changeset
|
242 |
|
54178 | 243 |
void prune_scavengable_nmethods(); |
47624
b055cb5170f5
8185141: Generalize scavengeable nmethod root handling
eosterlund
parents:
47622
diff
changeset
|
244 |
|
1 | 245 |
// Iteration functions. |
50752 | 246 |
void oop_iterate(OopIterateClosure* cl); |
1 | 247 |
void object_iterate(ObjectClosure* cl); |
1893
c82e388e17c5
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
1388
diff
changeset
|
248 |
void safe_object_iterate(ObjectClosure* cl); |
1 | 249 |
Space* space_containing(const void* addr) const; |
250 |
||
251 |
// A CollectedHeap is divided into a dense sequence of "blocks"; that is, |
|
252 |
// each address in the (reserved) heap is a member of exactly |
|
253 |
// one block. The defining characteristic of a block is that it is |
|
254 |
// possible to find its size, and thus to progress forward to the next |
|
255 |
// block. (Blocks may be of different sizes.) Thus, blocks may |
|
256 |
// represent Java objects, or they might be free blocks in a |
|
257 |
// free-list-based heap (or subheap), as long as the two kinds are |
|
258 |
// distinguishable and the size of each is determinable. |
|
259 |
||
260 |
// Returns the address of the start of the "block" that contains the |
|
261 |
// address "addr". We say "blocks" instead of "object" since some heaps |
|
262 |
// may not pack objects densely; a chunk may either be an object or a |
|
263 |
// non-object. |
|
264 |
virtual HeapWord* block_start(const void* addr) const; |
|
265 |
||
266 |
// Requires "addr" to be the start of a block, and returns "TRUE" iff |
|
267 |
// the block is an object. Assumes (and verifies in non-product |
|
268 |
// builds) that addr is in the allocated part of the heap and is |
|
269 |
// the start of a chunk. |
|
270 |
virtual bool block_is_obj(const HeapWord* addr) const; |
|
271 |
||
272 |
// Section on TLAB's. |
|
273 |
virtual bool supports_tlab_allocation() const; |
|
274 |
virtual size_t tlab_capacity(Thread* thr) const; |
|
22552 | 275 |
virtual size_t tlab_used(Thread* thr) const; |
1 | 276 |
virtual size_t unsafe_max_tlab_alloc(Thread* thr) const; |
49945 | 277 |
virtual HeapWord* allocate_new_tlab(size_t min_size, |
278 |
size_t requested_size, |
|
279 |
size_t* actual_size); |
|
1 | 280 |
|
281 |
// The "requestor" generation is performing some garbage collection |
|
282 |
// action for which it would be useful to have scratch space. The |
|
283 |
// requestor promises to allocate no more than "max_alloc_words" in any |
|
284 |
// older generation (via promotion say.) Any blocks of space that can |
|
285 |
// be provided are returned as a list of ScratchBlocks, sorted by |
|
286 |
// decreasing size. |
|
287 |
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
|
288 |
// 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
|
289 |
// contributed as it needs. |
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
290 |
void release_scratch(); |
1 | 291 |
|
292 |
// Ensure parsability: override |
|
293 |
virtual void ensure_parsability(bool retire_tlabs); |
|
294 |
||
295 |
// Time in ms since the longest time a collector ran in |
|
296 |
// in any generation. |
|
297 |
virtual jlong millis_since_last_gc(); |
|
298 |
||
299 |
// Total number of full collections completed. |
|
300 |
unsigned int total_full_collections_completed() { |
|
301 |
assert(_full_collections_completed <= _total_full_collections, |
|
302 |
"Can't complete more collections than were started"); |
|
303 |
return _full_collections_completed; |
|
304 |
} |
|
305 |
||
306 |
// Update above counter, as appropriate, at the end of a stop-world GC cycle |
|
307 |
unsigned int update_full_collections_completed(); |
|
308 |
// Update above counter, as appropriate, at the end of a concurrent GC cycle |
|
309 |
unsigned int update_full_collections_completed(unsigned int count); |
|
310 |
||
29200 | 311 |
// Update "time of last gc" for all generations to "now". |
1 | 312 |
void update_time_of_last_gc(jlong now) { |
29200 | 313 |
_young_gen->update_time_of_last_gc(now); |
314 |
_old_gen->update_time_of_last_gc(now); |
|
1 | 315 |
} |
316 |
||
317 |
// Update the gc statistics for each generation. |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
318 |
void update_gc_stats(Generation* current_generation, bool full) { |
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
319 |
_old_gen->update_gc_stats(current_generation, full); |
1 | 320 |
} |
321 |
||
322 |
bool no_gc_in_progress() { return !is_gc_active(); } |
|
323 |
||
324 |
// Override. |
|
325 |
void prepare_for_verify(); |
|
326 |
||
327 |
// Override. |
|
35061 | 328 |
void verify(VerifyOption option); |
1 | 329 |
|
330 |
// Override. |
|
10997
0be4b3be7197
7099849: G1: include heap region information in hs_err files
tonyp
parents:
9997
diff
changeset
|
331 |
virtual void print_on(outputStream* st) const; |
1 | 332 |
virtual void print_gc_threads_on(outputStream* st) const; |
333 |
virtual void gc_threads_do(ThreadClosure* tc) const; |
|
334 |
virtual void print_tracing_info() const; |
|
335 |
||
35061 | 336 |
void print_heap_change(size_t young_prev_used, size_t old_prev_used) const; |
1 | 337 |
|
338 |
// The functions below are helper functions that a subclass of |
|
339 |
// "CollectedHeap" can use in the implementation of its virtual |
|
340 |
// functions. |
|
341 |
||
342 |
class GenClosure : public StackObj { |
|
343 |
public: |
|
344 |
virtual void do_generation(Generation* gen) = 0; |
|
345 |
}; |
|
346 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
347 |
// 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
|
348 |
// If "old_to_young" determines the order. |
1 | 349 |
void generation_iterate(GenClosure* cl, bool old_to_young); |
350 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
351 |
// Return "true" if all generations have reached the |
1 | 352 |
// maximal committed limit that they can reach, without a garbage |
353 |
// collection. |
|
354 |
virtual bool is_maximal_no_gc() const; |
|
355 |
||
33212 | 356 |
// 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
|
357 |
// generations in a fully generational heap. |
33212 | 358 |
CardTableRS* rem_set() { return _rem_set; } |
28217
57791914628c
8067499: G1SATBCardTableModRefBS should not inherit from CardTableModRefBSForCTRS
kbarrett
parents:
27898
diff
changeset
|
359 |
|
1 | 360 |
// Convenience function to be used in situations where the heap type can be |
361 |
// asserted to be this type. |
|
362 |
static GenCollectedHeap* heap(); |
|
363 |
||
41682
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
364 |
// The ScanningOption determines which of the roots |
1 | 365 |
// the closure is applied to: |
366 |
// "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
|
367 |
enum ScanningOption { |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
368 |
SO_None = 0x0, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
369 |
SO_AllCodeCache = 0x8, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
370 |
SO_ScavengeCodeCache = 0x10 |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
371 |
}; |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
372 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
373 |
protected: |
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30764
diff
changeset
|
374 |
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
|
375 |
ScanningOption so, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
376 |
OopClosure* strong_roots, |
fac175f7a466
8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents:
29684
diff
changeset
|
377 |
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
|
378 |
CLDClosure* weak_cld_closure, |
36591
d0622cab5983
8150013: ParNew: Prune nmethods scavengable list.
cvarming
parents:
35061
diff
changeset
|
379 |
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
|
380 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
381 |
// Accessor for memory state verification support |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
382 |
NOT_PRODUCT( |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
383 |
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
|
384 |
) |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
385 |
|
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
386 |
virtual void gc_prologue(bool full); |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
387 |
virtual void gc_epilogue(bool full); |
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
388 |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
389 |
public: |
41682
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
390 |
void young_process_roots(StrongRootsScope* scope, |
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
391 |
OopsInGenClosure* root_closure, |
b63330180476
8166276: Refactor gen_process_roots to allow simpler fix for 8165949
jwilhelm
parents:
41283
diff
changeset
|
392 |
OopsInGenClosure* old_gen_closure, |
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
53244
diff
changeset
|
393 |
CLDClosure* cld_closure); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
394 |
|
41683
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
395 |
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
|
396 |
bool is_adjust_phase, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
397 |
ScanningOption so, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
398 |
bool only_strong_roots, |
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
399 |
OopsInGenClosure* root_closure, |
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
53244
diff
changeset
|
400 |
CLDClosure* cld_closure); |
41683
cd5d2527e163
8165949: Serial and ConcMarkSweep do not unload strings when class unloading is disabled
sjohanss
parents:
41682
diff
changeset
|
401 |
|
22882
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
402 |
// 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
|
403 |
// These include JNI weak roots, string table, |
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
404 |
// and referents of reachable weak refs. |
195c8f70d605
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
22552
diff
changeset
|
405 |
void gen_process_weak_roots(OopClosure* root_closure); |
1 | 406 |
|
407 |
// Set the saved marks of generations, if that makes sense. |
|
408 |
// In particular, if any generation might iterate over the oops |
|
409 |
// in other generations, it should call this method. |
|
410 |
void save_marks(); |
|
411 |
||
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
412 |
// Returns "true" iff no allocations have occurred since the last |
1 | 413 |
// call to "save_marks". |
31780 | 414 |
bool no_allocs_since_save_marks(); |
1 | 415 |
|
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
416 |
// 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
|
417 |
// 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
|
418 |
// 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
|
419 |
// 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
|
420 |
bool incremental_collection_will_fail(bool consult_young) { |
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
421 |
// 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
|
422 |
// 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
|
423 |
return incremental_collection_failed() || |
29684
a36d90acae41
8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents:
29200
diff
changeset
|
424 |
(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
|
425 |
} |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
426 |
|
1 | 427 |
// If a generation bails out of an incremental collection, |
428 |
// it sets this flag. |
|
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
429 |
bool incremental_collection_failed() const { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
430 |
return _incremental_collection_failed; |
1 | 431 |
} |
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
432 |
void set_incremental_collection_failed() { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
433 |
_incremental_collection_failed = true; |
1 | 434 |
} |
6985
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
435 |
void clear_incremental_collection_failed() { |
e9364ec299ac
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
6759
diff
changeset
|
436 |
_incremental_collection_failed = false; |
1 | 437 |
} |
438 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
12379
diff
changeset
|
439 |
// Promotion of obj into gen failed. Try to promote obj to higher |
1 | 440 |
// 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
|
441 |
// 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
|
442 |
// 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
|
443 |
oop handle_failed_promotion(Generation* old_gen, |
1 | 444 |
oop obj, |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
445 |
size_t obj_size); |
1 | 446 |
|
47622
817f2a7019e4
8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents:
47216
diff
changeset
|
447 |
|
1 | 448 |
private: |
49046
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
449 |
// Return true if an allocation should be attempted in the older generation |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
450 |
// if it fails in the younger generation. Return false, otherwise. |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
451 |
bool should_try_older_generation_allocation(size_t word_size) const; |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
452 |
|
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
453 |
// Try to allocate space by expanding the heap. |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
454 |
HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab); |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
455 |
|
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
456 |
HeapWord* mem_allocate_work(size_t size, |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
457 |
bool is_tlab, |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
458 |
bool* gc_overhead_limit_was_exceeded); |
c8e4dc1b9e39
8198511: Move allocation functions from GenCollectorPolicy to GenCollectedHeap
stefank
parents:
48961
diff
changeset
|
459 |
|
1 | 460 |
// Override |
461 |
void check_for_non_bad_heap_word_value(HeapWord* addr, |
|
462 |
size_t size) PRODUCT_RETURN; |
|
463 |
||
49982 | 464 |
#if INCLUDE_SERIALGC |
1 | 465 |
// For use by mark-sweep. As implemented, mark-sweep-compact is global |
466 |
// in an essential way: compaction is performed across generations, by |
|
467 |
// iterating over spaces. |
|
468 |
void prepare_for_compaction(); |
|
49982 | 469 |
#endif |
1 | 470 |
|
31358
693058672cc6
8077842: Remove the level parameter passed around in GenCollectedHeap
jwilhelm
parents:
30871
diff
changeset
|
471 |
// Perform a full collection of the generations up to and including max_generation. |
1 | 472 |
// This is the low level interface used by the public versions of |
473 |
// 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
|
474 |
void collect_locked(GCCause::Cause cause, GenerationType max_generation); |
1 | 475 |
|
971
f0b20be4165d
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
389
diff
changeset
|
476 |
// 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
|
477 |
void record_gen_tops_before_GC() PRODUCT_RETURN; |
54019 | 478 |
|
479 |
// Return true if we need to perform full collection. |
|
480 |
bool should_do_full_collection(size_t size, bool full, |
|
481 |
bool is_tlab, GenerationType max_gen) const; |
|
1 | 482 |
}; |
7397 | 483 |
|
53244
9807daeb47c4
8216167: Update include guards to reflect correct directories
coleenp
parents:
50800
diff
changeset
|
484 |
#endif // SHARE_GC_SHARED_GENCOLLECTEDHEAP_HPP |