graal-compiler: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 10098:71013d764f6e

8010780: G1: Eden occupancy/capacity output wrong after a full GC Summary: Move the calculation and recording of eden capacity to the start of a GC and print a detailed heap transition for full GCs. Reviewed-by: tschatzl, jmasa

author	johnc
date	Wed, 10 Apr 2013 10:57:34 -0700
parents	24ef5fb05e0f
children	c0000f77bc6d

comparison

equal deleted inserted replaced

-:ba42fd5e00e6
+:71013d764f6e
 /*
-* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // Timing
 assert(gc_cause() != GCCause::_java_lang_system_gc || explicit_gc, "invariant");
 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps);
 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty);
-TraceTime t(GCCauseString("Full GC", gc_cause()), G1Log::fine(), true, gclog_or_tty);
-TraceCollectorStats tcs(g1mm()->full_collection_counters());
-TraceMemoryManagerStats tms(true /* fullGC */, gc_cause());
-double start = os::elapsedTime();
-g1_policy()->record_full_collection_start();
-// Note: When we have a more flexible GC logging framework that
-// allows us to add optional attributes to a GC log record we
-// could consider timing and reporting how long we wait in the
-// following two methods.
-wait_while_free_regions_coming();
-// If we start the compaction before the CM threads finish
-// scanning the root regions we might trip them over as we'll
-// be moving objects / updating references. So let's wait until
-// they are done. By telling them to abort, they should complete
-// early.
-_cm->root_regions()->abort();
-_cm->root_regions()->wait_until_scan_finished();
-append_secondary_free_list_if_not_empty_with_lock();
-gc_prologue(true);
-increment_total_collections(true /* full gc */);
-increment_old_marking_cycles_started();
-size_t g1h_prev_used = used();
-assert(used() == recalculate_used(), "Should be equal");
-verify_before_gc();
-pre_full_gc_dump();
-COMPILER2_PRESENT(DerivedPointerTable::clear());
-// Disable discovery and empty the discovered lists
-// for the CM ref processor.
-ref_processor_cm()->disable_discovery();
-ref_processor_cm()->abandon_partial_discovery();
-ref_processor_cm()->verify_no_references_recorded();
-// Abandon current iterations of concurrent marking and concurrent
-// refinement, if any are in progress. We have to do this before
-// wait_until_scan_finished() below.
-concurrent_mark()->abort();
-// Make sure we'll choose a new allocation region afterwards.
-release_mutator_alloc_region();
-abandon_gc_alloc_regions();
-g1_rem_set()->cleanupHRRS();
-// We should call this after we retire any currently active alloc
-// regions so that all the ALLOC / RETIRE events are generated
-// before the start GC event.
-_hr_printer.start_gc(true /* full */, (size_t) total_collections());
-// We may have added regions to the current incremental collection
-// set between the last GC or pause and now. We need to clear the
-// incremental collection set and then start rebuilding it afresh
-// after this full GC.
-abandon_collection_set(g1_policy()->inc_cset_head());
-g1_policy()->clear_incremental_cset();
-g1_policy()->stop_incremental_cset_building();
-tear_down_region_sets(false /* free_list_only */);
-g1_policy()->set_gcs_are_young(true);
-// See the comments in g1CollectedHeap.hpp and
-// G1CollectedHeap::ref_processing_init() about
-// how reference processing currently works in G1.
-// Temporarily make discovery by the STW ref processor single threaded (non-MT).
-ReferenceProcessorMTDiscoveryMutator stw_rp_disc_ser(ref_processor_stw(), false);
-// Temporarily clear the STW ref processor's _is_alive_non_header field.
-ReferenceProcessorIsAliveMutator stw_rp_is_alive_null(ref_processor_stw(), NULL);
-ref_processor_stw()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
-ref_processor_stw()->setup_policy(do_clear_all_soft_refs);
-// Do collection work
 {
-HandleMark hm;  // Discard invalid handles created during gc
+TraceTime t(GCCauseString("Full GC", gc_cause()), G1Log::fine(), true, gclog_or_tty);
-G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs);
+TraceCollectorStats tcs(g1mm()->full_collection_counters());
-}
+TraceMemoryManagerStats tms(true /* fullGC */, gc_cause());
-assert(free_regions() == 0, "we should not have added any free regions");
+double start = os::elapsedTime();
-rebuild_region_sets(false /* free_list_only */);
+g1_policy()->record_full_collection_start();
-// Enqueue any discovered reference objects that have
+// Note: When we have a more flexible GC logging framework that
-// not been removed from the discovered lists.
+// allows us to add optional attributes to a GC log record we
-ref_processor_stw()->enqueue_discovered_references();
+// could consider timing and reporting how long we wait in the
+// following two methods.
-COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
+wait_while_free_regions_coming();
+// If we start the compaction before the CM threads finish
-MemoryService::track_memory_usage();
+// scanning the root regions we might trip them over as we'll
+// be moving objects / updating references. So let's wait until
-verify_after_gc();
+// they are done. By telling them to abort, they should complete
+// early.
-assert(!ref_processor_stw()->discovery_enabled(), "Postcondition");
+_cm->root_regions()->abort();
-ref_processor_stw()->verify_no_references_recorded();
+_cm->root_regions()->wait_until_scan_finished();
+append_secondary_free_list_if_not_empty_with_lock();
-// Delete metaspaces for unloaded class loaders and clean up loader_data graph
-ClassLoaderDataGraph::purge();
+gc_prologue(true);
+increment_total_collections(true /* full gc */);
-// Note: since we've just done a full GC, concurrent
+increment_old_marking_cycles_started();
-// marking is no longer active. Therefore we need not
-// re-enable reference discovery for the CM ref processor.
+assert(used() == recalculate_used(), "Should be equal");
-// That will be done at the start of the next marking cycle.
-assert(!ref_processor_cm()->discovery_enabled(), "Postcondition");
+verify_before_gc();
-ref_processor_cm()->verify_no_references_recorded();
+pre_full_gc_dump();
-reset_gc_time_stamp();
-// Since everything potentially moved, we will clear all remembered
+COMPILER2_PRESENT(DerivedPointerTable::clear());
-// sets, and clear all cards.  Later we will rebuild remebered
-// sets. We will also reset the GC time stamps of the regions.
+// Disable discovery and empty the discovered lists
-clear_rsets_post_compaction();
+// for the CM ref processor.
-check_gc_time_stamps();
+ref_processor_cm()->disable_discovery();
+ref_processor_cm()->abandon_partial_discovery();
-// Resize the heap if necessary.
+ref_processor_cm()->verify_no_references_recorded();
-resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size);
+// Abandon current iterations of concurrent marking and concurrent
-if (_hr_printer.is_active()) {
+// refinement, if any are in progress. We have to do this before
-// We should do this after we potentially resize the heap so
+// wait_until_scan_finished() below.
-// that all the COMMIT / UNCOMMIT events are generated before
+concurrent_mark()->abort();
-// the end GC event.
+// Make sure we'll choose a new allocation region afterwards.
-print_hrs_post_compaction();
+release_mutator_alloc_region();
-_hr_printer.end_gc(true /* full */, (size_t) total_collections());
+abandon_gc_alloc_regions();
-}
+g1_rem_set()->cleanupHRRS();
-if (_cg1r->use_cache()) {
+// We should call this after we retire any currently active alloc
-_cg1r->clear_and_record_card_counts();
+// regions so that all the ALLOC / RETIRE events are generated
-_cg1r->clear_hot_cache();
+// before the start GC event.
-}
+_hr_printer.start_gc(true /* full */, (size_t) total_collections());
-// Rebuild remembered sets of all regions.
+// We may have added regions to the current incremental collection
-if (G1CollectedHeap::use_parallel_gc_threads()) {
+// set between the last GC or pause and now. We need to clear the
-uint n_workers =
+// incremental collection set and then start rebuilding it afresh
-AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(),
+// after this full GC.
-workers()->active_workers(),
+abandon_collection_set(g1_policy()->inc_cset_head());
-Threads::number_of_non_daemon_threads());
+g1_policy()->clear_incremental_cset();
-assert(UseDynamicNumberOfGCThreads ||
+g1_policy()->stop_incremental_cset_building();
-n_workers == workers()->total_workers(),
-"If not dynamic should be using all the  workers");
+tear_down_region_sets(false /* free_list_only */);
-workers()->set_active_workers(n_workers);
+g1_policy()->set_gcs_are_young(true);
-// Set parallel threads in the heap (_n_par_threads) only
-// before a parallel phase and always reset it to 0 after
+// See the comments in g1CollectedHeap.hpp and
-// the phase so that the number of parallel threads does
+// G1CollectedHeap::ref_processing_init() about
-// no get carried forward to a serial phase where there
+// how reference processing currently works in G1.
-// may be code that is "possibly_parallel".
-set_par_threads(n_workers);
+// Temporarily make discovery by the STW ref processor single threaded (non-MT).
+ReferenceProcessorMTDiscoveryMutator stw_rp_disc_ser(ref_processor_stw(), false);
-ParRebuildRSTask rebuild_rs_task(this);
-assert(check_heap_region_claim_values(
+// Temporarily clear the STW ref processor's _is_alive_non_header field.
-HeapRegion::InitialClaimValue), "sanity check");
+ReferenceProcessorIsAliveMutator stw_rp_is_alive_null(ref_processor_stw(), NULL);
-assert(UseDynamicNumberOfGCThreads ||
-workers()->active_workers() == workers()->total_workers(),
+ref_processor_stw()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
-"Unless dynamic should use total workers");
+ref_processor_stw()->setup_policy(do_clear_all_soft_refs);
-// Use the most recent number of  active workers
-assert(workers()->active_workers() > 0,
+// Do collection work
-"Active workers not properly set");
+{
-set_par_threads(workers()->active_workers());
+HandleMark hm;  // Discard invalid handles created during gc
-workers()->run_task(&rebuild_rs_task);
+G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs);
-set_par_threads(0);
+}
-assert(check_heap_region_claim_values(
-HeapRegion::RebuildRSClaimValue), "sanity check");
+assert(free_regions() == 0, "we should not have added any free regions");
-reset_heap_region_claim_values();
+rebuild_region_sets(false /* free_list_only */);
-} else {
-RebuildRSOutOfRegionClosure rebuild_rs(this);
+// Enqueue any discovered reference objects that have
-heap_region_iterate(&rebuild_rs);
+// not been removed from the discovered lists.
-}
+ref_processor_stw()->enqueue_discovered_references();
-if (G1Log::fine()) {
+COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
-print_size_transition(gclog_or_tty, g1h_prev_used, used(), capacity());
-}
+MemoryService::track_memory_usage();
-if (true) { // FIXME
+verify_after_gc();
-MetaspaceGC::compute_new_size();
-}
+assert(!ref_processor_stw()->discovery_enabled(), "Postcondition");
+ref_processor_stw()->verify_no_references_recorded();
-// Start a new incremental collection set for the next pause
-assert(g1_policy()->collection_set() == NULL, "must be");
+// Delete metaspaces for unloaded class loaders and clean up loader_data graph
-g1_policy()->start_incremental_cset_building();
+ClassLoaderDataGraph::purge();
-// Clear the _cset_fast_test bitmap in anticipation of adding
+// Note: since we've just done a full GC, concurrent
-// regions to the incremental collection set for the next
+// marking is no longer active. Therefore we need not
-// evacuation pause.
+// re-enable reference discovery for the CM ref processor.
-clear_cset_fast_test();
+// That will be done at the start of the next marking cycle.
+assert(!ref_processor_cm()->discovery_enabled(), "Postcondition");
-init_mutator_alloc_region();
+ref_processor_cm()->verify_no_references_recorded();
-double end = os::elapsedTime();
+reset_gc_time_stamp();
-g1_policy()->record_full_collection_end();
+// Since everything potentially moved, we will clear all remembered
+// sets, and clear all cards.  Later we will rebuild remebered
+// sets. We will also reset the GC time stamps of the regions.
+clear_rsets_post_compaction();
+check_gc_time_stamps();
+// Resize the heap if necessary.
+resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size);
+if (_hr_printer.is_active()) {
+// We should do this after we potentially resize the heap so
+// that all the COMMIT / UNCOMMIT events are generated before
+// the end GC event.
+print_hrs_post_compaction();
+_hr_printer.end_gc(true /* full */, (size_t) total_collections());
+}
+if (_cg1r->use_cache()) {
+_cg1r->clear_and_record_card_counts();
+_cg1r->clear_hot_cache();
+}
+// Rebuild remembered sets of all regions.
+if (G1CollectedHeap::use_parallel_gc_threads()) {
+uint n_workers =
+AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(),
+workers()->active_workers(),
+Threads::number_of_non_daemon_threads());
+assert(UseDynamicNumberOfGCThreads ||
+n_workers == workers()->total_workers(),
+"If not dynamic should be using all the  workers");
+workers()->set_active_workers(n_workers);
+// Set parallel threads in the heap (_n_par_threads) only
+// before a parallel phase and always reset it to 0 after
+// the phase so that the number of parallel threads does
+// no get carried forward to a serial phase where there
+// may be code that is "possibly_parallel".
+set_par_threads(n_workers);
+ParRebuildRSTask rebuild_rs_task(this);
+assert(check_heap_region_claim_values(
+HeapRegion::InitialClaimValue), "sanity check");
+assert(UseDynamicNumberOfGCThreads ||
+workers()->active_workers() == workers()->total_workers(),
+"Unless dynamic should use total workers");
+// Use the most recent number of  active workers
+assert(workers()->active_workers() > 0,
+"Active workers not properly set");
+set_par_threads(workers()->active_workers());
+workers()->run_task(&rebuild_rs_task);
+set_par_threads(0);
+assert(check_heap_region_claim_values(
+HeapRegion::RebuildRSClaimValue), "sanity check");
+reset_heap_region_claim_values();
+} else {
+RebuildRSOutOfRegionClosure rebuild_rs(this);
+heap_region_iterate(&rebuild_rs);
+}
+if (true) { // FIXME
+MetaspaceGC::compute_new_size();
+}
 #ifdef TRACESPINNING
 ParallelTaskTerminator::print_termination_counts();
 #endif
