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