jdk-sandbox: comparison src/hotspot/share/gc/shared/genCollectedHeap.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "gc/shared/genArguments.hpp"
 #include "gc/shared/gcVMOperations.hpp"
 #include "gc/shared/genCollectedHeap.hpp"
 #include "gc/shared/genOopClosures.inline.hpp"
 #include "gc/shared/generationSpec.hpp"
+#include "gc/shared/locationPrinter.inline.hpp"
 #include "gc/shared/oopStorageParState.inline.hpp"
 #include "gc/shared/scavengableNMethods.hpp"
 #include "gc/shared/space.hpp"
 #include "gc/shared/strongRootsScope.hpp"
 #include "gc/shared/weakProcessor.hpp"
 // HeapWordSize).
 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize");
 // Allocate space for the heap.
-char* heap_address;
+ReservedHeapSpace heap_rs = allocate(HeapAlignment);
-ReservedSpace heap_rs;
-heap_address = allocate(HeapAlignment, &heap_rs);
 if (!heap_rs.is_reserved()) {
 vm_shutdown_during_initialization(
 "Could not reserve enough space for object heap");
 return JNI_ENOMEM;
 }
-initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
+initialize_reserved_region(heap_rs);
-_rem_set = create_rem_set(reserved_region());
+_rem_set = create_rem_set(heap_rs.region());
 _rem_set->initialize();
 CardTableBarrierSet *bs = new CardTableBarrierSet(_rem_set);
 bs->initialize();
 BarrierSet::set_barrier_set(bs);
 ReservedSpace young_rs = heap_rs.first_part(_young_gen_spec->max_size(), false, false);
 _young_gen = _young_gen_spec->init(young_rs, rem_set());
-heap_rs = heap_rs.last_part(_young_gen_spec->max_size());
+ReservedSpace old_rs = heap_rs.last_part(_young_gen_spec->max_size());
-ReservedSpace old_rs = heap_rs.first_part(_old_gen_spec->max_size(), false, false);
+old_rs = old_rs.first_part(_old_gen_spec->max_size(), false, false);
 _old_gen = _old_gen_spec->init(old_rs, rem_set());
 clear_incremental_collection_failed();
 return JNI_OK;
 }
 init_survivor_size,
 max_gc_pause_sec,
 GCTimeRatio);
 }