-gc_epilogue(true);
+// Discard all rset updates
+JavaThread::dirty_card_queue_set().abandon_logs();
-// Discard all rset updates
+assert(!G1DeferredRSUpdate
-JavaThread::dirty_card_queue_set().abandon_logs();
+|| (G1DeferredRSUpdate &&
-assert(!G1DeferredRSUpdate
+(dirty_card_queue_set().completed_buffers_num() == 0)), "Should not be any");
-|| (G1DeferredRSUpdate && (dirty_card_queue_set().completed_buffers_num() == 0)), "Should not be any");
+_young_list->reset_sampled_info();
-_young_list->reset_sampled_info();
+// At this point there should be no regions in the
-// At this point there should be no regions in the
+// entire heap tagged as young.
-// entire heap tagged as young.
+assert(check_young_list_empty(true /* check_heap */),
-assert( check_young_list_empty(true /* check_heap */),
+"young list should be empty at this point");
-"young list should be empty at this point");
+// Update the number of full collections that have been completed.
-// Update the number of full collections that have been completed.
+increment_old_marking_cycles_completed(false /* concurrent */);
-increment_old_marking_cycles_completed(false /* concurrent */);
+_hrs.verify_optional();
-_hrs.verify_optional();
+verify_region_sets_optional();
-verify_region_sets_optional();
+// Start a new incremental collection set for the next pause
+assert(g1_policy()->collection_set() == NULL, "must be");
+g1_policy()->start_incremental_cset_building();
+// Clear the _cset_fast_test bitmap in anticipation of adding
+// regions to the incremental collection set for the next
+// evacuation pause.
+clear_cset_fast_test();
+init_mutator_alloc_region();
+double end = os::elapsedTime();
+g1_policy()->record_full_collection_end();
+if (G1Log::fine()) {
+g1_policy()->print_heap_transition();
+}
+// We must call G1MonitoringSupport::update_sizes() in the same scoping level
+// as an active TraceMemoryManagerStats object (i.e. before the destructor for the
+// TraceMemoryManagerStats is called) so that the G1 memory pools are updated
+// before any GC notifications are raised.
+g1mm()->update_sizes();
+gc_epilogue(true);
+}
+if (G1Log::finer()) {
+g1_policy()->print_detailed_heap_transition();
+}
 print_heap_after_gc();
