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