-char* GenCollectedHeap::allocate(size_t alignment,
+ReservedHeapSpace GenCollectedHeap::allocate(size_t alignment) {
-ReservedSpace* heap_rs){
 // Now figure out the total size.
 const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
 assert(alignment % pageSize == 0, "Must be");
 // Check for overflow.
 }
 assert(total_reserved % alignment == 0,
 "Gen size; total_reserved=" SIZE_FORMAT ", alignment="
 SIZE_FORMAT, total_reserved, alignment);
-*heap_rs = Universe::reserve_heap(total_reserved, alignment);
+ReservedHeapSpace heap_rs = Universe::reserve_heap(total_reserved, alignment);
 os::trace_page_sizes("Heap",
 MinHeapSize,
 total_reserved,
 alignment,
-heap_rs->base(),
+heap_rs.base(),
-heap_rs->size());
+heap_rs.size());
-return heap_rs->base();
+return heap_rs;
 }
 class GenIsScavengable : public BoolObjectClosure {
 public:
 bool do_object_b(oop obj) {
 }
 void GenCollectedHeap::ref_processing_init() {
 _young_gen->ref_processor_init();
 _old_gen->ref_processor_init();
+}
+PreGenGCValues GenCollectedHeap::get_pre_gc_values() const {
+const DefNewGeneration* const def_new_gen = (DefNewGeneration*) young_gen();
+return PreGenGCValues(def_new_gen->used(),
+def_new_gen->capacity(),
+def_new_gen->eden()->used(),
+def_new_gen->eden()->capacity(),
+def_new_gen->from()->used(),
+def_new_gen->from()->capacity(),
+old_gen()->used(),
+old_gen()->capacity());
 }
 GenerationSpec* GenCollectedHeap::young_gen_spec() const {
 return _young_gen_spec;
 }
 const bool do_clear_all_soft_refs = clear_all_soft_refs ||
 soft_ref_policy()->should_clear_all_soft_refs();
 ClearedAllSoftRefs casr(do_clear_all_soft_refs, soft_ref_policy());
-const size_t metadata_prev_used = MetaspaceUtils::used_bytes();
 FlagSetting fl(_is_gc_active, true);
 bool complete = full && (max_generation == OldGen);
 bool old_collects_young = complete && !ScavengeBeforeFullGC;
 bool do_young_collection = !old_collects_young && _young_gen->should_collect(full, size, is_tlab);
-size_t young_prev_used = _young_gen->used();
+const PreGenGCValues pre_gc_values = get_pre_gc_values();
-size_t old_prev_used = _old_gen->used();
 bool run_verification = total_collections() >= VerifyGCStartAt;
 bool prepared_for_verification = false;
 bool do_full_collection = false;
 do_full_collection = should_do_full_collection(size, full, is_tlab, max_generation);
 if (!do_full_collection) {
 // Adjust generation sizes.
 _young_gen->compute_new_size();
-print_heap_change(young_prev_used, old_prev_used);
+print_heap_change(pre_gc_values);
-MetaspaceUtils::print_metaspace_change(metadata_prev_used);
 // Track memory usage and detect low memory after GC finishes
 MemoryService::track_memory_usage();
 gc_epilogue(complete);
 MetaspaceUtils::verify_metrics();
 // Resize the metaspace capacity after full collections
 MetaspaceGC::compute_new_size();
 update_full_collections_completed();
-print_heap_change(young_prev_used, old_prev_used);
+print_heap_change(pre_gc_values);
-MetaspaceUtils::print_metaspace_change(metadata_prev_used);
 // Track memory usage and detect low memory after GC finishes
 MemoryService::track_memory_usage();
 // Need to tell the epilogue code we are done with Full GC, regardless what was
 #if INCLUDE_AOT
 if (UseAOT && _process_strong_tasks->try_claim_task(GCH_PS_aot_oops_do)) {
 AOTLoader::oops_do(strong_roots);
 }
 #endif
-#if INCLUDE_JVMCI
-if (EnableJVMCI && _process_strong_tasks->try_claim_task(GCH_PS_jvmci_oops_do)) {
-JVMCI::oops_do(strong_roots);
-}
-#endif
 if (_process_strong_tasks->try_claim_task(GCH_PS_SystemDictionary_oops_do)) {
 SystemDictionary::oops_do(strong_roots);
 }
 if (_process_strong_tasks->try_claim_task(GCH_PS_CodeCache_oops_do)) {
 }
 // public collection interfaces
 void GenCollectedHeap::collect(GCCause::Cause cause) {
-if (cause == GCCause::_wb_young_gc) {
+if ((cause == GCCause::_wb_young_gc) ||
-// Young collection for the WhiteBox API.
+(cause == GCCause::_gc_locker)) {
+// Young collection for WhiteBox or GCLocker.
 collect(cause, YoungGen);
 } else {
 #ifdef ASSERT
 if (cause == GCCause::_scavenge_alot) {
 // Young collection only.
 void GenCollectedHeap::collect_locked(GCCause::Cause cause, GenerationType max_generation) {
 // Read the GC count while holding the Heap_lock
 unsigned int gc_count_before      = total_collections();
 unsigned int full_gc_count_before = total_full_collections();
+if (GCLocker::should_discard(cause, gc_count_before)) {
+return;
+}
 {
 MutexUnlocker mu(Heap_lock);  // give up heap lock, execute gets it back
 VM_GenCollectFull op(gc_count_before, full_gc_count_before,
 cause, max_generation);
 VMThread::execute(&op);
 do_full_collection(clear_all_soft_refs, OldGen);
 }
 void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs,
 GenerationType last_generation) {
-GenerationType local_last_generation;
-if (!incremental_collection_will_fail(false /* don't consult_young */) &&
-gc_cause() == GCCause::_gc_locker) {
-local_last_generation = YoungGen;
-} else {
-local_last_generation = last_generation;
-}
 do_collection(true,                   // full
 clear_all_soft_refs,    // clear_all_soft_refs
 0,                      // size
 false,                  // is_tlab
-local_last_generation); // last_generation
+last_generation);       // last_generation
 // Hack XXX FIX ME !!!
 // A scavenge may not have been attempted, or may have
 // been attempted and failed, because the old gen was too full
-if (local_last_generation == YoungGen && gc_cause() == GCCause::_gc_locker &&
+if (gc_cause() == GCCause::_gc_locker && incremental_collection_failed()) {
-incremental_collection_will_fail(false /* don't consult_young */)) {
 log_debug(gc, jni)("GC locker: Trying a full collection because scavenge failed");
 // This time allow the old gen to be collected as well
 do_collection(true,                // full
 clear_all_soft_refs, // clear_all_soft_refs
 0,                   // size
 }
 void GenCollectedHeap::print_gc_threads_on(outputStream* st) const {
 }
+bool GenCollectedHeap::print_location(outputStream* st, void* addr) const {
+return BlockLocationPrinter<GenCollectedHeap>::print_location(st, addr);
+}
 void GenCollectedHeap::print_tracing_info() const {
 if (log_is_enabled(Debug, gc, heap, exit)) {
 LogStreamHandle(Debug, gc, heap, exit) lsh;
 _young_gen->print_summary_info_on(&lsh);
 _old_gen->print_summary_info_on(&lsh);
 }
 }
-void GenCollectedHeap::print_heap_change(size_t young_prev_used, size_t old_prev_used) const {
+void GenCollectedHeap::print_heap_change(const PreGenGCValues& pre_gc_values) const {
-log_info(gc, heap)("%s: " SIZE_FORMAT "K->" SIZE_FORMAT "K("  SIZE_FORMAT "K)",
+const DefNewGeneration* const def_new_gen = (DefNewGeneration*) young_gen();
-_young_gen->short_name(), young_prev_used / K, _young_gen->used() /K, _young_gen->capacity() /K);
-log_info(gc, heap)("%s: " SIZE_FORMAT "K->" SIZE_FORMAT "K("  SIZE_FORMAT "K)",
+log_info(gc, heap)(HEAP_CHANGE_FORMAT" "
-_old_gen->short_name(), old_prev_used / K, _old_gen->used() /K, _old_gen->capacity() /K);
+HEAP_CHANGE_FORMAT" "
+HEAP_CHANGE_FORMAT,
+HEAP_CHANGE_FORMAT_ARGS(def_new_gen->short_name(),
+pre_gc_values.young_gen_used(),
+pre_gc_values.young_gen_capacity(),
+def_new_gen->used(),
+def_new_gen->capacity()),
+HEAP_CHANGE_FORMAT_ARGS("Eden",
+pre_gc_values.eden_used(),
+pre_gc_values.eden_capacity(),
+def_new_gen->eden()->used(),
+def_new_gen->eden()->capacity()),
+HEAP_CHANGE_FORMAT_ARGS("From",
+pre_gc_values.from_used(),
+pre_gc_values.from_capacity(),
+def_new_gen->from()->used(),
+def_new_gen->from()->capacity()));
+log_info(gc, heap)(HEAP_CHANGE_FORMAT,
+HEAP_CHANGE_FORMAT_ARGS(old_gen()->short_name(),
+pre_gc_values.old_gen_used(),
+pre_gc_values.old_gen_capacity(),
+old_gen()->used(),
+old_gen()->capacity()));
+MetaspaceUtils::print_metaspace_change(pre_gc_values.metaspace_sizes());
 }
 class GenGCPrologueClosure: public GenCollectedHeap::GenClosure {
 private:
 bool _full;

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54786	ebf733a324d4
child 58679	9c3209ff7550