Mercurial > hg > truffle
annotate src/share/vm/memory/generation.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 | 30c99d8e0f02 |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17727
diff
changeset
|
2 * Copyright (c) 1997, 2014, 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:
1145
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1145
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:
1145
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_MEMORY_GENERATION_HPP |
| 26 #define SHARE_VM_MEMORY_GENERATION_HPP | |
| 27 | |
| 28 #include "gc_implementation/shared/collectorCounters.hpp" | |
| 29 #include "memory/allocation.hpp" | |
| 30 #include "memory/memRegion.hpp" | |
| 31 #include "memory/referenceProcessor.hpp" | |
| 32 #include "memory/universe.hpp" | |
| 33 #include "memory/watermark.hpp" | |
| 34 #include "runtime/mutex.hpp" | |
| 35 #include "runtime/perfData.hpp" | |
| 36 #include "runtime/virtualspace.hpp" | |
| 37 | |
| 0 | 38 // A Generation models a heap area for similarly-aged objects. |
| 39 // It will contain one ore more spaces holding the actual objects. | |
| 40 // | |
| 41 // The Generation class hierarchy: | |
| 42 // | |
| 43 // Generation - abstract base class | |
| 44 // - DefNewGeneration - allocation area (copy collected) | |
| 45 // - ParNewGeneration - a DefNewGeneration that is collected by | |
| 46 // several threads | |
| 47 // - CardGeneration - abstract class adding offset array behavior | |
| 48 // - OneContigSpaceCardGeneration - abstract class holding a single | |
| 49 // contiguous space with card marking | |
| 50 // - TenuredGeneration - tenured (old object) space (markSweepCompact) | |
| 51 // - ConcurrentMarkSweepGeneration - Mostly Concurrent Mark Sweep Generation | |
| 52 // (Detlefs-Printezis refinement of | |
| 53 // Boehm-Demers-Schenker) | |
| 54 // | |
| 55 // The system configurations currently allowed are: | |
| 56 // | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
57 // DefNewGeneration + TenuredGeneration |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
58 // DefNewGeneration + ConcurrentMarkSweepGeneration |
| 0 | 59 // |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
60 // ParNewGeneration + TenuredGeneration |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
61 // ParNewGeneration + ConcurrentMarkSweepGeneration |
| 0 | 62 // |
| 63 | |
| 64 class DefNewGeneration; | |
| 65 class GenerationSpec; | |
| 66 class CompactibleSpace; | |
| 67 class ContiguousSpace; | |
| 68 class CompactPoint; | |
| 69 class OopsInGenClosure; | |
| 70 class OopClosure; | |
| 71 class ScanClosure; | |
| 72 class FastScanClosure; | |
| 73 class GenCollectedHeap; | |
| 74 class GenRemSet; | |
| 75 class GCStats; | |
| 76 | |
| 77 // A "ScratchBlock" represents a block of memory in one generation usable by | |
| 78 // another. It represents "num_words" free words, starting at and including | |
| 79 // the address of "this". | |
| 80 struct ScratchBlock { | |
| 81 ScratchBlock* next; | |
| 82 size_t num_words; | |
| 83 HeapWord scratch_space[1]; // Actually, of size "num_words-2" (assuming | |
| 84 // first two fields are word-sized.) | |
| 85 }; | |
| 86 | |
| 87 | |
| 6197 | 88 class Generation: public CHeapObj<mtGC> { |
| 0 | 89 friend class VMStructs; |
| 90 private: | |
| 91 jlong _time_of_last_gc; // time when last gc on this generation happened (ms) | |
| 92 MemRegion _prev_used_region; // for collectors that want to "remember" a value for | |
| 93 // used region at some specific point during collection. | |
| 94 | |
| 95 protected: | |
| 96 // Minimum and maximum addresses for memory reserved (not necessarily | |
| 97 // committed) for generation. | |
| 98 // Used by card marking code. Must not overlap with address ranges of | |
| 99 // other generations. | |
| 100 MemRegion _reserved; | |
| 101 | |
| 102 // Memory area reserved for generation | |
| 103 VirtualSpace _virtual_space; | |
| 104 | |
| 105 // Level in the generation hierarchy. | |
| 106 int _level; | |
| 107 | |
| 108 // ("Weak") Reference processing support | |
| 109 ReferenceProcessor* _ref_processor; | |
| 110 | |
| 111 // Performance Counters | |
| 112 CollectorCounters* _gc_counters; | |
| 113 | |
| 114 // Statistics for garbage collection | |
| 115 GCStats* _gc_stats; | |
| 116 | |
| 117 // Returns the next generation in the configuration, or else NULL if this | |
| 118 // is the highest generation. | |
| 119 Generation* next_gen() const; | |
| 120 | |
| 121 // Initialize the generation. | |
| 122 Generation(ReservedSpace rs, size_t initial_byte_size, int level); | |
| 123 | |
| 124 // Apply "cl->do_oop" to (the address of) (exactly) all the ref fields in | |
| 125 // "sp" that point into younger generations. | |
| 126 // The iteration is only over objects allocated at the start of the | |
| 127 // iterations; objects allocated as a result of applying the closure are | |
| 128 // not included. | |
| 129 void younger_refs_in_space_iterate(Space* sp, OopsInGenClosure* cl); | |
| 130 | |
| 131 public: | |
| 132 // The set of possible generation kinds. | |
| 133 enum Name { | |
| 134 ASParNew, | |
| 135 ASConcurrentMarkSweep, | |
| 136 DefNew, | |
| 137 ParNew, | |
| 138 MarkSweepCompact, | |
| 139 ConcurrentMarkSweep, | |
| 140 Other | |
| 141 }; | |
| 142 | |
| 143 enum SomePublicConstants { | |
| 144 // Generations are GenGrain-aligned and have size that are multiples of | |
| 145 // GenGrain. | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
146 // Note: on ARM we add 1 bit for card_table_base to be properly aligned |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
147 // (we expect its low byte to be zero - see implementation of post_barrier) |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
148 LogOfGenGrain = 16 ARM_ONLY(+1), |
| 0 | 149 GenGrain = 1 << LogOfGenGrain |
| 150 }; | |
| 151 | |
| 152 // allocate and initialize ("weak") refs processing support | |
| 153 virtual void ref_processor_init(); | |
| 154 void set_ref_processor(ReferenceProcessor* rp) { | |
| 155 assert(_ref_processor == NULL, "clobbering existing _ref_processor"); | |
| 156 _ref_processor = rp; | |
| 157 } | |
| 158 | |
| 159 virtual Generation::Name kind() { return Generation::Other; } | |
| 160 GenerationSpec* spec(); | |
| 161 | |
| 162 // This properly belongs in the collector, but for now this | |
| 163 // will do. | |
| 164 virtual bool refs_discovery_is_atomic() const { return true; } | |
| 165 virtual bool refs_discovery_is_mt() const { return false; } | |
| 166 | |
| 167 // Space enquiries (results in bytes) | |
| 168 virtual size_t capacity() const = 0; // The maximum number of object bytes the | |
| 169 // generation can currently hold. | |
| 170 virtual size_t used() const = 0; // The number of used bytes in the gen. | |
| 171 virtual size_t free() const = 0; // The number of free bytes in the gen. | |
| 172 | |
| 173 // Support for java.lang.Runtime.maxMemory(); see CollectedHeap. | |
| 174 // Returns the total number of bytes available in a generation | |
| 175 // for the allocation of objects. | |
| 176 virtual size_t max_capacity() const; | |
| 177 | |
| 178 // If this is a young generation, the maximum number of bytes that can be | |
| 179 // allocated in this generation before a GC is triggered. | |
| 180 virtual size_t capacity_before_gc() const { return 0; } | |
| 181 | |
| 182 // The largest number of contiguous free bytes in the generation, | |
| 183 // including expansion (Assumes called at a safepoint.) | |
| 184 virtual size_t contiguous_available() const = 0; | |
| 185 // The largest number of contiguous free bytes in this or any higher generation. | |
| 186 virtual size_t max_contiguous_available() const; | |
| 187 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
188 // Returns true if promotions of the specified amount are |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
189 // likely to succeed without a promotion failure. |
| 0 | 190 // Promotion of the full amount is not guaranteed but |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
191 // might be attempted in the worst case. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
192 virtual bool promotion_attempt_is_safe(size_t max_promotion_in_bytes) const; |
| 0 | 193 |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
579
diff
changeset
|
194 // For a non-young generation, this interface can be used to inform a |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
579
diff
changeset
|
195 // generation that a promotion attempt into that generation failed. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
579
diff
changeset
|
196 // Typically used to enable diagnostic output for post-mortem analysis, |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
579
diff
changeset
|
197 // but other uses of the interface are not ruled out. |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
579
diff
changeset
|
198 virtual void promotion_failure_occurred() { /* does nothing */ } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
579
diff
changeset
|
199 |
| 0 | 200 // Return an estimate of the maximum allocation that could be performed |
| 201 // in the generation without triggering any collection or expansion | |
| 202 // activity. It is "unsafe" because no locks are taken; the result | |
| 203 // should be treated as an approximation, not a guarantee, for use in | |
| 204 // heuristic resizing decisions. | |
| 205 virtual size_t unsafe_max_alloc_nogc() const = 0; | |
| 206 | |
| 207 // Returns true if this generation cannot be expanded further | |
| 208 // without a GC. Override as appropriate. | |
| 209 virtual bool is_maximal_no_gc() const { | |
| 210 return _virtual_space.uncommitted_size() == 0; | |
| 211 } | |
| 212 | |
| 213 MemRegion reserved() const { return _reserved; } | |
| 214 | |
| 215 // Returns a region guaranteed to contain all the objects in the | |
| 216 // generation. | |
| 217 virtual MemRegion used_region() const { return _reserved; } | |
| 218 | |
| 219 MemRegion prev_used_region() const { return _prev_used_region; } | |
| 220 virtual void save_used_region() { _prev_used_region = used_region(); } | |
| 221 | |
| 4708 | 222 // Returns "TRUE" iff "p" points into the committed areas in the generation. |
| 0 | 223 // For some kinds of generations, this may be an expensive operation. |
| 224 // To avoid performance problems stemming from its inadvertent use in | |
| 225 // product jvm's, we restrict its use to assertion checking or | |
| 226 // verification only. | |
| 227 virtual bool is_in(const void* p) const; | |
| 228 | |
| 229 /* Returns "TRUE" iff "p" points into the reserved area of the generation. */ | |
| 230 bool is_in_reserved(const void* p) const { | |
| 231 return _reserved.contains(p); | |
| 232 } | |
| 233 | |
| 234 // Check that the generation kind is DefNewGeneration or a sub | |
| 235 // class of DefNewGeneration and return a DefNewGeneration* | |
| 236 DefNewGeneration* as_DefNewGeneration(); | |
| 237 | |
| 238 // If some space in the generation contains the given "addr", return a | |
| 239 // pointer to that space, else return "NULL". | |
| 240 virtual Space* space_containing(const void* addr) const; | |
| 241 | |
| 242 // Iteration - do not use for time critical operations | |
| 243 virtual void space_iterate(SpaceClosure* blk, bool usedOnly = false) = 0; | |
| 244 | |
| 245 // Returns the first space, if any, in the generation that can participate | |
| 246 // in compaction, or else "NULL". | |
| 247 virtual CompactibleSpace* first_compaction_space() const = 0; | |
| 248 | |
| 249 // Returns "true" iff this generation should be used to allocate an | |
| 250 // object of the given size. Young generations might | |
| 251 // wish to exclude very large objects, for example, since, if allocated | |
| 252 // often, they would greatly increase the frequency of young-gen | |
| 253 // collection. | |
| 254 virtual bool should_allocate(size_t word_size, bool is_tlab) { | |
| 255 bool result = false; | |
| 256 size_t overflow_limit = (size_t)1 << (BitsPerSize_t - LogHeapWordSize); | |
| 257 if (!is_tlab || supports_tlab_allocation()) { | |
| 258 result = (word_size > 0) && (word_size < overflow_limit); | |
| 259 } | |
| 260 return result; | |
| 261 } | |
| 262 | |
| 263 // Allocate and returns a block of the requested size, or returns "NULL". | |
| 264 // Assumes the caller has done any necessary locking. | |
| 265 virtual HeapWord* allocate(size_t word_size, bool is_tlab) = 0; | |
| 266 | |
| 267 // Like "allocate", but performs any necessary locking internally. | |
| 268 virtual HeapWord* par_allocate(size_t word_size, bool is_tlab) = 0; | |
| 269 | |
| 270 // A 'younger' gen has reached an allocation limit, and uses this to notify | |
| 271 // the next older gen. The return value is a new limit, or NULL if none. The | |
| 272 // caller must do the necessary locking. | |
| 273 virtual HeapWord* allocation_limit_reached(Space* space, HeapWord* top, | |
| 274 size_t word_size) { | |
| 275 return NULL; | |
| 276 } | |
| 277 | |
| 278 // Some generation may offer a region for shared, contiguous allocation, | |
| 279 // via inlined code (by exporting the address of the top and end fields | |
| 280 // defining the extent of the contiguous allocation region.) | |
| 281 | |
| 282 // This function returns "true" iff the heap supports this kind of | |
| 283 // allocation. (More precisely, this means the style of allocation that | |
| 284 // increments *top_addr()" with a CAS.) (Default is "no".) | |
| 285 // A generation that supports this allocation style must use lock-free | |
| 286 // allocation for *all* allocation, since there are times when lock free | |
| 287 // allocation will be concurrent with plain "allocate" calls. | |
| 288 virtual bool supports_inline_contig_alloc() const { return false; } | |
| 289 | |
| 290 // These functions return the addresses of the fields that define the | |
| 291 // boundaries of the contiguous allocation area. (These fields should be | |
| 292 // physicall near to one another.) | |
| 293 virtual HeapWord** top_addr() const { return NULL; } | |
| 294 virtual HeapWord** end_addr() const { return NULL; } | |
| 295 | |
| 296 // Thread-local allocation buffers | |
| 297 virtual bool supports_tlab_allocation() const { return false; } | |
| 298 virtual size_t tlab_capacity() const { | |
| 299 guarantee(false, "Generation doesn't support thread local allocation buffers"); | |
| 300 return 0; | |
| 301 } | |
| 17727 | 302 virtual size_t tlab_used() const { |
| 303 guarantee(false, "Generation doesn't support thread local allocation buffers"); | |
| 304 return 0; | |
| 305 } | |
| 0 | 306 virtual size_t unsafe_max_tlab_alloc() const { |
| 307 guarantee(false, "Generation doesn't support thread local allocation buffers"); | |
| 308 return 0; | |
| 309 } | |
| 310 | |
| 311 // "obj" is the address of an object in a younger generation. Allocate space | |
| 312 // for "obj" in the current (or some higher) generation, and copy "obj" into | |
| 313 // the newly allocated space, if possible, returning the result (or NULL if | |
| 314 // the allocation failed). | |
| 315 // | |
| 316 // The "obj_size" argument is just obj->size(), passed along so the caller can | |
| 317 // avoid repeating the virtual call to retrieve it. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
318 virtual oop promote(oop obj, size_t obj_size); |
| 0 | 319 |
| 320 // Thread "thread_num" (0 <= i < ParalleGCThreads) wants to promote | |
| 321 // object "obj", whose original mark word was "m", and whose size is | |
| 322 // "word_sz". If possible, allocate space for "obj", copy obj into it | |
| 323 // (taking care to copy "m" into the mark word when done, since the mark | |
| 324 // word of "obj" may have been overwritten with a forwarding pointer, and | |
| 325 // also taking care to copy the klass pointer *last*. Returns the new | |
| 326 // object if successful, or else NULL. | |
| 327 virtual oop par_promote(int thread_num, | |
| 328 oop obj, markOop m, size_t word_sz); | |
| 329 | |
| 330 // Undo, if possible, the most recent par_promote_alloc allocation by | |
| 331 // "thread_num" ("obj", of "word_sz"). | |
| 332 virtual void par_promote_alloc_undo(int thread_num, | |
| 333 HeapWord* obj, size_t word_sz); | |
| 334 | |
| 335 // Informs the current generation that all par_promote_alloc's in the | |
| 336 // collection have been completed; any supporting data structures can be | |
| 337 // reset. Default is to do nothing. | |
| 338 virtual void par_promote_alloc_done(int thread_num) {} | |
| 339 | |
| 340 // Informs the current generation that all oop_since_save_marks_iterates | |
| 341 // performed by "thread_num" in the current collection, if any, have been | |
| 342 // completed; any supporting data structures can be reset. Default is to | |
| 343 // do nothing. | |
| 344 virtual void par_oop_since_save_marks_iterate_done(int thread_num) {} | |
| 345 | |
| 346 // This generation will collect all younger generations | |
| 347 // during a full collection. | |
| 348 virtual bool full_collects_younger_generations() const { return false; } | |
| 349 | |
| 350 // This generation does in-place marking, meaning that mark words | |
| 351 // are mutated during the marking phase and presumably reinitialized | |
| 352 // to a canonical value after the GC. This is currently used by the | |
| 353 // biased locking implementation to determine whether additional | |
| 354 // work is required during the GC prologue and epilogue. | |
| 355 virtual bool performs_in_place_marking() const { return true; } | |
| 356 | |
| 357 // Returns "true" iff collect() should subsequently be called on this | |
| 358 // this generation. See comment below. | |
| 359 // This is a generic implementation which can be overridden. | |
| 360 // | |
| 361 // Note: in the current (1.4) implementation, when genCollectedHeap's | |
| 362 // incremental_collection_will_fail flag is set, all allocations are | |
| 363 // slow path (the only fast-path place to allocate is DefNew, which | |
| 364 // will be full if the flag is set). | |
| 365 // Thus, older generations which collect younger generations should | |
| 366 // test this flag and collect if it is set. | |
| 367 virtual bool should_collect(bool full, | |
| 368 size_t word_size, | |
| 369 bool is_tlab) { | |
| 370 return (full || should_allocate(word_size, is_tlab)); | |
| 371 } | |
| 372 | |
|
1888
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
373 // Returns true if the collection is likely to be safely |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
374 // completed. Even if this method returns true, a collection |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
375 // may not be guaranteed to succeed, and the system should be |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
376 // able to safely unwind and recover from that failure, albeit |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
377 // at some additional cost. |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
378 virtual bool collection_attempt_is_safe() { |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
379 guarantee(false, "Are you sure you want to call this method?"); |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
380 return true; |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
381 } |
|
a7214d79fcf1
6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents:
1681
diff
changeset
|
382 |
| 0 | 383 // Perform a garbage collection. |
| 384 // If full is true attempt a full garbage collection of this generation. | |
| 385 // Otherwise, attempting to (at least) free enough space to support an | |
| 386 // allocation of the given "word_size". | |
| 387 virtual void collect(bool full, | |
| 388 bool clear_all_soft_refs, | |
| 389 size_t word_size, | |
| 390 bool is_tlab) = 0; | |
| 391 | |
| 392 // Perform a heap collection, attempting to create (at least) enough | |
| 393 // space to support an allocation of the given "word_size". If | |
| 394 // successful, perform the allocation and return the resulting | |
| 395 // "oop" (initializing the allocated block). If the allocation is | |
| 396 // still unsuccessful, return "NULL". | |
| 397 virtual HeapWord* expand_and_allocate(size_t word_size, | |
| 398 bool is_tlab, | |
| 399 bool parallel = false) = 0; | |
| 400 | |
| 401 // Some generations may require some cleanup or preparation actions before | |
| 402 // allowing a collection. The default is to do nothing. | |
| 403 virtual void gc_prologue(bool full) {}; | |
| 404 | |
| 405 // Some generations may require some cleanup actions after a collection. | |
| 406 // The default is to do nothing. | |
| 407 virtual void gc_epilogue(bool full) {}; | |
| 408 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
409 // Save the high water marks for the used space in a generation. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
410 virtual void record_spaces_top() {}; |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
411 |
| 0 | 412 // Some generations may need to be "fixed-up" after some allocation |
| 413 // activity to make them parsable again. The default is to do nothing. | |
| 414 virtual void ensure_parsability() {}; | |
| 415 | |
| 416 // Time (in ms) when we were last collected or now if a collection is | |
| 417 // in progress. | |
| 418 virtual jlong time_of_last_gc(jlong now) { | |
|
4712
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
419 // Both _time_of_last_gc and now are set using a time source |
|
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
420 // that guarantees monotonically non-decreasing values provided |
|
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
421 // the underlying platform provides such a source. So we still |
|
e7dead7e90af
7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents:
4708
diff
changeset
|
422 // have to guard against non-monotonicity. |
| 0 | 423 NOT_PRODUCT( |
| 424 if (now < _time_of_last_gc) { | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17727
diff
changeset
|
425 warning("time warp: "INT64_FORMAT" to "INT64_FORMAT, (int64_t)_time_of_last_gc, (int64_t)now); |
| 0 | 426 } |
| 427 ) | |
| 428 return _time_of_last_gc; | |
| 429 } | |
| 430 | |
| 431 virtual void update_time_of_last_gc(jlong now) { | |
| 432 _time_of_last_gc = now; | |
| 433 } | |
| 434 | |
| 435 // Generations may keep statistics about collection. This | |
| 436 // method updates those statistics. current_level is | |
| 437 // the level of the collection that has most recently | |
| 438 // occurred. This allows the generation to decide what | |
| 439 // statistics are valid to collect. For example, the | |
| 440 // generation can decide to gather the amount of promoted data | |
| 441 // if the collection of the younger generations has completed. | |
| 442 GCStats* gc_stats() const { return _gc_stats; } | |
| 443 virtual void update_gc_stats(int current_level, bool full) {} | |
| 444 | |
| 445 // Mark sweep support phase2 | |
| 446 virtual void prepare_for_compaction(CompactPoint* cp); | |
| 447 // Mark sweep support phase3 | |
| 448 virtual void adjust_pointers(); | |
| 449 // Mark sweep support phase4 | |
| 450 virtual void compact(); | |
| 451 virtual void post_compact() {ShouldNotReachHere();} | |
| 452 | |
| 453 // Support for CMS's rescan. In this general form we return a pointer | |
| 454 // to an abstract object that can be used, based on specific previously | |
| 455 // decided protocols, to exchange information between generations, | |
| 456 // information that may be useful for speeding up certain types of | |
| 457 // garbage collectors. A NULL value indicates to the client that | |
| 458 // no data recording is expected by the provider. The data-recorder is | |
| 459 // expected to be GC worker thread-local, with the worker index | |
| 460 // indicated by "thr_num". | |
| 461 virtual void* get_data_recorder(int thr_num) { return NULL; } | |
|
11973
7b06ae405d7b
6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents:
11096
diff
changeset
|
462 virtual void sample_eden_chunk() {} |
| 0 | 463 |
| 464 // Some generations may require some cleanup actions before allowing | |
| 465 // a verification. | |
| 466 virtual void prepare_for_verify() {}; | |
| 467 | |
| 468 // Accessing "marks". | |
| 469 | |
| 470 // This function gives a generation a chance to note a point between | |
| 471 // collections. For example, a contiguous generation might note the | |
| 472 // beginning allocation point post-collection, which might allow some later | |
| 473 // operations to be optimized. | |
| 474 virtual void save_marks() {} | |
| 475 | |
| 476 // This function allows generations to initialize any "saved marks". That | |
| 477 // is, should only be called when the generation is empty. | |
| 478 virtual void reset_saved_marks() {} | |
| 479 | |
| 480 // This function is "true" iff any no allocations have occurred in the | |
| 481 // generation since the last call to "save_marks". | |
| 482 virtual bool no_allocs_since_save_marks() = 0; | |
| 483 | |
| 484 // Apply "cl->apply" to (the addresses of) all reference fields in objects | |
| 485 // allocated in the current generation since the last call to "save_marks". | |
| 486 // If more objects are allocated in this generation as a result of applying | |
| 487 // the closure, iterates over reference fields in those objects as well. | |
| 488 // Calls "save_marks" at the end of the iteration. | |
| 489 // General signature... | |
| 490 virtual void oop_since_save_marks_iterate_v(OopsInGenClosure* cl) = 0; | |
| 491 // ...and specializations for de-virtualization. (The general | |
| 492 // implemention of the _nv versions call the virtual version. | |
| 493 // Note that the _nv suffix is not really semantically necessary, | |
| 494 // but it avoids some not-so-useful warnings on Solaris.) | |
| 495 #define Generation_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ | |
| 496 virtual void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \ | |
| 497 oop_since_save_marks_iterate_v((OopsInGenClosure*)cl); \ | |
| 498 } | |
| 499 SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(Generation_SINCE_SAVE_MARKS_DECL) | |
| 500 | |
| 501 #undef Generation_SINCE_SAVE_MARKS_DECL | |
| 502 | |
| 503 // The "requestor" generation is performing some garbage collection | |
| 504 // action for which it would be useful to have scratch space. If | |
| 505 // the target is not the requestor, no gc actions will be required | |
| 506 // of the target. The requestor promises to allocate no more than | |
| 507 // "max_alloc_words" in the target generation (via promotion say, | |
| 508 // if the requestor is a young generation and the target is older). | |
| 509 // If the target generation can provide any scratch space, it adds | |
| 510 // it to "list", leaving "list" pointing to the head of the | |
| 511 // augmented list. The default is to offer no space. | |
| 512 virtual void contribute_scratch(ScratchBlock*& list, Generation* requestor, | |
| 513 size_t max_alloc_words) {} | |
| 514 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
515 // Give each generation an opportunity to do clean up for any |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
516 // contributed scratch. |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
517 virtual void reset_scratch() {}; |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
518 |
| 0 | 519 // When an older generation has been collected, and perhaps resized, |
| 520 // this method will be invoked on all younger generations (from older to | |
| 521 // younger), allowing them to resize themselves as appropriate. | |
| 522 virtual void compute_new_size() = 0; | |
| 523 | |
| 524 // Printing | |
| 525 virtual const char* name() const = 0; | |
| 526 virtual const char* short_name() const = 0; | |
| 527 | |
| 528 int level() const { return _level; } | |
| 529 | |
| 530 // Attributes | |
| 531 | |
| 532 // True iff the given generation may only be the youngest generation. | |
| 533 virtual bool must_be_youngest() const = 0; | |
| 534 // True iff the given generation may only be the oldest generation. | |
| 535 virtual bool must_be_oldest() const = 0; | |
| 536 | |
| 537 // Reference Processing accessor | |
| 538 ReferenceProcessor* const ref_processor() { return _ref_processor; } | |
| 539 | |
| 540 // Iteration. | |
| 541 | |
| 542 // Iterate over all the ref-containing fields of all objects in the | |
| 543 // generation, calling "cl.do_oop" on each. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
544 virtual void oop_iterate(ExtendedOopClosure* cl); |
| 0 | 545 |
| 546 // Iterate over all objects in the generation, calling "cl.do_object" on | |
| 547 // each. | |
| 548 virtual void object_iterate(ObjectClosure* cl); | |
| 549 | |
|
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
271
diff
changeset
|
550 // Iterate over all safe objects in the generation, calling "cl.do_object" on |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
271
diff
changeset
|
551 // each. An object is safe if its references point to other objects in |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
271
diff
changeset
|
552 // the heap. This defaults to object_iterate() unless overridden. |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
271
diff
changeset
|
553 virtual void safe_object_iterate(ObjectClosure* cl); |
|
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
271
diff
changeset
|
554 |
| 0 | 555 // Apply "cl->do_oop" to (the address of) all and only all the ref fields |
| 556 // in the current generation that contain pointers to objects in younger | |
| 557 // generations. Objects allocated since the last "save_marks" call are | |
| 558 // excluded. | |
| 559 virtual void younger_refs_iterate(OopsInGenClosure* cl) = 0; | |
| 560 | |
| 561 // Inform a generation that it longer contains references to objects | |
| 562 // in any younger generation. [e.g. Because younger gens are empty, | |
| 563 // clear the card table.] | |
| 564 virtual void clear_remembered_set() { } | |
| 565 | |
| 566 // Inform a generation that some of its objects have moved. [e.g. The | |
| 567 // generation's spaces were compacted, invalidating the card table.] | |
| 568 virtual void invalidate_remembered_set() { } | |
| 569 | |
| 570 // Block abstraction. | |
| 571 | |
| 572 // Returns the address of the start of the "block" that contains the | |
| 573 // address "addr". We say "blocks" instead of "object" since some heaps | |
| 574 // may not pack objects densely; a chunk may either be an object or a | |
| 575 // non-object. | |
| 576 virtual HeapWord* block_start(const void* addr) const; | |
| 577 | |
| 578 // Requires "addr" to be the start of a chunk, and returns its size. | |
| 579 // "addr + size" is required to be the start of a new chunk, or the end | |
| 580 // of the active area of the heap. | |
| 581 virtual size_t block_size(const HeapWord* addr) const ; | |
| 582 | |
| 583 // Requires "addr" to be the start of a block, and returns "TRUE" iff | |
| 584 // the block is an object. | |
| 585 virtual bool block_is_obj(const HeapWord* addr) const; | |
| 586 | |
| 587 | |
| 588 // PrintGC, PrintGCDetails support | |
| 589 void print_heap_change(size_t prev_used) const; | |
| 590 | |
| 591 // PrintHeapAtGC support | |
| 592 virtual void print() const; | |
| 593 virtual void print_on(outputStream* st) const; | |
| 594 | |
| 6008 | 595 virtual void verify() = 0; |
| 0 | 596 |
| 597 struct StatRecord { | |
| 598 int invocations; | |
| 599 elapsedTimer accumulated_time; | |
| 600 StatRecord() : | |
| 601 invocations(0), | |
| 602 accumulated_time(elapsedTimer()) {} | |
| 603 }; | |
| 604 private: | |
| 605 StatRecord _stat_record; | |
| 606 public: | |
| 607 StatRecord* stat_record() { return &_stat_record; } | |
| 608 | |
| 609 virtual void print_summary_info(); | |
| 610 virtual void print_summary_info_on(outputStream* st); | |
| 611 | |
| 612 // Performance Counter support | |
| 613 virtual void update_counters() = 0; | |
| 614 virtual CollectorCounters* counters() { return _gc_counters; } | |
| 615 }; | |
| 616 | |
| 617 // Class CardGeneration is a generation that is covered by a card table, | |
| 618 // and uses a card-size block-offset array to implement block_start. | |
| 619 | |
| 620 // class BlockOffsetArray; | |
| 621 // class BlockOffsetArrayContigSpace; | |
| 622 class BlockOffsetSharedArray; | |
| 623 | |
| 624 class CardGeneration: public Generation { | |
| 625 friend class VMStructs; | |
| 626 protected: | |
| 627 // This is shared with other generations. | |
| 628 GenRemSet* _rs; | |
| 629 // This is local to this generation. | |
| 630 BlockOffsetSharedArray* _bts; | |
| 631 | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
632 // current shrinking effect: this damps shrinking when the heap gets empty. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
633 size_t _shrink_factor; |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
634 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
635 size_t _min_heap_delta_bytes; // Minimum amount to expand. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
636 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
637 // Some statistics from before gc started. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
638 // These are gathered in the gc_prologue (and should_collect) |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
639 // to control growing/shrinking policy in spite of promotions. |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
640 size_t _capacity_at_prologue; |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
641 size_t _used_at_prologue; |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
642 |
| 0 | 643 CardGeneration(ReservedSpace rs, size_t initial_byte_size, int level, |
| 644 GenRemSet* remset); | |
| 645 | |
| 646 public: | |
| 647 | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
648 // Attempt to expand the generation by "bytes". Expand by at a |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
649 // minimum "expand_bytes". Return true if some amount (not |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
650 // necessarily the full "bytes") was done. |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
651 virtual bool expand(size_t bytes, size_t expand_bytes); |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
652 |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
653 // Shrink generation with specified size (returns false if unable to shrink) |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
654 virtual void shrink(size_t bytes) = 0; |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
655 |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
656 virtual void compute_new_size(); |
|
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
657 |
| 0 | 658 virtual void clear_remembered_set(); |
| 659 | |
| 660 virtual void invalidate_remembered_set(); | |
| 661 | |
| 662 virtual void prepare_for_verify(); | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
663 |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
664 // Grow generation with specified size (returns false if unable to grow) |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
665 virtual bool grow_by(size_t bytes) = 0; |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
666 // Grow generation to reserved size. |
|
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
667 virtual bool grow_to_reserved() = 0; |
| 0 | 668 }; |
| 669 | |
| 670 // OneContigSpaceCardGeneration models a heap of old objects contained in a single | |
| 671 // contiguous space. | |
| 672 // | |
| 673 // Garbage collection is performed using mark-compact. | |
| 674 | |
| 675 class OneContigSpaceCardGeneration: public CardGeneration { | |
| 676 friend class VMStructs; | |
| 677 // Abstractly, this is a subtype that gets access to protected fields. | |
| 678 friend class VM_PopulateDumpSharedSpace; | |
| 679 | |
| 680 protected: | |
| 681 ContiguousSpace* _the_space; // actual space holding objects | |
| 682 WaterMark _last_gc; // watermark between objects allocated before | |
| 683 // and after last GC. | |
| 684 | |
| 685 // Grow generation with specified size (returns false if unable to grow) | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
686 virtual bool grow_by(size_t bytes); |
| 0 | 687 // Grow generation to reserved size. |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
688 virtual bool grow_to_reserved(); |
| 0 | 689 // Shrink generation with specified size (returns false if unable to shrink) |
| 690 void shrink_by(size_t bytes); | |
| 691 | |
| 692 // Allocation failure | |
|
271
818a18cd69a8
6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents:
269
diff
changeset
|
693 virtual bool expand(size_t bytes, size_t expand_bytes); |
| 0 | 694 void shrink(size_t bytes); |
| 695 | |
| 696 // Accessing spaces | |
| 697 ContiguousSpace* the_space() const { return _the_space; } | |
| 698 | |
| 699 public: | |
| 700 OneContigSpaceCardGeneration(ReservedSpace rs, size_t initial_byte_size, | |
| 701 int level, GenRemSet* remset, | |
| 702 ContiguousSpace* space) : | |
| 703 CardGeneration(rs, initial_byte_size, level, remset), | |
|
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
6725
diff
changeset
|
704 _the_space(space) |
| 0 | 705 {} |
| 706 | |
| 707 inline bool is_in(const void* p) const; | |
| 708 | |
| 709 // Space enquiries | |
| 710 size_t capacity() const; | |
| 711 size_t used() const; | |
| 712 size_t free() const; | |
| 713 | |
| 714 MemRegion used_region() const; | |
| 715 | |
| 716 size_t unsafe_max_alloc_nogc() const; | |
| 717 size_t contiguous_available() const; | |
| 718 | |
| 719 // Iteration | |
| 720 void object_iterate(ObjectClosure* blk); | |
| 721 void space_iterate(SpaceClosure* blk, bool usedOnly = false); | |
| 722 | |
| 723 void younger_refs_iterate(OopsInGenClosure* blk); | |
| 724 | |
| 725 inline CompactibleSpace* first_compaction_space() const; | |
| 726 | |
| 727 virtual inline HeapWord* allocate(size_t word_size, bool is_tlab); | |
| 728 virtual inline HeapWord* par_allocate(size_t word_size, bool is_tlab); | |
| 729 | |
| 730 // Accessing marks | |
| 731 inline WaterMark top_mark(); | |
| 732 inline WaterMark bottom_mark(); | |
| 733 | |
| 734 #define OneContig_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \ | |
| 735 void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl); | |
| 736 OneContig_SINCE_SAVE_MARKS_DECL(OopsInGenClosure,_v) | |
| 737 SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(OneContig_SINCE_SAVE_MARKS_DECL) | |
| 738 | |
| 739 void save_marks(); | |
| 740 void reset_saved_marks(); | |
| 741 bool no_allocs_since_save_marks(); | |
| 742 | |
| 743 inline size_t block_size(const HeapWord* addr) const; | |
| 744 | |
| 745 inline bool block_is_obj(const HeapWord* addr) const; | |
| 746 | |
| 747 virtual void collect(bool full, | |
| 748 bool clear_all_soft_refs, | |
| 749 size_t size, | |
| 750 bool is_tlab); | |
| 751 HeapWord* expand_and_allocate(size_t size, | |
| 752 bool is_tlab, | |
| 753 bool parallel = false); | |
| 754 | |
| 755 virtual void prepare_for_verify(); | |
| 756 | |
| 757 virtual void gc_epilogue(bool full); | |
| 758 | |
|
263
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
759 virtual void record_spaces_top(); |
|
12eea04c8b06
6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents:
113
diff
changeset
|
760 |
| 6008 | 761 virtual void verify(); |
| 0 | 762 virtual void print_on(outputStream* st) const; |
| 763 }; | |
| 1972 | 764 |
| 765 #endif // SHARE_VM_MEMORY_GENERATION_HPP |