Mercurial > hg > truffle
annotate src/share/vm/memory/genCollectedHeap.hpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 439f0d76cff3 |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12030
diff
changeset
|
2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1166
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1166
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1166
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP |
| 26 #define SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP | |
| 27 | |
| 28 #include "gc_implementation/shared/adaptiveSizePolicy.hpp" | |
| 29 #include "memory/collectorPolicy.hpp" | |
| 30 #include "memory/generation.hpp" | |
| 31 #include "memory/sharedHeap.hpp" | |
| 32 | |
| 0 | 33 class SubTasksDone; |
| 34 | |
| 35 // A "GenCollectedHeap" is a SharedHeap that uses generational | |
| 36 // collection. It is represented with a sequence of Generation's. | |
| 37 class GenCollectedHeap : public SharedHeap { | |
| 38 friend class GenCollectorPolicy; | |
| 39 friend class Generation; | |
| 40 friend class DefNewGeneration; | |
| 41 friend class TenuredGeneration; | |
| 42 friend class ConcurrentMarkSweepGeneration; | |
| 43 friend class CMSCollector; | |
| 44 friend class GenMarkSweep; | |
| 45 friend class VM_GenCollectForAllocation; | |
| 46 friend class VM_GenCollectFull; | |
| 47 friend class VM_GenCollectFullConcurrent; | |
| 48 friend class VM_GC_HeapInspection; | |
| 49 friend class VM_HeapDumper; | |
| 50 friend class HeapInspection; | |
| 51 friend class GCCauseSetter; | |
| 52 friend class VMStructs; | |
| 53 public: | |
| 54 enum SomeConstants { | |
| 55 max_gens = 10 | |
| 56 }; | |
| 57 | |
| 58 friend class VM_PopulateDumpSharedSpace; | |
| 59 | |
| 60 protected: | |
| 61 // Fields: | |
| 62 static GenCollectedHeap* _gch; | |
| 63 | |
| 64 private: | |
| 65 int _n_gens; | |
| 66 Generation* _gens[max_gens]; | |
| 67 GenerationSpec** _gen_specs; | |
| 68 | |
| 69 // The generational collector policy. | |
| 70 GenCollectorPolicy* _gen_policy; | |
| 71 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
72 // Indicates that the most recent previous incremental collection failed. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
73 // The flag is cleared when an action is taken that might clear the |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
74 // condition that caused that incremental collection to fail. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
75 bool _incremental_collection_failed; |
| 0 | 76 |
| 77 // In support of ExplicitGCInvokesConcurrent functionality | |
| 78 unsigned int _full_collections_completed; | |
| 79 | |
| 80 // Data structure for claiming the (potentially) parallel tasks in | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
81 // (gen-specific) roots processing. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
82 SubTasksDone* _gen_process_roots_tasks; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
83 SubTasksDone* gen_process_roots_tasks() { return _gen_process_roots_tasks; } |
| 0 | 84 |
| 85 // In block contents verification, the number of header words to skip | |
| 86 NOT_PRODUCT(static size_t _skip_header_HeapWords;) | |
| 87 | |
| 88 protected: | |
| 89 // Helper functions for allocation | |
| 90 HeapWord* attempt_allocation(size_t size, | |
| 91 bool is_tlab, | |
| 92 bool first_only); | |
| 93 | |
| 94 // Helper function for two callbacks below. | |
| 95 // Considers collection of the first max_level+1 generations. | |
| 96 void do_collection(bool full, | |
| 97 bool clear_all_soft_refs, | |
| 98 size_t size, | |
| 99 bool is_tlab, | |
| 100 int max_level); | |
| 101 | |
| 102 // Callback from VM_GenCollectForAllocation operation. | |
| 103 // This function does everything necessary/possible to satisfy an | |
| 104 // allocation request that failed in the youngest generation that should | |
| 105 // have handled it (including collection, expansion, etc.) | |
| 106 HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab); | |
| 107 | |
| 108 // Callback from VM_GenCollectFull operation. | |
| 109 // Perform a full collection of the first max_level+1 generations. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
110 virtual void do_full_collection(bool clear_all_soft_refs); |
| 0 | 111 void do_full_collection(bool clear_all_soft_refs, int max_level); |
| 112 | |
| 113 // Does the "cause" of GC indicate that | |
| 114 // we absolutely __must__ clear soft refs? | |
| 115 bool must_clear_all_soft_refs(); | |
| 116 | |
| 117 public: | |
| 118 GenCollectedHeap(GenCollectorPolicy *policy); | |
| 119 | |
| 120 GCStats* gc_stats(int level) const; | |
| 121 | |
| 122 // Returns JNI_OK on success | |
| 123 virtual jint initialize(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
124 char* allocate(size_t alignment, |
| 0 | 125 size_t* _total_reserved, int* _n_covered_regions, |
| 126 ReservedSpace* heap_rs); | |
| 127 | |
| 128 // Does operations required after initialization has been done. | |
| 129 void post_initialize(); | |
| 130 | |
| 131 // Initialize ("weak") refs processing support | |
| 132 virtual void ref_processing_init(); | |
| 133 | |
| 134 virtual CollectedHeap::Name kind() const { | |
| 135 return CollectedHeap::GenCollectedHeap; | |
| 136 } | |
| 137 | |
| 138 // The generational collector policy. | |
| 139 GenCollectorPolicy* gen_policy() const { return _gen_policy; } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
140 virtual CollectorPolicy* collector_policy() const { return (CollectorPolicy*) gen_policy(); } |
| 0 | 141 |
| 142 // Adaptive size policy | |
| 143 virtual AdaptiveSizePolicy* size_policy() { | |
| 144 return gen_policy()->size_policy(); | |
| 145 } | |
| 146 | |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12030
diff
changeset
|
147 // Return the (conservative) maximum heap alignment |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12030
diff
changeset
|
148 static size_t conservative_max_heap_alignment() { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12030
diff
changeset
|
149 return Generation::GenGrain; |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12030
diff
changeset
|
150 } |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12030
diff
changeset
|
151 |
| 0 | 152 size_t capacity() const; |
| 153 size_t used() const; | |
| 154 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
155 // Save the "used_region" for generations level and lower. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
156 void save_used_regions(int level); |
| 0 | 157 |
| 158 size_t max_capacity() const; | |
| 159 | |
| 160 HeapWord* mem_allocate(size_t size, | |
| 161 bool* gc_overhead_limit_was_exceeded); | |
| 162 | |
| 163 // We may support a shared contiguous allocation area, if the youngest | |
| 164 // generation does. | |
| 165 bool supports_inline_contig_alloc() const; | |
| 166 HeapWord** top_addr() const; | |
| 167 HeapWord** end_addr() const; | |
| 168 | |
| 169 // Does this heap support heap inspection? (+PrintClassHistogram) | |
| 170 virtual bool supports_heap_inspection() const { return true; } | |
| 171 | |
| 172 // Perform a full collection of the heap; intended for use in implementing | |
| 173 // "System.gc". This implies as full a collection as the CollectedHeap | |
| 174 // supports. Caller does not hold the Heap_lock on entry. | |
| 175 void collect(GCCause::Cause cause); | |
| 176 | |
| 177 // The same as above but assume that the caller holds the Heap_lock. | |
| 178 void collect_locked(GCCause::Cause cause); | |
| 179 | |
| 180 // Perform a full collection of the first max_level+1 generations. | |
| 181 // Mostly used for testing purposes. Caller does not hold the Heap_lock on entry. | |
| 182 void collect(GCCause::Cause cause, int max_level); | |
| 183 | |
| 4708 | 184 // Returns "TRUE" iff "p" points into the committed areas of the heap. |
| 0 | 185 // The methods is_in(), is_in_closed_subset() and is_in_youngest() may |
| 186 // be expensive to compute in general, so, to prevent | |
| 187 // their inadvertent use in product jvm's, we restrict their use to | |
| 188 // assertion checking or verification only. | |
| 189 bool is_in(const void* p) const; | |
| 190 | |
| 191 // override | |
| 192 bool is_in_closed_subset(const void* p) const { | |
| 193 if (UseConcMarkSweepGC) { | |
| 194 return is_in_reserved(p); | |
| 195 } else { | |
| 196 return is_in(p); | |
| 197 } | |
| 198 } | |
| 199 | |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
200 // Returns true if the reference is to an object in the reserved space |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
201 // for the young generation. |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
202 // Assumes the the young gen address range is less than that of the old gen. |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
203 bool is_in_young(oop p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
204 |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
205 #ifdef ASSERT |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
206 virtual bool is_in_partial_collection(const void* p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
207 #endif |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
208 |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
209 virtual bool is_scavengable(const void* addr) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
210 return is_in_young((oop)addr); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
211 } |
| 0 | 212 |
| 213 // Iteration functions. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
214 void oop_iterate(ExtendedOopClosure* cl); |
| 0 | 215 void object_iterate(ObjectClosure* cl); |
|
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
216 void safe_object_iterate(ObjectClosure* cl); |
| 0 | 217 Space* space_containing(const void* addr) const; |
| 218 | |
| 219 // A CollectedHeap is divided into a dense sequence of "blocks"; that is, | |
| 220 // each address in the (reserved) heap is a member of exactly | |
| 221 // one block. The defining characteristic of a block is that it is | |
| 222 // possible to find its size, and thus to progress forward to the next | |
| 223 // block. (Blocks may be of different sizes.) Thus, blocks may | |
| 224 // represent Java objects, or they might be free blocks in a | |
| 225 // free-list-based heap (or subheap), as long as the two kinds are | |
| 226 // distinguishable and the size of each is determinable. | |
| 227 | |
| 228 // Returns the address of the start of the "block" that contains the | |
| 229 // address "addr". We say "blocks" instead of "object" since some heaps | |
| 230 // may not pack objects densely; a chunk may either be an object or a | |
| 231 // non-object. | |
| 232 virtual HeapWord* block_start(const void* addr) const; | |
| 233 | |
| 234 // Requires "addr" to be the start of a chunk, and returns its size. | |
| 235 // "addr + size" is required to be the start of a new chunk, or the end | |
| 236 // of the active area of the heap. Assumes (and verifies in non-product | |
| 237 // builds) that addr is in the allocated part of the heap and is | |
| 238 // the start of a chunk. | |
| 239 virtual size_t block_size(const HeapWord* addr) const; | |
| 240 | |
| 241 // Requires "addr" to be the start of a block, and returns "TRUE" iff | |
| 242 // the block is an object. Assumes (and verifies in non-product | |
| 243 // builds) that addr is in the allocated part of the heap and is | |
| 244 // the start of a chunk. | |
| 245 virtual bool block_is_obj(const HeapWord* addr) const; | |
| 246 | |
| 247 // Section on TLAB's. | |
| 248 virtual bool supports_tlab_allocation() const; | |
| 249 virtual size_t tlab_capacity(Thread* thr) const; | |
| 17727 | 250 virtual size_t tlab_used(Thread* thr) const; |
| 0 | 251 virtual size_t unsafe_max_tlab_alloc(Thread* thr) const; |
| 252 virtual HeapWord* allocate_new_tlab(size_t size); | |
| 253 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
254 // Can a compiler initialize a new object without store barriers? |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
255 // This permission only extends from the creation of a new object |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
256 // via a TLAB up to the first subsequent safepoint. |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
257 virtual bool can_elide_tlab_store_barriers() const { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
258 return true; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
259 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
142
diff
changeset
|
260 |
| 1166 | 261 virtual bool card_mark_must_follow_store() const { |
| 262 return UseConcMarkSweepGC; | |
| 263 } | |
| 264 | |
|
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
265 // We don't need barriers for stores to objects in the |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
266 // young gen and, a fortiori, for initializing stores to |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
267 // objects therein. This applies to {DefNew,ParNew}+{Tenured,CMS} |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
268 // only and may need to be re-examined in case other |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
269 // kinds of collectors are implemented in the future. |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
270 virtual bool can_elide_initializing_store_barrier(oop new_obj) { |
|
1028
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
271 // We wanted to assert that:- |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
272 // assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
273 // "Check can_elide_initializing_store_barrier() for this collector"); |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
274 // but unfortunately the flag UseSerialGC need not necessarily always |
|
052a899eec3e
6892749: assert(UseParNewGC || UseSerialGC || UseConcMarkSweepGC, "...") fails
ysr
parents:
1027
diff
changeset
|
275 // be set when DefNew+Tenured are being used. |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3293
diff
changeset
|
276 return is_in_young(new_obj); |
|
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
277 } |
|
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
989
diff
changeset
|
278 |
| 0 | 279 // The "requestor" generation is performing some garbage collection |
| 280 // action for which it would be useful to have scratch space. The | |
| 281 // requestor promises to allocate no more than "max_alloc_words" in any | |
| 282 // older generation (via promotion say.) Any blocks of space that can | |
| 283 // be provided are returned as a list of ScratchBlocks, sorted by | |
| 284 // decreasing size. | |
| 285 ScratchBlock* gather_scratch(Generation* requestor, size_t max_alloc_words); | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
286 // Allow each generation to reset any scratch space that it has |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
287 // contributed as it needs. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
288 void release_scratch(); |
| 0 | 289 |
| 290 // Ensure parsability: override | |
| 291 virtual void ensure_parsability(bool retire_tlabs); | |
| 292 | |
| 293 // Time in ms since the longest time a collector ran in | |
| 294 // in any generation. | |
| 295 virtual jlong millis_since_last_gc(); | |
| 296 | |
| 297 // Total number of full collections completed. | |
| 298 unsigned int total_full_collections_completed() { | |
| 299 assert(_full_collections_completed <= _total_full_collections, | |
| 300 "Can't complete more collections than were started"); | |
| 301 return _full_collections_completed; | |
| 302 } | |
| 303 | |
| 304 // Update above counter, as appropriate, at the end of a stop-world GC cycle | |
| 305 unsigned int update_full_collections_completed(); | |
| 306 // Update above counter, as appropriate, at the end of a concurrent GC cycle | |
| 307 unsigned int update_full_collections_completed(unsigned int count); | |
| 308 | |
| 309 // Update "time of last gc" for all constituent generations | |
| 310 // to "now". | |
| 311 void update_time_of_last_gc(jlong now) { | |
| 312 for (int i = 0; i < _n_gens; i++) { | |
| 313 _gens[i]->update_time_of_last_gc(now); | |
| 314 } | |
| 315 } | |
| 316 | |
| 317 // Update the gc statistics for each generation. | |
| 318 // "level" is the level of the lastest collection | |
| 319 void update_gc_stats(int current_level, bool full) { | |
| 320 for (int i = 0; i < _n_gens; i++) { | |
| 321 _gens[i]->update_gc_stats(current_level, full); | |
| 322 } | |
| 323 } | |
| 324 | |
| 325 // Override. | |
| 326 bool no_gc_in_progress() { return !is_gc_active(); } | |
| 327 | |
| 328 // Override. | |
| 329 void prepare_for_verify(); | |
| 330 | |
| 331 // Override. | |
| 6008 | 332 void verify(bool silent, VerifyOption option); |
| 0 | 333 |
| 334 // Override. | |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
3774
diff
changeset
|
335 virtual void print_on(outputStream* st) const; |
| 0 | 336 virtual void print_gc_threads_on(outputStream* st) const; |
| 337 virtual void gc_threads_do(ThreadClosure* tc) const; | |
| 338 virtual void print_tracing_info() const; | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
6725
diff
changeset
|
339 virtual void print_on_error(outputStream* st) const; |
| 0 | 340 |
| 341 // PrintGC, PrintGCDetails support | |
| 342 void print_heap_change(size_t prev_used) const; | |
| 343 | |
| 344 // The functions below are helper functions that a subclass of | |
| 345 // "CollectedHeap" can use in the implementation of its virtual | |
| 346 // functions. | |
| 347 | |
| 348 class GenClosure : public StackObj { | |
| 349 public: | |
| 350 virtual void do_generation(Generation* gen) = 0; | |
| 351 }; | |
| 352 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
353 // Apply "cl.do_generation" to all generations in the heap |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
354 // If "old_to_young" determines the order. |
| 0 | 355 void generation_iterate(GenClosure* cl, bool old_to_young); |
| 356 | |
| 357 void space_iterate(SpaceClosure* cl); | |
| 358 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
359 // Return "true" if all generations have reached the |
| 0 | 360 // maximal committed limit that they can reach, without a garbage |
| 361 // collection. | |
| 362 virtual bool is_maximal_no_gc() const; | |
| 363 | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
364 // Return the generation before "gen". |
| 0 | 365 Generation* prev_gen(Generation* gen) const { |
| 366 int l = gen->level(); | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
367 guarantee(l > 0, "Out of bounds"); |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
368 return _gens[l-1]; |
| 0 | 369 } |
| 370 | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
371 // Return the generation after "gen". |
| 0 | 372 Generation* next_gen(Generation* gen) const { |
| 373 int l = gen->level() + 1; | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
374 guarantee(l < _n_gens, "Out of bounds"); |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
375 return _gens[l]; |
| 0 | 376 } |
| 377 | |
| 378 Generation* get_gen(int i) const { | |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
379 guarantee(i >= 0 && i < _n_gens, "Out of bounds"); |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
380 return _gens[i]; |
| 0 | 381 } |
| 382 | |
| 383 int n_gens() const { | |
| 384 assert(_n_gens == gen_policy()->number_of_generations(), "Sanity"); | |
| 385 return _n_gens; | |
| 386 } | |
| 387 | |
| 388 // Convenience function to be used in situations where the heap type can be | |
| 389 // asserted to be this type. | |
| 390 static GenCollectedHeap* heap(); | |
| 391 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4708
diff
changeset
|
392 void set_par_threads(uint t); |
| 0 | 393 |
| 394 // Invoke the "do_oop" method of one of the closures "not_older_gens" | |
| 395 // or "older_gens" on root locations for the generation at | |
| 396 // "level". (The "older_gens" closure is used for scanning references | |
| 397 // from older generations; "not_older_gens" is used everywhere else.) | |
| 398 // If "younger_gens_as_roots" is false, younger generations are | |
| 399 // not scanned as roots; in this case, the caller must be arranging to | |
| 400 // scan the younger generations itself. (For example, a generation might | |
| 401 // explicitly mark reachable objects in younger generations, to avoid | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
402 // excess storage retention.) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
403 // The "so" argument determines which of the roots |
| 0 | 404 // the closure is applied to: |
| 405 // "SO_None" does none; | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
406 private: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
407 void gen_process_roots(int level, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
408 bool younger_gens_as_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
409 bool activate_scope, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
410 SharedHeap::ScanningOption so, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
411 OopsInGenClosure* not_older_gens, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
412 OopsInGenClosure* weak_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
413 OopsInGenClosure* older_gens, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
414 CLDClosure* cld_closure, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
415 CLDClosure* weak_cld_closure, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
416 CodeBlobClosure* code_closure); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
417 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
418 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
419 static const bool StrongAndWeakRoots = false; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
420 static const bool StrongRootsOnly = true; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
421 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
422 void gen_process_roots(int level, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
423 bool younger_gens_as_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
424 bool activate_scope, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
425 SharedHeap::ScanningOption so, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
426 bool only_strong_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
427 OopsInGenClosure* not_older_gens, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
428 OopsInGenClosure* older_gens, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20264
diff
changeset
|
429 CLDClosure* cld_closure); |
| 0 | 430 |
|
20257
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
431 // Apply "root_closure" to all the weak roots of the system. |
|
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
432 // These include JNI weak roots, string table, |
|
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
433 // and referents of reachable weak refs. |
|
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20254
diff
changeset
|
434 void gen_process_weak_roots(OopClosure* root_closure); |
| 0 | 435 |
| 436 // Set the saved marks of generations, if that makes sense. | |
| 437 // In particular, if any generation might iterate over the oops | |
| 438 // in other generations, it should call this method. | |
| 439 void save_marks(); | |
| 440 | |
| 441 // Apply "cur->do_oop" or "older->do_oop" to all the oops in objects | |
| 442 // allocated since the last call to save_marks in generations at or above | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
443 // "level". The "cur" closure is |
| 0 | 444 // applied to references in the generation at "level", and the "older" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
445 // closure to older generations. |
| 0 | 446 #define GCH_SINCE_SAVE_MARKS_ITERATE_DECL(OopClosureType, nv_suffix) \ |
| 447 void oop_since_save_marks_iterate(int level, \ | |
| 448 OopClosureType* cur, \ | |
| 449 OopClosureType* older); | |
| 450 | |
| 451 ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DECL) | |
| 452 | |
| 453 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DECL | |
| 454 | |
| 455 // Returns "true" iff no allocations have occurred in any generation at | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
456 // "level" or above since the last |
| 0 | 457 // call to "save_marks". |
| 458 bool no_allocs_since_save_marks(int level); | |
| 459 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
460 // Returns true if an incremental collection is likely to fail. |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
461 // We optionally consult the young gen, if asked to do so; |
|
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
462 // otherwise we base our answer on whether the previous incremental |
|
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
463 // collection attempt failed with no corrective action as of yet. |
|
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
464 bool incremental_collection_will_fail(bool consult_young) { |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
465 // Assumes a 2-generation system; the first disjunct remembers if an |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
466 // incremental collection failed, even when we thought (second disjunct) |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
467 // that it would not. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
468 assert(heap()->collector_policy()->is_two_generation_policy(), |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
469 "the following definition may not be suitable for an n(>2)-generation system"); |
|
1994
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
470 return incremental_collection_failed() || |
|
6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents:
1972
diff
changeset
|
471 (consult_young && !get_gen(0)->collection_attempt_is_safe()); |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
472 } |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
473 |
| 0 | 474 // If a generation bails out of an incremental collection, |
| 475 // it sets this flag. | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
476 bool incremental_collection_failed() const { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
477 return _incremental_collection_failed; |
| 0 | 478 } |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
479 void set_incremental_collection_failed() { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
480 _incremental_collection_failed = true; |
| 0 | 481 } |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
482 void clear_incremental_collection_failed() { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1833
diff
changeset
|
483 _incremental_collection_failed = false; |
| 0 | 484 } |
| 485 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6008
diff
changeset
|
486 // Promotion of obj into gen failed. Try to promote obj to higher |
| 0 | 487 // gens in ascending order; return the new location of obj if successful. |
|
12030
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
488 // Otherwise, try expand-and-allocate for obj in both the young and old |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
489 // generation; return the new location of obj if successful. Otherwise, return NULL. |
|
330dfb0476f4
8022800: Use specific generations rather than generation iteration
brutisso
parents:
11096
diff
changeset
|
490 oop handle_failed_promotion(Generation* old_gen, |
| 0 | 491 oop obj, |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
492 size_t obj_size); |
| 0 | 493 |
| 494 private: | |
| 495 // Accessor for memory state verification support | |
| 496 NOT_PRODUCT( | |
| 497 static size_t skip_header_HeapWords() { return _skip_header_HeapWords; } | |
| 498 ) | |
| 499 | |
| 500 // Override | |
| 501 void check_for_non_bad_heap_word_value(HeapWord* addr, | |
| 502 size_t size) PRODUCT_RETURN; | |
| 503 | |
| 504 // For use by mark-sweep. As implemented, mark-sweep-compact is global | |
| 505 // in an essential way: compaction is performed across generations, by | |
| 506 // iterating over spaces. | |
| 507 void prepare_for_compaction(); | |
| 508 | |
| 509 // Perform a full collection of the first max_level+1 generations. | |
| 510 // This is the low level interface used by the public versions of | |
| 511 // collect() and collect_locked(). Caller holds the Heap_lock on entry. | |
| 512 void collect_locked(GCCause::Cause cause, int max_level); | |
| 513 | |
| 514 // Returns success or failure. | |
| 515 bool create_cms_collector(); | |
| 516 | |
| 517 // In support of ExplicitGCInvokesConcurrent functionality | |
| 518 bool should_do_concurrent_full_gc(GCCause::Cause cause); | |
| 519 void collect_mostly_concurrent(GCCause::Cause cause); | |
| 520 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
521 // Save the tops of the spaces in all generations |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
522 void record_gen_tops_before_GC() PRODUCT_RETURN; |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
142
diff
changeset
|
523 |
| 0 | 524 protected: |
| 525 virtual void gc_prologue(bool full); | |
| 526 virtual void gc_epilogue(bool full); | |
| 527 }; | |
| 1972 | 528 |
| 529 #endif // SHARE_VM_MEMORY_GENCOLLECTEDHEAP_HPP |