1 /* 2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "gc_implementation/shared/gcTimer.hpp" 27 #include "gc_implementation/shared/gcTrace.hpp" 28 #include "gc_implementation/shared/spaceDecorator.hpp" 29 #include "gc_interface/collectedHeap.inline.hpp" 30 #include "memory/allocation.inline.hpp" 31 #include "memory/blockOffsetTable.inline.hpp" 32 #include "memory/cardTableRS.hpp" 33 #include "memory/gcLocker.inline.hpp" 34 #include "memory/genCollectedHeap.hpp" 35 #include "memory/genMarkSweep.hpp" 36 #include "memory/genOopClosures.hpp" 37 #include "memory/genOopClosures.inline.hpp" 38 #include "memory/generation.hpp" 39 #include "memory/space.inline.hpp" 40 #include "oops/oop.inline.hpp" 41 #include "runtime/java.hpp" 42 #include "utilities/copy.hpp" 43 #include "utilities/events.hpp" 44 45 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC 46 47 Generation::Generation(ReservedSpace rs, size_t initial_size, int level) : 48 _level(level), 49 _ref_processor(NULL) { 50 if (!_virtual_space.initialize(rs, initial_size)) { 51 vm_exit_during_initialization("Could not reserve enough space for " 52 "object heap"); 53 } 54 // Mangle all of the the initial generation. 55 if (ZapUnusedHeapArea) { 56 MemRegion mangle_region((HeapWord*)_virtual_space.low(), 57 (HeapWord*)_virtual_space.high()); 58 SpaceMangler::mangle_region(mangle_region); 59 } 60 _reserved = MemRegion((HeapWord*)_virtual_space.low_boundary(), 61 (HeapWord*)_virtual_space.high_boundary()); 62 } 63 64 GenerationSpec* Generation::spec() { 65 GenCollectedHeap* gch = GenCollectedHeap::heap(); 66 assert(0 <= level() && level() < gch->_n_gens, "Bad gen level"); 67 return level() == 0 ? gch->gen_policy()->young_gen_spec() : gch->gen_policy()->old_gen_spec(); 68 } 69 70 size_t Generation::max_capacity() const { 71 return reserved().byte_size(); 72 } 73 74 void Generation::print_heap_change(size_t prev_used) const { 75 if (PrintGCDetails && Verbose) { 76 gclog_or_tty->print(" " SIZE_FORMAT 77 "->" SIZE_FORMAT 78 "(" SIZE_FORMAT ")", 79 prev_used, used(), capacity()); 80 } else { 81 gclog_or_tty->print(" " SIZE_FORMAT "K" 82 "->" SIZE_FORMAT "K" 83 "(" SIZE_FORMAT "K)", 84 prev_used / K, used() / K, capacity() / K); 85 } 86 } 87 88 // By default we get a single threaded default reference processor; 89 // generations needing multi-threaded refs processing or discovery override this method. 90 void Generation::ref_processor_init() { 91 assert(_ref_processor == NULL, "a reference processor already exists"); 92 assert(!_reserved.is_empty(), "empty generation?"); 93 _ref_processor = new ReferenceProcessor(_reserved); // a vanilla reference processor 94 if (_ref_processor == NULL) { 95 vm_exit_during_initialization("Could not allocate ReferenceProcessor object"); 96 } 97 } 98 99 void Generation::print() const { print_on(tty); } 100 101 void Generation::print_on(outputStream* st) const { 102 st->print(" %-20s", name()); 103 st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", 104 capacity()/K, used()/K); 105 st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", 106 _virtual_space.low_boundary(), 107 _virtual_space.high(), 108 _virtual_space.high_boundary()); 109 } 110 111 void Generation::print_summary_info() { print_summary_info_on(tty); } 112 113 void Generation::print_summary_info_on(outputStream* st) { 114 StatRecord* sr = stat_record(); 115 double time = sr->accumulated_time.seconds(); 116 st->print_cr("[Accumulated GC generation %d time %3.7f secs, " 117 "%d GC's, avg GC time %3.7f]", 118 level(), time, sr->invocations, 119 sr->invocations > 0 ? time / sr->invocations : 0.0); 120 } 121 122 // Utility iterator classes 123 124 class GenerationIsInReservedClosure : public SpaceClosure { 125 public: 126 const void* _p; 127 Space* sp; 128 virtual void do_space(Space* s) { 129 if (sp == NULL) { 130 if (s->is_in_reserved(_p)) sp = s; 131 } 132 } 133 GenerationIsInReservedClosure(const void* p) : _p(p), sp(NULL) {} 134 }; 135 136 class GenerationIsInClosure : public SpaceClosure { 137 public: 138 const void* _p; 139 Space* sp; 140 virtual void do_space(Space* s) { 141 if (sp == NULL) { 142 if (s->is_in(_p)) sp = s; 143 } 144 } 145 GenerationIsInClosure(const void* p) : _p(p), sp(NULL) {} 146 }; 147 148 bool Generation::is_in(const void* p) const { 149 GenerationIsInClosure blk(p); 150 ((Generation*)this)->space_iterate(&blk); 151 return blk.sp != NULL; 152 } 153 154 Generation* Generation::next_gen() const { 155 GenCollectedHeap* gch = GenCollectedHeap::heap(); 156 if (level() == 0) { 157 return gch->old_gen(); 158 } else { 159 return NULL; 160 } 161 } 162 163 size_t Generation::max_contiguous_available() const { 164 // The largest number of contiguous free words in this or any higher generation. 165 size_t max = 0; 166 for (const Generation* gen = this; gen != NULL; gen = gen->next_gen()) { 167 size_t avail = gen->contiguous_available(); 168 if (avail > max) { 169 max = avail; 170 } 171 } 172 return max; 173 } 174 175 bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const { 176 size_t available = max_contiguous_available(); 177 bool res = (available >= max_promotion_in_bytes); 178 if (PrintGC && Verbose) { 179 gclog_or_tty->print_cr( 180 "Generation: promo attempt is%s safe: available("SIZE_FORMAT") %s max_promo("SIZE_FORMAT")", 181 res? "":" not", available, res? ">=":"<", 182 max_promotion_in_bytes); 183 } 184 return res; 185 } 186 187 // Ignores "ref" and calls allocate(). 188 oop Generation::promote(oop obj, size_t obj_size) { 189 assert(obj_size == (size_t)obj->size(), "bad obj_size passed in"); 190 191 #ifndef PRODUCT 192 if (Universe::heap()->promotion_should_fail()) { 193 return NULL; 194 } 195 #endif // #ifndef PRODUCT 196 197 HeapWord* result = allocate(obj_size, false); 198 if (result != NULL) { 199 Copy::aligned_disjoint_words((HeapWord*)obj, result, obj_size); 200 return oop(result); 201 } else { 202 GenCollectedHeap* gch = GenCollectedHeap::heap(); 203 return gch->handle_failed_promotion(this, obj, obj_size); 204 } 205 } 206 207 oop Generation::par_promote(int thread_num, 208 oop obj, markOop m, size_t word_sz) { 209 // Could do a bad general impl here that gets a lock. But no. 210 ShouldNotCallThis(); 211 return NULL; 212 } 213 214 Space* Generation::space_containing(const void* p) const { 215 GenerationIsInReservedClosure blk(p); 216 // Cast away const 217 ((Generation*)this)->space_iterate(&blk); 218 return blk.sp; 219 } 220 221 // Some of these are mediocre general implementations. Should be 222 // overridden to get better performance. 223 224 class GenerationBlockStartClosure : public SpaceClosure { 225 public: 226 const void* _p; 227 HeapWord* _start; 228 virtual void do_space(Space* s) { 229 if (_start == NULL && s->is_in_reserved(_p)) { 230 _start = s->block_start(_p); 231 } 232 } 233 GenerationBlockStartClosure(const void* p) { _p = p; _start = NULL; } 234 }; 235 236 HeapWord* Generation::block_start(const void* p) const { 237 GenerationBlockStartClosure blk(p); 238 // Cast away const 239 ((Generation*)this)->space_iterate(&blk); 240 return blk._start; 241 } 242 243 class GenerationBlockSizeClosure : public SpaceClosure { 244 public: 245 const HeapWord* _p; 246 size_t size; 247 virtual void do_space(Space* s) { 248 if (size == 0 && s->is_in_reserved(_p)) { 249 size = s->block_size(_p); 250 } 251 } 252 GenerationBlockSizeClosure(const HeapWord* p) { _p = p; size = 0; } 253 }; 254 255 size_t Generation::block_size(const HeapWord* p) const { 256 GenerationBlockSizeClosure blk(p); 257 // Cast away const 258 ((Generation*)this)->space_iterate(&blk); 259 assert(blk.size > 0, "seems reasonable"); 260 return blk.size; 261 } 262 263 class GenerationBlockIsObjClosure : public SpaceClosure { 264 public: 265 const HeapWord* _p; 266 bool is_obj; 267 virtual void do_space(Space* s) { 268 if (!is_obj && s->is_in_reserved(_p)) { 269 is_obj |= s->block_is_obj(_p); 270 } 271 } 272 GenerationBlockIsObjClosure(const HeapWord* p) { _p = p; is_obj = false; } 273 }; 274 275 bool Generation::block_is_obj(const HeapWord* p) const { 276 GenerationBlockIsObjClosure blk(p); 277 // Cast away const 278 ((Generation*)this)->space_iterate(&blk); 279 return blk.is_obj; 280 } 281 282 class GenerationOopIterateClosure : public SpaceClosure { 283 public: 284 ExtendedOopClosure* _cl; 285 virtual void do_space(Space* s) { 286 s->oop_iterate(_cl); 287 } 288 GenerationOopIterateClosure(ExtendedOopClosure* cl) : 289 _cl(cl) {} 290 }; 291 292 void Generation::oop_iterate(ExtendedOopClosure* cl) { 293 GenerationOopIterateClosure blk(cl); 294 space_iterate(&blk); 295 } 296 297 void Generation::younger_refs_in_space_iterate(Space* sp, 298 OopsInGenClosure* cl) { 299 GenRemSet* rs = GenCollectedHeap::heap()->rem_set(); 300 rs->younger_refs_in_space_iterate(sp, cl); 301 } 302 303 class GenerationObjIterateClosure : public SpaceClosure { 304 private: 305 ObjectClosure* _cl; 306 public: 307 virtual void do_space(Space* s) { 308 s->object_iterate(_cl); 309 } 310 GenerationObjIterateClosure(ObjectClosure* cl) : _cl(cl) {} 311 }; 312 313 void Generation::object_iterate(ObjectClosure* cl) { 314 GenerationObjIterateClosure blk(cl); 315 space_iterate(&blk); 316 } 317 318 class GenerationSafeObjIterateClosure : public SpaceClosure { 319 private: 320 ObjectClosure* _cl; 321 public: 322 virtual void do_space(Space* s) { 323 s->safe_object_iterate(_cl); 324 } 325 GenerationSafeObjIterateClosure(ObjectClosure* cl) : _cl(cl) {} 326 }; 327 328 void Generation::safe_object_iterate(ObjectClosure* cl) { 329 GenerationSafeObjIterateClosure blk(cl); 330 space_iterate(&blk); 331 } 332 333 void Generation::prepare_for_compaction(CompactPoint* cp) { 334 // Generic implementation, can be specialized 335 CompactibleSpace* space = first_compaction_space(); 336 while (space != NULL) { 337 space->prepare_for_compaction(cp); 338 space = space->next_compaction_space(); 339 } 340 } 341 342 class AdjustPointersClosure: public SpaceClosure { 343 public: 344 void do_space(Space* sp) { 345 sp->adjust_pointers(); 346 } 347 }; 348 349 void Generation::adjust_pointers() { 350 // Note that this is done over all spaces, not just the compactible 351 // ones. 352 AdjustPointersClosure blk; 353 space_iterate(&blk, true); 354 } 355 356 void Generation::compact() { 357 CompactibleSpace* sp = first_compaction_space(); 358 while (sp != NULL) { 359 sp->compact(); 360 sp = sp->next_compaction_space(); 361 } 362 }