-// We must call G1MonitoringSupport::update_sizes() in the same scoping level
+post_full_gc_dump();
-// as an active TraceMemoryManagerStats object (i.e. before the destructor for the
+}
-// TraceMemoryManagerStats is called) so that the G1 memory pools are updated
-// before any GC notifications are raised.
-g1mm()->update_sizes();
-}
-post_full_gc_dump();
 return true;
 }
 void G1CollectedHeap::do_full_collection(bool clear_all_soft_refs) {
 // Preserving the old comment here if that helps the investigation:
 //
 // The elapsed time induced by the start time below deliberately elides
 // the possible verification above.
 double sample_start_time_sec = os::elapsedTime();
-size_t start_used_bytes = used();
 #if YOUNG_LIST_VERBOSE
 gclog_or_tty->print_cr("\nBefore recording pause start.\nYoung_list:");
 _young_list->print();
 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
 #endif // YOUNG_LIST_VERBOSE
-g1_policy()->record_collection_pause_start(sample_start_time_sec,
+g1_policy()->record_collection_pause_start(sample_start_time_sec);
-start_used_bytes);
 double scan_wait_start = os::elapsedTime();
 // We have to wait until the CM threads finish scanning the
 // root regions as it's the only way to ensure that all the
 // objects on them have been correctly scanned before we start

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 10098:71013d764f6e