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