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 &region_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 }