1 /* 2 * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/classLoaderDataGraph.hpp" 27 #include "classfile/stringTable.hpp" 28 #include "classfile/symbolTable.hpp" 29 #include "classfile/vmSymbols.hpp" 30 #include "code/codeCache.hpp" 31 #include "compiler/oopMap.hpp" 32 #include "gc/serial/cardTableRS.hpp" 33 #include "gc/serial/serialFullGC.hpp" 34 #include "gc/serial/serialHeap.inline.hpp" 35 #include "gc/serial/serialMemoryPools.hpp" 36 #include "gc/serial/serialVMOperations.hpp" 37 #include "gc/serial/tenuredGeneration.inline.hpp" 38 #include "gc/shared/cardTableBarrierSet.hpp" 39 #include "gc/shared/classUnloadingContext.hpp" 40 #include "gc/shared/collectedHeap.inline.hpp" 41 #include "gc/shared/collectorCounters.hpp" 42 #include "gc/shared/continuationGCSupport.inline.hpp" 43 #include "gc/shared/gcId.hpp" 44 #include "gc/shared/gcInitLogger.hpp" 45 #include "gc/shared/gcLocker.inline.hpp" 46 #include "gc/shared/gcPolicyCounters.hpp" 47 #include "gc/shared/gcTrace.hpp" 48 #include "gc/shared/gcTraceTime.inline.hpp" 49 #include "gc/shared/gcVMOperations.hpp" 50 #include "gc/shared/genArguments.hpp" 51 #include "gc/shared/isGCActiveMark.hpp" 52 #include "gc/shared/locationPrinter.inline.hpp" 53 #include "gc/shared/oopStorage.inline.hpp" 54 #include "gc/shared/oopStorageParState.inline.hpp" 55 #include "gc/shared/oopStorageSet.inline.hpp" 56 #include "gc/shared/scavengableNMethods.hpp" 57 #include "gc/shared/slidingForwarding.hpp" 58 #include "gc/shared/space.hpp" 59 #include "gc/shared/strongRootsScope.hpp" 60 #include "gc/shared/suspendibleThreadSet.hpp" 61 #include "gc/shared/weakProcessor.hpp" 62 #include "gc/shared/workerThread.hpp" 63 #include "memory/iterator.hpp" 64 #include "memory/metaspaceCounters.hpp" 65 #include "memory/metaspaceUtils.hpp" 66 #include "memory/resourceArea.hpp" 67 #include "memory/universe.hpp" 68 #include "oops/oop.inline.hpp" 69 #include "runtime/handles.hpp" 70 #include "runtime/handles.inline.hpp" 71 #include "runtime/java.hpp" 72 #include "runtime/mutexLocker.hpp" 73 #include "runtime/threads.hpp" 74 #include "runtime/vmThread.hpp" 75 #include "services/memoryManager.hpp" 76 #include "services/memoryService.hpp" 77 #include "utilities/debug.hpp" 78 #include "utilities/formatBuffer.hpp" 79 #include "utilities/macros.hpp" 80 #include "utilities/stack.inline.hpp" 81 #include "utilities/vmError.hpp" 82 #if INCLUDE_JVMCI 83 #include "jvmci/jvmci.hpp" 84 #endif 85 86 SerialHeap* SerialHeap::heap() { 87 return named_heap<SerialHeap>(CollectedHeap::Serial); 88 } 89 90 SerialHeap::SerialHeap() : 91 CollectedHeap(), 92 _young_gen(nullptr), 93 _old_gen(nullptr), 94 _rem_set(nullptr), 95 _gc_policy_counters(new GCPolicyCounters("Copy:MSC", 2, 2)), 96 _incremental_collection_failed(false), 97 _young_manager(nullptr), 98 _old_manager(nullptr), 99 _eden_pool(nullptr), 100 _survivor_pool(nullptr), 101 _old_pool(nullptr) { 102 _young_manager = new GCMemoryManager("Copy"); 103 _old_manager = new GCMemoryManager("MarkSweepCompact"); 104 } 105 106 void SerialHeap::initialize_serviceability() { 107 DefNewGeneration* young = young_gen(); 108 109 // Add a memory pool for each space and young gen doesn't 110 // support low memory detection as it is expected to get filled up. 111 _eden_pool = new ContiguousSpacePool(young->eden(), 112 "Eden Space", 113 young->max_eden_size(), 114 false /* support_usage_threshold */); 115 _survivor_pool = new SurvivorContiguousSpacePool(young, 116 "Survivor Space", 117 young->max_survivor_size(), 118 false /* support_usage_threshold */); 119 TenuredGeneration* old = old_gen(); 120 _old_pool = new TenuredGenerationPool(old, "Tenured Gen", true); 121 122 _young_manager->add_pool(_eden_pool); 123 _young_manager->add_pool(_survivor_pool); 124 young->set_gc_manager(_young_manager); 125 126 _old_manager->add_pool(_eden_pool); 127 _old_manager->add_pool(_survivor_pool); 128 _old_manager->add_pool(_old_pool); 129 old->set_gc_manager(_old_manager); 130 } 131 132 GrowableArray<GCMemoryManager*> SerialHeap::memory_managers() { 133 GrowableArray<GCMemoryManager*> memory_managers(2); 134 memory_managers.append(_young_manager); 135 memory_managers.append(_old_manager); 136 return memory_managers; 137 } 138 139 GrowableArray<MemoryPool*> SerialHeap::memory_pools() { 140 GrowableArray<MemoryPool*> memory_pools(3); 141 memory_pools.append(_eden_pool); 142 memory_pools.append(_survivor_pool); 143 memory_pools.append(_old_pool); 144 return memory_pools; 145 } 146 147 void SerialHeap::safepoint_synchronize_begin() { 148 if (UseStringDeduplication) { 149 SuspendibleThreadSet::synchronize(); 150 } 151 } 152 153 void SerialHeap::safepoint_synchronize_end() { 154 if (UseStringDeduplication) { 155 SuspendibleThreadSet::desynchronize(); 156 } 157 } 158 159 HeapWord* SerialHeap::allocate_loaded_archive_space(size_t word_size) { 160 MutexLocker ml(Heap_lock); 161 return old_gen()->allocate(word_size, false /* is_tlab */); 162 } 163 164 void SerialHeap::complete_loaded_archive_space(MemRegion archive_space) { 165 assert(old_gen()->used_region().contains(archive_space), "Archive space not contained in old gen"); 166 old_gen()->complete_loaded_archive_space(archive_space); 167 } 168 169 void SerialHeap::pin_object(JavaThread* thread, oop obj) { 170 GCLocker::lock_critical(thread); 171 } 172 173 void SerialHeap::unpin_object(JavaThread* thread, oop obj) { 174 GCLocker::unlock_critical(thread); 175 } 176 177 jint SerialHeap::initialize() { 178 // Allocate space for the heap. 179 180 ReservedHeapSpace heap_rs = allocate(HeapAlignment); 181 182 if (!heap_rs.is_reserved()) { 183 vm_shutdown_during_initialization( 184 "Could not reserve enough space for object heap"); 185 return JNI_ENOMEM; 186 } 187 188 initialize_reserved_region(heap_rs); 189 190 ReservedSpace young_rs = heap_rs.first_part(MaxNewSize); 191 ReservedSpace old_rs = heap_rs.last_part(MaxNewSize); 192 193 _rem_set = new CardTableRS(heap_rs.region()); 194 _rem_set->initialize(young_rs.base(), old_rs.base()); 195 196 CardTableBarrierSet *bs = new CardTableBarrierSet(_rem_set); 197 bs->initialize(); 198 BarrierSet::set_barrier_set(bs); 199 200 _young_gen = new DefNewGeneration(young_rs, NewSize, MinNewSize, MaxNewSize); 201 _old_gen = new TenuredGeneration(old_rs, OldSize, MinOldSize, MaxOldSize, rem_set()); 202 203 GCInitLogger::print(); 204 205 SlidingForwarding::initialize(_reserved, SpaceAlignment / HeapWordSize); 206 207 return JNI_OK; 208 } 209 210 ReservedHeapSpace SerialHeap::allocate(size_t alignment) { 211 // Now figure out the total size. 212 const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size(); 213 assert(alignment % pageSize == 0, "Must be"); 214 215 // Check for overflow. 216 size_t total_reserved = MaxNewSize + MaxOldSize; 217 if (total_reserved < MaxNewSize) { 218 vm_exit_during_initialization("The size of the object heap + VM data exceeds " 219 "the maximum representable size"); 220 } 221 assert(total_reserved % alignment == 0, 222 "Gen size; total_reserved=" SIZE_FORMAT ", alignment=" 223 SIZE_FORMAT, total_reserved, alignment); 224 225 ReservedHeapSpace heap_rs = Universe::reserve_heap(total_reserved, alignment); 226 size_t used_page_size = heap_rs.page_size(); 227 228 os::trace_page_sizes("Heap", 229 MinHeapSize, 230 total_reserved, 231 heap_rs.base(), 232 heap_rs.size(), 233 used_page_size); 234 235 return heap_rs; 236 } 237 238 class GenIsScavengable : public BoolObjectClosure { 239 public: 240 bool do_object_b(oop obj) { 241 return SerialHeap::heap()->is_in_young(obj); 242 } 243 }; 244 245 static GenIsScavengable _is_scavengable; 246 247 void SerialHeap::post_initialize() { 248 CollectedHeap::post_initialize(); 249 250 DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen; 251 252 def_new_gen->ref_processor_init(); 253 254 SerialFullGC::initialize(); 255 256 ScavengableNMethods::initialize(&_is_scavengable); 257 } 258 259 PreGenGCValues SerialHeap::get_pre_gc_values() const { 260 const DefNewGeneration* const def_new_gen = (DefNewGeneration*) young_gen(); 261 262 return PreGenGCValues(def_new_gen->used(), 263 def_new_gen->capacity(), 264 def_new_gen->eden()->used(), 265 def_new_gen->eden()->capacity(), 266 def_new_gen->from()->used(), 267 def_new_gen->from()->capacity(), 268 old_gen()->used(), 269 old_gen()->capacity()); 270 } 271 272 size_t SerialHeap::capacity() const { 273 return _young_gen->capacity() + _old_gen->capacity(); 274 } 275 276 size_t SerialHeap::used() const { 277 return _young_gen->used() + _old_gen->used(); 278 } 279 280 size_t SerialHeap::max_capacity() const { 281 return _young_gen->max_capacity() + _old_gen->max_capacity(); 282 } 283 284 // Return true if any of the following is true: 285 // . the allocation won't fit into the current young gen heap 286 // . gc locker is occupied (jni critical section) 287 // . heap memory is tight -- the most recent previous collection 288 // was a full collection because a partial collection (would 289 // have) failed and is likely to fail again 290 bool SerialHeap::should_try_older_generation_allocation(size_t word_size) const { 291 size_t young_capacity = _young_gen->capacity_before_gc(); 292 return (word_size > heap_word_size(young_capacity)) 293 || GCLocker::is_active_and_needs_gc() 294 || incremental_collection_failed(); 295 } 296 297 HeapWord* SerialHeap::expand_heap_and_allocate(size_t size, bool is_tlab) { 298 HeapWord* result = nullptr; 299 if (_old_gen->should_allocate(size, is_tlab)) { 300 result = _old_gen->expand_and_allocate(size, is_tlab); 301 } 302 if (result == nullptr) { 303 if (_young_gen->should_allocate(size, is_tlab)) { 304 result = _young_gen->expand_and_allocate(size, is_tlab); 305 } 306 } 307 assert(result == nullptr || is_in_reserved(result), "result not in heap"); 308 return result; 309 } 310 311 HeapWord* SerialHeap::mem_allocate_work(size_t size, 312 bool is_tlab) { 313 314 HeapWord* result = nullptr; 315 316 // Loop until the allocation is satisfied, or unsatisfied after GC. 317 for (uint try_count = 1, gclocker_stalled_count = 0; /* return or throw */; try_count += 1) { 318 319 // First allocation attempt is lock-free. 320 DefNewGeneration *young = _young_gen; 321 if (young->should_allocate(size, is_tlab)) { 322 result = young->par_allocate(size, is_tlab); 323 if (result != nullptr) { 324 assert(is_in_reserved(result), "result not in heap"); 325 return result; 326 } 327 } 328 uint gc_count_before; // Read inside the Heap_lock locked region. 329 { 330 MutexLocker ml(Heap_lock); 331 log_trace(gc, alloc)("SerialHeap::mem_allocate_work: attempting locked slow path allocation"); 332 // Note that only large objects get a shot at being 333 // allocated in later generations. 334 bool first_only = !should_try_older_generation_allocation(size); 335 336 result = attempt_allocation(size, is_tlab, first_only); 337 if (result != nullptr) { 338 assert(is_in_reserved(result), "result not in heap"); 339 return result; 340 } 341 342 if (GCLocker::is_active_and_needs_gc()) { 343 if (is_tlab) { 344 return nullptr; // Caller will retry allocating individual object. 345 } 346 if (!is_maximal_no_gc()) { 347 // Try and expand heap to satisfy request. 348 result = expand_heap_and_allocate(size, is_tlab); 349 // Result could be null if we are out of space. 350 if (result != nullptr) { 351 return result; 352 } 353 } 354 355 if (gclocker_stalled_count > GCLockerRetryAllocationCount) { 356 return nullptr; // We didn't get to do a GC and we didn't get any memory. 357 } 358 359 // If this thread is not in a jni critical section, we stall 360 // the requestor until the critical section has cleared and 361 // GC allowed. When the critical section clears, a GC is 362 // initiated by the last thread exiting the critical section; so 363 // we retry the allocation sequence from the beginning of the loop, 364 // rather than causing more, now probably unnecessary, GC attempts. 365 JavaThread* jthr = JavaThread::current(); 366 if (!jthr->in_critical()) { 367 MutexUnlocker mul(Heap_lock); 368 // Wait for JNI critical section to be exited 369 GCLocker::stall_until_clear(); 370 gclocker_stalled_count += 1; 371 continue; 372 } else { 373 if (CheckJNICalls) { 374 fatal("Possible deadlock due to allocating while" 375 " in jni critical section"); 376 } 377 return nullptr; 378 } 379 } 380 381 // Read the gc count while the heap lock is held. 382 gc_count_before = total_collections(); 383 } 384 385 VM_SerialCollectForAllocation op(size, is_tlab, gc_count_before); 386 VMThread::execute(&op); 387 if (op.prologue_succeeded()) { 388 result = op.result(); 389 if (op.gc_locked()) { 390 assert(result == nullptr, "must be null if gc_locked() is true"); 391 continue; // Retry and/or stall as necessary. 392 } 393 394 assert(result == nullptr || is_in_reserved(result), 395 "result not in heap"); 396 return result; 397 } 398 399 // Give a warning if we seem to be looping forever. 400 if ((QueuedAllocationWarningCount > 0) && 401 (try_count % QueuedAllocationWarningCount == 0)) { 402 log_warning(gc, ergo)("SerialHeap::mem_allocate_work retries %d times," 403 " size=" SIZE_FORMAT " %s", try_count, size, is_tlab ? "(TLAB)" : ""); 404 } 405 } 406 } 407 408 HeapWord* SerialHeap::attempt_allocation(size_t size, 409 bool is_tlab, 410 bool first_only) { 411 HeapWord* res = nullptr; 412 413 if (_young_gen->should_allocate(size, is_tlab)) { 414 res = _young_gen->allocate(size, is_tlab); 415 if (res != nullptr || first_only) { 416 return res; 417 } 418 } 419 420 if (_old_gen->should_allocate(size, is_tlab)) { 421 res = _old_gen->allocate(size, is_tlab); 422 } 423 424 return res; 425 } 426 427 HeapWord* SerialHeap::mem_allocate(size_t size, 428 bool* gc_overhead_limit_was_exceeded) { 429 return mem_allocate_work(size, 430 false /* is_tlab */); 431 } 432 433 bool SerialHeap::must_clear_all_soft_refs() { 434 return _gc_cause == GCCause::_metadata_GC_clear_soft_refs || 435 _gc_cause == GCCause::_wb_full_gc; 436 } 437 438 bool SerialHeap::is_young_gc_safe() const { 439 if (!_young_gen->to()->is_empty()) { 440 return false; 441 } 442 return _old_gen->promotion_attempt_is_safe(_young_gen->used()); 443 } 444 445 bool SerialHeap::do_young_collection(bool clear_soft_refs) { 446 if (!is_young_gc_safe()) { 447 return false; 448 } 449 IsSTWGCActiveMark gc_active_mark; 450 SvcGCMarker sgcm(SvcGCMarker::MINOR); 451 GCIdMark gc_id_mark; 452 GCTraceCPUTime tcpu(_young_gen->gc_tracer()); 453 GCTraceTime(Info, gc) t("Pause Young", nullptr, gc_cause(), true); 454 TraceCollectorStats tcs(_young_gen->counters()); 455 TraceMemoryManagerStats tmms(_young_gen->gc_manager(), gc_cause(), "end of minor GC"); 456 print_heap_before_gc(); 457 const PreGenGCValues pre_gc_values = get_pre_gc_values(); 458 459 increment_total_collections(false); 460 const bool should_verify = total_collections() >= VerifyGCStartAt; 461 if (should_verify && VerifyBeforeGC) { 462 prepare_for_verify(); 463 Universe::verify("Before GC"); 464 } 465 gc_prologue(false); 466 COMPILER2_OR_JVMCI_PRESENT(DerivedPointerTable::clear()); 467 468 save_marks(); 469 470 bool result = _young_gen->collect(clear_soft_refs); 471 472 COMPILER2_OR_JVMCI_PRESENT(DerivedPointerTable::update_pointers()); 473 474 // Only update stats for successful young-gc 475 if (result) { 476 _old_gen->update_promote_stats(); 477 } 478 479 if (should_verify && VerifyAfterGC) { 480 Universe::verify("After GC"); 481 } 482 483 _young_gen->compute_new_size(); 484 485 print_heap_change(pre_gc_values); 486 487 // Track memory usage and detect low memory after GC finishes 488 MemoryService::track_memory_usage(); 489 490 gc_epilogue(false); 491 492 print_heap_after_gc(); 493 494 return result; 495 } 496 497 void SerialHeap::register_nmethod(nmethod* nm) { 498 ScavengableNMethods::register_nmethod(nm); 499 } 500 501 void SerialHeap::unregister_nmethod(nmethod* nm) { 502 ScavengableNMethods::unregister_nmethod(nm); 503 } 504 505 void SerialHeap::verify_nmethod(nmethod* nm) { 506 ScavengableNMethods::verify_nmethod(nm); 507 } 508 509 void SerialHeap::prune_scavengable_nmethods() { 510 ScavengableNMethods::prune_nmethods_not_into_young(); 511 } 512 513 void SerialHeap::prune_unlinked_nmethods() { 514 ScavengableNMethods::prune_unlinked_nmethods(); 515 } 516 517 HeapWord* SerialHeap::satisfy_failed_allocation(size_t size, bool is_tlab) { 518 assert(size != 0, "precondition"); 519 520 HeapWord* result = nullptr; 521 522 GCLocker::check_active_before_gc(); 523 if (GCLocker::is_active_and_needs_gc()) { 524 // GC locker is active; instead of a collection we will attempt 525 // to expand the heap, if there's room for expansion. 526 if (!is_maximal_no_gc()) { 527 result = expand_heap_and_allocate(size, is_tlab); 528 } 529 return result; // Could be null if we are out of space. 530 } 531 532 // If young-gen can handle this allocation, attempt young-gc firstly. 533 bool should_run_young_gc = _young_gen->should_allocate(size, is_tlab); 534 collect_at_safepoint(!should_run_young_gc); 535 536 result = attempt_allocation(size, is_tlab, false /*first_only*/); 537 if (result != nullptr) { 538 return result; 539 } 540 541 // OK, collection failed, try expansion. 542 result = expand_heap_and_allocate(size, is_tlab); 543 if (result != nullptr) { 544 return result; 545 } 546 547 // If we reach this point, we're really out of memory. Try every trick 548 // we can to reclaim memory. Force collection of soft references. Force 549 // a complete compaction of the heap. Any additional methods for finding 550 // free memory should be here, especially if they are expensive. If this 551 // attempt fails, an OOM exception will be thrown. 552 { 553 UIntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted 554 const bool clear_all_soft_refs = true; 555 do_full_collection_no_gc_locker(clear_all_soft_refs); 556 } 557 558 result = attempt_allocation(size, is_tlab, false /* first_only */); 559 if (result != nullptr) { 560 return result; 561 } 562 // The previous full-gc can shrink the heap, so re-expand it. 563 result = expand_heap_and_allocate(size, is_tlab); 564 if (result != nullptr) { 565 return result; 566 } 567 568 // What else? We might try synchronous finalization later. If the total 569 // space available is large enough for the allocation, then a more 570 // complete compaction phase than we've tried so far might be 571 // appropriate. 572 return nullptr; 573 } 574 575 void SerialHeap::process_roots(ScanningOption so, 576 OopClosure* strong_roots, 577 CLDClosure* strong_cld_closure, 578 CLDClosure* weak_cld_closure, 579 NMethodToOopClosure* code_roots) { 580 // General roots. 581 assert(code_roots != nullptr, "code root closure should always be set"); 582 583 ClassLoaderDataGraph::roots_cld_do(strong_cld_closure, weak_cld_closure); 584 585 // Only process code roots from thread stacks if we aren't visiting the entire CodeCache anyway 586 NMethodToOopClosure* roots_from_code_p = (so & SO_AllCodeCache) ? nullptr : code_roots; 587 588 Threads::oops_do(strong_roots, roots_from_code_p); 589 590 OopStorageSet::strong_oops_do(strong_roots); 591 592 if (so & SO_ScavengeCodeCache) { 593 assert(code_roots != nullptr, "must supply closure for code cache"); 594 595 // We only visit parts of the CodeCache when scavenging. 596 ScavengableNMethods::nmethods_do(code_roots); 597 } 598 if (so & SO_AllCodeCache) { 599 assert(code_roots != nullptr, "must supply closure for code cache"); 600 601 // CMSCollector uses this to do intermediate-strength collections. 602 // We scan the entire code cache, since CodeCache::do_unloading is not called. 603 CodeCache::nmethods_do(code_roots); 604 } 605 } 606 607 template <typename OopClosureType> 608 static void oop_iterate_from(OopClosureType* blk, ContiguousSpace* space, HeapWord** from) { 609 assert(*from != nullptr, "precondition"); 610 HeapWord* t; 611 HeapWord* p = *from; 612 613 const intx interval = PrefetchScanIntervalInBytes; 614 do { 615 t = space->top(); 616 while (p < t) { 617 Prefetch::write(p, interval); 618 p += cast_to_oop(p)->oop_iterate_size(blk); 619 } 620 } while (t < space->top()); 621 622 *from = space->top(); 623 } 624 625 void SerialHeap::scan_evacuated_objs(YoungGenScanClosure* young_cl, 626 OldGenScanClosure* old_cl) { 627 ContiguousSpace* to_space = young_gen()->to(); 628 do { 629 oop_iterate_from(young_cl, to_space, &_young_gen_saved_top); 630 oop_iterate_from(old_cl, old_gen()->space(), &_old_gen_saved_top); 631 // Recheck to-space only, because postcondition of oop_iterate_from is no 632 // unscanned objs 633 } while (_young_gen_saved_top != to_space->top()); 634 guarantee(young_gen()->promo_failure_scan_is_complete(), "Failed to finish scan"); 635 } 636 637 void SerialHeap::try_collect_at_safepoint(bool full) { 638 assert(SafepointSynchronize::is_at_safepoint(), "precondition"); 639 if (GCLocker::check_active_before_gc()) { 640 return; 641 } 642 collect_at_safepoint(full); 643 } 644 645 void SerialHeap::collect_at_safepoint(bool full) { 646 assert(!GCLocker::is_active(), "precondition"); 647 bool clear_soft_refs = must_clear_all_soft_refs(); 648 649 if (!full) { 650 bool success = do_young_collection(clear_soft_refs); 651 if (success) { 652 return; 653 } 654 // Upgrade to Full-GC if young-gc fails 655 } 656 do_full_collection_no_gc_locker(clear_soft_refs); 657 } 658 659 // public collection interfaces 660 void SerialHeap::collect(GCCause::Cause cause) { 661 // The caller doesn't have the Heap_lock 662 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock"); 663 664 unsigned int gc_count_before; 665 unsigned int full_gc_count_before; 666 667 { 668 MutexLocker ml(Heap_lock); 669 // Read the GC count while holding the Heap_lock 670 gc_count_before = total_collections(); 671 full_gc_count_before = total_full_collections(); 672 } 673 674 if (GCLocker::should_discard(cause, gc_count_before)) { 675 return; 676 } 677 678 bool should_run_young_gc = (cause == GCCause::_wb_young_gc) 679 || (cause == GCCause::_gc_locker) 680 DEBUG_ONLY(|| (cause == GCCause::_scavenge_alot)); 681 682 while (true) { 683 VM_SerialGCCollect op(!should_run_young_gc, 684 gc_count_before, 685 full_gc_count_before, 686 cause); 687 VMThread::execute(&op); 688 689 if (!GCCause::is_explicit_full_gc(cause)) { 690 return; 691 } 692 693 { 694 MutexLocker ml(Heap_lock); 695 // Read the GC count while holding the Heap_lock 696 if (full_gc_count_before != total_full_collections()) { 697 return; 698 } 699 } 700 701 if (GCLocker::is_active_and_needs_gc()) { 702 // If GCLocker is active, wait until clear before retrying. 703 GCLocker::stall_until_clear(); 704 } 705 } 706 } 707 708 void SerialHeap::do_full_collection(bool clear_all_soft_refs) { 709 if (GCLocker::check_active_before_gc()) { 710 return; 711 } 712 do_full_collection_no_gc_locker(clear_all_soft_refs); 713 } 714 715 void SerialHeap::do_full_collection_no_gc_locker(bool clear_all_soft_refs) { 716 IsSTWGCActiveMark gc_active_mark; 717 SvcGCMarker sgcm(SvcGCMarker::FULL); 718 GCIdMark gc_id_mark; 719 GCTraceCPUTime tcpu(SerialFullGC::gc_tracer()); 720 GCTraceTime(Info, gc) t("Pause Full", nullptr, gc_cause(), true); 721 TraceCollectorStats tcs(_old_gen->counters()); 722 TraceMemoryManagerStats tmms(_old_gen->gc_manager(), gc_cause(), "end of major GC"); 723 const PreGenGCValues pre_gc_values = get_pre_gc_values(); 724 print_heap_before_gc(); 725 726 increment_total_collections(true); 727 const bool should_verify = total_collections() >= VerifyGCStartAt; 728 if (should_verify && VerifyBeforeGC) { 729 prepare_for_verify(); 730 Universe::verify("Before GC"); 731 } 732 733 gc_prologue(true); 734 COMPILER2_OR_JVMCI_PRESENT(DerivedPointerTable::clear()); 735 CodeCache::on_gc_marking_cycle_start(); 736 ClassUnloadingContext ctx(1 /* num_nmethod_unlink_workers */, 737 false /* unregister_nmethods_during_purge */, 738 false /* lock_nmethod_free_separately */); 739 740 STWGCTimer* gc_timer = SerialFullGC::gc_timer(); 741 gc_timer->register_gc_start(); 742 743 SerialOldTracer* gc_tracer = SerialFullGC::gc_tracer(); 744 gc_tracer->report_gc_start(gc_cause(), gc_timer->gc_start()); 745 746 pre_full_gc_dump(gc_timer); 747 748 SerialFullGC::invoke_at_safepoint(clear_all_soft_refs); 749 750 post_full_gc_dump(gc_timer); 751 752 gc_timer->register_gc_end(); 753 754 gc_tracer->report_gc_end(gc_timer->gc_end(), gc_timer->time_partitions()); 755 CodeCache::on_gc_marking_cycle_finish(); 756 CodeCache::arm_all_nmethods(); 757 COMPILER2_OR_JVMCI_PRESENT(DerivedPointerTable::update_pointers()); 758 759 // Adjust generation sizes. 760 _old_gen->compute_new_size(); 761 _young_gen->compute_new_size(); 762 763 // Delete metaspaces for unloaded class loaders and clean up loader_data graph 764 ClassLoaderDataGraph::purge(/*at_safepoint*/true); 765 DEBUG_ONLY(MetaspaceUtils::verify();) 766 767 // Need to clear claim bits for the next mark. 768 ClassLoaderDataGraph::clear_claimed_marks(); 769 770 _old_gen->update_promote_stats(); 771 772 // Resize the metaspace capacity after full collections 773 MetaspaceGC::compute_new_size(); 774 775 print_heap_change(pre_gc_values); 776 777 // Track memory usage and detect low memory after GC finishes 778 MemoryService::track_memory_usage(); 779 780 // Need to tell the epilogue code we are done with Full GC, regardless what was 781 // the initial value for "complete" flag. 782 gc_epilogue(true); 783 784 print_heap_after_gc(); 785 786 if (should_verify && VerifyAfterGC) { 787 Universe::verify("After GC"); 788 } 789 } 790 791 bool SerialHeap::is_in_young(const void* p) const { 792 bool result = p < _old_gen->reserved().start(); 793 assert(result == _young_gen->is_in_reserved(p), 794 "incorrect test - result=%d, p=" PTR_FORMAT, result, p2i(p)); 795 return result; 796 } 797 798 bool SerialHeap::requires_barriers(stackChunkOop obj) const { 799 return !is_in_young(obj); 800 } 801 802 // Returns "TRUE" iff "p" points into the committed areas of the heap. 803 bool SerialHeap::is_in(const void* p) const { 804 return _young_gen->is_in(p) || _old_gen->is_in(p); 805 } 806 807 void SerialHeap::object_iterate(ObjectClosure* cl) { 808 _young_gen->object_iterate(cl); 809 _old_gen->object_iterate(cl); 810 } 811 812 HeapWord* SerialHeap::block_start(const void* addr) const { 813 assert(is_in_reserved(addr), "block_start of address outside of heap"); 814 if (_young_gen->is_in_reserved(addr)) { 815 assert(_young_gen->is_in(addr), "addr should be in allocated part of generation"); 816 return _young_gen->block_start(addr); 817 } 818 819 assert(_old_gen->is_in_reserved(addr), "Some generation should contain the address"); 820 assert(_old_gen->is_in(addr), "addr should be in allocated part of generation"); 821 return _old_gen->block_start(addr); 822 } 823 824 bool SerialHeap::block_is_obj(const HeapWord* addr) const { 825 assert(is_in_reserved(addr), "block_is_obj of address outside of heap"); 826 assert(block_start(addr) == addr, "addr must be a block start"); 827 828 if (_young_gen->is_in_reserved(addr)) { 829 return _young_gen->eden()->is_in(addr) 830 || _young_gen->from()->is_in(addr) 831 || _young_gen->to() ->is_in(addr); 832 } 833 834 assert(_old_gen->is_in_reserved(addr), "must be in old-gen"); 835 return addr < _old_gen->space()->top(); 836 } 837 838 size_t SerialHeap::tlab_capacity(Thread* thr) const { 839 // Only young-gen supports tlab allocation. 840 return _young_gen->tlab_capacity(); 841 } 842 843 size_t SerialHeap::tlab_used(Thread* thr) const { 844 return _young_gen->tlab_used(); 845 } 846 847 size_t SerialHeap::unsafe_max_tlab_alloc(Thread* thr) const { 848 return _young_gen->unsafe_max_tlab_alloc(); 849 } 850 851 HeapWord* SerialHeap::allocate_new_tlab(size_t min_size, 852 size_t requested_size, 853 size_t* actual_size) { 854 HeapWord* result = mem_allocate_work(requested_size /* size */, 855 true /* is_tlab */); 856 if (result != nullptr) { 857 *actual_size = requested_size; 858 } 859 860 return result; 861 } 862 863 void SerialHeap::prepare_for_verify() { 864 ensure_parsability(false); // no need to retire TLABs 865 } 866 867 bool SerialHeap::is_maximal_no_gc() const { 868 // We don't expand young-gen except at a GC. 869 return _old_gen->is_maximal_no_gc(); 870 } 871 872 void SerialHeap::save_marks() { 873 _young_gen_saved_top = _young_gen->to()->top(); 874 _old_gen_saved_top = _old_gen->space()->top(); 875 } 876 877 void SerialHeap::verify(VerifyOption option /* ignored */) { 878 log_debug(gc, verify)("%s", _old_gen->name()); 879 _old_gen->verify(); 880 881 log_debug(gc, verify)("%s", _young_gen->name()); 882 _young_gen->verify(); 883 884 log_debug(gc, verify)("RemSet"); 885 rem_set()->verify(); 886 } 887 888 void SerialHeap::print_on(outputStream* st) const { 889 if (_young_gen != nullptr) { 890 _young_gen->print_on(st); 891 } 892 if (_old_gen != nullptr) { 893 _old_gen->print_on(st); 894 } 895 MetaspaceUtils::print_on(st); 896 } 897 898 void SerialHeap::gc_threads_do(ThreadClosure* tc) const { 899 } 900 901 bool SerialHeap::print_location(outputStream* st, void* addr) const { 902 return BlockLocationPrinter<SerialHeap>::print_location(st, addr); 903 } 904 905 void SerialHeap::print_tracing_info() const { 906 // Does nothing 907 } 908 909 void SerialHeap::print_heap_change(const PreGenGCValues& pre_gc_values) const { 910 const DefNewGeneration* const def_new_gen = (DefNewGeneration*) young_gen(); 911 912 log_info(gc, heap)(HEAP_CHANGE_FORMAT" " 913 HEAP_CHANGE_FORMAT" " 914 HEAP_CHANGE_FORMAT, 915 HEAP_CHANGE_FORMAT_ARGS(def_new_gen->short_name(), 916 pre_gc_values.young_gen_used(), 917 pre_gc_values.young_gen_capacity(), 918 def_new_gen->used(), 919 def_new_gen->capacity()), 920 HEAP_CHANGE_FORMAT_ARGS("Eden", 921 pre_gc_values.eden_used(), 922 pre_gc_values.eden_capacity(), 923 def_new_gen->eden()->used(), 924 def_new_gen->eden()->capacity()), 925 HEAP_CHANGE_FORMAT_ARGS("From", 926 pre_gc_values.from_used(), 927 pre_gc_values.from_capacity(), 928 def_new_gen->from()->used(), 929 def_new_gen->from()->capacity())); 930 log_info(gc, heap)(HEAP_CHANGE_FORMAT, 931 HEAP_CHANGE_FORMAT_ARGS(old_gen()->short_name(), 932 pre_gc_values.old_gen_used(), 933 pre_gc_values.old_gen_capacity(), 934 old_gen()->used(), 935 old_gen()->capacity())); 936 MetaspaceUtils::print_metaspace_change(pre_gc_values.metaspace_sizes()); 937 } 938 939 void SerialHeap::gc_prologue(bool full) { 940 // Fill TLAB's and such 941 ensure_parsability(true); // retire TLABs 942 943 _old_gen->gc_prologue(); 944 }; 945 946 void SerialHeap::gc_epilogue(bool full) { 947 #if COMPILER2_OR_JVMCI 948 assert(DerivedPointerTable::is_empty(), "derived pointer present"); 949 #endif // COMPILER2_OR_JVMCI 950 951 resize_all_tlabs(); 952 953 _young_gen->gc_epilogue(full); 954 _old_gen->gc_epilogue(); 955 956 MetaspaceCounters::update_performance_counters(); 957 }; --- EOF ---