1 /* 2 * Copyright (c) 2014, 2021, Red Hat, Inc. All rights reserved. 3 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. 4 * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. 5 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 6 * 7 * This code is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License version 2 only, as 9 * published by the Free Software Foundation. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 * 25 */ 26 27 28 #include "compiler/oopMap.hpp" 29 #include "gc/shared/continuationGCSupport.hpp" 30 #include "gc/shared/fullGCForwarding.inline.hpp" 31 #include "gc/shared/gcTraceTime.inline.hpp" 32 #include "gc/shared/preservedMarks.inline.hpp" 33 #include "gc/shared/tlab_globals.hpp" 34 #include "gc/shared/workerThread.hpp" 35 #include "gc/shenandoah/heuristics/shenandoahHeuristics.hpp" 36 #include "gc/shenandoah/shenandoahClosures.inline.hpp" 37 #include "gc/shenandoah/shenandoahCollectionSet.hpp" 38 #include "gc/shenandoah/shenandoahCollectorPolicy.hpp" 39 #include "gc/shenandoah/shenandoahConcurrentGC.hpp" 40 #include "gc/shenandoah/shenandoahFreeSet.hpp" 41 #include "gc/shenandoah/shenandoahFullGC.hpp" 42 #include "gc/shenandoah/shenandoahGenerationalFullGC.hpp" 43 #include "gc/shenandoah/shenandoahGlobalGeneration.hpp" 44 #include "gc/shenandoah/shenandoahHeap.inline.hpp" 45 #include "gc/shenandoah/shenandoahHeapRegion.inline.hpp" 46 #include "gc/shenandoah/shenandoahHeapRegionClosures.hpp" 47 #include "gc/shenandoah/shenandoahHeapRegionSet.hpp" 48 #include "gc/shenandoah/shenandoahMark.inline.hpp" 49 #include "gc/shenandoah/shenandoahMarkingContext.inline.hpp" 50 #include "gc/shenandoah/shenandoahMetrics.hpp" 51 #include "gc/shenandoah/shenandoahMonitoringSupport.hpp" 52 #include "gc/shenandoah/shenandoahPhaseTimings.hpp" 53 #include "gc/shenandoah/shenandoahReferenceProcessor.hpp" 54 #include "gc/shenandoah/shenandoahRootProcessor.inline.hpp" 55 #include "gc/shenandoah/shenandoahSTWMark.hpp" 56 #include "gc/shenandoah/shenandoahUtils.hpp" 57 #include "gc/shenandoah/shenandoahVerifier.hpp" 58 #include "gc/shenandoah/shenandoahVMOperations.hpp" 59 #include "gc/shenandoah/shenandoahWorkerPolicy.hpp" 60 #include "memory/metaspaceUtils.hpp" 61 #include "memory/universe.hpp" 62 #include "oops/compressedOops.inline.hpp" 63 #include "oops/oop.inline.hpp" 64 #include "runtime/orderAccess.hpp" 65 #include "runtime/vmThread.hpp" 66 #include "utilities/copy.hpp" 67 #include "utilities/events.hpp" 68 #include "utilities/growableArray.hpp" 69 70 ShenandoahFullGC::ShenandoahFullGC() : 71 _gc_timer(ShenandoahHeap::heap()->gc_timer()), 72 _preserved_marks(new PreservedMarksSet(true)) {} 73 74 ShenandoahFullGC::~ShenandoahFullGC() { 75 delete _preserved_marks; 76 } 77 78 bool ShenandoahFullGC::collect(GCCause::Cause cause) { 79 vmop_entry_full(cause); 80 // Always success 81 return true; 82 } 83 84 void ShenandoahFullGC::vmop_entry_full(GCCause::Cause cause) { 85 ShenandoahHeap* const heap = ShenandoahHeap::heap(); 86 TraceCollectorStats tcs(heap->monitoring_support()->full_stw_collection_counters()); 87 ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::full_gc_gross); 88 89 heap->try_inject_alloc_failure(); 90 VM_ShenandoahFullGC op(cause, this); 91 VMThread::execute(&op); 92 } 93 94 void ShenandoahFullGC::entry_full(GCCause::Cause cause) { 95 static const char* msg = "Pause Full"; 96 ShenandoahPausePhase gc_phase(msg, ShenandoahPhaseTimings::full_gc, true /* log_heap_usage */); 97 EventMark em("%s", msg); 98 99 ShenandoahWorkerScope scope(ShenandoahHeap::heap()->workers(), 100 ShenandoahWorkerPolicy::calc_workers_for_fullgc(), 101 "full gc"); 102 103 op_full(cause); 104 } 105 106 void ShenandoahFullGC::op_full(GCCause::Cause cause) { 107 ShenandoahMetricsSnapshot metrics; 108 metrics.snap_before(); 109 110 // Perform full GC 111 do_it(cause); 112 113 ShenandoahHeap* const heap = ShenandoahHeap::heap(); 114 115 if (heap->mode()->is_generational()) { 116 ShenandoahGenerationalFullGC::handle_completion(heap); 117 } 118 119 metrics.snap_after(); 120 121 if (metrics.is_good_progress(heap->global_generation())) { 122 heap->notify_gc_progress(); 123 } else { 124 // Nothing to do. Tell the allocation path that we have failed to make 125 // progress, and it can finally fail. 126 heap->notify_gc_no_progress(); 127 } 128 129 // Regardless if progress was made, we record that we completed a "successful" full GC. 130 heap->global_generation()->heuristics()->record_success_full(); 131 heap->shenandoah_policy()->record_success_full(); 132 133 { 134 ShenandoahTimingsTracker timing(ShenandoahPhaseTimings::full_gc_propagate_gc_state); 135 heap->propagate_gc_state_to_all_threads(); 136 } 137 } 138 139 void ShenandoahFullGC::do_it(GCCause::Cause gc_cause) { 140 ShenandoahHeap* heap = ShenandoahHeap::heap(); 141 142 if (heap->mode()->is_generational()) { 143 ShenandoahGenerationalFullGC::prepare(); 144 } 145 146 if (ShenandoahVerify) { 147 heap->verifier()->verify_before_fullgc(); 148 } 149 150 if (VerifyBeforeGC) { 151 Universe::verify(); 152 } 153 154 // Degenerated GC may carry concurrent root flags when upgrading to 155 // full GC. We need to reset it before mutators resume. 156 heap->set_concurrent_strong_root_in_progress(false); 157 heap->set_concurrent_weak_root_in_progress(false); 158 159 heap->set_full_gc_in_progress(true); 160 161 assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "must be at a safepoint"); 162 assert(Thread::current()->is_VM_thread(), "Do full GC only while world is stopped"); 163 164 { 165 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_heapdump_pre); 166 heap->pre_full_gc_dump(_gc_timer); 167 } 168 169 { 170 ShenandoahGCPhase prepare_phase(ShenandoahPhaseTimings::full_gc_prepare); 171 // Full GC is supposed to recover from any GC state: 172 173 // a0. Remember if we have forwarded objects 174 bool has_forwarded_objects = heap->has_forwarded_objects(); 175 176 // a1. Cancel evacuation, if in progress 177 if (heap->is_evacuation_in_progress()) { 178 heap->set_evacuation_in_progress(false); 179 } 180 assert(!heap->is_evacuation_in_progress(), "sanity"); 181 182 // a2. Cancel update-refs, if in progress 183 if (heap->is_update_refs_in_progress()) { 184 heap->set_update_refs_in_progress(false); 185 } 186 assert(!heap->is_update_refs_in_progress(), "sanity"); 187 188 // b. Cancel all concurrent marks, if in progress 189 if (heap->is_concurrent_mark_in_progress()) { 190 heap->cancel_concurrent_mark(); 191 } 192 assert(!heap->is_concurrent_mark_in_progress(), "sanity"); 193 194 // c. Update roots if this full GC is due to evac-oom, which may carry from-space pointers in roots. 195 if (has_forwarded_objects) { 196 update_roots(true /*full_gc*/); 197 } 198 199 // d. Abandon reference discovery and clear all discovered references. 200 ShenandoahReferenceProcessor* rp = heap->global_generation()->ref_processor(); 201 rp->abandon_partial_discovery(); 202 203 // e. Sync pinned region status from the CP marks 204 heap->sync_pinned_region_status(); 205 206 if (heap->mode()->is_generational()) { 207 ShenandoahGenerationalFullGC::restore_top_before_promote(heap); 208 } 209 210 // The rest of prologue: 211 _preserved_marks->init(heap->workers()->active_workers()); 212 213 assert(heap->has_forwarded_objects() == has_forwarded_objects, "This should not change"); 214 } 215 216 if (UseTLAB) { 217 // Note: PLABs are also retired with GCLABs in generational mode. 218 heap->gclabs_retire(ResizeTLAB); 219 heap->tlabs_retire(ResizeTLAB); 220 } 221 222 OrderAccess::fence(); 223 224 phase1_mark_heap(); 225 226 // Once marking is done, which may have fixed up forwarded objects, we can drop it. 227 // Coming out of Full GC, we would not have any forwarded objects. 228 // This also prevents resolves with fwdptr from kicking in while adjusting pointers in phase3. 229 heap->set_has_forwarded_objects(false); 230 231 heap->set_full_gc_move_in_progress(true); 232 233 // Setup workers for the rest 234 OrderAccess::fence(); 235 236 // Initialize worker slices 237 ShenandoahHeapRegionSet** worker_slices = NEW_C_HEAP_ARRAY(ShenandoahHeapRegionSet*, heap->max_workers(), mtGC); 238 for (uint i = 0; i < heap->max_workers(); i++) { 239 worker_slices[i] = new ShenandoahHeapRegionSet(); 240 } 241 242 ShenandoahGenerationalHeap::TransferResult result; 243 { 244 // The rest of code performs region moves, where region status is undefined 245 // until all phases run together. 246 ShenandoahHeapLocker lock(heap->lock()); 247 248 phase2_calculate_target_addresses(worker_slices); 249 250 OrderAccess::fence(); 251 252 phase3_update_references(); 253 254 phase4_compact_objects(worker_slices); 255 256 result = phase5_epilog(); 257 } 258 if (heap->mode()->is_generational()) { 259 LogTarget(Info, gc, ergo) lt; 260 if (lt.is_enabled()) { 261 LogStream ls(lt); 262 result.print_on("Full GC", &ls); 263 } 264 } 265 266 // Resize metaspace 267 MetaspaceGC::compute_new_size(); 268 269 // Free worker slices 270 for (uint i = 0; i < heap->max_workers(); i++) { 271 delete worker_slices[i]; 272 } 273 FREE_C_HEAP_ARRAY(ShenandoahHeapRegionSet*, worker_slices); 274 275 heap->set_full_gc_move_in_progress(false); 276 heap->set_full_gc_in_progress(false); 277 278 if (ShenandoahVerify) { 279 heap->verifier()->verify_after_fullgc(); 280 } 281 282 if (VerifyAfterGC) { 283 Universe::verify(); 284 } 285 286 { 287 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_heapdump_post); 288 heap->post_full_gc_dump(_gc_timer); 289 } 290 } 291 292 void ShenandoahFullGC::phase1_mark_heap() { 293 GCTraceTime(Info, gc, phases) time("Phase 1: Mark live objects", _gc_timer); 294 ShenandoahGCPhase mark_phase(ShenandoahPhaseTimings::full_gc_mark); 295 296 ShenandoahHeap* heap = ShenandoahHeap::heap(); 297 298 heap->global_generation()->reset_mark_bitmap<true, true>(); 299 assert(heap->marking_context()->is_bitmap_clear(), "sanity"); 300 assert(!heap->global_generation()->is_mark_complete(), "sanity"); 301 302 heap->set_unload_classes(heap->global_generation()->heuristics()->can_unload_classes()); 303 304 ShenandoahReferenceProcessor* rp = heap->global_generation()->ref_processor(); 305 // enable ("weak") refs discovery 306 rp->set_soft_reference_policy(true); // forcefully purge all soft references 307 308 ShenandoahSTWMark mark(heap->global_generation(), true /*full_gc*/); 309 mark.mark(); 310 heap->parallel_cleaning(true /* full_gc */); 311 312 if (ShenandoahHeap::heap()->mode()->is_generational()) { 313 ShenandoahGenerationalFullGC::log_live_in_old(heap); 314 } 315 } 316 317 class ShenandoahPrepareForCompactionObjectClosure : public ObjectClosure { 318 private: 319 PreservedMarks* const _preserved_marks; 320 ShenandoahHeap* const _heap; 321 GrowableArray<ShenandoahHeapRegion*>& _empty_regions; 322 int _empty_regions_pos; 323 ShenandoahHeapRegion* _to_region; 324 ShenandoahHeapRegion* _from_region; 325 HeapWord* _compact_point; 326 327 public: 328 ShenandoahPrepareForCompactionObjectClosure(PreservedMarks* preserved_marks, 329 GrowableArray<ShenandoahHeapRegion*>& empty_regions, 330 ShenandoahHeapRegion* to_region) : 331 _preserved_marks(preserved_marks), 332 _heap(ShenandoahHeap::heap()), 333 _empty_regions(empty_regions), 334 _empty_regions_pos(0), 335 _to_region(to_region), 336 _from_region(nullptr), 337 _compact_point(to_region->bottom()) {} 338 339 void set_from_region(ShenandoahHeapRegion* from_region) { 340 _from_region = from_region; 341 } 342 343 void finish() { 344 assert(_to_region != nullptr, "should not happen"); 345 _to_region->set_new_top(_compact_point); 346 } 347 348 bool is_compact_same_region() { 349 return _from_region == _to_region; 350 } 351 352 int empty_regions_pos() { 353 return _empty_regions_pos; 354 } 355 356 void do_object(oop p) { 357 assert(_from_region != nullptr, "must set before work"); 358 assert(_heap->gc_generation()->complete_marking_context()->is_marked(p), "must be marked"); 359 assert(!_heap->gc_generation()->complete_marking_context()->allocated_after_mark_start(p), "must be truly marked"); 360 361 size_t obj_size = p->size(); 362 if (_compact_point + obj_size > _to_region->end()) { 363 finish(); 364 365 // Object doesn't fit. Pick next empty region and start compacting there. 366 ShenandoahHeapRegion* new_to_region; 367 if (_empty_regions_pos < _empty_regions.length()) { 368 new_to_region = _empty_regions.at(_empty_regions_pos); 369 _empty_regions_pos++; 370 } else { 371 // Out of empty region? Compact within the same region. 372 new_to_region = _from_region; 373 } 374 375 assert(new_to_region != _to_region, "must not reuse same to-region"); 376 assert(new_to_region != nullptr, "must not be null"); 377 _to_region = new_to_region; 378 _compact_point = _to_region->bottom(); 379 } 380 381 // Object fits into current region, record new location, if object does not move: 382 assert(_compact_point + obj_size <= _to_region->end(), "must fit"); 383 shenandoah_assert_not_forwarded(nullptr, p); 384 if (_compact_point != cast_from_oop<HeapWord*>(p)) { 385 _preserved_marks->push_if_necessary(p, p->mark()); 386 FullGCForwarding::forward_to(p, cast_to_oop(_compact_point)); 387 } 388 _compact_point += obj_size; 389 } 390 }; 391 392 class ShenandoahPrepareForCompactionTask : public WorkerTask { 393 private: 394 PreservedMarksSet* const _preserved_marks; 395 ShenandoahHeap* const _heap; 396 ShenandoahHeapRegionSet** const _worker_slices; 397 398 public: 399 ShenandoahPrepareForCompactionTask(PreservedMarksSet *preserved_marks, ShenandoahHeapRegionSet **worker_slices) : 400 WorkerTask("Shenandoah Prepare For Compaction"), 401 _preserved_marks(preserved_marks), 402 _heap(ShenandoahHeap::heap()), _worker_slices(worker_slices) { 403 } 404 405 static bool is_candidate_region(ShenandoahHeapRegion* r) { 406 // Empty region: get it into the slice to defragment the slice itself. 407 // We could have skipped this without violating correctness, but we really 408 // want to compact all live regions to the start of the heap, which sometimes 409 // means moving them into the fully empty regions. 410 if (r->is_empty()) return true; 411 412 // Can move the region, and this is not the humongous region. Humongous 413 // moves are special cased here, because their moves are handled separately. 414 return r->is_stw_move_allowed() && !r->is_humongous(); 415 } 416 417 void work(uint worker_id) override; 418 private: 419 template<typename ClosureType> 420 void prepare_for_compaction(ClosureType& cl, 421 GrowableArray<ShenandoahHeapRegion*>& empty_regions, 422 ShenandoahHeapRegionSetIterator& it, 423 ShenandoahHeapRegion* from_region); 424 }; 425 426 void ShenandoahPrepareForCompactionTask::work(uint worker_id) { 427 ShenandoahParallelWorkerSession worker_session(worker_id); 428 ShenandoahHeapRegionSet* slice = _worker_slices[worker_id]; 429 ShenandoahHeapRegionSetIterator it(slice); 430 ShenandoahHeapRegion* from_region = it.next(); 431 // No work? 432 if (from_region == nullptr) { 433 return; 434 } 435 436 // Sliding compaction. Walk all regions in the slice, and compact them. 437 // Remember empty regions and reuse them as needed. 438 ResourceMark rm; 439 440 GrowableArray<ShenandoahHeapRegion*> empty_regions((int)_heap->num_regions()); 441 442 if (_heap->mode()->is_generational()) { 443 ShenandoahPrepareForGenerationalCompactionObjectClosure cl(_preserved_marks->get(worker_id), 444 empty_regions, from_region, worker_id); 445 prepare_for_compaction(cl, empty_regions, it, from_region); 446 } else { 447 ShenandoahPrepareForCompactionObjectClosure cl(_preserved_marks->get(worker_id), empty_regions, from_region); 448 prepare_for_compaction(cl, empty_regions, it, from_region); 449 } 450 } 451 452 template<typename ClosureType> 453 void ShenandoahPrepareForCompactionTask::prepare_for_compaction(ClosureType& cl, 454 GrowableArray<ShenandoahHeapRegion*>& empty_regions, 455 ShenandoahHeapRegionSetIterator& it, 456 ShenandoahHeapRegion* from_region) { 457 while (from_region != nullptr) { 458 assert(is_candidate_region(from_region), "Sanity"); 459 cl.set_from_region(from_region); 460 if (from_region->has_live()) { 461 _heap->marked_object_iterate(from_region, &cl); 462 } 463 464 // Compacted the region to somewhere else? From-region is empty then. 465 if (!cl.is_compact_same_region()) { 466 empty_regions.append(from_region); 467 } 468 from_region = it.next(); 469 } 470 cl.finish(); 471 472 // Mark all remaining regions as empty 473 for (int pos = cl.empty_regions_pos(); pos < empty_regions.length(); ++pos) { 474 ShenandoahHeapRegion* r = empty_regions.at(pos); 475 r->set_new_top(r->bottom()); 476 } 477 } 478 479 void ShenandoahFullGC::calculate_target_humongous_objects() { 480 ShenandoahHeap* heap = ShenandoahHeap::heap(); 481 482 // Compute the new addresses for humongous objects. We need to do this after addresses 483 // for regular objects are calculated, and we know what regions in heap suffix are 484 // available for humongous moves. 485 // 486 // Scan the heap backwards, because we are compacting humongous regions towards the end. 487 // Maintain the contiguous compaction window in [to_begin; to_end), so that we can slide 488 // humongous start there. 489 // 490 // The complication is potential non-movable regions during the scan. If such region is 491 // detected, then sliding restarts towards that non-movable region. 492 493 size_t to_begin = heap->num_regions(); 494 size_t to_end = heap->num_regions(); 495 496 log_debug(gc)("Full GC calculating target humongous objects from end %zu", to_end); 497 for (size_t c = heap->num_regions(); c > 0; c--) { 498 ShenandoahHeapRegion *r = heap->get_region(c - 1); 499 if (r->is_humongous_continuation() || (r->new_top() == r->bottom())) { 500 // To-region candidate: record this, and continue scan 501 to_begin = r->index(); 502 continue; 503 } 504 505 if (r->is_humongous_start() && r->is_stw_move_allowed()) { 506 // From-region candidate: movable humongous region 507 oop old_obj = cast_to_oop(r->bottom()); 508 size_t words_size = old_obj->size(); 509 size_t num_regions = ShenandoahHeapRegion::required_regions(words_size * HeapWordSize); 510 511 size_t start = to_end - num_regions; 512 513 if (start >= to_begin && start != r->index()) { 514 // Fits into current window, and the move is non-trivial. Record the move then, and continue scan. 515 _preserved_marks->get(0)->push_if_necessary(old_obj, old_obj->mark()); 516 FullGCForwarding::forward_to(old_obj, cast_to_oop(heap->get_region(start)->bottom())); 517 to_end = start; 518 continue; 519 } 520 } 521 522 // Failed to fit. Scan starting from current region. 523 to_begin = r->index(); 524 to_end = r->index(); 525 } 526 } 527 528 class ShenandoahEnsureHeapActiveClosure: public ShenandoahHeapRegionClosure { 529 private: 530 ShenandoahHeap* const _heap; 531 532 public: 533 ShenandoahEnsureHeapActiveClosure() : _heap(ShenandoahHeap::heap()) {} 534 void heap_region_do(ShenandoahHeapRegion* r) { 535 if (r->is_trash()) { 536 r->try_recycle_under_lock(); 537 } 538 if (r->is_cset()) { 539 // Leave affiliation unchanged 540 r->make_regular_bypass(); 541 } 542 if (r->is_empty_uncommitted()) { 543 r->make_committed_bypass(); 544 } 545 assert (r->is_committed(), "only committed regions in heap now, see region %zu", r->index()); 546 547 // Record current region occupancy: this communicates empty regions are free 548 // to the rest of Full GC code. 549 r->set_new_top(r->top()); 550 } 551 }; 552 553 class ShenandoahTrashImmediateGarbageClosure: public ShenandoahHeapRegionClosure { 554 private: 555 ShenandoahHeap* const _heap; 556 ShenandoahMarkingContext* const _ctx; 557 558 public: 559 ShenandoahTrashImmediateGarbageClosure() : 560 _heap(ShenandoahHeap::heap()), 561 _ctx(ShenandoahHeap::heap()->global_generation()->complete_marking_context()) {} 562 563 void heap_region_do(ShenandoahHeapRegion* r) override { 564 if (r->is_humongous_start()) { 565 oop humongous_obj = cast_to_oop(r->bottom()); 566 if (!_ctx->is_marked(humongous_obj)) { 567 assert(!r->has_live(), "Region %zu is not marked, should not have live", r->index()); 568 _heap->trash_humongous_region_at(r); 569 } else { 570 assert(r->has_live(), "Region %zu should have live", r->index()); 571 } 572 } else if (r->is_humongous_continuation()) { 573 // If we hit continuation, the non-live humongous starts should have been trashed already 574 assert(r->humongous_start_region()->has_live(), "Region %zu should have live", r->index()); 575 } else if (r->is_regular()) { 576 if (!r->has_live()) { 577 r->make_trash_immediate(); 578 } 579 } 580 } 581 }; 582 583 void ShenandoahFullGC::distribute_slices(ShenandoahHeapRegionSet** worker_slices) { 584 ShenandoahHeap* heap = ShenandoahHeap::heap(); 585 586 uint n_workers = heap->workers()->active_workers(); 587 size_t n_regions = heap->num_regions(); 588 589 // What we want to accomplish: have the dense prefix of data, while still balancing 590 // out the parallel work. 591 // 592 // Assuming the amount of work is driven by the live data that needs moving, we can slice 593 // the entire heap into equal-live-sized prefix slices, and compact into them. So, each 594 // thread takes all regions in its prefix subset, and then it takes some regions from 595 // the tail. 596 // 597 // Tail region selection becomes interesting. 598 // 599 // First, we want to distribute the regions fairly between the workers, and those regions 600 // might have different amount of live data. So, until we sure no workers need live data, 601 // we need to only take what the worker needs. 602 // 603 // Second, since we slide everything to the left in each slice, the most busy regions 604 // would be the ones on the left. Which means we want to have all workers have their after-tail 605 // regions as close to the left as possible. 606 // 607 // The easiest way to do this is to distribute after-tail regions in round-robin between 608 // workers that still need live data. 609 // 610 // Consider parallel workers A, B, C, then the target slice layout would be: 611 // 612 // AAAAAAAABBBBBBBBCCCCCCCC|ABCABCABCABCABCABCABCABABABABABABABABABABAAAAA 613 // 614 // (.....dense-prefix.....) (.....................tail...................) 615 // [all regions fully live] [left-most regions are fuller that right-most] 616 // 617 618 // Compute how much live data is there. This would approximate the size of dense prefix 619 // we target to create. 620 size_t total_live = 0; 621 for (size_t idx = 0; idx < n_regions; idx++) { 622 ShenandoahHeapRegion *r = heap->get_region(idx); 623 if (ShenandoahPrepareForCompactionTask::is_candidate_region(r)) { 624 total_live += r->get_live_data_words(); 625 } 626 } 627 628 // Estimate the size for the dense prefix. Note that we specifically count only the 629 // "full" regions, so there would be some non-full regions in the slice tail. 630 size_t live_per_worker = total_live / n_workers; 631 size_t prefix_regions_per_worker = live_per_worker / ShenandoahHeapRegion::region_size_words(); 632 size_t prefix_regions_total = prefix_regions_per_worker * n_workers; 633 prefix_regions_total = MIN2(prefix_regions_total, n_regions); 634 assert(prefix_regions_total <= n_regions, "Sanity"); 635 636 // There might be non-candidate regions in the prefix. To compute where the tail actually 637 // ends up being, we need to account those as well. 638 size_t prefix_end = prefix_regions_total; 639 for (size_t idx = 0; idx < prefix_regions_total; idx++) { 640 ShenandoahHeapRegion *r = heap->get_region(idx); 641 if (!ShenandoahPrepareForCompactionTask::is_candidate_region(r)) { 642 prefix_end++; 643 } 644 } 645 prefix_end = MIN2(prefix_end, n_regions); 646 assert(prefix_end <= n_regions, "Sanity"); 647 648 // Distribute prefix regions per worker: each thread definitely gets its own same-sized 649 // subset of dense prefix. 650 size_t prefix_idx = 0; 651 652 size_t* live = NEW_C_HEAP_ARRAY(size_t, n_workers, mtGC); 653 654 for (size_t wid = 0; wid < n_workers; wid++) { 655 ShenandoahHeapRegionSet* slice = worker_slices[wid]; 656 657 live[wid] = 0; 658 size_t regs = 0; 659 660 // Add all prefix regions for this worker 661 while (prefix_idx < prefix_end && regs < prefix_regions_per_worker) { 662 ShenandoahHeapRegion *r = heap->get_region(prefix_idx); 663 if (ShenandoahPrepareForCompactionTask::is_candidate_region(r)) { 664 slice->add_region(r); 665 live[wid] += r->get_live_data_words(); 666 regs++; 667 } 668 prefix_idx++; 669 } 670 } 671 672 // Distribute the tail among workers in round-robin fashion. 673 size_t wid = n_workers - 1; 674 675 for (size_t tail_idx = prefix_end; tail_idx < n_regions; tail_idx++) { 676 ShenandoahHeapRegion *r = heap->get_region(tail_idx); 677 if (ShenandoahPrepareForCompactionTask::is_candidate_region(r)) { 678 assert(wid < n_workers, "Sanity"); 679 680 size_t live_region = r->get_live_data_words(); 681 682 // Select next worker that still needs live data. 683 size_t old_wid = wid; 684 do { 685 wid++; 686 if (wid == n_workers) wid = 0; 687 } while (live[wid] + live_region >= live_per_worker && old_wid != wid); 688 689 if (old_wid == wid) { 690 // Circled back to the same worker? This means liveness data was 691 // miscalculated. Bump the live_per_worker limit so that 692 // everyone gets a piece of the leftover work. 693 live_per_worker += ShenandoahHeapRegion::region_size_words(); 694 } 695 696 worker_slices[wid]->add_region(r); 697 live[wid] += live_region; 698 } 699 } 700 701 FREE_C_HEAP_ARRAY(size_t, live); 702 703 #ifdef ASSERT 704 ResourceBitMap map(n_regions); 705 for (size_t wid = 0; wid < n_workers; wid++) { 706 ShenandoahHeapRegionSetIterator it(worker_slices[wid]); 707 ShenandoahHeapRegion* r = it.next(); 708 while (r != nullptr) { 709 size_t idx = r->index(); 710 assert(ShenandoahPrepareForCompactionTask::is_candidate_region(r), "Sanity: %zu", idx); 711 assert(!map.at(idx), "No region distributed twice: %zu", idx); 712 map.at_put(idx, true); 713 r = it.next(); 714 } 715 } 716 717 for (size_t rid = 0; rid < n_regions; rid++) { 718 bool is_candidate = ShenandoahPrepareForCompactionTask::is_candidate_region(heap->get_region(rid)); 719 bool is_distributed = map.at(rid); 720 assert(is_distributed || !is_candidate, "All candidates are distributed: %zu", rid); 721 } 722 #endif 723 } 724 725 void ShenandoahFullGC::phase2_calculate_target_addresses(ShenandoahHeapRegionSet** worker_slices) { 726 GCTraceTime(Info, gc, phases) time("Phase 2: Compute new object addresses", _gc_timer); 727 ShenandoahGCPhase calculate_address_phase(ShenandoahPhaseTimings::full_gc_calculate_addresses); 728 729 ShenandoahHeap* heap = ShenandoahHeap::heap(); 730 731 // About to figure out which regions can be compacted, make sure pinning status 732 // had been updated in GC prologue. 733 heap->assert_pinned_region_status(); 734 735 { 736 // Trash the immediately collectible regions before computing addresses 737 ShenandoahTrashImmediateGarbageClosure trash_immediate_garbage; 738 ShenandoahExcludeRegionClosure<FREE> cl(&trash_immediate_garbage); 739 heap->heap_region_iterate(&cl); 740 741 // Make sure regions are in good state: committed, active, clean. 742 // This is needed because we are potentially sliding the data through them. 743 ShenandoahEnsureHeapActiveClosure ecl; 744 heap->heap_region_iterate(&ecl); 745 } 746 747 // Compute the new addresses for regular objects 748 { 749 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_calculate_addresses_regular); 750 751 distribute_slices(worker_slices); 752 753 ShenandoahPrepareForCompactionTask task(_preserved_marks, worker_slices); 754 heap->workers()->run_task(&task); 755 } 756 757 // Compute the new addresses for humongous objects 758 { 759 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_calculate_addresses_humong); 760 calculate_target_humongous_objects(); 761 } 762 } 763 764 class ShenandoahAdjustPointersClosure : public MetadataVisitingOopIterateClosure { 765 private: 766 ShenandoahHeap* const _heap; 767 ShenandoahMarkingContext* const _ctx; 768 769 template <class T> 770 inline void do_oop_work(T* p) { 771 T o = RawAccess<>::oop_load(p); 772 if (!CompressedOops::is_null(o)) { 773 oop obj = CompressedOops::decode_not_null(o); 774 assert(_ctx->is_marked(obj), "must be marked"); 775 if (FullGCForwarding::is_forwarded(obj)) { 776 oop forw = FullGCForwarding::forwardee(obj); 777 RawAccess<IS_NOT_NULL>::oop_store(p, forw); 778 } 779 } 780 } 781 782 public: 783 ShenandoahAdjustPointersClosure() : 784 _heap(ShenandoahHeap::heap()), 785 _ctx(ShenandoahHeap::heap()->gc_generation()->complete_marking_context()) {} 786 787 void do_oop(oop* p) { do_oop_work(p); } 788 void do_oop(narrowOop* p) { do_oop_work(p); } 789 void do_method(Method* m) {} 790 void do_nmethod(nmethod* nm) {} 791 }; 792 793 class ShenandoahAdjustPointersObjectClosure : public ObjectClosure { 794 private: 795 ShenandoahHeap* const _heap; 796 ShenandoahAdjustPointersClosure _cl; 797 798 public: 799 ShenandoahAdjustPointersObjectClosure() : 800 _heap(ShenandoahHeap::heap()) { 801 } 802 void do_object(oop p) { 803 assert(_heap->gc_generation()->complete_marking_context()->is_marked(p), "must be marked"); 804 p->oop_iterate(&_cl); 805 } 806 }; 807 808 class ShenandoahAdjustPointersTask : public WorkerTask { 809 private: 810 ShenandoahHeap* const _heap; 811 ShenandoahRegionIterator _regions; 812 813 public: 814 ShenandoahAdjustPointersTask() : 815 WorkerTask("Shenandoah Adjust Pointers"), 816 _heap(ShenandoahHeap::heap()) { 817 } 818 819 void work(uint worker_id) { 820 ShenandoahParallelWorkerSession worker_session(worker_id); 821 ShenandoahAdjustPointersObjectClosure obj_cl; 822 ShenandoahHeapRegion* r = _regions.next(); 823 while (r != nullptr) { 824 if (!r->is_humongous_continuation() && r->has_live()) { 825 _heap->marked_object_iterate(r, &obj_cl); 826 } 827 if (_heap->mode()->is_generational()) { 828 ShenandoahGenerationalFullGC::maybe_coalesce_and_fill_region(r); 829 } 830 r = _regions.next(); 831 } 832 } 833 }; 834 835 class ShenandoahAdjustRootPointersTask : public WorkerTask { 836 private: 837 ShenandoahRootAdjuster* _rp; 838 PreservedMarksSet* _preserved_marks; 839 public: 840 ShenandoahAdjustRootPointersTask(ShenandoahRootAdjuster* rp, PreservedMarksSet* preserved_marks) : 841 WorkerTask("Shenandoah Adjust Root Pointers"), 842 _rp(rp), 843 _preserved_marks(preserved_marks) {} 844 845 void work(uint worker_id) { 846 ShenandoahParallelWorkerSession worker_session(worker_id); 847 ShenandoahAdjustPointersClosure cl; 848 _rp->roots_do(worker_id, &cl); 849 _preserved_marks->get(worker_id)->adjust_during_full_gc(); 850 } 851 }; 852 853 void ShenandoahFullGC::phase3_update_references() { 854 GCTraceTime(Info, gc, phases) time("Phase 3: Adjust pointers", _gc_timer); 855 ShenandoahGCPhase adjust_pointer_phase(ShenandoahPhaseTimings::full_gc_adjust_pointers); 856 857 ShenandoahHeap* heap = ShenandoahHeap::heap(); 858 859 WorkerThreads* workers = heap->workers(); 860 uint nworkers = workers->active_workers(); 861 { 862 #if COMPILER2_OR_JVMCI 863 DerivedPointerTable::clear(); 864 #endif 865 ShenandoahRootAdjuster rp(nworkers, ShenandoahPhaseTimings::full_gc_adjust_roots); 866 ShenandoahAdjustRootPointersTask task(&rp, _preserved_marks); 867 workers->run_task(&task); 868 #if COMPILER2_OR_JVMCI 869 DerivedPointerTable::update_pointers(); 870 #endif 871 } 872 873 ShenandoahAdjustPointersTask adjust_pointers_task; 874 workers->run_task(&adjust_pointers_task); 875 } 876 877 class ShenandoahCompactObjectsClosure : public ObjectClosure { 878 private: 879 ShenandoahHeap* const _heap; 880 uint const _worker_id; 881 882 public: 883 ShenandoahCompactObjectsClosure(uint worker_id) : 884 _heap(ShenandoahHeap::heap()), _worker_id(worker_id) {} 885 886 void do_object(oop p) { 887 assert(_heap->gc_generation()->complete_marking_context()->is_marked(p), "must be marked"); 888 size_t size = p->size(); 889 if (FullGCForwarding::is_forwarded(p)) { 890 HeapWord* compact_from = cast_from_oop<HeapWord*>(p); 891 HeapWord* compact_to = cast_from_oop<HeapWord*>(FullGCForwarding::forwardee(p)); 892 assert(compact_from != compact_to, "Forwarded object should move"); 893 Copy::aligned_conjoint_words(compact_from, compact_to, size); 894 oop new_obj = cast_to_oop(compact_to); 895 896 ContinuationGCSupport::relativize_stack_chunk(new_obj); 897 new_obj->init_mark(); 898 } 899 } 900 }; 901 902 class ShenandoahCompactObjectsTask : public WorkerTask { 903 private: 904 ShenandoahHeap* const _heap; 905 ShenandoahHeapRegionSet** const _worker_slices; 906 907 public: 908 ShenandoahCompactObjectsTask(ShenandoahHeapRegionSet** worker_slices) : 909 WorkerTask("Shenandoah Compact Objects"), 910 _heap(ShenandoahHeap::heap()), 911 _worker_slices(worker_slices) { 912 } 913 914 void work(uint worker_id) { 915 ShenandoahParallelWorkerSession worker_session(worker_id); 916 ShenandoahHeapRegionSetIterator slice(_worker_slices[worker_id]); 917 918 ShenandoahCompactObjectsClosure cl(worker_id); 919 ShenandoahHeapRegion* r = slice.next(); 920 while (r != nullptr) { 921 assert(!r->is_humongous(), "must not get humongous regions here"); 922 if (r->has_live()) { 923 _heap->marked_object_iterate(r, &cl); 924 } 925 r->set_top(r->new_top()); 926 r = slice.next(); 927 } 928 } 929 }; 930 931 class ShenandoahPostCompactClosure : public ShenandoahHeapRegionClosure { 932 private: 933 ShenandoahHeap* const _heap; 934 bool _is_generational; 935 size_t _young_regions, _young_usage, _young_humongous_waste; 936 size_t _old_regions, _old_usage, _old_humongous_waste; 937 938 public: 939 ShenandoahPostCompactClosure() : _heap(ShenandoahHeap::heap()), 940 _is_generational(_heap->mode()->is_generational()), 941 _young_regions(0), 942 _young_usage(0), 943 _young_humongous_waste(0), 944 _old_regions(0), 945 _old_usage(0), 946 _old_humongous_waste(0) 947 { 948 _heap->free_set()->clear(); 949 } 950 951 void heap_region_do(ShenandoahHeapRegion* r) { 952 assert (!r->is_cset(), "cset regions should have been demoted already"); 953 954 // Need to reset the complete-top-at-mark-start pointer here because 955 // the complete marking bitmap is no longer valid. This ensures 956 // size-based iteration in marked_object_iterate(). 957 // NOTE: See blurb at ShenandoahMCResetCompleteBitmapTask on why we need to skip 958 // pinned regions. 959 if (!r->is_pinned()) { 960 _heap->gc_generation()->complete_marking_context()->reset_top_at_mark_start(r); 961 } 962 963 size_t live = r->used(); 964 965 // Make empty regions that have been allocated into regular 966 if (r->is_empty() && live > 0) { 967 if (!_is_generational) { 968 r->make_affiliated_maybe(); 969 } 970 // else, generational mode compaction has already established affiliation. 971 r->make_regular_bypass(); 972 if (ZapUnusedHeapArea) { 973 SpaceMangler::mangle_region(MemRegion(r->top(), r->end())); 974 } 975 } 976 977 // Reclaim regular regions that became empty 978 if (r->is_regular() && live == 0) { 979 r->make_trash(); 980 } 981 982 // Recycle all trash regions 983 if (r->is_trash()) { 984 live = 0; 985 r->try_recycle_under_lock(); 986 } else { 987 if (r->is_old()) { 988 ShenandoahGenerationalFullGC::account_for_region(r, _old_regions, _old_usage, _old_humongous_waste); 989 } else if (r->is_young()) { 990 ShenandoahGenerationalFullGC::account_for_region(r, _young_regions, _young_usage, _young_humongous_waste); 991 } 992 } 993 r->set_live_data(live); 994 r->reset_alloc_metadata(); 995 } 996 997 void update_generation_usage() { 998 if (_is_generational) { 999 _heap->old_generation()->establish_usage(_old_regions, _old_usage, _old_humongous_waste); 1000 _heap->young_generation()->establish_usage(_young_regions, _young_usage, _young_humongous_waste); 1001 } else { 1002 assert(_old_regions == 0, "Old regions only expected in generational mode"); 1003 assert(_old_usage == 0, "Old usage only expected in generational mode"); 1004 assert(_old_humongous_waste == 0, "Old humongous waste only expected in generational mode"); 1005 } 1006 1007 // In generational mode, global usage should be the sum of young and old. This is also true 1008 // for non-generational modes except that there are no old regions. 1009 _heap->global_generation()->establish_usage(_old_regions + _young_regions, 1010 _old_usage + _young_usage, 1011 _old_humongous_waste + _young_humongous_waste); 1012 } 1013 }; 1014 1015 void ShenandoahFullGC::compact_humongous_objects() { 1016 // Compact humongous regions, based on their fwdptr objects. 1017 // 1018 // This code is serial, because doing the in-slice parallel sliding is tricky. In most cases, 1019 // humongous regions are already compacted, and do not require further moves, which alleviates 1020 // sliding costs. We may consider doing this in parallel in the future. 1021 1022 ShenandoahHeap* heap = ShenandoahHeap::heap(); 1023 1024 for (size_t c = heap->num_regions(); c > 0; c--) { 1025 ShenandoahHeapRegion* r = heap->get_region(c - 1); 1026 if (r->is_humongous_start()) { 1027 oop old_obj = cast_to_oop(r->bottom()); 1028 if (!FullGCForwarding::is_forwarded(old_obj)) { 1029 // No need to move the object, it stays at the same slot 1030 continue; 1031 } 1032 size_t words_size = old_obj->size(); 1033 size_t num_regions = ShenandoahHeapRegion::required_regions(words_size * HeapWordSize); 1034 1035 size_t old_start = r->index(); 1036 size_t old_end = old_start + num_regions - 1; 1037 size_t new_start = heap->heap_region_index_containing(FullGCForwarding::forwardee(old_obj)); 1038 size_t new_end = new_start + num_regions - 1; 1039 assert(old_start != new_start, "must be real move"); 1040 assert(r->is_stw_move_allowed(), "Region %zu should be movable", r->index()); 1041 1042 log_debug(gc)("Full GC compaction moves humongous object from region %zu to region %zu", old_start, new_start); 1043 Copy::aligned_conjoint_words(r->bottom(), heap->get_region(new_start)->bottom(), words_size); 1044 ContinuationGCSupport::relativize_stack_chunk(cast_to_oop<HeapWord*>(r->bottom())); 1045 1046 oop new_obj = cast_to_oop(heap->get_region(new_start)->bottom()); 1047 new_obj->init_mark(); 1048 1049 { 1050 ShenandoahAffiliation original_affiliation = r->affiliation(); 1051 for (size_t c = old_start; c <= old_end; c++) { 1052 ShenandoahHeapRegion* r = heap->get_region(c); 1053 // Leave humongous region affiliation unchanged. 1054 r->make_regular_bypass(); 1055 r->set_top(r->bottom()); 1056 } 1057 1058 for (size_t c = new_start; c <= new_end; c++) { 1059 ShenandoahHeapRegion* r = heap->get_region(c); 1060 if (c == new_start) { 1061 r->make_humongous_start_bypass(original_affiliation); 1062 } else { 1063 r->make_humongous_cont_bypass(original_affiliation); 1064 } 1065 1066 // Trailing region may be non-full, record the remainder there 1067 size_t remainder = words_size & ShenandoahHeapRegion::region_size_words_mask(); 1068 if ((c == new_end) && (remainder != 0)) { 1069 r->set_top(r->bottom() + remainder); 1070 } else { 1071 r->set_top(r->end()); 1072 } 1073 1074 r->reset_alloc_metadata(); 1075 } 1076 } 1077 } 1078 } 1079 } 1080 1081 // This is slightly different to ShHeap::reset_next_mark_bitmap: 1082 // we need to remain able to walk pinned regions. 1083 // Since pinned region do not move and don't get compacted, we will get holes with 1084 // unreachable objects in them (which may have pointers to unloaded Klasses and thus 1085 // cannot be iterated over using oop->size(). The only way to safely iterate over those is using 1086 // a valid marking bitmap and valid TAMS pointer. This class only resets marking 1087 // bitmaps for un-pinned regions, and later we only reset TAMS for unpinned regions. 1088 class ShenandoahMCResetCompleteBitmapTask : public WorkerTask { 1089 private: 1090 ShenandoahRegionIterator _regions; 1091 1092 public: 1093 ShenandoahMCResetCompleteBitmapTask() : 1094 WorkerTask("Shenandoah Reset Bitmap") { 1095 } 1096 1097 void work(uint worker_id) { 1098 ShenandoahParallelWorkerSession worker_session(worker_id); 1099 ShenandoahHeapRegion* region = _regions.next(); 1100 ShenandoahHeap* heap = ShenandoahHeap::heap(); 1101 ShenandoahMarkingContext* const ctx = heap->gc_generation()->complete_marking_context(); 1102 while (region != nullptr) { 1103 if (heap->is_bitmap_slice_committed(region) && !region->is_pinned() && region->has_live()) { 1104 ctx->clear_bitmap(region); 1105 } 1106 region = _regions.next(); 1107 } 1108 } 1109 }; 1110 1111 void ShenandoahFullGC::phase4_compact_objects(ShenandoahHeapRegionSet** worker_slices) { 1112 GCTraceTime(Info, gc, phases) time("Phase 4: Move objects", _gc_timer); 1113 ShenandoahGCPhase compaction_phase(ShenandoahPhaseTimings::full_gc_copy_objects); 1114 1115 ShenandoahHeap* heap = ShenandoahHeap::heap(); 1116 1117 // Compact regular objects first 1118 { 1119 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_copy_objects_regular); 1120 ShenandoahCompactObjectsTask compact_task(worker_slices); 1121 heap->workers()->run_task(&compact_task); 1122 } 1123 1124 // Compact humongous objects after regular object moves 1125 { 1126 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_copy_objects_humong); 1127 compact_humongous_objects(); 1128 } 1129 } 1130 1131 ShenandoahGenerationalHeap::TransferResult ShenandoahFullGC::phase5_epilog() { 1132 GCTraceTime(Info, gc, phases) time("Phase 5: Full GC epilog", _gc_timer); 1133 ShenandoahHeap* heap = ShenandoahHeap::heap(); 1134 ShenandoahGenerationalHeap::TransferResult result; 1135 1136 // Reset complete bitmap. We're about to reset the complete-top-at-mark-start pointer 1137 // and must ensure the bitmap is in sync. 1138 { 1139 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_copy_objects_reset_complete); 1140 ShenandoahMCResetCompleteBitmapTask task; 1141 heap->workers()->run_task(&task); 1142 } 1143 1144 // Bring regions in proper states after the collection, and set heap properties. 1145 { 1146 ShenandoahGCPhase phase(ShenandoahPhaseTimings::full_gc_copy_objects_rebuild); 1147 ShenandoahPostCompactClosure post_compact; 1148 heap->heap_region_iterate(&post_compact); 1149 post_compact.update_generation_usage(); 1150 1151 if (heap->mode()->is_generational()) { 1152 ShenandoahGenerationalFullGC::balance_generations_after_gc(heap); 1153 } 1154 1155 heap->collection_set()->clear(); 1156 size_t young_cset_regions, old_cset_regions; 1157 size_t first_old, last_old, num_old; 1158 heap->free_set()->prepare_to_rebuild(young_cset_regions, old_cset_regions, first_old, last_old, num_old); 1159 1160 // We also do not expand old generation size following Full GC because we have scrambled age populations and 1161 // no longer have objects separated by age into distinct regions. 1162 if (heap->mode()->is_generational()) { 1163 ShenandoahGenerationalFullGC::compute_balances(); 1164 } 1165 1166 heap->free_set()->finish_rebuild(young_cset_regions, old_cset_regions, num_old); 1167 1168 // Set mark incomplete because the marking bitmaps have been reset except pinned regions. 1169 heap->global_generation()->set_mark_incomplete(); 1170 1171 heap->clear_cancelled_gc(true /* clear oom handler */); 1172 } 1173 1174 _preserved_marks->restore(heap->workers()); 1175 _preserved_marks->reclaim(); 1176 1177 // We defer generation resizing actions until after cset regions have been recycled. We do this even following an 1178 // abbreviated cycle. 1179 if (heap->mode()->is_generational()) { 1180 result = ShenandoahGenerationalFullGC::balance_generations_after_rebuilding_free_set(); 1181 ShenandoahGenerationalFullGC::rebuild_remembered_set(heap); 1182 } 1183 return result; 1184 }