1 /* 2 * Copyright (c) 2005, 2025, 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 "classfile/classLoaderDataGraph.hpp" 26 #include "classfile/javaClasses.inline.hpp" 27 #include "classfile/stringTable.hpp" 28 #include "classfile/symbolTable.hpp" 29 #include "classfile/systemDictionary.hpp" 30 #include "code/codeCache.hpp" 31 #include "compiler/oopMap.hpp" 32 #include "gc/parallel/objectStartArray.inline.hpp" 33 #include "gc/parallel/parallelArguments.hpp" 34 #include "gc/parallel/parallelScavengeHeap.inline.hpp" 35 #include "gc/parallel/parMarkBitMap.inline.hpp" 36 #include "gc/parallel/psAdaptiveSizePolicy.hpp" 37 #include "gc/parallel/psCompactionManager.inline.hpp" 38 #include "gc/parallel/psOldGen.hpp" 39 #include "gc/parallel/psParallelCompact.inline.hpp" 40 #include "gc/parallel/psPromotionManager.inline.hpp" 41 #include "gc/parallel/psRootType.hpp" 42 #include "gc/parallel/psScavenge.hpp" 43 #include "gc/parallel/psStringDedup.hpp" 44 #include "gc/parallel/psYoungGen.hpp" 45 #include "gc/shared/classUnloadingContext.hpp" 46 #include "gc/shared/fullGCForwarding.inline.hpp" 47 #include "gc/shared/gcCause.hpp" 48 #include "gc/shared/gcHeapSummary.hpp" 49 #include "gc/shared/gcId.hpp" 50 #include "gc/shared/gcLocker.hpp" 51 #include "gc/shared/gcTimer.hpp" 52 #include "gc/shared/gcTrace.hpp" 53 #include "gc/shared/gcTraceTime.inline.hpp" 54 #include "gc/shared/gcVMOperations.hpp" 55 #include "gc/shared/isGCActiveMark.hpp" 56 #include "gc/shared/oopStorage.inline.hpp" 57 #include "gc/shared/oopStorageSet.inline.hpp" 58 #include "gc/shared/oopStorageSetParState.inline.hpp" 59 #include "gc/shared/preservedMarks.inline.hpp" 60 #include "gc/shared/referencePolicy.hpp" 61 #include "gc/shared/referenceProcessor.hpp" 62 #include "gc/shared/referenceProcessorPhaseTimes.hpp" 63 #include "gc/shared/spaceDecorator.hpp" 64 #include "gc/shared/strongRootsScope.hpp" 65 #include "gc/shared/taskTerminator.hpp" 66 #include "gc/shared/weakProcessor.inline.hpp" 67 #include "gc/shared/workerPolicy.hpp" 68 #include "gc/shared/workerThread.hpp" 69 #include "gc/shared/workerUtils.hpp" 70 #include "logging/log.hpp" 71 #include "memory/iterator.inline.hpp" 72 #include "memory/memoryReserver.hpp" 73 #include "memory/metaspaceUtils.hpp" 74 #include "memory/resourceArea.hpp" 75 #include "memory/universe.hpp" 76 #include "nmt/memTracker.hpp" 77 #include "oops/access.inline.hpp" 78 #include "oops/flatArrayKlass.inline.hpp" 79 #include "oops/instanceClassLoaderKlass.inline.hpp" 80 #include "oops/instanceKlass.inline.hpp" 81 #include "oops/instanceMirrorKlass.inline.hpp" 82 #include "oops/methodData.hpp" 83 #include "oops/objArrayKlass.inline.hpp" 84 #include "oops/oop.inline.hpp" 85 #include "runtime/atomic.hpp" 86 #include "runtime/handles.inline.hpp" 87 #include "runtime/java.hpp" 88 #include "runtime/safepoint.hpp" 89 #include "runtime/threads.hpp" 90 #include "runtime/vmThread.hpp" 91 #include "services/memoryService.hpp" 92 #include "utilities/align.hpp" 93 #include "utilities/debug.hpp" 94 #include "utilities/events.hpp" 95 #include "utilities/formatBuffer.hpp" 96 #include "utilities/macros.hpp" 97 #include "utilities/stack.inline.hpp" 98 #if INCLUDE_JVMCI 99 #include "jvmci/jvmci.hpp" 100 #endif 101 102 #include <math.h> 103 104 // All sizes are in HeapWords. 105 const size_t ParallelCompactData::Log2RegionSize = 16; // 64K words 106 const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize; 107 static_assert(ParallelCompactData::RegionSize >= BitsPerWord, "region-start bit word-aligned"); 108 const size_t ParallelCompactData::RegionSizeBytes = 109 RegionSize << LogHeapWordSize; 110 const size_t ParallelCompactData::RegionSizeOffsetMask = RegionSize - 1; 111 const size_t ParallelCompactData::RegionAddrOffsetMask = RegionSizeBytes - 1; 112 const size_t ParallelCompactData::RegionAddrMask = ~RegionAddrOffsetMask; 113 114 const ParallelCompactData::RegionData::region_sz_t 115 ParallelCompactData::RegionData::dc_shift = 27; 116 117 const ParallelCompactData::RegionData::region_sz_t 118 ParallelCompactData::RegionData::dc_mask = ~0U << dc_shift; 119 120 const ParallelCompactData::RegionData::region_sz_t 121 ParallelCompactData::RegionData::dc_one = 0x1U << dc_shift; 122 123 const ParallelCompactData::RegionData::region_sz_t 124 ParallelCompactData::RegionData::los_mask = ~dc_mask; 125 126 const ParallelCompactData::RegionData::region_sz_t 127 ParallelCompactData::RegionData::dc_claimed = 0x8U << dc_shift; 128 129 const ParallelCompactData::RegionData::region_sz_t 130 ParallelCompactData::RegionData::dc_completed = 0xcU << dc_shift; 131 132 bool ParallelCompactData::RegionData::is_clear() { 133 return (_destination == nullptr) && 134 (_source_region == 0) && 135 (_partial_obj_addr == nullptr) && 136 (_partial_obj_size == 0) && 137 (_dc_and_los == 0) && 138 (_shadow_state == 0); 139 } 140 141 #ifdef ASSERT 142 void ParallelCompactData::RegionData::verify_clear() { 143 assert(_destination == nullptr, "inv"); 144 assert(_source_region == 0, "inv"); 145 assert(_partial_obj_addr == nullptr, "inv"); 146 assert(_partial_obj_size == 0, "inv"); 147 assert(_dc_and_los == 0, "inv"); 148 assert(_shadow_state == 0, "inv"); 149 } 150 #endif 151 152 SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id]; 153 154 SpanSubjectToDiscoveryClosure PSParallelCompact::_span_based_discoverer; 155 ReferenceProcessor* PSParallelCompact::_ref_processor = nullptr; 156 157 void SplitInfo::record(size_t split_region_idx, HeapWord* split_point, size_t preceding_live_words) { 158 assert(split_region_idx != 0, "precondition"); 159 160 // Obj denoted by split_point will be deferred to the next space. 161 assert(split_point != nullptr, "precondition"); 162 163 const ParallelCompactData& sd = PSParallelCompact::summary_data(); 164 165 PSParallelCompact::RegionData* split_region_ptr = sd.region(split_region_idx); 166 assert(preceding_live_words < split_region_ptr->data_size(), "inv"); 167 168 HeapWord* preceding_destination = split_region_ptr->destination(); 169 assert(preceding_destination != nullptr, "inv"); 170 171 // How many regions does the preceding part occupy 172 uint preceding_destination_count; 173 if (preceding_live_words == 0) { 174 preceding_destination_count = 0; 175 } else { 176 // -1 so that the ending address doesn't fall on the region-boundary 177 if (sd.region_align_down(preceding_destination) == 178 sd.region_align_down(preceding_destination + preceding_live_words - 1)) { 179 preceding_destination_count = 1; 180 } else { 181 preceding_destination_count = 2; 182 } 183 } 184 185 _split_region_idx = split_region_idx; 186 _split_point = split_point; 187 _preceding_live_words = preceding_live_words; 188 _preceding_destination = preceding_destination; 189 _preceding_destination_count = preceding_destination_count; 190 } 191 192 void SplitInfo::clear() 193 { 194 _split_region_idx = 0; 195 _split_point = nullptr; 196 _preceding_live_words = 0; 197 _preceding_destination = nullptr; 198 _preceding_destination_count = 0; 199 assert(!is_valid(), "sanity"); 200 } 201 202 #ifdef ASSERT 203 void SplitInfo::verify_clear() 204 { 205 assert(_split_region_idx == 0, "not clear"); 206 assert(_split_point == nullptr, "not clear"); 207 assert(_preceding_live_words == 0, "not clear"); 208 assert(_preceding_destination == nullptr, "not clear"); 209 assert(_preceding_destination_count == 0, "not clear"); 210 } 211 #endif // #ifdef ASSERT 212 213 214 void PSParallelCompact::print_on_error(outputStream* st) { 215 _mark_bitmap.print_on_error(st); 216 } 217 218 ParallelCompactData::ParallelCompactData() : 219 _heap_start(nullptr), 220 DEBUG_ONLY(_heap_end(nullptr) COMMA) 221 _region_vspace(nullptr), 222 _reserved_byte_size(0), 223 _region_data(nullptr), 224 _region_count(0) {} 225 226 bool ParallelCompactData::initialize(MemRegion reserved_heap) 227 { 228 _heap_start = reserved_heap.start(); 229 const size_t heap_size = reserved_heap.word_size(); 230 DEBUG_ONLY(_heap_end = _heap_start + heap_size;) 231 232 assert(region_align_down(_heap_start) == _heap_start, 233 "region start not aligned"); 234 235 return initialize_region_data(heap_size); 236 } 237 238 PSVirtualSpace* 239 ParallelCompactData::create_vspace(size_t count, size_t element_size) 240 { 241 const size_t raw_bytes = count * element_size; 242 const size_t page_sz = os::page_size_for_region_aligned(raw_bytes, 10); 243 const size_t granularity = os::vm_allocation_granularity(); 244 const size_t rs_align = MAX2(page_sz, granularity); 245 246 _reserved_byte_size = align_up(raw_bytes, rs_align); 247 248 ReservedSpace rs = MemoryReserver::reserve(_reserved_byte_size, 249 rs_align, 250 page_sz); 251 252 if (!rs.is_reserved()) { 253 // Failed to reserve memory. 254 return nullptr; 255 } 256 257 os::trace_page_sizes("Parallel Compact Data", raw_bytes, raw_bytes, rs.base(), 258 rs.size(), page_sz); 259 260 MemTracker::record_virtual_memory_tag((address)rs.base(), mtGC); 261 262 PSVirtualSpace* vspace = new PSVirtualSpace(rs, page_sz); 263 264 if (!vspace->expand_by(_reserved_byte_size)) { 265 // Failed to commit memory. 266 267 delete vspace; 268 269 // Release memory reserved in the space. 270 MemoryReserver::release(rs); 271 272 return nullptr; 273 } 274 275 return vspace; 276 } 277 278 bool ParallelCompactData::initialize_region_data(size_t heap_size) 279 { 280 assert(is_aligned(heap_size, RegionSize), "precondition"); 281 282 const size_t count = heap_size >> Log2RegionSize; 283 _region_vspace = create_vspace(count, sizeof(RegionData)); 284 if (_region_vspace != nullptr) { 285 _region_data = (RegionData*)_region_vspace->reserved_low_addr(); 286 _region_count = count; 287 return true; 288 } 289 return false; 290 } 291 292 void ParallelCompactData::clear_range(size_t beg_region, size_t end_region) { 293 assert(beg_region <= _region_count, "beg_region out of range"); 294 assert(end_region <= _region_count, "end_region out of range"); 295 296 const size_t region_cnt = end_region - beg_region; 297 memset(_region_data + beg_region, 0, region_cnt * sizeof(RegionData)); 298 } 299 300 void 301 ParallelCompactData::summarize_dense_prefix(HeapWord* beg, HeapWord* end) 302 { 303 assert(is_region_aligned(beg), "not RegionSize aligned"); 304 assert(is_region_aligned(end), "not RegionSize aligned"); 305 306 size_t cur_region = addr_to_region_idx(beg); 307 const size_t end_region = addr_to_region_idx(end); 308 HeapWord* addr = beg; 309 while (cur_region < end_region) { 310 _region_data[cur_region].set_destination(addr); 311 _region_data[cur_region].set_destination_count(0); 312 _region_data[cur_region].set_source_region(cur_region); 313 314 // Update live_obj_size so the region appears completely full. 315 size_t live_size = RegionSize - _region_data[cur_region].partial_obj_size(); 316 _region_data[cur_region].set_live_obj_size(live_size); 317 318 ++cur_region; 319 addr += RegionSize; 320 } 321 } 322 323 // The total live words on src_region would overflow the target space, so find 324 // the overflowing object and record the split point. The invariant is that an 325 // obj should not cross space boundary. 326 HeapWord* ParallelCompactData::summarize_split_space(size_t src_region, 327 SplitInfo& split_info, 328 HeapWord* const destination, 329 HeapWord* const target_end, 330 HeapWord** target_next) { 331 assert(destination <= target_end, "sanity"); 332 assert(destination + _region_data[src_region].data_size() > target_end, 333 "region should not fit into target space"); 334 assert(is_region_aligned(target_end), "sanity"); 335 336 size_t partial_obj_size = _region_data[src_region].partial_obj_size(); 337 338 if (destination + partial_obj_size > target_end) { 339 assert(partial_obj_size > 0, "inv"); 340 // The overflowing obj is from a previous region. 341 // 342 // source-regions: 343 // 344 // *************** 345 // | A|AA | 346 // *************** 347 // ^ 348 // | split-point 349 // 350 // dest-region: 351 // 352 // ******** 353 // |~~~~A | 354 // ******** 355 // ^^ 356 // || target-space-end 357 // | 358 // | destination 359 // 360 // AAA would overflow target-space. 361 // 362 HeapWord* overflowing_obj = _region_data[src_region].partial_obj_addr(); 363 size_t split_region = addr_to_region_idx(overflowing_obj); 364 365 // The number of live words before the overflowing object on this split region 366 size_t preceding_live_words; 367 if (is_region_aligned(overflowing_obj)) { 368 preceding_live_words = 0; 369 } else { 370 // Words accounted by the overflowing object on the split region 371 size_t overflowing_size = pointer_delta(region_align_up(overflowing_obj), overflowing_obj); 372 preceding_live_words = region(split_region)->data_size() - overflowing_size; 373 } 374 375 split_info.record(split_region, overflowing_obj, preceding_live_words); 376 377 // The [overflowing_obj, src_region_start) part has been accounted for, so 378 // must move back the new_top, now that this overflowing obj is deferred. 379 HeapWord* new_top = destination - pointer_delta(region_to_addr(src_region), overflowing_obj); 380 381 // If the overflowing obj was relocated to its original destination, 382 // those destination regions would have their source_region set. Now that 383 // this overflowing obj is relocated somewhere else, reset the 384 // source_region. 385 { 386 size_t range_start = addr_to_region_idx(region_align_up(new_top)); 387 size_t range_end = addr_to_region_idx(region_align_up(destination)); 388 for (size_t i = range_start; i < range_end; ++i) { 389 region(i)->set_source_region(0); 390 } 391 } 392 393 // Update new top of target space 394 *target_next = new_top; 395 396 return overflowing_obj; 397 } 398 399 // Obj-iteration to locate the overflowing obj 400 HeapWord* region_start = region_to_addr(src_region); 401 HeapWord* region_end = region_start + RegionSize; 402 HeapWord* cur_addr = region_start + partial_obj_size; 403 size_t live_words = partial_obj_size; 404 405 while (true) { 406 assert(cur_addr < region_end, "inv"); 407 cur_addr = PSParallelCompact::mark_bitmap()->find_obj_beg(cur_addr, region_end); 408 // There must be an overflowing obj in this region 409 assert(cur_addr < region_end, "inv"); 410 411 oop obj = cast_to_oop(cur_addr); 412 size_t obj_size = obj->size(); 413 if (destination + live_words + obj_size > target_end) { 414 // Found the overflowing obj 415 split_info.record(src_region, cur_addr, live_words); 416 *target_next = destination + live_words; 417 return cur_addr; 418 } 419 420 live_words += obj_size; 421 cur_addr += obj_size; 422 } 423 } 424 425 size_t ParallelCompactData::live_words_in_space(const MutableSpace* space, 426 HeapWord** full_region_prefix_end) { 427 size_t cur_region = addr_to_region_idx(space->bottom()); 428 const size_t end_region = addr_to_region_idx(region_align_up(space->top())); 429 size_t live_words = 0; 430 if (full_region_prefix_end == nullptr) { 431 for (/* empty */; cur_region < end_region; ++cur_region) { 432 live_words += _region_data[cur_region].data_size(); 433 } 434 } else { 435 bool first_set = false; 436 for (/* empty */; cur_region < end_region; ++cur_region) { 437 size_t live_words_in_region = _region_data[cur_region].data_size(); 438 if (!first_set && live_words_in_region < RegionSize) { 439 *full_region_prefix_end = region_to_addr(cur_region); 440 first_set = true; 441 } 442 live_words += live_words_in_region; 443 } 444 if (!first_set) { 445 // All regions are full of live objs. 446 assert(is_region_aligned(space->top()), "inv"); 447 *full_region_prefix_end = space->top(); 448 } 449 assert(*full_region_prefix_end != nullptr, "postcondition"); 450 assert(is_region_aligned(*full_region_prefix_end), "inv"); 451 assert(*full_region_prefix_end >= space->bottom(), "in-range"); 452 assert(*full_region_prefix_end <= space->top(), "in-range"); 453 } 454 return live_words; 455 } 456 457 bool ParallelCompactData::summarize(SplitInfo& split_info, 458 HeapWord* source_beg, HeapWord* source_end, 459 HeapWord** source_next, 460 HeapWord* target_beg, HeapWord* target_end, 461 HeapWord** target_next) 462 { 463 HeapWord* const source_next_val = source_next == nullptr ? nullptr : *source_next; 464 log_develop_trace(gc, compaction)( 465 "sb=" PTR_FORMAT " se=" PTR_FORMAT " sn=" PTR_FORMAT 466 "tb=" PTR_FORMAT " te=" PTR_FORMAT " tn=" PTR_FORMAT, 467 p2i(source_beg), p2i(source_end), p2i(source_next_val), 468 p2i(target_beg), p2i(target_end), p2i(*target_next)); 469 470 size_t cur_region = addr_to_region_idx(source_beg); 471 const size_t end_region = addr_to_region_idx(region_align_up(source_end)); 472 473 HeapWord *dest_addr = target_beg; 474 for (/* empty */; cur_region < end_region; cur_region++) { 475 size_t words = _region_data[cur_region].data_size(); 476 477 // Skip empty ones 478 if (words == 0) { 479 continue; 480 } 481 482 if (split_info.is_split(cur_region)) { 483 assert(words > split_info.preceding_live_words(), "inv"); 484 words -= split_info.preceding_live_words(); 485 } 486 487 _region_data[cur_region].set_destination(dest_addr); 488 489 // If cur_region does not fit entirely into the target space, find a point 490 // at which the source space can be 'split' so that part is copied to the 491 // target space and the rest is copied elsewhere. 492 if (dest_addr + words > target_end) { 493 assert(source_next != nullptr, "source_next is null when splitting"); 494 *source_next = summarize_split_space(cur_region, split_info, dest_addr, 495 target_end, target_next); 496 return false; 497 } 498 499 uint destination_count = split_info.is_split(cur_region) 500 ? split_info.preceding_destination_count() 501 : 0; 502 503 HeapWord* const last_addr = dest_addr + words - 1; 504 const size_t dest_region_1 = addr_to_region_idx(dest_addr); 505 const size_t dest_region_2 = addr_to_region_idx(last_addr); 506 507 // Initially assume that the destination regions will be the same and 508 // adjust the value below if necessary. Under this assumption, if 509 // cur_region == dest_region_2, then cur_region will be compacted 510 // completely into itself. 511 destination_count += cur_region == dest_region_2 ? 0 : 1; 512 if (dest_region_1 != dest_region_2) { 513 // Destination regions differ; adjust destination_count. 514 destination_count += 1; 515 // Data from cur_region will be copied to the start of dest_region_2. 516 _region_data[dest_region_2].set_source_region(cur_region); 517 } else if (is_region_aligned(dest_addr)) { 518 // Data from cur_region will be copied to the start of the destination 519 // region. 520 _region_data[dest_region_1].set_source_region(cur_region); 521 } 522 523 _region_data[cur_region].set_destination_count(destination_count); 524 dest_addr += words; 525 } 526 527 *target_next = dest_addr; 528 return true; 529 } 530 531 #ifdef ASSERT 532 void ParallelCompactData::verify_clear() { 533 for (uint cur_idx = 0; cur_idx < region_count(); ++cur_idx) { 534 if (!region(cur_idx)->is_clear()) { 535 log_warning(gc)("Uncleared Region: %u", cur_idx); 536 region(cur_idx)->verify_clear(); 537 } 538 } 539 } 540 #endif // #ifdef ASSERT 541 542 STWGCTimer PSParallelCompact::_gc_timer; 543 ParallelOldTracer PSParallelCompact::_gc_tracer; 544 elapsedTimer PSParallelCompact::_accumulated_time; 545 unsigned int PSParallelCompact::_maximum_compaction_gc_num = 0; 546 CollectorCounters* PSParallelCompact::_counters = nullptr; 547 ParMarkBitMap PSParallelCompact::_mark_bitmap; 548 ParallelCompactData PSParallelCompact::_summary_data; 549 550 PSParallelCompact::IsAliveClosure PSParallelCompact::_is_alive_closure; 551 552 class PCAdjustPointerClosure: public BasicOopIterateClosure { 553 template <typename T> 554 void do_oop_work(T* p) { PSParallelCompact::adjust_pointer(p); } 555 556 public: 557 virtual void do_oop(oop* p) { do_oop_work(p); } 558 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 559 560 virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; } 561 }; 562 563 static PCAdjustPointerClosure pc_adjust_pointer_closure; 564 565 bool PSParallelCompact::IsAliveClosure::do_object_b(oop p) { return mark_bitmap()->is_marked(p); } 566 567 void PSParallelCompact::post_initialize() { 568 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 569 _span_based_discoverer.set_span(heap->reserved_region()); 570 _ref_processor = 571 new ReferenceProcessor(&_span_based_discoverer, 572 ParallelGCThreads, // mt processing degree 573 ParallelGCThreads, // mt discovery degree 574 false, // concurrent_discovery 575 &_is_alive_closure); // non-header is alive closure 576 577 _counters = new CollectorCounters("Parallel full collection pauses", 1); 578 579 // Initialize static fields in ParCompactionManager. 580 ParCompactionManager::initialize(mark_bitmap()); 581 } 582 583 bool PSParallelCompact::initialize_aux_data() { 584 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 585 MemRegion mr = heap->reserved_region(); 586 assert(mr.byte_size() != 0, "heap should be reserved"); 587 588 initialize_space_info(); 589 590 if (!_mark_bitmap.initialize(mr)) { 591 vm_shutdown_during_initialization( 592 err_msg("Unable to allocate %zuKB bitmaps for parallel " 593 "garbage collection for the requested %zuKB heap.", 594 _mark_bitmap.reserved_byte_size()/K, mr.byte_size()/K)); 595 return false; 596 } 597 598 if (!_summary_data.initialize(mr)) { 599 vm_shutdown_during_initialization( 600 err_msg("Unable to allocate %zuKB card tables for parallel " 601 "garbage collection for the requested %zuKB heap.", 602 _summary_data.reserved_byte_size()/K, mr.byte_size()/K)); 603 return false; 604 } 605 606 return true; 607 } 608 609 void PSParallelCompact::initialize_space_info() 610 { 611 memset(&_space_info, 0, sizeof(_space_info)); 612 613 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 614 PSYoungGen* young_gen = heap->young_gen(); 615 616 _space_info[old_space_id].set_space(heap->old_gen()->object_space()); 617 _space_info[eden_space_id].set_space(young_gen->eden_space()); 618 _space_info[from_space_id].set_space(young_gen->from_space()); 619 _space_info[to_space_id].set_space(young_gen->to_space()); 620 621 _space_info[old_space_id].set_start_array(heap->old_gen()->start_array()); 622 } 623 624 void 625 PSParallelCompact::clear_data_covering_space(SpaceId id) 626 { 627 // At this point, top is the value before GC, new_top() is the value that will 628 // be set at the end of GC. The marking bitmap is cleared to top; nothing 629 // should be marked above top. The summary data is cleared to the larger of 630 // top & new_top. 631 MutableSpace* const space = _space_info[id].space(); 632 HeapWord* const bot = space->bottom(); 633 HeapWord* const top = space->top(); 634 HeapWord* const max_top = MAX2(top, _space_info[id].new_top()); 635 636 _mark_bitmap.clear_range(bot, top); 637 638 const size_t beg_region = _summary_data.addr_to_region_idx(bot); 639 const size_t end_region = 640 _summary_data.addr_to_region_idx(_summary_data.region_align_up(max_top)); 641 _summary_data.clear_range(beg_region, end_region); 642 643 // Clear the data used to 'split' regions. 644 SplitInfo& split_info = _space_info[id].split_info(); 645 if (split_info.is_valid()) { 646 split_info.clear(); 647 } 648 DEBUG_ONLY(split_info.verify_clear();) 649 } 650 651 void PSParallelCompact::pre_compact() 652 { 653 // Update the from & to space pointers in space_info, since they are swapped 654 // at each young gen gc. Do the update unconditionally (even though a 655 // promotion failure does not swap spaces) because an unknown number of young 656 // collections will have swapped the spaces an unknown number of times. 657 GCTraceTime(Debug, gc, phases) tm("Pre Compact", &_gc_timer); 658 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 659 _space_info[from_space_id].set_space(heap->young_gen()->from_space()); 660 _space_info[to_space_id].set_space(heap->young_gen()->to_space()); 661 662 // Increment the invocation count 663 heap->increment_total_collections(true); 664 665 CodeCache::on_gc_marking_cycle_start(); 666 667 heap->print_heap_before_gc(); 668 heap->trace_heap_before_gc(&_gc_tracer); 669 670 // Fill in TLABs 671 heap->ensure_parsability(true); // retire TLABs 672 673 if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) { 674 Universe::verify("Before GC"); 675 } 676 677 DEBUG_ONLY(mark_bitmap()->verify_clear();) 678 DEBUG_ONLY(summary_data().verify_clear();) 679 } 680 681 void PSParallelCompact::post_compact() 682 { 683 GCTraceTime(Info, gc, phases) tm("Post Compact", &_gc_timer); 684 ParCompactionManager::remove_all_shadow_regions(); 685 686 CodeCache::on_gc_marking_cycle_finish(); 687 CodeCache::arm_all_nmethods(); 688 689 for (unsigned int id = old_space_id; id < last_space_id; ++id) { 690 // Clear the marking bitmap, summary data and split info. 691 clear_data_covering_space(SpaceId(id)); 692 { 693 MutableSpace* space = _space_info[id].space(); 694 HeapWord* top = space->top(); 695 HeapWord* new_top = _space_info[id].new_top(); 696 if (ZapUnusedHeapArea && new_top < top) { 697 space->mangle_region(MemRegion(new_top, top)); 698 } 699 // Update top(). Must be done after clearing the bitmap and summary data. 700 space->set_top(new_top); 701 } 702 } 703 704 #ifdef ASSERT 705 { 706 mark_bitmap()->verify_clear(); 707 summary_data().verify_clear(); 708 } 709 #endif 710 711 ParCompactionManager::flush_all_string_dedup_requests(); 712 713 MutableSpace* const eden_space = _space_info[eden_space_id].space(); 714 MutableSpace* const from_space = _space_info[from_space_id].space(); 715 MutableSpace* const to_space = _space_info[to_space_id].space(); 716 717 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 718 bool eden_empty = eden_space->is_empty(); 719 720 // Update heap occupancy information which is used as input to the soft ref 721 // clearing policy at the next gc. 722 Universe::heap()->update_capacity_and_used_at_gc(); 723 724 bool young_gen_empty = eden_empty && from_space->is_empty() && 725 to_space->is_empty(); 726 727 PSCardTable* ct = heap->card_table(); 728 MemRegion old_mr = heap->old_gen()->committed(); 729 if (young_gen_empty) { 730 ct->clear_MemRegion(old_mr); 731 } else { 732 ct->dirty_MemRegion(old_mr); 733 } 734 735 { 736 // Delete metaspaces for unloaded class loaders and clean up loader_data graph 737 GCTraceTime(Debug, gc, phases) t("Purge Class Loader Data", gc_timer()); 738 ClassLoaderDataGraph::purge(true /* at_safepoint */); 739 DEBUG_ONLY(MetaspaceUtils::verify();) 740 } 741 742 // Need to clear claim bits for the next mark. 743 ClassLoaderDataGraph::clear_claimed_marks(); 744 745 heap->prune_scavengable_nmethods(); 746 747 #if COMPILER2_OR_JVMCI 748 DerivedPointerTable::update_pointers(); 749 #endif 750 751 // Signal that we have completed a visit to all live objects. 752 Universe::heap()->record_whole_heap_examined_timestamp(); 753 } 754 755 HeapWord* PSParallelCompact::compute_dense_prefix_for_old_space(MutableSpace* old_space, 756 HeapWord* full_region_prefix_end) { 757 const size_t region_size = ParallelCompactData::RegionSize; 758 const ParallelCompactData& sd = summary_data(); 759 760 // Iteration starts with the region *after* the full-region-prefix-end. 761 const RegionData* const start_region = sd.addr_to_region_ptr(full_region_prefix_end); 762 // If final region is not full, iteration stops before that region, 763 // because fill_dense_prefix_end assumes that prefix_end <= top. 764 const RegionData* const end_region = sd.addr_to_region_ptr(old_space->top()); 765 assert(start_region <= end_region, "inv"); 766 767 size_t max_waste = old_space->capacity_in_words() * (MarkSweepDeadRatio / 100.0); 768 const RegionData* cur_region = start_region; 769 for (/* empty */; cur_region < end_region; ++cur_region) { 770 assert(region_size >= cur_region->data_size(), "inv"); 771 size_t dead_size = region_size - cur_region->data_size(); 772 if (max_waste < dead_size) { 773 break; 774 } 775 max_waste -= dead_size; 776 } 777 778 HeapWord* const prefix_end = sd.region_to_addr(cur_region); 779 assert(sd.is_region_aligned(prefix_end), "postcondition"); 780 assert(prefix_end >= full_region_prefix_end, "in-range"); 781 assert(prefix_end <= old_space->top(), "in-range"); 782 return prefix_end; 783 } 784 785 void PSParallelCompact::fill_dense_prefix_end(SpaceId id) { 786 // Comparing two sizes to decide if filling is required: 787 // 788 // The size of the filler (min-obj-size) is 2 heap words with the default 789 // MinObjAlignment, since both markword and klass take 1 heap word. 790 // With +UseCompactObjectHeaders, the minimum filler size is only one word, 791 // because the Klass* gets encoded in the mark-word. 792 // 793 // The size of the gap (if any) right before dense-prefix-end is 794 // MinObjAlignment. 795 // 796 // Need to fill in the gap only if it's smaller than min-obj-size, and the 797 // filler obj will extend to next region. 798 799 if (MinObjAlignment >= checked_cast<int>(CollectedHeap::min_fill_size())) { 800 return; 801 } 802 803 assert(!UseCompactObjectHeaders, "Compact headers can allocate small objects"); 804 assert(CollectedHeap::min_fill_size() == 2, "inv"); 805 HeapWord* const dense_prefix_end = dense_prefix(id); 806 assert(_summary_data.is_region_aligned(dense_prefix_end), "precondition"); 807 assert(dense_prefix_end <= space(id)->top(), "precondition"); 808 if (dense_prefix_end == space(id)->top()) { 809 // Must not have single-word gap right before prefix-end/top. 810 return; 811 } 812 RegionData* const region_after_dense_prefix = _summary_data.addr_to_region_ptr(dense_prefix_end); 813 814 if (region_after_dense_prefix->partial_obj_size() != 0 || 815 _mark_bitmap.is_marked(dense_prefix_end)) { 816 // The region after the dense prefix starts with live bytes. 817 return; 818 } 819 820 HeapWord* block_start = start_array(id)->block_start_reaching_into_card(dense_prefix_end); 821 if (block_start == dense_prefix_end - 1) { 822 assert(!_mark_bitmap.is_marked(block_start), "inv"); 823 // There is exactly one heap word gap right before the dense prefix end, so we need a filler object. 824 // The filler object will extend into region_after_dense_prefix. 825 const size_t obj_len = 2; // min-fill-size 826 HeapWord* const obj_beg = dense_prefix_end - 1; 827 CollectedHeap::fill_with_object(obj_beg, obj_len); 828 _mark_bitmap.mark_obj(obj_beg); 829 _summary_data.addr_to_region_ptr(obj_beg)->add_live_obj(1); 830 region_after_dense_prefix->set_partial_obj_size(1); 831 region_after_dense_prefix->set_partial_obj_addr(obj_beg); 832 assert(start_array(id) != nullptr, "sanity"); 833 start_array(id)->update_for_block(obj_beg, obj_beg + obj_len); 834 } 835 } 836 837 bool PSParallelCompact::check_maximum_compaction(size_t total_live_words, 838 MutableSpace* const old_space, 839 HeapWord* full_region_prefix_end) { 840 841 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 842 843 // Check System.GC 844 bool is_max_on_system_gc = UseMaximumCompactionOnSystemGC 845 && GCCause::is_user_requested_gc(heap->gc_cause()); 846 847 // Check if all live objs are larger than old-gen. 848 const bool is_old_gen_overflowing = (total_live_words > old_space->capacity_in_words()); 849 850 // JVM flags 851 const uint total_invocations = heap->total_full_collections(); 852 assert(total_invocations >= _maximum_compaction_gc_num, "sanity"); 853 const size_t gcs_since_max = total_invocations - _maximum_compaction_gc_num; 854 const bool is_interval_ended = gcs_since_max > HeapMaximumCompactionInterval; 855 856 // If all regions in old-gen are full 857 const bool is_region_full = 858 full_region_prefix_end >= _summary_data.region_align_down(old_space->top()); 859 860 if (is_max_on_system_gc || is_old_gen_overflowing || is_interval_ended || is_region_full) { 861 _maximum_compaction_gc_num = total_invocations; 862 return true; 863 } 864 865 return false; 866 } 867 868 void PSParallelCompact::summary_phase() 869 { 870 GCTraceTime(Info, gc, phases) tm("Summary Phase", &_gc_timer); 871 872 MutableSpace* const old_space = _space_info[old_space_id].space(); 873 { 874 size_t total_live_words = 0; 875 HeapWord* full_region_prefix_end = nullptr; 876 { 877 // old-gen 878 size_t live_words = _summary_data.live_words_in_space(old_space, 879 &full_region_prefix_end); 880 total_live_words += live_words; 881 } 882 // young-gen 883 for (uint i = eden_space_id; i < last_space_id; ++i) { 884 const MutableSpace* space = _space_info[i].space(); 885 size_t live_words = _summary_data.live_words_in_space(space); 886 total_live_words += live_words; 887 _space_info[i].set_new_top(space->bottom() + live_words); 888 _space_info[i].set_dense_prefix(space->bottom()); 889 } 890 891 bool maximum_compaction = check_maximum_compaction(total_live_words, 892 old_space, 893 full_region_prefix_end); 894 HeapWord* dense_prefix_end = maximum_compaction 895 ? full_region_prefix_end 896 : compute_dense_prefix_for_old_space(old_space, 897 full_region_prefix_end); 898 SpaceId id = old_space_id; 899 _space_info[id].set_dense_prefix(dense_prefix_end); 900 901 if (dense_prefix_end != old_space->bottom()) { 902 fill_dense_prefix_end(id); 903 _summary_data.summarize_dense_prefix(old_space->bottom(), dense_prefix_end); 904 } 905 906 // Compacting objs in [dense_prefix_end, old_space->top()) 907 _summary_data.summarize(_space_info[id].split_info(), 908 dense_prefix_end, old_space->top(), nullptr, 909 dense_prefix_end, old_space->end(), 910 _space_info[id].new_top_addr()); 911 } 912 913 // Summarize the remaining spaces in the young gen. The initial target space 914 // is the old gen. If a space does not fit entirely into the target, then the 915 // remainder is compacted into the space itself and that space becomes the new 916 // target. 917 SpaceId dst_space_id = old_space_id; 918 HeapWord* dst_space_end = old_space->end(); 919 HeapWord** new_top_addr = _space_info[dst_space_id].new_top_addr(); 920 for (unsigned int id = eden_space_id; id < last_space_id; ++id) { 921 const MutableSpace* space = _space_info[id].space(); 922 const size_t live = pointer_delta(_space_info[id].new_top(), 923 space->bottom()); 924 const size_t available = pointer_delta(dst_space_end, *new_top_addr); 925 926 if (live > 0 && live <= available) { 927 // All the live data will fit. 928 bool done = _summary_data.summarize(_space_info[id].split_info(), 929 space->bottom(), space->top(), 930 nullptr, 931 *new_top_addr, dst_space_end, 932 new_top_addr); 933 assert(done, "space must fit into old gen"); 934 935 // Reset the new_top value for the space. 936 _space_info[id].set_new_top(space->bottom()); 937 } else if (live > 0) { 938 // Attempt to fit part of the source space into the target space. 939 HeapWord* next_src_addr = nullptr; 940 bool done = _summary_data.summarize(_space_info[id].split_info(), 941 space->bottom(), space->top(), 942 &next_src_addr, 943 *new_top_addr, dst_space_end, 944 new_top_addr); 945 assert(!done, "space should not fit into old gen"); 946 assert(next_src_addr != nullptr, "sanity"); 947 948 // The source space becomes the new target, so the remainder is compacted 949 // within the space itself. 950 dst_space_id = SpaceId(id); 951 dst_space_end = space->end(); 952 new_top_addr = _space_info[id].new_top_addr(); 953 done = _summary_data.summarize(_space_info[id].split_info(), 954 next_src_addr, space->top(), 955 nullptr, 956 space->bottom(), dst_space_end, 957 new_top_addr); 958 assert(done, "space must fit when compacted into itself"); 959 assert(*new_top_addr <= space->top(), "usage should not grow"); 960 } 961 } 962 } 963 964 // This method should contain all heap-specific policy for invoking a full 965 // collection. invoke_no_policy() will only attempt to compact the heap; it 966 // will do nothing further. If we need to bail out for policy reasons, scavenge 967 // before full gc, or any other specialized behavior, it needs to be added here. 968 // 969 // Note that this method should only be called from the vm_thread while at a 970 // safepoint. 971 // 972 // Note that the all_soft_refs_clear flag in the soft ref policy 973 // may be true because this method can be called without intervening 974 // activity. For example when the heap space is tight and full measure 975 // are being taken to free space. 976 bool PSParallelCompact::invoke(bool clear_all_soft_refs) { 977 assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint"); 978 assert(Thread::current() == (Thread*)VMThread::vm_thread(), 979 "should be in vm thread"); 980 981 SvcGCMarker sgcm(SvcGCMarker::FULL); 982 IsSTWGCActiveMark mark; 983 984 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 985 clear_all_soft_refs = clear_all_soft_refs 986 || heap->soft_ref_policy()->should_clear_all_soft_refs(); 987 988 return PSParallelCompact::invoke_no_policy(clear_all_soft_refs); 989 } 990 991 // This method contains no policy. You should probably 992 // be calling invoke() instead. 993 bool PSParallelCompact::invoke_no_policy(bool clear_all_soft_refs) { 994 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); 995 assert(ref_processor() != nullptr, "Sanity"); 996 997 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap(); 998 999 GCIdMark gc_id_mark; 1000 _gc_timer.register_gc_start(); 1001 _gc_tracer.report_gc_start(heap->gc_cause(), _gc_timer.gc_start()); 1002 1003 GCCause::Cause gc_cause = heap->gc_cause(); 1004 PSYoungGen* young_gen = heap->young_gen(); 1005 PSOldGen* old_gen = heap->old_gen(); 1006 PSAdaptiveSizePolicy* size_policy = heap->size_policy(); 1007 1008 // The scope of casr should end after code that can change 1009 // SoftRefPolicy::_should_clear_all_soft_refs. 1010 ClearedAllSoftRefs casr(clear_all_soft_refs, 1011 heap->soft_ref_policy()); 1012 1013 // Make sure data structures are sane, make the heap parsable, and do other 1014 // miscellaneous bookkeeping. 1015 pre_compact(); 1016 1017 const PreGenGCValues pre_gc_values = heap->get_pre_gc_values(); 1018 1019 { 1020 const uint active_workers = 1021 WorkerPolicy::calc_active_workers(ParallelScavengeHeap::heap()->workers().max_workers(), 1022 ParallelScavengeHeap::heap()->workers().active_workers(), 1023 Threads::number_of_non_daemon_threads()); 1024 ParallelScavengeHeap::heap()->workers().set_active_workers(active_workers); 1025 1026 GCTraceCPUTime tcpu(&_gc_tracer); 1027 GCTraceTime(Info, gc) tm("Pause Full", nullptr, gc_cause, true); 1028 1029 heap->pre_full_gc_dump(&_gc_timer); 1030 1031 TraceCollectorStats tcs(counters()); 1032 TraceMemoryManagerStats tms(heap->old_gc_manager(), gc_cause, "end of major GC"); 1033 1034 if (log_is_enabled(Debug, gc, heap, exit)) { 1035 accumulated_time()->start(); 1036 } 1037 1038 // Let the size policy know we're starting 1039 size_policy->major_collection_begin(); 1040 1041 #if COMPILER2_OR_JVMCI 1042 DerivedPointerTable::clear(); 1043 #endif 1044 1045 ref_processor()->start_discovery(clear_all_soft_refs); 1046 1047 ClassUnloadingContext ctx(1 /* num_nmethod_unlink_workers */, 1048 false /* unregister_nmethods_during_purge */, 1049 false /* lock_nmethod_free_separately */); 1050 1051 marking_phase(&_gc_tracer); 1052 1053 summary_phase(); 1054 1055 #if COMPILER2_OR_JVMCI 1056 assert(DerivedPointerTable::is_active(), "Sanity"); 1057 DerivedPointerTable::set_active(false); 1058 #endif 1059 1060 forward_to_new_addr(); 1061 1062 adjust_pointers(); 1063 1064 compact(); 1065 1066 ParCompactionManager::_preserved_marks_set->restore(&ParallelScavengeHeap::heap()->workers()); 1067 1068 ParCompactionManager::verify_all_region_stack_empty(); 1069 1070 // Reset the mark bitmap, summary data, and do other bookkeeping. Must be 1071 // done before resizing. 1072 post_compact(); 1073 1074 // Let the size policy know we're done 1075 size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause); 1076 1077 if (UseAdaptiveSizePolicy) { 1078 log_debug(gc, ergo)("AdaptiveSizeStart: collection: %d ", heap->total_collections()); 1079 log_trace(gc, ergo)("old_gen_capacity: %zu young_gen_capacity: %zu", 1080 old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes()); 1081 1082 // Don't check if the size_policy is ready here. Let 1083 // the size_policy check that internally. 1084 if (UseAdaptiveGenerationSizePolicyAtMajorCollection && 1085 AdaptiveSizePolicy::should_update_promo_stats(gc_cause)) { 1086 // Swap the survivor spaces if from_space is empty. The 1087 // resize_young_gen() called below is normally used after 1088 // a successful young GC and swapping of survivor spaces; 1089 // otherwise, it will fail to resize the young gen with 1090 // the current implementation. 1091 if (young_gen->from_space()->is_empty()) { 1092 young_gen->from_space()->clear(SpaceDecorator::Mangle); 1093 young_gen->swap_spaces(); 1094 } 1095 1096 // Calculate optimal free space amounts 1097 assert(young_gen->max_gen_size() > 1098 young_gen->from_space()->capacity_in_bytes() + 1099 young_gen->to_space()->capacity_in_bytes(), 1100 "Sizes of space in young gen are out-of-bounds"); 1101 1102 size_t young_live = young_gen->used_in_bytes(); 1103 size_t eden_live = young_gen->eden_space()->used_in_bytes(); 1104 size_t old_live = old_gen->used_in_bytes(); 1105 size_t cur_eden = young_gen->eden_space()->capacity_in_bytes(); 1106 size_t max_old_gen_size = old_gen->max_gen_size(); 1107 size_t max_eden_size = young_gen->max_gen_size() - 1108 young_gen->from_space()->capacity_in_bytes() - 1109 young_gen->to_space()->capacity_in_bytes(); 1110 1111 // Used for diagnostics 1112 size_policy->clear_generation_free_space_flags(); 1113 1114 size_policy->compute_generations_free_space(young_live, 1115 eden_live, 1116 old_live, 1117 cur_eden, 1118 max_old_gen_size, 1119 max_eden_size, 1120 true /* full gc*/); 1121 1122 size_policy->check_gc_overhead_limit(eden_live, 1123 max_old_gen_size, 1124 max_eden_size, 1125 true /* full gc*/, 1126 gc_cause, 1127 heap->soft_ref_policy()); 1128 1129 size_policy->decay_supplemental_growth(true /* full gc*/); 1130 1131 heap->resize_old_gen( 1132 size_policy->calculated_old_free_size_in_bytes()); 1133 1134 heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), 1135 size_policy->calculated_survivor_size_in_bytes()); 1136 } 1137 1138 log_debug(gc, ergo)("AdaptiveSizeStop: collection: %d ", heap->total_collections()); 1139 } 1140 1141 if (UsePerfData) { 1142 PSGCAdaptivePolicyCounters* const counters = heap->gc_policy_counters(); 1143 counters->update_counters(); 1144 counters->update_old_capacity(old_gen->capacity_in_bytes()); 1145 counters->update_young_capacity(young_gen->capacity_in_bytes()); 1146 } 1147 1148 heap->resize_all_tlabs(); 1149 1150 // Resize the metaspace capacity after a collection 1151 MetaspaceGC::compute_new_size(); 1152 1153 if (log_is_enabled(Debug, gc, heap, exit)) { 1154 accumulated_time()->stop(); 1155 } 1156 1157 heap->print_heap_change(pre_gc_values); 1158 1159 // Track memory usage and detect low memory 1160 MemoryService::track_memory_usage(); 1161 heap->update_counters(); 1162 1163 heap->post_full_gc_dump(&_gc_timer); 1164 } 1165 1166 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) { 1167 Universe::verify("After GC"); 1168 } 1169 1170 heap->print_heap_after_gc(); 1171 heap->trace_heap_after_gc(&_gc_tracer); 1172 1173 AdaptiveSizePolicyOutput::print(size_policy, heap->total_collections()); 1174 1175 _gc_timer.register_gc_end(); 1176 1177 _gc_tracer.report_dense_prefix(dense_prefix(old_space_id)); 1178 _gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions()); 1179 1180 return true; 1181 } 1182 1183 class PCAddThreadRootsMarkingTaskClosure : public ThreadClosure { 1184 private: 1185 uint _worker_id; 1186 1187 public: 1188 PCAddThreadRootsMarkingTaskClosure(uint worker_id) : _worker_id(worker_id) { } 1189 void do_thread(Thread* thread) { 1190 assert(ParallelScavengeHeap::heap()->is_stw_gc_active(), "called outside gc"); 1191 1192 ResourceMark rm; 1193 1194 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(_worker_id); 1195 1196 MarkingNMethodClosure mark_and_push_in_blobs(&cm->_mark_and_push_closure, 1197 !NMethodToOopClosure::FixRelocations, 1198 true /* keepalive nmethods */); 1199 1200 thread->oops_do(&cm->_mark_and_push_closure, &mark_and_push_in_blobs); 1201 1202 // Do the real work 1203 cm->follow_marking_stacks(); 1204 } 1205 }; 1206 1207 void steal_marking_work(TaskTerminator& terminator, uint worker_id) { 1208 assert(ParallelScavengeHeap::heap()->is_stw_gc_active(), "called outside gc"); 1209 1210 ParCompactionManager* cm = 1211 ParCompactionManager::gc_thread_compaction_manager(worker_id); 1212 1213 do { 1214 ScannerTask task; 1215 if (ParCompactionManager::steal(worker_id, task)) { 1216 cm->follow_contents(task, true); 1217 } 1218 cm->follow_marking_stacks(); 1219 } while (!terminator.offer_termination()); 1220 } 1221 1222 class MarkFromRootsTask : public WorkerTask { 1223 StrongRootsScope _strong_roots_scope; // needed for Threads::possibly_parallel_threads_do 1224 OopStorageSetStrongParState<false /* concurrent */, false /* is_const */> _oop_storage_set_par_state; 1225 TaskTerminator _terminator; 1226 uint _active_workers; 1227 1228 public: 1229 MarkFromRootsTask(uint active_workers) : 1230 WorkerTask("MarkFromRootsTask"), 1231 _strong_roots_scope(active_workers), 1232 _terminator(active_workers, ParCompactionManager::marking_stacks()), 1233 _active_workers(active_workers) {} 1234 1235 virtual void work(uint worker_id) { 1236 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); 1237 cm->create_marking_stats_cache(); 1238 { 1239 CLDToOopClosure cld_closure(&cm->_mark_and_push_closure, ClassLoaderData::_claim_stw_fullgc_mark); 1240 ClassLoaderDataGraph::always_strong_cld_do(&cld_closure); 1241 1242 // Do the real work 1243 cm->follow_marking_stacks(); 1244 } 1245 1246 { 1247 PCAddThreadRootsMarkingTaskClosure closure(worker_id); 1248 Threads::possibly_parallel_threads_do(_active_workers > 1 /* is_par */, &closure); 1249 } 1250 1251 // Mark from OopStorages 1252 { 1253 _oop_storage_set_par_state.oops_do(&cm->_mark_and_push_closure); 1254 // Do the real work 1255 cm->follow_marking_stacks(); 1256 } 1257 1258 if (_active_workers > 1) { 1259 steal_marking_work(_terminator, worker_id); 1260 } 1261 } 1262 }; 1263 1264 class ParallelCompactRefProcProxyTask : public RefProcProxyTask { 1265 TaskTerminator _terminator; 1266 1267 public: 1268 ParallelCompactRefProcProxyTask(uint max_workers) 1269 : RefProcProxyTask("ParallelCompactRefProcProxyTask", max_workers), 1270 _terminator(_max_workers, ParCompactionManager::marking_stacks()) {} 1271 1272 void work(uint worker_id) override { 1273 assert(worker_id < _max_workers, "sanity"); 1274 ParCompactionManager* cm = (_tm == RefProcThreadModel::Single) ? ParCompactionManager::get_vmthread_cm() : ParCompactionManager::gc_thread_compaction_manager(worker_id); 1275 BarrierEnqueueDiscoveredFieldClosure enqueue; 1276 ParCompactionManager::FollowStackClosure complete_gc(cm, (_tm == RefProcThreadModel::Single) ? nullptr : &_terminator, worker_id); 1277 _rp_task->rp_work(worker_id, PSParallelCompact::is_alive_closure(), &cm->_mark_and_push_closure, &enqueue, &complete_gc); 1278 } 1279 1280 void prepare_run_task_hook() override { 1281 _terminator.reset_for_reuse(_queue_count); 1282 } 1283 }; 1284 1285 static void flush_marking_stats_cache(const uint num_workers) { 1286 for (uint i = 0; i < num_workers; ++i) { 1287 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(i); 1288 cm->flush_and_destroy_marking_stats_cache(); 1289 } 1290 } 1291 1292 void PSParallelCompact::marking_phase(ParallelOldTracer *gc_tracer) { 1293 // Recursively traverse all live objects and mark them 1294 GCTraceTime(Info, gc, phases) tm("Marking Phase", &_gc_timer); 1295 1296 uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers(); 1297 1298 ClassLoaderDataGraph::verify_claimed_marks_cleared(ClassLoaderData::_claim_stw_fullgc_mark); 1299 { 1300 GCTraceTime(Debug, gc, phases) tm("Par Mark", &_gc_timer); 1301 1302 MarkFromRootsTask task(active_gc_threads); 1303 ParallelScavengeHeap::heap()->workers().run_task(&task); 1304 } 1305 1306 // Process reference objects found during marking 1307 { 1308 GCTraceTime(Debug, gc, phases) tm("Reference Processing", &_gc_timer); 1309 1310 ReferenceProcessorStats stats; 1311 ReferenceProcessorPhaseTimes pt(&_gc_timer, ref_processor()->max_num_queues()); 1312 1313 ref_processor()->set_active_mt_degree(active_gc_threads); 1314 ParallelCompactRefProcProxyTask task(ref_processor()->max_num_queues()); 1315 stats = ref_processor()->process_discovered_references(task, pt); 1316 1317 gc_tracer->report_gc_reference_stats(stats); 1318 pt.print_all_references(); 1319 } 1320 1321 { 1322 GCTraceTime(Debug, gc, phases) tm("Flush Marking Stats", &_gc_timer); 1323 1324 flush_marking_stats_cache(active_gc_threads); 1325 } 1326 1327 // This is the point where the entire marking should have completed. 1328 ParCompactionManager::verify_all_marking_stack_empty(); 1329 1330 { 1331 GCTraceTime(Debug, gc, phases) tm("Weak Processing", &_gc_timer); 1332 WeakProcessor::weak_oops_do(&ParallelScavengeHeap::heap()->workers(), 1333 is_alive_closure(), 1334 &do_nothing_cl, 1335 1); 1336 } 1337 1338 { 1339 GCTraceTime(Debug, gc, phases) tm_m("Class Unloading", &_gc_timer); 1340 1341 ClassUnloadingContext* ctx = ClassUnloadingContext::context(); 1342 1343 bool unloading_occurred; 1344 { 1345 CodeCache::UnlinkingScope scope(is_alive_closure()); 1346 1347 // Follow system dictionary roots and unload classes. 1348 unloading_occurred = SystemDictionary::do_unloading(&_gc_timer); 1349 1350 // Unload nmethods. 1351 CodeCache::do_unloading(unloading_occurred); 1352 } 1353 1354 { 1355 GCTraceTime(Debug, gc, phases) t("Purge Unlinked NMethods", gc_timer()); 1356 // Release unloaded nmethod's memory. 1357 ctx->purge_nmethods(); 1358 } 1359 { 1360 GCTraceTime(Debug, gc, phases) ur("Unregister NMethods", &_gc_timer); 1361 ParallelScavengeHeap::heap()->prune_unlinked_nmethods(); 1362 } 1363 { 1364 GCTraceTime(Debug, gc, phases) t("Free Code Blobs", gc_timer()); 1365 ctx->free_nmethods(); 1366 } 1367 1368 // Prune dead klasses from subklass/sibling/implementor lists. 1369 Klass::clean_weak_klass_links(unloading_occurred); 1370 1371 // Clean JVMCI metadata handles. 1372 JVMCI_ONLY(JVMCI::do_unloading(unloading_occurred)); 1373 } 1374 1375 { 1376 GCTraceTime(Debug, gc, phases) tm("Report Object Count", &_gc_timer); 1377 _gc_tracer.report_object_count_after_gc(is_alive_closure(), &ParallelScavengeHeap::heap()->workers()); 1378 } 1379 #if TASKQUEUE_STATS 1380 ParCompactionManager::print_and_reset_taskqueue_stats(); 1381 #endif 1382 } 1383 1384 template<typename Func> 1385 void PSParallelCompact::adjust_in_space_helper(SpaceId id, volatile uint* claim_counter, Func&& on_stripe) { 1386 MutableSpace* sp = PSParallelCompact::space(id); 1387 HeapWord* const bottom = sp->bottom(); 1388 HeapWord* const top = sp->top(); 1389 if (bottom == top) { 1390 return; 1391 } 1392 1393 const uint num_regions_per_stripe = 2; 1394 const size_t region_size = ParallelCompactData::RegionSize; 1395 const size_t stripe_size = num_regions_per_stripe * region_size; 1396 1397 while (true) { 1398 uint counter = Atomic::fetch_then_add(claim_counter, num_regions_per_stripe); 1399 HeapWord* cur_stripe = bottom + counter * region_size; 1400 if (cur_stripe >= top) { 1401 break; 1402 } 1403 HeapWord* stripe_end = MIN2(cur_stripe + stripe_size, top); 1404 on_stripe(cur_stripe, stripe_end); 1405 } 1406 } 1407 1408 void PSParallelCompact::adjust_in_old_space(volatile uint* claim_counter) { 1409 // Regions in old-space shouldn't be split. 1410 assert(!_space_info[old_space_id].split_info().is_valid(), "inv"); 1411 1412 auto scan_obj_with_limit = [&] (HeapWord* obj_start, HeapWord* left, HeapWord* right) { 1413 assert(mark_bitmap()->is_marked(obj_start), "inv"); 1414 oop obj = cast_to_oop(obj_start); 1415 return obj->oop_iterate_size(&pc_adjust_pointer_closure, MemRegion(left, right)); 1416 }; 1417 1418 adjust_in_space_helper(old_space_id, claim_counter, [&] (HeapWord* stripe_start, HeapWord* stripe_end) { 1419 assert(_summary_data.is_region_aligned(stripe_start), "inv"); 1420 RegionData* cur_region = _summary_data.addr_to_region_ptr(stripe_start); 1421 HeapWord* obj_start; 1422 if (cur_region->partial_obj_size() != 0) { 1423 obj_start = cur_region->partial_obj_addr(); 1424 obj_start += scan_obj_with_limit(obj_start, stripe_start, stripe_end); 1425 } else { 1426 obj_start = stripe_start; 1427 } 1428 1429 while (obj_start < stripe_end) { 1430 obj_start = mark_bitmap()->find_obj_beg(obj_start, stripe_end); 1431 if (obj_start >= stripe_end) { 1432 break; 1433 } 1434 obj_start += scan_obj_with_limit(obj_start, stripe_start, stripe_end); 1435 } 1436 }); 1437 } 1438 1439 void PSParallelCompact::adjust_in_young_space(SpaceId id, volatile uint* claim_counter) { 1440 adjust_in_space_helper(id, claim_counter, [](HeapWord* stripe_start, HeapWord* stripe_end) { 1441 HeapWord* obj_start = stripe_start; 1442 while (obj_start < stripe_end) { 1443 obj_start = mark_bitmap()->find_obj_beg(obj_start, stripe_end); 1444 if (obj_start >= stripe_end) { 1445 break; 1446 } 1447 oop obj = cast_to_oop(obj_start); 1448 obj_start += obj->oop_iterate_size(&pc_adjust_pointer_closure); 1449 } 1450 }); 1451 } 1452 1453 void PSParallelCompact::adjust_pointers_in_spaces(uint worker_id, volatile uint* claim_counters) { 1454 auto start_time = Ticks::now(); 1455 adjust_in_old_space(&claim_counters[0]); 1456 for (uint id = eden_space_id; id < last_space_id; ++id) { 1457 adjust_in_young_space(SpaceId(id), &claim_counters[id]); 1458 } 1459 log_trace(gc, phases)("adjust_pointers_in_spaces worker %u: %.3f ms", worker_id, (Ticks::now() - start_time).seconds() * 1000); 1460 } 1461 1462 class PSAdjustTask final : public WorkerTask { 1463 SubTasksDone _sub_tasks; 1464 WeakProcessor::Task _weak_proc_task; 1465 OopStorageSetStrongParState<false, false> _oop_storage_iter; 1466 uint _nworkers; 1467 volatile uint _claim_counters[PSParallelCompact::last_space_id] = {}; 1468 1469 enum PSAdjustSubTask { 1470 PSAdjustSubTask_code_cache, 1471 1472 PSAdjustSubTask_num_elements 1473 }; 1474 1475 public: 1476 PSAdjustTask(uint nworkers) : 1477 WorkerTask("PSAdjust task"), 1478 _sub_tasks(PSAdjustSubTask_num_elements), 1479 _weak_proc_task(nworkers), 1480 _nworkers(nworkers) { 1481 1482 ClassLoaderDataGraph::verify_claimed_marks_cleared(ClassLoaderData::_claim_stw_fullgc_adjust); 1483 if (nworkers > 1) { 1484 Threads::change_thread_claim_token(); 1485 } 1486 } 1487 1488 ~PSAdjustTask() { 1489 Threads::assert_all_threads_claimed(); 1490 } 1491 1492 void work(uint worker_id) { 1493 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); 1494 cm->preserved_marks()->adjust_during_full_gc(); 1495 { 1496 // adjust pointers in all spaces 1497 PSParallelCompact::adjust_pointers_in_spaces(worker_id, _claim_counters); 1498 } 1499 { 1500 ResourceMark rm; 1501 Threads::possibly_parallel_oops_do(_nworkers > 1, &pc_adjust_pointer_closure, nullptr); 1502 } 1503 _oop_storage_iter.oops_do(&pc_adjust_pointer_closure); 1504 { 1505 CLDToOopClosure cld_closure(&pc_adjust_pointer_closure, ClassLoaderData::_claim_stw_fullgc_adjust); 1506 ClassLoaderDataGraph::cld_do(&cld_closure); 1507 } 1508 { 1509 AlwaysTrueClosure always_alive; 1510 _weak_proc_task.work(worker_id, &always_alive, &pc_adjust_pointer_closure); 1511 } 1512 if (_sub_tasks.try_claim_task(PSAdjustSubTask_code_cache)) { 1513 NMethodToOopClosure adjust_code(&pc_adjust_pointer_closure, NMethodToOopClosure::FixRelocations); 1514 CodeCache::nmethods_do(&adjust_code); 1515 } 1516 _sub_tasks.all_tasks_claimed(); 1517 } 1518 }; 1519 1520 void PSParallelCompact::adjust_pointers() { 1521 // Adjust the pointers to reflect the new locations 1522 GCTraceTime(Info, gc, phases) tm("Adjust Pointers", &_gc_timer); 1523 uint nworkers = ParallelScavengeHeap::heap()->workers().active_workers(); 1524 PSAdjustTask task(nworkers); 1525 ParallelScavengeHeap::heap()->workers().run_task(&task); 1526 } 1527 1528 // Split [start, end) evenly for a number of workers and return the 1529 // range for worker_id. 1530 static void split_regions_for_worker(size_t start, size_t end, 1531 uint worker_id, uint num_workers, 1532 size_t* worker_start, size_t* worker_end) { 1533 assert(start < end, "precondition"); 1534 assert(num_workers > 0, "precondition"); 1535 assert(worker_id < num_workers, "precondition"); 1536 1537 size_t num_regions = end - start; 1538 size_t num_regions_per_worker = num_regions / num_workers; 1539 size_t remainder = num_regions % num_workers; 1540 // The first few workers will get one extra. 1541 *worker_start = start + worker_id * num_regions_per_worker 1542 + MIN2(checked_cast<size_t>(worker_id), remainder); 1543 *worker_end = *worker_start + num_regions_per_worker 1544 + (worker_id < remainder ? 1 : 0); 1545 } 1546 1547 void PSParallelCompact::forward_to_new_addr() { 1548 GCTraceTime(Info, gc, phases) tm("Forward", &_gc_timer); 1549 uint nworkers = ParallelScavengeHeap::heap()->workers().active_workers(); 1550 1551 struct ForwardTask final : public WorkerTask { 1552 uint _num_workers; 1553 1554 explicit ForwardTask(uint num_workers) : 1555 WorkerTask("PSForward task"), 1556 _num_workers(num_workers) {} 1557 1558 static void forward_objs_in_range(ParCompactionManager* cm, 1559 HeapWord* start, 1560 HeapWord* end, 1561 HeapWord* destination) { 1562 HeapWord* cur_addr = start; 1563 HeapWord* new_addr = destination; 1564 1565 while (cur_addr < end) { 1566 cur_addr = mark_bitmap()->find_obj_beg(cur_addr, end); 1567 if (cur_addr >= end) { 1568 return; 1569 } 1570 assert(mark_bitmap()->is_marked(cur_addr), "inv"); 1571 oop obj = cast_to_oop(cur_addr); 1572 if (new_addr != cur_addr) { 1573 cm->preserved_marks()->push_if_necessary(obj, obj->mark()); 1574 FullGCForwarding::forward_to(obj, cast_to_oop(new_addr)); 1575 } 1576 size_t obj_size = obj->size(); 1577 new_addr += obj_size; 1578 cur_addr += obj_size; 1579 } 1580 } 1581 1582 void work(uint worker_id) override { 1583 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); 1584 for (uint id = old_space_id; id < last_space_id; ++id) { 1585 MutableSpace* sp = PSParallelCompact::space(SpaceId(id)); 1586 HeapWord* dense_prefix_addr = dense_prefix(SpaceId(id)); 1587 HeapWord* top = sp->top(); 1588 1589 if (dense_prefix_addr == top) { 1590 continue; 1591 } 1592 1593 const SplitInfo& split_info = _space_info[SpaceId(id)].split_info(); 1594 1595 size_t dense_prefix_region = _summary_data.addr_to_region_idx(dense_prefix_addr); 1596 size_t top_region = _summary_data.addr_to_region_idx(_summary_data.region_align_up(top)); 1597 size_t start_region; 1598 size_t end_region; 1599 split_regions_for_worker(dense_prefix_region, top_region, 1600 worker_id, _num_workers, 1601 &start_region, &end_region); 1602 for (size_t cur_region = start_region; cur_region < end_region; ++cur_region) { 1603 RegionData* region_ptr = _summary_data.region(cur_region); 1604 size_t partial_obj_size = region_ptr->partial_obj_size(); 1605 1606 if (partial_obj_size == ParallelCompactData::RegionSize) { 1607 // No obj-start 1608 continue; 1609 } 1610 1611 HeapWord* region_start = _summary_data.region_to_addr(cur_region); 1612 HeapWord* region_end = region_start + ParallelCompactData::RegionSize; 1613 1614 if (split_info.is_split(cur_region)) { 1615 // Part 1: will be relocated to space-1 1616 HeapWord* preceding_destination = split_info.preceding_destination(); 1617 HeapWord* split_point = split_info.split_point(); 1618 forward_objs_in_range(cm, region_start + partial_obj_size, split_point, preceding_destination + partial_obj_size); 1619 1620 // Part 2: will be relocated to space-2 1621 HeapWord* destination = region_ptr->destination(); 1622 forward_objs_in_range(cm, split_point, region_end, destination); 1623 } else { 1624 HeapWord* destination = region_ptr->destination(); 1625 forward_objs_in_range(cm, region_start + partial_obj_size, region_end, destination + partial_obj_size); 1626 } 1627 } 1628 } 1629 } 1630 } task(nworkers); 1631 1632 ParallelScavengeHeap::heap()->workers().run_task(&task); 1633 debug_only(verify_forward();) 1634 } 1635 1636 #ifdef ASSERT 1637 void PSParallelCompact::verify_forward() { 1638 HeapWord* old_dense_prefix_addr = dense_prefix(SpaceId(old_space_id)); 1639 RegionData* old_region = _summary_data.region(_summary_data.addr_to_region_idx(old_dense_prefix_addr)); 1640 HeapWord* bump_ptr = old_region->partial_obj_size() != 0 1641 ? old_dense_prefix_addr + old_region->partial_obj_size() 1642 : old_dense_prefix_addr; 1643 SpaceId bump_ptr_space = old_space_id; 1644 1645 for (uint id = old_space_id; id < last_space_id; ++id) { 1646 MutableSpace* sp = PSParallelCompact::space(SpaceId(id)); 1647 HeapWord* dense_prefix_addr = dense_prefix(SpaceId(id)); 1648 HeapWord* top = sp->top(); 1649 HeapWord* cur_addr = dense_prefix_addr; 1650 1651 while (cur_addr < top) { 1652 cur_addr = mark_bitmap()->find_obj_beg(cur_addr, top); 1653 if (cur_addr >= top) { 1654 break; 1655 } 1656 assert(mark_bitmap()->is_marked(cur_addr), "inv"); 1657 assert(bump_ptr <= _space_info[bump_ptr_space].new_top(), "inv"); 1658 // Move to the space containing cur_addr 1659 if (bump_ptr == _space_info[bump_ptr_space].new_top()) { 1660 bump_ptr = space(space_id(cur_addr))->bottom(); 1661 bump_ptr_space = space_id(bump_ptr); 1662 } 1663 oop obj = cast_to_oop(cur_addr); 1664 if (cur_addr == bump_ptr) { 1665 assert(!FullGCForwarding::is_forwarded(obj), "inv"); 1666 } else { 1667 assert(FullGCForwarding::forwardee(obj) == cast_to_oop(bump_ptr), "inv"); 1668 } 1669 bump_ptr += obj->size(); 1670 cur_addr += obj->size(); 1671 } 1672 } 1673 } 1674 #endif 1675 1676 // Helper class to print 8 region numbers per line and then print the total at the end. 1677 class FillableRegionLogger : public StackObj { 1678 private: 1679 Log(gc, compaction) log; 1680 static const int LineLength = 8; 1681 size_t _regions[LineLength]; 1682 int _next_index; 1683 bool _enabled; 1684 size_t _total_regions; 1685 public: 1686 FillableRegionLogger() : _next_index(0), _enabled(log_develop_is_enabled(Trace, gc, compaction)), _total_regions(0) { } 1687 ~FillableRegionLogger() { 1688 log.trace("%zu initially fillable regions", _total_regions); 1689 } 1690 1691 void print_line() { 1692 if (!_enabled || _next_index == 0) { 1693 return; 1694 } 1695 FormatBuffer<> line("Fillable: "); 1696 for (int i = 0; i < _next_index; i++) { 1697 line.append(" %7zu", _regions[i]); 1698 } 1699 log.trace("%s", line.buffer()); 1700 _next_index = 0; 1701 } 1702 1703 void handle(size_t region) { 1704 if (!_enabled) { 1705 return; 1706 } 1707 _regions[_next_index++] = region; 1708 if (_next_index == LineLength) { 1709 print_line(); 1710 } 1711 _total_regions++; 1712 } 1713 }; 1714 1715 void PSParallelCompact::prepare_region_draining_tasks(uint parallel_gc_threads) 1716 { 1717 GCTraceTime(Trace, gc, phases) tm("Drain Task Setup", &_gc_timer); 1718 1719 // Find the threads that are active 1720 uint worker_id = 0; 1721 1722 // Find all regions that are available (can be filled immediately) and 1723 // distribute them to the thread stacks. The iteration is done in reverse 1724 // order (high to low) so the regions will be removed in ascending order. 1725 1726 const ParallelCompactData& sd = PSParallelCompact::summary_data(); 1727 1728 // id + 1 is used to test termination so unsigned can 1729 // be used with an old_space_id == 0. 1730 FillableRegionLogger region_logger; 1731 for (unsigned int id = to_space_id; id + 1 > old_space_id; --id) { 1732 SpaceInfo* const space_info = _space_info + id; 1733 HeapWord* const new_top = space_info->new_top(); 1734 1735 const size_t beg_region = sd.addr_to_region_idx(space_info->dense_prefix()); 1736 const size_t end_region = 1737 sd.addr_to_region_idx(sd.region_align_up(new_top)); 1738 1739 for (size_t cur = end_region - 1; cur + 1 > beg_region; --cur) { 1740 if (sd.region(cur)->claim_unsafe()) { 1741 ParCompactionManager* cm = ParCompactionManager::gc_thread_compaction_manager(worker_id); 1742 bool result = sd.region(cur)->mark_normal(); 1743 assert(result, "Must succeed at this point."); 1744 cm->region_stack()->push(cur); 1745 region_logger.handle(cur); 1746 // Assign regions to tasks in round-robin fashion. 1747 if (++worker_id == parallel_gc_threads) { 1748 worker_id = 0; 1749 } 1750 } 1751 } 1752 region_logger.print_line(); 1753 } 1754 } 1755 1756 static void compaction_with_stealing_work(TaskTerminator* terminator, uint worker_id) { 1757 assert(ParallelScavengeHeap::heap()->is_stw_gc_active(), "called outside gc"); 1758 1759 ParCompactionManager* cm = 1760 ParCompactionManager::gc_thread_compaction_manager(worker_id); 1761 1762 // Drain the stacks that have been preloaded with regions 1763 // that are ready to fill. 1764 1765 cm->drain_region_stacks(); 1766 1767 guarantee(cm->region_stack()->is_empty(), "Not empty"); 1768 1769 size_t region_index = 0; 1770 1771 while (true) { 1772 if (ParCompactionManager::steal(worker_id, region_index)) { 1773 PSParallelCompact::fill_and_update_region(cm, region_index); 1774 cm->drain_region_stacks(); 1775 } else if (PSParallelCompact::steal_unavailable_region(cm, region_index)) { 1776 // Fill and update an unavailable region with the help of a shadow region 1777 PSParallelCompact::fill_and_update_shadow_region(cm, region_index); 1778 cm->drain_region_stacks(); 1779 } else { 1780 if (terminator->offer_termination()) { 1781 break; 1782 } 1783 // Go around again. 1784 } 1785 } 1786 } 1787 1788 class FillDensePrefixAndCompactionTask: public WorkerTask { 1789 uint _num_workers; 1790 TaskTerminator _terminator; 1791 1792 public: 1793 FillDensePrefixAndCompactionTask(uint active_workers) : 1794 WorkerTask("FillDensePrefixAndCompactionTask"), 1795 _num_workers(active_workers), 1796 _terminator(active_workers, ParCompactionManager::region_task_queues()) { 1797 } 1798 1799 virtual void work(uint worker_id) { 1800 { 1801 auto start = Ticks::now(); 1802 PSParallelCompact::fill_dead_objs_in_dense_prefix(worker_id, _num_workers); 1803 log_trace(gc, phases)("Fill dense prefix by worker %u: %.3f ms", worker_id, (Ticks::now() - start).seconds() * 1000); 1804 } 1805 compaction_with_stealing_work(&_terminator, worker_id); 1806 } 1807 }; 1808 1809 void PSParallelCompact::fill_range_in_dense_prefix(HeapWord* start, HeapWord* end) { 1810 #ifdef ASSERT 1811 { 1812 assert(start < end, "precondition"); 1813 assert(mark_bitmap()->find_obj_beg(start, end) == end, "precondition"); 1814 HeapWord* bottom = _space_info[old_space_id].space()->bottom(); 1815 if (start != bottom) { 1816 HeapWord* obj_start = mark_bitmap()->find_obj_beg_reverse(bottom, start); 1817 HeapWord* after_obj = obj_start + cast_to_oop(obj_start)->size(); 1818 assert(after_obj == start, "precondition"); 1819 } 1820 } 1821 #endif 1822 1823 CollectedHeap::fill_with_objects(start, pointer_delta(end, start)); 1824 HeapWord* addr = start; 1825 do { 1826 size_t size = cast_to_oop(addr)->size(); 1827 start_array(old_space_id)->update_for_block(addr, addr + size); 1828 addr += size; 1829 } while (addr < end); 1830 } 1831 1832 void PSParallelCompact::fill_dead_objs_in_dense_prefix(uint worker_id, uint num_workers) { 1833 ParMarkBitMap* bitmap = mark_bitmap(); 1834 1835 HeapWord* const bottom = _space_info[old_space_id].space()->bottom(); 1836 HeapWord* const prefix_end = dense_prefix(old_space_id); 1837 1838 if (bottom == prefix_end) { 1839 return; 1840 } 1841 1842 size_t bottom_region = _summary_data.addr_to_region_idx(bottom); 1843 size_t prefix_end_region = _summary_data.addr_to_region_idx(prefix_end); 1844 1845 size_t start_region; 1846 size_t end_region; 1847 split_regions_for_worker(bottom_region, prefix_end_region, 1848 worker_id, num_workers, 1849 &start_region, &end_region); 1850 1851 if (start_region == end_region) { 1852 return; 1853 } 1854 1855 HeapWord* const start_addr = _summary_data.region_to_addr(start_region); 1856 HeapWord* const end_addr = _summary_data.region_to_addr(end_region); 1857 1858 // Skip live partial obj (if any) from previous region. 1859 HeapWord* cur_addr; 1860 RegionData* start_region_ptr = _summary_data.region(start_region); 1861 if (start_region_ptr->partial_obj_size() != 0) { 1862 HeapWord* partial_obj_start = start_region_ptr->partial_obj_addr(); 1863 assert(bitmap->is_marked(partial_obj_start), "inv"); 1864 cur_addr = partial_obj_start + cast_to_oop(partial_obj_start)->size(); 1865 } else { 1866 cur_addr = start_addr; 1867 } 1868 1869 // end_addr is inclusive to handle regions starting with dead space. 1870 while (cur_addr <= end_addr) { 1871 // Use prefix_end to handle trailing obj in each worker region-chunk. 1872 HeapWord* live_start = bitmap->find_obj_beg(cur_addr, prefix_end); 1873 if (cur_addr != live_start) { 1874 // Only worker 0 handles proceeding dead space. 1875 if (cur_addr != start_addr || worker_id == 0) { 1876 fill_range_in_dense_prefix(cur_addr, live_start); 1877 } 1878 } 1879 if (live_start >= end_addr) { 1880 break; 1881 } 1882 assert(bitmap->is_marked(live_start), "inv"); 1883 cur_addr = live_start + cast_to_oop(live_start)->size(); 1884 } 1885 } 1886 1887 void PSParallelCompact::compact() { 1888 GCTraceTime(Info, gc, phases) tm("Compaction Phase", &_gc_timer); 1889 1890 uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers(); 1891 1892 initialize_shadow_regions(active_gc_threads); 1893 prepare_region_draining_tasks(active_gc_threads); 1894 1895 { 1896 GCTraceTime(Trace, gc, phases) tm("Par Compact", &_gc_timer); 1897 1898 FillDensePrefixAndCompactionTask task(active_gc_threads); 1899 ParallelScavengeHeap::heap()->workers().run_task(&task); 1900 1901 #ifdef ASSERT 1902 verify_filler_in_dense_prefix(); 1903 1904 // Verify that all regions have been processed. 1905 for (unsigned int id = old_space_id; id < last_space_id; ++id) { 1906 verify_complete(SpaceId(id)); 1907 } 1908 #endif 1909 } 1910 } 1911 1912 #ifdef ASSERT 1913 void PSParallelCompact::verify_filler_in_dense_prefix() { 1914 HeapWord* bottom = _space_info[old_space_id].space()->bottom(); 1915 HeapWord* dense_prefix_end = dense_prefix(old_space_id); 1916 HeapWord* cur_addr = bottom; 1917 while (cur_addr < dense_prefix_end) { 1918 oop obj = cast_to_oop(cur_addr); 1919 oopDesc::verify(obj); 1920 if (!mark_bitmap()->is_marked(cur_addr)) { 1921 Klass* k = cast_to_oop(cur_addr)->klass(); 1922 assert(k == Universe::fillerArrayKlass() || k == vmClasses::FillerObject_klass(), "inv"); 1923 } 1924 cur_addr += obj->size(); 1925 } 1926 } 1927 1928 void PSParallelCompact::verify_complete(SpaceId space_id) { 1929 // All Regions served as compaction targets, from dense_prefix() to 1930 // new_top(), should be marked as filled and all Regions between new_top() 1931 // and top() should be available (i.e., should have been emptied). 1932 ParallelCompactData& sd = summary_data(); 1933 SpaceInfo si = _space_info[space_id]; 1934 HeapWord* new_top_addr = sd.region_align_up(si.new_top()); 1935 HeapWord* old_top_addr = sd.region_align_up(si.space()->top()); 1936 const size_t beg_region = sd.addr_to_region_idx(si.dense_prefix()); 1937 const size_t new_top_region = sd.addr_to_region_idx(new_top_addr); 1938 const size_t old_top_region = sd.addr_to_region_idx(old_top_addr); 1939 1940 size_t cur_region; 1941 for (cur_region = beg_region; cur_region < new_top_region; ++cur_region) { 1942 const RegionData* const c = sd.region(cur_region); 1943 assert(c->completed(), "region %zu not filled: destination_count=%u", 1944 cur_region, c->destination_count()); 1945 } 1946 1947 for (cur_region = new_top_region; cur_region < old_top_region; ++cur_region) { 1948 const RegionData* const c = sd.region(cur_region); 1949 assert(c->available(), "region %zu not empty: destination_count=%u", 1950 cur_region, c->destination_count()); 1951 } 1952 } 1953 #endif // #ifdef ASSERT 1954 1955 // Return the SpaceId for the space containing addr. If addr is not in the 1956 // heap, last_space_id is returned. In debug mode it expects the address to be 1957 // in the heap and asserts such. 1958 PSParallelCompact::SpaceId PSParallelCompact::space_id(HeapWord* addr) { 1959 assert(ParallelScavengeHeap::heap()->is_in_reserved(addr), "addr not in the heap"); 1960 1961 for (unsigned int id = old_space_id; id < last_space_id; ++id) { 1962 if (_space_info[id].space()->contains(addr)) { 1963 return SpaceId(id); 1964 } 1965 } 1966 1967 assert(false, "no space contains the addr"); 1968 return last_space_id; 1969 } 1970 1971 // Skip over count live words starting from beg, and return the address of the 1972 // next live word. Callers must also ensure that there are enough live words in 1973 // the range [beg, end) to skip. 1974 HeapWord* PSParallelCompact::skip_live_words(HeapWord* beg, HeapWord* end, size_t count) 1975 { 1976 ParMarkBitMap* m = mark_bitmap(); 1977 HeapWord* cur_addr = beg; 1978 while (true) { 1979 cur_addr = m->find_obj_beg(cur_addr, end); 1980 assert(cur_addr < end, "inv"); 1981 size_t obj_size = cast_to_oop(cur_addr)->size(); 1982 // Strictly greater-than 1983 if (obj_size > count) { 1984 return cur_addr + count; 1985 } 1986 count -= obj_size; 1987 cur_addr += obj_size; 1988 } 1989 } 1990 1991 // On starting to fill a destination region (dest-region), we need to know the 1992 // location of the word that will be at the start of the dest-region after 1993 // compaction. A dest-region can have one or more source regions, but only the 1994 // first source-region contains this location. This location is retrieved by 1995 // calling `first_src_addr` on a dest-region. 1996 // Conversely, a source-region has a dest-region which holds the destination of 1997 // the first live word on this source-region, based on which the destination 1998 // for the rest of live words can be derived. 1999 // 2000 // Note: 2001 // There is some complication due to space-boundary-fragmentation (an obj can't 2002 // cross space-boundary) -- a source-region may be split and behave like two 2003 // distinct regions with their own dest-region, as depicted below. 2004 // 2005 // source-region: region-n 2006 // 2007 // ********************** 2008 // | A|A~~~~B|B | 2009 // ********************** 2010 // n-1 n n+1 2011 // 2012 // AA, BB denote two live objs. ~~~~ denotes unknown number of live objs. 2013 // 2014 // Assuming the dest-region for region-n is the final region before 2015 // old-space-end and its first-live-word is the middle of AA, the heap content 2016 // will look like the following after compaction: 2017 // 2018 // ************** ************* 2019 // A|A~~~~ | |BB | 2020 // ************** ************* 2021 // ^ ^ 2022 // | old-space-end | eden-space-start 2023 // 2024 // Therefore, in this example, region-n will have two dest-regions: 2025 // 1. the final region in old-space 2026 // 2. the first region in eden-space. 2027 // To handle this special case, we introduce the concept of split-region, whose 2028 // contents are relocated to two spaces. `SplitInfo` captures all necessary 2029 // info about the split, the first part, spliting-point, and the second part. 2030 HeapWord* PSParallelCompact::first_src_addr(HeapWord* const dest_addr, 2031 SpaceId src_space_id, 2032 size_t src_region_idx) 2033 { 2034 const size_t RegionSize = ParallelCompactData::RegionSize; 2035 const ParallelCompactData& sd = summary_data(); 2036 assert(sd.is_region_aligned(dest_addr), "precondition"); 2037 2038 const RegionData* const src_region_ptr = sd.region(src_region_idx); 2039 assert(src_region_ptr->data_size() > 0, "src region cannot be empty"); 2040 2041 const size_t partial_obj_size = src_region_ptr->partial_obj_size(); 2042 HeapWord* const src_region_destination = src_region_ptr->destination(); 2043 2044 HeapWord* const region_start = sd.region_to_addr(src_region_idx); 2045 HeapWord* const region_end = sd.region_to_addr(src_region_idx) + RegionSize; 2046 2047 // Identify the actual destination for the first live words on this region, 2048 // taking split-region into account. 2049 HeapWord* region_start_destination; 2050 const SplitInfo& split_info = _space_info[src_space_id].split_info(); 2051 if (split_info.is_split(src_region_idx)) { 2052 // The second part of this split region; use the recorded split point. 2053 if (dest_addr == src_region_destination) { 2054 return split_info.split_point(); 2055 } 2056 region_start_destination = split_info.preceding_destination(); 2057 } else { 2058 region_start_destination = src_region_destination; 2059 } 2060 2061 // Calculate the offset to be skipped 2062 size_t words_to_skip = pointer_delta(dest_addr, region_start_destination); 2063 2064 HeapWord* result; 2065 if (partial_obj_size > words_to_skip) { 2066 result = region_start + words_to_skip; 2067 } else { 2068 words_to_skip -= partial_obj_size; 2069 result = skip_live_words(region_start + partial_obj_size, region_end, words_to_skip); 2070 } 2071 2072 if (split_info.is_split(src_region_idx)) { 2073 assert(result < split_info.split_point(), "postcondition"); 2074 } else { 2075 assert(result < region_end, "postcondition"); 2076 } 2077 2078 return result; 2079 } 2080 2081 void PSParallelCompact::decrement_destination_counts(ParCompactionManager* cm, 2082 SpaceId src_space_id, 2083 size_t beg_region, 2084 HeapWord* end_addr) 2085 { 2086 ParallelCompactData& sd = summary_data(); 2087 2088 #ifdef ASSERT 2089 MutableSpace* const src_space = _space_info[src_space_id].space(); 2090 HeapWord* const beg_addr = sd.region_to_addr(beg_region); 2091 assert(src_space->contains(beg_addr) || beg_addr == src_space->end(), 2092 "src_space_id does not match beg_addr"); 2093 assert(src_space->contains(end_addr) || end_addr == src_space->end(), 2094 "src_space_id does not match end_addr"); 2095 #endif // #ifdef ASSERT 2096 2097 RegionData* const beg = sd.region(beg_region); 2098 RegionData* const end = sd.addr_to_region_ptr(sd.region_align_up(end_addr)); 2099 2100 // Regions up to new_top() are enqueued if they become available. 2101 HeapWord* const new_top = _space_info[src_space_id].new_top(); 2102 RegionData* const enqueue_end = 2103 sd.addr_to_region_ptr(sd.region_align_up(new_top)); 2104 2105 for (RegionData* cur = beg; cur < end; ++cur) { 2106 assert(cur->data_size() > 0, "region must have live data"); 2107 cur->decrement_destination_count(); 2108 if (cur < enqueue_end && cur->available() && cur->claim()) { 2109 if (cur->mark_normal()) { 2110 cm->push_region(sd.region(cur)); 2111 } else if (cur->mark_copied()) { 2112 // Try to copy the content of the shadow region back to its corresponding 2113 // heap region if the shadow region is filled. Otherwise, the GC thread 2114 // fills the shadow region will copy the data back (see 2115 // MoveAndUpdateShadowClosure::complete_region). 2116 copy_back(sd.region_to_addr(cur->shadow_region()), sd.region_to_addr(cur)); 2117 ParCompactionManager::push_shadow_region_mt_safe(cur->shadow_region()); 2118 cur->set_completed(); 2119 } 2120 } 2121 } 2122 } 2123 2124 size_t PSParallelCompact::next_src_region(MoveAndUpdateClosure& closure, 2125 SpaceId& src_space_id, 2126 HeapWord*& src_space_top, 2127 HeapWord* end_addr) 2128 { 2129 ParallelCompactData& sd = PSParallelCompact::summary_data(); 2130 2131 size_t src_region_idx = 0; 2132 2133 // Skip empty regions (if any) up to the top of the space. 2134 HeapWord* const src_aligned_up = sd.region_align_up(end_addr); 2135 RegionData* src_region_ptr = sd.addr_to_region_ptr(src_aligned_up); 2136 HeapWord* const top_aligned_up = sd.region_align_up(src_space_top); 2137 const RegionData* const top_region_ptr = sd.addr_to_region_ptr(top_aligned_up); 2138 2139 while (src_region_ptr < top_region_ptr && src_region_ptr->data_size() == 0) { 2140 ++src_region_ptr; 2141 } 2142 2143 if (src_region_ptr < top_region_ptr) { 2144 // Found the first non-empty region in the same space. 2145 src_region_idx = sd.region(src_region_ptr); 2146 closure.set_source(sd.region_to_addr(src_region_idx)); 2147 return src_region_idx; 2148 } 2149 2150 // Switch to a new source space and find the first non-empty region. 2151 uint space_id = src_space_id + 1; 2152 assert(space_id < last_space_id, "not enough spaces"); 2153 2154 for (/* empty */; space_id < last_space_id; ++space_id) { 2155 HeapWord* bottom = _space_info[space_id].space()->bottom(); 2156 HeapWord* top = _space_info[space_id].space()->top(); 2157 // Skip empty space 2158 if (bottom == top) { 2159 continue; 2160 } 2161 2162 // Identify the first region that contains live words in this space 2163 size_t cur_region = sd.addr_to_region_idx(bottom); 2164 size_t end_region = sd.addr_to_region_idx(sd.region_align_up(top)); 2165 2166 for (/* empty */ ; cur_region < end_region; ++cur_region) { 2167 RegionData* cur = sd.region(cur_region); 2168 if (cur->live_obj_size() > 0) { 2169 HeapWord* region_start_addr = sd.region_to_addr(cur_region); 2170 2171 src_space_id = SpaceId(space_id); 2172 src_space_top = top; 2173 closure.set_source(region_start_addr); 2174 return cur_region; 2175 } 2176 } 2177 } 2178 2179 ShouldNotReachHere(); 2180 } 2181 2182 HeapWord* PSParallelCompact::partial_obj_end(HeapWord* region_start_addr) { 2183 ParallelCompactData& sd = summary_data(); 2184 assert(sd.is_region_aligned(region_start_addr), "precondition"); 2185 2186 // Use per-region partial_obj_size to locate the end of the obj, that extends 2187 // to region_start_addr. 2188 size_t start_region_idx = sd.addr_to_region_idx(region_start_addr); 2189 size_t end_region_idx = sd.region_count(); 2190 size_t accumulated_size = 0; 2191 for (size_t region_idx = start_region_idx; region_idx < end_region_idx; ++region_idx) { 2192 size_t cur_partial_obj_size = sd.region(region_idx)->partial_obj_size(); 2193 accumulated_size += cur_partial_obj_size; 2194 if (cur_partial_obj_size != ParallelCompactData::RegionSize) { 2195 break; 2196 } 2197 } 2198 return region_start_addr + accumulated_size; 2199 } 2200 2201 // Use region_idx as the destination region, and evacuate all live objs on its 2202 // source regions to this destination region. 2203 void PSParallelCompact::fill_region(ParCompactionManager* cm, MoveAndUpdateClosure& closure, size_t region_idx) 2204 { 2205 ParMarkBitMap* const bitmap = mark_bitmap(); 2206 ParallelCompactData& sd = summary_data(); 2207 RegionData* const region_ptr = sd.region(region_idx); 2208 2209 // Get the source region and related info. 2210 size_t src_region_idx = region_ptr->source_region(); 2211 SpaceId src_space_id = space_id(sd.region_to_addr(src_region_idx)); 2212 HeapWord* src_space_top = _space_info[src_space_id].space()->top(); 2213 HeapWord* dest_addr = sd.region_to_addr(region_idx); 2214 2215 closure.set_source(first_src_addr(dest_addr, src_space_id, src_region_idx)); 2216 2217 // Adjust src_region_idx to prepare for decrementing destination counts (the 2218 // destination count is not decremented when a region is copied to itself). 2219 if (src_region_idx == region_idx) { 2220 src_region_idx += 1; 2221 } 2222 2223 // source-region: 2224 // 2225 // ********** 2226 // | ~~~ | 2227 // ********** 2228 // ^ 2229 // |-- closure.source() / first_src_addr 2230 // 2231 // 2232 // ~~~ : live words 2233 // 2234 // destination-region: 2235 // 2236 // ********** 2237 // | | 2238 // ********** 2239 // ^ 2240 // |-- region-start 2241 if (bitmap->is_unmarked(closure.source())) { 2242 // An object overflows the previous destination region, so this 2243 // destination region should copy the remainder of the object or as much as 2244 // will fit. 2245 HeapWord* const old_src_addr = closure.source(); 2246 { 2247 HeapWord* region_start = sd.region_align_down(closure.source()); 2248 HeapWord* obj_start = bitmap->find_obj_beg_reverse(region_start, closure.source()); 2249 HeapWord* obj_end; 2250 if (obj_start != closure.source()) { 2251 assert(bitmap->is_marked(obj_start), "inv"); 2252 // Found the actual obj-start, try to find the obj-end using either 2253 // size() if this obj is completely contained in the current region. 2254 HeapWord* next_region_start = region_start + ParallelCompactData::RegionSize; 2255 HeapWord* partial_obj_start = (next_region_start >= src_space_top) 2256 ? nullptr 2257 : sd.addr_to_region_ptr(next_region_start)->partial_obj_addr(); 2258 // This obj extends to next region iff partial_obj_addr of the *next* 2259 // region is the same as obj-start. 2260 if (partial_obj_start == obj_start) { 2261 // This obj extends to next region. 2262 obj_end = partial_obj_end(next_region_start); 2263 } else { 2264 // Completely contained in this region; safe to use size(). 2265 obj_end = obj_start + cast_to_oop(obj_start)->size(); 2266 } 2267 } else { 2268 // This obj extends to current region. 2269 obj_end = partial_obj_end(region_start); 2270 } 2271 size_t partial_obj_size = pointer_delta(obj_end, closure.source()); 2272 closure.copy_partial_obj(partial_obj_size); 2273 } 2274 2275 if (closure.is_full()) { 2276 decrement_destination_counts(cm, src_space_id, src_region_idx, closure.source()); 2277 closure.complete_region(dest_addr, region_ptr); 2278 return; 2279 } 2280 2281 // Finished copying without using up the current destination-region 2282 HeapWord* const end_addr = sd.region_align_down(closure.source()); 2283 if (sd.region_align_down(old_src_addr) != end_addr) { 2284 assert(sd.region_align_up(old_src_addr) == end_addr, "only one region"); 2285 // The partial object was copied from more than one source region. 2286 decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr); 2287 2288 // Move to the next source region, possibly switching spaces as well. All 2289 // args except end_addr may be modified. 2290 src_region_idx = next_src_region(closure, src_space_id, src_space_top, end_addr); 2291 } 2292 } 2293 2294 // Handle the rest obj-by-obj, where we know obj-start. 2295 do { 2296 HeapWord* cur_addr = closure.source(); 2297 HeapWord* const end_addr = MIN2(sd.region_align_up(cur_addr + 1), 2298 src_space_top); 2299 // To handle the case where the final obj in source region extends to next region. 2300 HeapWord* final_obj_start = (end_addr == src_space_top) 2301 ? nullptr 2302 : sd.addr_to_region_ptr(end_addr)->partial_obj_addr(); 2303 // Apply closure on objs inside [cur_addr, end_addr) 2304 do { 2305 cur_addr = bitmap->find_obj_beg(cur_addr, end_addr); 2306 if (cur_addr == end_addr) { 2307 break; 2308 } 2309 size_t obj_size; 2310 if (final_obj_start == cur_addr) { 2311 obj_size = pointer_delta(partial_obj_end(end_addr), cur_addr); 2312 } else { 2313 // This obj doesn't extend into next region; size() is safe to use. 2314 obj_size = cast_to_oop(cur_addr)->size(); 2315 } 2316 closure.do_addr(cur_addr, obj_size); 2317 cur_addr += obj_size; 2318 } while (cur_addr < end_addr && !closure.is_full()); 2319 2320 if (closure.is_full()) { 2321 decrement_destination_counts(cm, src_space_id, src_region_idx, closure.source()); 2322 closure.complete_region(dest_addr, region_ptr); 2323 return; 2324 } 2325 2326 decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr); 2327 2328 // Move to the next source region, possibly switching spaces as well. All 2329 // args except end_addr may be modified. 2330 src_region_idx = next_src_region(closure, src_space_id, src_space_top, end_addr); 2331 } while (true); 2332 } 2333 2334 void PSParallelCompact::fill_and_update_region(ParCompactionManager* cm, size_t region_idx) 2335 { 2336 MoveAndUpdateClosure cl(mark_bitmap(), region_idx); 2337 fill_region(cm, cl, region_idx); 2338 } 2339 2340 void PSParallelCompact::fill_and_update_shadow_region(ParCompactionManager* cm, size_t region_idx) 2341 { 2342 // Get a shadow region first 2343 ParallelCompactData& sd = summary_data(); 2344 RegionData* const region_ptr = sd.region(region_idx); 2345 size_t shadow_region = ParCompactionManager::pop_shadow_region_mt_safe(region_ptr); 2346 // The InvalidShadow return value indicates the corresponding heap region is available, 2347 // so use MoveAndUpdateClosure to fill the normal region. Otherwise, use 2348 // MoveAndUpdateShadowClosure to fill the acquired shadow region. 2349 if (shadow_region == ParCompactionManager::InvalidShadow) { 2350 MoveAndUpdateClosure cl(mark_bitmap(), region_idx); 2351 region_ptr->shadow_to_normal(); 2352 return fill_region(cm, cl, region_idx); 2353 } else { 2354 MoveAndUpdateShadowClosure cl(mark_bitmap(), region_idx, shadow_region); 2355 return fill_region(cm, cl, region_idx); 2356 } 2357 } 2358 2359 void PSParallelCompact::copy_back(HeapWord *shadow_addr, HeapWord *region_addr) 2360 { 2361 Copy::aligned_conjoint_words(shadow_addr, region_addr, _summary_data.RegionSize); 2362 } 2363 2364 bool PSParallelCompact::steal_unavailable_region(ParCompactionManager* cm, size_t ®ion_idx) 2365 { 2366 size_t next = cm->next_shadow_region(); 2367 ParallelCompactData& sd = summary_data(); 2368 size_t old_new_top = sd.addr_to_region_idx(_space_info[old_space_id].new_top()); 2369 uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers(); 2370 2371 while (next < old_new_top) { 2372 if (sd.region(next)->mark_shadow()) { 2373 region_idx = next; 2374 return true; 2375 } 2376 next = cm->move_next_shadow_region_by(active_gc_threads); 2377 } 2378 2379 return false; 2380 } 2381 2382 // The shadow region is an optimization to address region dependencies in full GC. The basic 2383 // idea is making more regions available by temporally storing their live objects in empty 2384 // shadow regions to resolve dependencies between them and the destination regions. Therefore, 2385 // GC threads need not wait destination regions to be available before processing sources. 2386 // 2387 // A typical workflow would be: 2388 // After draining its own stack and failing to steal from others, a GC worker would pick an 2389 // unavailable region (destination count > 0) and get a shadow region. Then the worker fills 2390 // the shadow region by copying live objects from source regions of the unavailable one. Once 2391 // the unavailable region becomes available, the data in the shadow region will be copied back. 2392 // Shadow regions are empty regions in the to-space and regions between top and end of other spaces. 2393 void PSParallelCompact::initialize_shadow_regions(uint parallel_gc_threads) 2394 { 2395 const ParallelCompactData& sd = PSParallelCompact::summary_data(); 2396 2397 for (unsigned int id = old_space_id; id < last_space_id; ++id) { 2398 SpaceInfo* const space_info = _space_info + id; 2399 MutableSpace* const space = space_info->space(); 2400 2401 const size_t beg_region = 2402 sd.addr_to_region_idx(sd.region_align_up(MAX2(space_info->new_top(), space->top()))); 2403 const size_t end_region = 2404 sd.addr_to_region_idx(sd.region_align_down(space->end())); 2405 2406 for (size_t cur = beg_region; cur < end_region; ++cur) { 2407 ParCompactionManager::push_shadow_region(cur); 2408 } 2409 } 2410 2411 size_t beg_region = sd.addr_to_region_idx(_space_info[old_space_id].dense_prefix()); 2412 for (uint i = 0; i < parallel_gc_threads; i++) { 2413 ParCompactionManager *cm = ParCompactionManager::gc_thread_compaction_manager(i); 2414 cm->set_next_shadow_region(beg_region + i); 2415 } 2416 } 2417 2418 void MoveAndUpdateClosure::copy_partial_obj(size_t partial_obj_size) 2419 { 2420 size_t words = MIN2(partial_obj_size, words_remaining()); 2421 2422 // This test is necessary; if omitted, the pointer updates to a partial object 2423 // that crosses the dense prefix boundary could be overwritten. 2424 if (source() != copy_destination()) { 2425 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());) 2426 Copy::aligned_conjoint_words(source(), copy_destination(), words); 2427 } 2428 update_state(words); 2429 } 2430 2431 void MoveAndUpdateClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) { 2432 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::NormalRegion, "Region should be finished"); 2433 region_ptr->set_completed(); 2434 } 2435 2436 void MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) { 2437 assert(destination() != nullptr, "sanity"); 2438 _source = addr; 2439 2440 // The start_array must be updated even if the object is not moving. 2441 if (_start_array != nullptr) { 2442 _start_array->update_for_block(destination(), destination() + words); 2443 } 2444 2445 // Avoid overflow 2446 words = MIN2(words, words_remaining()); 2447 assert(words > 0, "inv"); 2448 2449 if (copy_destination() != source()) { 2450 DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());) 2451 assert(source() != destination(), "inv"); 2452 assert(FullGCForwarding::is_forwarded(cast_to_oop(source())), "inv"); 2453 assert(FullGCForwarding::forwardee(cast_to_oop(source())) == cast_to_oop(destination()), "inv"); 2454 // Read the klass before the copying, since it might destroy the klass (i.e. overlapping copy) 2455 // and if partial copy, the destination klass may not be copied yet 2456 Klass* klass = cast_to_oop(source())->klass(); 2457 Copy::aligned_conjoint_words(source(), copy_destination(), words); 2458 cast_to_oop(copy_destination())->set_mark(Klass::default_prototype_header(klass)); 2459 } 2460 2461 update_state(words); 2462 } 2463 2464 void MoveAndUpdateShadowClosure::complete_region(HeapWord* dest_addr, PSParallelCompact::RegionData* region_ptr) { 2465 assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow"); 2466 // Record the shadow region index 2467 region_ptr->set_shadow_region(_shadow); 2468 // Mark the shadow region as filled to indicate the data is ready to be 2469 // copied back 2470 region_ptr->mark_filled(); 2471 // Try to copy the content of the shadow region back to its corresponding 2472 // heap region if available; the GC thread that decreases the destination 2473 // count to zero will do the copying otherwise (see 2474 // PSParallelCompact::decrement_destination_counts). 2475 if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) { 2476 region_ptr->set_completed(); 2477 PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr); 2478 ParCompactionManager::push_shadow_region_mt_safe(_shadow); 2479 } 2480 }