1 /* 2 * Copyright (c) 2001, 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 "classfile/systemDictionary.hpp" 27 #include "gc/parallel/objectStartArray.hpp" 28 #include "gc/parallel/parallelScavengeHeap.hpp" 29 #include "gc/parallel/psMarkSweep.hpp" 30 #include "gc/parallel/psMarkSweepDecorator.hpp" 31 #include "gc/serial/markSweep.inline.hpp" 32 #include "gc/shared/liveRange.hpp" 33 #include "gc/shared/spaceDecorator.hpp" 34 #include "oops/oop.inline.hpp" 35 #include "runtime/prefetch.inline.hpp" 36 37 PSMarkSweepDecorator* PSMarkSweepDecorator::_destination_decorator = NULL; 38 39 40 void PSMarkSweepDecorator::set_destination_decorator_tenured() { 41 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 42 _destination_decorator = heap->old_gen()->object_mark_sweep(); 43 } 44 45 void PSMarkSweepDecorator::advance_destination_decorator() { 46 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 47 48 assert(_destination_decorator != NULL, "Sanity"); 49 50 PSMarkSweepDecorator* first = heap->old_gen()->object_mark_sweep(); 51 PSMarkSweepDecorator* second = heap->young_gen()->eden_mark_sweep(); 52 PSMarkSweepDecorator* third = heap->young_gen()->from_mark_sweep(); 53 PSMarkSweepDecorator* fourth = heap->young_gen()->to_mark_sweep(); 54 55 if ( _destination_decorator == first ) { 56 _destination_decorator = second; 57 } else if ( _destination_decorator == second ) { 58 _destination_decorator = third; 59 } else if ( _destination_decorator == third ) { 60 _destination_decorator = fourth; 61 } else { 62 fatal("PSMarkSweep attempting to advance past last compaction area"); 63 } 64 } 65 66 PSMarkSweepDecorator* PSMarkSweepDecorator::destination_decorator() { 67 assert(_destination_decorator != NULL, "Sanity"); 68 69 return _destination_decorator; 70 } 71 72 // FIX ME FIX ME FIX ME FIX ME!!!!!!!!! 73 // The object forwarding code is duplicated. Factor this out!!!!! 74 // 75 // This method "precompacts" objects inside its space to dest. It places forwarding 76 // pointers into markOops for use by adjust_pointers. If "dest" should overflow, we 77 // finish by compacting into our own space. 78 79 void PSMarkSweepDecorator::precompact() { 80 // Reset our own compact top. 81 set_compaction_top(space()->bottom()); 82 83 /* We allow some amount of garbage towards the bottom of the space, so 84 * we don't start compacting before there is a significant gain to be made. 85 * Occasionally, we want to ensure a full compaction, which is determined 86 * by the MarkSweepAlwaysCompactCount parameter. This is a significant 87 * performance improvement! 88 */ 89 bool skip_dead = ((PSMarkSweep::total_invocations() % MarkSweepAlwaysCompactCount) != 0); 90 91 size_t allowed_deadspace = 0; 92 if (skip_dead) { 93 const size_t ratio = allowed_dead_ratio(); 94 allowed_deadspace = space()->capacity_in_words() * ratio / 100; 95 } 96 97 // Fetch the current destination decorator 98 PSMarkSweepDecorator* dest = destination_decorator(); 99 ObjectStartArray* start_array = dest->start_array(); 100 101 HeapWord* compact_top = dest->compaction_top(); 102 HeapWord* compact_end = dest->space()->end(); 103 104 HeapWord* q = space()->bottom(); 105 HeapWord* t = space()->top(); 106 107 HeapWord* end_of_live= q; /* One byte beyond the last byte of the last 108 live object. */ 109 HeapWord* first_dead = space()->end(); /* The first dead object. */ 110 LiveRange* liveRange = NULL; /* The current live range, recorded in the 111 first header of preceding free area. */ 112 _first_dead = first_dead; 113 114 const intx interval = PrefetchScanIntervalInBytes; 115 116 while (q < t) { 117 assert(oop(q)->mark()->is_marked() || oop(q)->mark()->is_unlocked() || 118 oop(q)->mark()->has_bias_pattern(), 119 "these are the only valid states during a mark sweep"); 120 if (oop(q)->is_gc_marked()) { 121 /* prefetch beyond q */ 122 Prefetch::write(q, interval); 123 size_t size = oop(q)->size(); 124 125 size_t compaction_max_size = pointer_delta(compact_end, compact_top); 126 127 // This should only happen if a space in the young gen overflows the 128 // old gen. If that should happen, we null out the start_array, because 129 // the young spaces are not covered by one. 130 while(size > compaction_max_size) { 131 // First record the last compact_top 132 dest->set_compaction_top(compact_top); 133 134 // Advance to the next compaction decorator 135 advance_destination_decorator(); 136 dest = destination_decorator(); 137 138 // Update compaction info 139 start_array = dest->start_array(); 140 compact_top = dest->compaction_top(); 141 compact_end = dest->space()->end(); 142 assert(compact_top == dest->space()->bottom(), "Advanced to space already in use"); 143 assert(compact_end > compact_top, "Must always be space remaining"); 144 compaction_max_size = 145 pointer_delta(compact_end, compact_top); 146 } 147 148 // store the forwarding pointer into the mark word 149 if (q != compact_top) { 150 oop(q)->forward_to(oop(compact_top)); 151 assert(oop(q)->is_gc_marked(), "encoding the pointer should preserve the mark"); 152 } else { 153 // if the object isn't moving we can just set the mark to the default 154 // mark and handle it specially later on. 155 oop(q)->init_mark(); 156 assert(oop(q)->forwardee() == NULL, "should be forwarded to NULL"); 157 } 158 159 // Update object start array 160 if (start_array) { 161 start_array->allocate_block(compact_top); 162 } 163 164 compact_top += size; 165 assert(compact_top <= dest->space()->end(), 166 "Exceeding space in destination"); 167 168 q += size; 169 end_of_live = q; 170 } else { 171 /* run over all the contiguous dead objects */ 172 HeapWord* end = q; 173 do { 174 /* prefetch beyond end */ 175 Prefetch::write(end, interval); 176 end += oop(end)->size(); 177 } while (end < t && (!oop(end)->is_gc_marked())); 178 179 /* see if we might want to pretend this object is alive so that 180 * we don't have to compact quite as often. 181 */ 182 if (allowed_deadspace > 0 && q == compact_top) { 183 size_t sz = pointer_delta(end, q); 184 if (insert_deadspace(allowed_deadspace, q, sz)) { 185 size_t compaction_max_size = pointer_delta(compact_end, compact_top); 186 187 // This should only happen if a space in the young gen overflows the 188 // old gen. If that should happen, we null out the start_array, because 189 // the young spaces are not covered by one. 190 while (sz > compaction_max_size) { 191 // First record the last compact_top 192 dest->set_compaction_top(compact_top); 193 194 // Advance to the next compaction decorator 195 advance_destination_decorator(); 196 dest = destination_decorator(); 197 198 // Update compaction info 199 start_array = dest->start_array(); 200 compact_top = dest->compaction_top(); 201 compact_end = dest->space()->end(); 202 assert(compact_top == dest->space()->bottom(), "Advanced to space already in use"); 203 assert(compact_end > compact_top, "Must always be space remaining"); 204 compaction_max_size = 205 pointer_delta(compact_end, compact_top); 206 } 207 208 // store the forwarding pointer into the mark word 209 if (q != compact_top) { 210 oop(q)->forward_to(oop(compact_top)); 211 assert(oop(q)->is_gc_marked(), "encoding the pointer should preserve the mark"); 212 } else { 213 // if the object isn't moving we can just set the mark to the default 214 // mark and handle it specially later on. 215 oop(q)->init_mark(); 216 assert(oop(q)->forwardee() == NULL, "should be forwarded to NULL"); 217 } 218 219 // Update object start array 220 if (start_array) { 221 start_array->allocate_block(compact_top); 222 } 223 224 compact_top += sz; 225 assert(compact_top <= dest->space()->end(), 226 "Exceeding space in destination"); 227 228 q = end; 229 end_of_live = end; 230 continue; 231 } 232 } 233 234 /* for the previous LiveRange, record the end of the live objects. */ 235 if (liveRange) { 236 liveRange->set_end(q); 237 } 238 239 /* record the current LiveRange object. 240 * liveRange->start() is overlaid on the mark word. 241 */ 242 liveRange = (LiveRange*)q; 243 liveRange->set_start(end); 244 liveRange->set_end(end); 245 246 /* see if this is the first dead region. */ 247 if (q < first_dead) { 248 first_dead = q; 249 } 250 251 /* move on to the next object */ 252 q = end; 253 } 254 } 255 256 assert(q == t, "just checking"); 257 if (liveRange != NULL) { 258 liveRange->set_end(q); 259 } 260 _end_of_live = end_of_live; 261 if (end_of_live < first_dead) { 262 first_dead = end_of_live; 263 } 264 _first_dead = first_dead; 265 266 // Update compaction top 267 dest->set_compaction_top(compact_top); 268 } 269 270 bool PSMarkSweepDecorator::insert_deadspace(size_t& allowed_deadspace_words, 271 HeapWord* q, size_t deadlength) { 272 if (allowed_deadspace_words >= deadlength) { 273 allowed_deadspace_words -= deadlength; 274 CollectedHeap::fill_with_object(q, deadlength); 275 oop(q)->set_mark(oop(q)->mark()->set_marked()); 276 assert((int) deadlength == oop(q)->size(), "bad filler object size"); 277 // Recall that we required "q == compaction_top". 278 return true; 279 } else { 280 allowed_deadspace_words = 0; 281 return false; 282 } 283 } 284 285 void PSMarkSweepDecorator::adjust_pointers() { 286 // adjust all the interior pointers to point at the new locations of objects 287 // Used by MarkSweep::mark_sweep_phase3() 288 289 HeapWord* q = space()->bottom(); 290 HeapWord* t = _end_of_live; // Established by "prepare_for_compaction". 291 292 assert(_first_dead <= _end_of_live, "Stands to reason, no?"); 293 294 if (q < t && _first_dead > q && 295 !oop(q)->is_gc_marked()) { 296 // we have a chunk of the space which hasn't moved and we've 297 // reinitialized the mark word during the previous pass, so we can't 298 // use is_gc_marked for the traversal. 299 HeapWord* end = _first_dead; 300 301 while (q < end) { 302 // point all the oops to the new location 303 size_t size = MarkSweep::adjust_pointers(oop(q)); 304 q += size; 305 } 306 307 if (_first_dead == t) { 308 q = t; 309 } else { 310 // $$$ This is funky. Using this to read the previously written 311 // LiveRange. See also use below. 312 q = (HeapWord*)oop(_first_dead)->mark()->decode_pointer(); 313 } 314 } 315 const intx interval = PrefetchScanIntervalInBytes; 316 317 debug_only(HeapWord* prev_q = NULL); 318 while (q < t) { 319 // prefetch beyond q 320 Prefetch::write(q, interval); 321 if (oop(q)->is_gc_marked()) { 322 // q is alive 323 // point all the oops to the new location 324 size_t size = MarkSweep::adjust_pointers(oop(q)); 325 debug_only(prev_q = q); 326 q += size; 327 } else { 328 // q is not a live object, so its mark should point at the next 329 // live object 330 debug_only(prev_q = q); 331 q = (HeapWord*) oop(q)->mark()->decode_pointer(); 332 assert(q > prev_q, "we should be moving forward through memory"); 333 } 334 } 335 336 assert(q == t, "just checking"); 337 } 338 339 void PSMarkSweepDecorator::compact(bool mangle_free_space ) { 340 // Copy all live objects to their new location 341 // Used by MarkSweep::mark_sweep_phase4() 342 343 HeapWord* q = space()->bottom(); 344 HeapWord* const t = _end_of_live; 345 debug_only(HeapWord* prev_q = NULL); 346 347 if (q < t && _first_dead > q && 348 !oop(q)->is_gc_marked()) { 349 #ifdef ASSERT 350 // we have a chunk of the space which hasn't moved and we've reinitialized the 351 // mark word during the previous pass, so we can't use is_gc_marked for the 352 // traversal. 353 HeapWord* const end = _first_dead; 354 355 while (q < end) { 356 size_t size = oop(q)->size(); 357 assert(!oop(q)->is_gc_marked(), "should be unmarked (special dense prefix handling)"); 358 debug_only(prev_q = q); 359 q += size; 360 } 361 #endif 362 363 if (_first_dead == t) { 364 q = t; 365 } else { 366 // $$$ Funky 367 q = (HeapWord*) oop(_first_dead)->mark()->decode_pointer(); 368 } 369 } 370 371 const intx scan_interval = PrefetchScanIntervalInBytes; 372 const intx copy_interval = PrefetchCopyIntervalInBytes; 373 374 while (q < t) { 375 if (!oop(q)->is_gc_marked()) { 376 // mark is pointer to next marked oop 377 debug_only(prev_q = q); 378 q = (HeapWord*) oop(q)->mark()->decode_pointer(); 379 assert(q > prev_q, "we should be moving forward through memory"); 380 } else { 381 // prefetch beyond q 382 Prefetch::read(q, scan_interval); 383 384 // size and destination 385 size_t size = oop(q)->size(); 386 HeapWord* compaction_top = (HeapWord*)oop(q)->forwardee(); 387 388 // prefetch beyond compaction_top 389 Prefetch::write(compaction_top, copy_interval); 390 391 // copy object and reinit its mark 392 assert(q != compaction_top, "everything in this pass should be moving"); 393 Copy::aligned_conjoint_words(q, compaction_top, size); 394 oop(compaction_top)->init_mark(); 395 assert(oop(compaction_top)->klass() != NULL, "should have a class"); 396 397 debug_only(prev_q = q); 398 q += size; 399 } 400 } 401 402 assert(compaction_top() >= space()->bottom() && compaction_top() <= space()->end(), 403 "should point inside space"); 404 space()->set_top(compaction_top()); 405 406 if (mangle_free_space) { 407 space()->mangle_unused_area(); 408 } 409 }