8034246: remove CMS and ParNew adaptive size policy code
Reviewed-by: tschatzl, jwilhelm, mgerdin
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp Thu Jun 26 16:01:07 2014 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1354 +0,0 @@
-/*
- * Copyright (c) 2004, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
-#include "gc_implementation/shared/gcStats.hpp"
-#include "memory/defNewGeneration.hpp"
-#include "memory/genCollectedHeap.hpp"
-#include "runtime/thread.hpp"
-#ifdef TARGET_OS_FAMILY_linux
-# include "os_linux.inline.hpp"
-#endif
-#ifdef TARGET_OS_FAMILY_solaris
-# include "os_solaris.inline.hpp"
-#endif
-#ifdef TARGET_OS_FAMILY_windows
-# include "os_windows.inline.hpp"
-#endif
-#ifdef TARGET_OS_FAMILY_aix
-# include "os_aix.inline.hpp"
-#endif
-#ifdef TARGET_OS_FAMILY_bsd
-# include "os_bsd.inline.hpp"
-#endif
-elapsedTimer CMSAdaptiveSizePolicy::_concurrent_timer;
-elapsedTimer CMSAdaptiveSizePolicy::_STW_timer;
-
-// Defined if the granularity of the time measurements is potentially too large.
-#define CLOCK_GRANULARITY_TOO_LARGE
-
-CMSAdaptiveSizePolicy::CMSAdaptiveSizePolicy(size_t init_eden_size,
- size_t init_promo_size,
- size_t init_survivor_size,
- double max_gc_minor_pause_sec,
- double max_gc_pause_sec,
- uint gc_cost_ratio) :
- AdaptiveSizePolicy(init_eden_size,
- init_promo_size,
- init_survivor_size,
- max_gc_pause_sec,
- gc_cost_ratio) {
-
- clear_internal_time_intervals();
-
- _processor_count = os::active_processor_count();
-
- if (CMSConcurrentMTEnabled && (ConcGCThreads > 1)) {
- assert(_processor_count > 0, "Processor count is suspect");
- _concurrent_processor_count = MIN2((uint) ConcGCThreads,
- (uint) _processor_count);
- } else {
- _concurrent_processor_count = 1;
- }
-
- _avg_concurrent_time = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_concurrent_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_concurrent_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
-
- _avg_initial_pause = new AdaptivePaddedAverage(AdaptiveTimeWeight,
- PausePadding);
- _avg_remark_pause = new AdaptivePaddedAverage(AdaptiveTimeWeight,
- PausePadding);
-
- _avg_cms_STW_time = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_cms_STW_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
-
- _avg_cms_free = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_cms_free_at_sweep = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_cms_promo = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
-
- // Mark-sweep-compact
- _avg_msc_pause = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_msc_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_msc_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
-
- // Mark-sweep
- _avg_ms_pause = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_ms_interval = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
- _avg_ms_gc_cost = new AdaptiveWeightedAverage(AdaptiveTimeWeight);
-
- // Variables that estimate pause times as a function of generation
- // size.
- _remark_pause_old_estimator =
- new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
- _initial_pause_old_estimator =
- new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
- _remark_pause_young_estimator =
- new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
- _initial_pause_young_estimator =
- new LinearLeastSquareFit(AdaptiveSizePolicyWeight);
-
- // Alignment comes from that used in ReservedSpace.
- _generation_alignment = os::vm_allocation_granularity();
-
- // Start the concurrent timer here so that the first
- // concurrent_phases_begin() measures a finite mutator
- // time. A finite mutator time is used to determine
- // if a concurrent collection has been started. If this
- // proves to be a problem, use some explicit flag to
- // signal that a concurrent collection has been started.
- _concurrent_timer.start();
- _STW_timer.start();
-}
-
-double CMSAdaptiveSizePolicy::concurrent_processor_fraction() {
- // For now assume no other daemon threads are taking alway
- // cpu's from the application.
- return ((double) _concurrent_processor_count / (double) _processor_count);
-}
-
-double CMSAdaptiveSizePolicy::concurrent_collection_cost(
- double interval_in_seconds) {
- // When the precleaning and sweeping phases use multiple
- // threads, change one_processor_fraction to
- // concurrent_processor_fraction().
- double one_processor_fraction = 1.0 / ((double) processor_count());
- double concurrent_cost =
- collection_cost(_latest_cms_concurrent_marking_time_secs,
- interval_in_seconds) * concurrent_processor_fraction() +
- collection_cost(_latest_cms_concurrent_precleaning_time_secs,
- interval_in_seconds) * one_processor_fraction +
- collection_cost(_latest_cms_concurrent_sweeping_time_secs,
- interval_in_seconds) * one_processor_fraction;
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "\nCMSAdaptiveSizePolicy::scaled_concurrent_collection_cost(%f) "
- "_latest_cms_concurrent_marking_cost %f "
- "_latest_cms_concurrent_precleaning_cost %f "
- "_latest_cms_concurrent_sweeping_cost %f "
- "concurrent_processor_fraction %f "
- "concurrent_cost %f ",
- interval_in_seconds,
- collection_cost(_latest_cms_concurrent_marking_time_secs,
- interval_in_seconds),
- collection_cost(_latest_cms_concurrent_precleaning_time_secs,
- interval_in_seconds),
- collection_cost(_latest_cms_concurrent_sweeping_time_secs,
- interval_in_seconds),
- concurrent_processor_fraction(),
- concurrent_cost);
- }
- return concurrent_cost;
-}
-
-double CMSAdaptiveSizePolicy::concurrent_collection_time() {
- double latest_cms_sum_concurrent_phases_time_secs =
- _latest_cms_concurrent_marking_time_secs +
- _latest_cms_concurrent_precleaning_time_secs +
- _latest_cms_concurrent_sweeping_time_secs;
- return latest_cms_sum_concurrent_phases_time_secs;
-}
-
-double CMSAdaptiveSizePolicy::scaled_concurrent_collection_time() {
- // When the precleaning and sweeping phases use multiple
- // threads, change one_processor_fraction to
- // concurrent_processor_fraction().
- double one_processor_fraction = 1.0 / ((double) processor_count());
- double latest_cms_sum_concurrent_phases_time_secs =
- _latest_cms_concurrent_marking_time_secs * concurrent_processor_fraction() +
- _latest_cms_concurrent_precleaning_time_secs * one_processor_fraction +
- _latest_cms_concurrent_sweeping_time_secs * one_processor_fraction ;
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "\nCMSAdaptiveSizePolicy::scaled_concurrent_collection_time "
- "_latest_cms_concurrent_marking_time_secs %f "
- "_latest_cms_concurrent_precleaning_time_secs %f "
- "_latest_cms_concurrent_sweeping_time_secs %f "
- "concurrent_processor_fraction %f "
- "latest_cms_sum_concurrent_phases_time_secs %f ",
- _latest_cms_concurrent_marking_time_secs,
- _latest_cms_concurrent_precleaning_time_secs,
- _latest_cms_concurrent_sweeping_time_secs,
- concurrent_processor_fraction(),
- latest_cms_sum_concurrent_phases_time_secs);
- }
- return latest_cms_sum_concurrent_phases_time_secs;
-}
-
-void CMSAdaptiveSizePolicy::update_minor_pause_old_estimator(
- double minor_pause_in_ms) {
- // Get the equivalent of the free space
- // that is available for promotions in the CMS generation
- // and use that to update _minor_pause_old_estimator
-
- // Don't implement this until it is needed. A warning is
- // printed if _minor_pause_old_estimator is used.
-}
-
-void CMSAdaptiveSizePolicy::concurrent_marking_begin() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print(" ");
- gclog_or_tty->stamp();
- gclog_or_tty->print(": concurrent_marking_begin ");
- }
- // Update the interval time
- _concurrent_timer.stop();
- _latest_cms_collection_end_to_collection_start_secs = _concurrent_timer.seconds();
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_marking_begin: "
- "mutator time %f", _latest_cms_collection_end_to_collection_start_secs);
- }
- _concurrent_timer.reset();
- _concurrent_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::concurrent_marking_end() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->stamp();
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_marking_end()");
- }
-
- _concurrent_timer.stop();
- _latest_cms_concurrent_marking_time_secs = _concurrent_timer.seconds();
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("\n CMSAdaptiveSizePolicy::concurrent_marking_end"
- ":concurrent marking time (s) %f",
- _latest_cms_concurrent_marking_time_secs);
- }
-}
-
-void CMSAdaptiveSizePolicy::concurrent_precleaning_begin() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->stamp();
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::concurrent_precleaning_begin()");
- }
- _concurrent_timer.reset();
- _concurrent_timer.start();
-}
-
-
-void CMSAdaptiveSizePolicy::concurrent_precleaning_end() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->stamp();
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_precleaning_end()");
- }
-
- _concurrent_timer.stop();
- // May be set again by a second call during the same collection.
- _latest_cms_concurrent_precleaning_time_secs = _concurrent_timer.seconds();
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("\n CMSAdaptiveSizePolicy::concurrent_precleaning_end"
- ":concurrent precleaning time (s) %f",
- _latest_cms_concurrent_precleaning_time_secs);
- }
-}
-
-void CMSAdaptiveSizePolicy::concurrent_sweeping_begin() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->stamp();
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::concurrent_sweeping_begin()");
- }
- _concurrent_timer.reset();
- _concurrent_timer.start();
-}
-
-
-void CMSAdaptiveSizePolicy::concurrent_sweeping_end() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->stamp();
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_sweeping_end()");
- }
-
- _concurrent_timer.stop();
- _latest_cms_concurrent_sweeping_time_secs = _concurrent_timer.seconds();
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("\n CMSAdaptiveSizePolicy::concurrent_sweeping_end"
- ":concurrent sweeping time (s) %f",
- _latest_cms_concurrent_sweeping_time_secs);
- }
-}
-
-void CMSAdaptiveSizePolicy::concurrent_phases_end(GCCause::Cause gc_cause,
- size_t cur_eden,
- size_t cur_promo) {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print(" ");
- gclog_or_tty->stamp();
- gclog_or_tty->print(": concurrent_phases_end ");
- }
-
- // Update the concurrent timer
- _concurrent_timer.stop();
-
- if (gc_cause != GCCause::_java_lang_system_gc ||
- UseAdaptiveSizePolicyWithSystemGC) {
-
- avg_cms_free()->sample(cur_promo);
- double latest_cms_sum_concurrent_phases_time_secs =
- concurrent_collection_time();
-
- _avg_concurrent_time->sample(latest_cms_sum_concurrent_phases_time_secs);
-
- // Cost of collection (unit-less)
-
- // Total interval for collection. May not be valid. Tests
- // below determine whether to use this.
- //
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("\nCMSAdaptiveSizePolicy::concurrent_phases_end \n"
- "_latest_cms_reset_end_to_initial_mark_start_secs %f \n"
- "_latest_cms_initial_mark_start_to_end_time_secs %f \n"
- "_latest_cms_remark_start_to_end_time_secs %f \n"
- "_latest_cms_concurrent_marking_time_secs %f \n"
- "_latest_cms_concurrent_precleaning_time_secs %f \n"
- "_latest_cms_concurrent_sweeping_time_secs %f \n"
- "latest_cms_sum_concurrent_phases_time_secs %f \n"
- "_latest_cms_collection_end_to_collection_start_secs %f \n"
- "concurrent_processor_fraction %f",
- _latest_cms_reset_end_to_initial_mark_start_secs,
- _latest_cms_initial_mark_start_to_end_time_secs,
- _latest_cms_remark_start_to_end_time_secs,
- _latest_cms_concurrent_marking_time_secs,
- _latest_cms_concurrent_precleaning_time_secs,
- _latest_cms_concurrent_sweeping_time_secs,
- latest_cms_sum_concurrent_phases_time_secs,
- _latest_cms_collection_end_to_collection_start_secs,
- concurrent_processor_fraction());
- }
- double interval_in_seconds =
- _latest_cms_initial_mark_start_to_end_time_secs +
- _latest_cms_remark_start_to_end_time_secs +
- latest_cms_sum_concurrent_phases_time_secs +
- _latest_cms_collection_end_to_collection_start_secs;
- assert(interval_in_seconds >= 0.0,
- "Bad interval between cms collections");
-
- // Sample for performance counter
- avg_concurrent_interval()->sample(interval_in_seconds);
-
- // STW costs (initial and remark pauses)
- // Cost of collection (unit-less)
- assert(_latest_cms_initial_mark_start_to_end_time_secs >= 0.0,
- "Bad initial mark pause");
- assert(_latest_cms_remark_start_to_end_time_secs >= 0.0,
- "Bad remark pause");
- double STW_time_in_seconds =
- _latest_cms_initial_mark_start_to_end_time_secs +
- _latest_cms_remark_start_to_end_time_secs;
- double STW_collection_cost = 0.0;
- if (interval_in_seconds > 0.0) {
- // cost for the STW phases of the concurrent collection.
- STW_collection_cost = STW_time_in_seconds / interval_in_seconds;
- avg_cms_STW_gc_cost()->sample(STW_collection_cost);
- }
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("cmsAdaptiveSizePolicy::STW_collection_end: "
- "STW gc cost: %f average: %f", STW_collection_cost,
- avg_cms_STW_gc_cost()->average());
- gclog_or_tty->print_cr(" STW pause: %f (ms) STW period %f (ms)",
- (double) STW_time_in_seconds * MILLIUNITS,
- (double) interval_in_seconds * MILLIUNITS);
- }
-
- double concurrent_cost = 0.0;
- if (latest_cms_sum_concurrent_phases_time_secs > 0.0) {
- concurrent_cost = concurrent_collection_cost(interval_in_seconds);
-
- avg_concurrent_gc_cost()->sample(concurrent_cost);
- // Average this ms cost into all the other types gc costs
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("cmsAdaptiveSizePolicy::concurrent_phases_end: "
- "concurrent gc cost: %f average: %f",
- concurrent_cost,
- _avg_concurrent_gc_cost->average());
- gclog_or_tty->print_cr(" concurrent time: %f (ms) cms period %f (ms)"
- " processor fraction: %f",
- latest_cms_sum_concurrent_phases_time_secs * MILLIUNITS,
- interval_in_seconds * MILLIUNITS,
- concurrent_processor_fraction());
- }
- }
- double total_collection_cost = STW_collection_cost + concurrent_cost;
- avg_major_gc_cost()->sample(total_collection_cost);
-
- // Gather information for estimating future behavior
- double initial_pause_in_ms = _latest_cms_initial_mark_start_to_end_time_secs * MILLIUNITS;
- double remark_pause_in_ms = _latest_cms_remark_start_to_end_time_secs * MILLIUNITS;
-
- double cur_promo_size_in_mbytes = ((double)cur_promo)/((double)M);
- initial_pause_old_estimator()->update(cur_promo_size_in_mbytes,
- initial_pause_in_ms);
- remark_pause_old_estimator()->update(cur_promo_size_in_mbytes,
- remark_pause_in_ms);
- major_collection_estimator()->update(cur_promo_size_in_mbytes,
- total_collection_cost);
-
- // This estimate uses the average eden size. It could also
- // have used the latest eden size. Which is better?
- double cur_eden_size_in_mbytes = ((double)cur_eden)/((double) M);
- initial_pause_young_estimator()->update(cur_eden_size_in_mbytes,
- initial_pause_in_ms);
- remark_pause_young_estimator()->update(cur_eden_size_in_mbytes,
- remark_pause_in_ms);
- }
-
- clear_internal_time_intervals();
-
- set_first_after_collection();
-
- // The concurrent phases keeps track of it's own mutator interval
- // with this timer. This allows the stop-the-world phase to
- // be included in the mutator time so that the stop-the-world time
- // is not double counted. Reset and start it.
- _concurrent_timer.reset();
- _concurrent_timer.start();
-
- // The mutator time between STW phases does not include the
- // concurrent collection time.
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::checkpoint_roots_initial_begin() {
- // Update the interval time
- _STW_timer.stop();
- _latest_cms_reset_end_to_initial_mark_start_secs = _STW_timer.seconds();
- // Reset for the initial mark
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::checkpoint_roots_initial_end(
- GCCause::Cause gc_cause) {
- _STW_timer.stop();
-
- if (gc_cause != GCCause::_java_lang_system_gc ||
- UseAdaptiveSizePolicyWithSystemGC) {
- _latest_cms_initial_mark_start_to_end_time_secs = _STW_timer.seconds();
- avg_initial_pause()->sample(_latest_cms_initial_mark_start_to_end_time_secs);
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print(
- "cmsAdaptiveSizePolicy::checkpoint_roots_initial_end: "
- "initial pause: %f ", _latest_cms_initial_mark_start_to_end_time_secs);
- }
- }
-
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::checkpoint_roots_final_begin() {
- _STW_timer.stop();
- _latest_cms_initial_mark_end_to_remark_start_secs = _STW_timer.seconds();
- // Start accumulating time for the remark in the STW timer.
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::checkpoint_roots_final_end(
- GCCause::Cause gc_cause) {
- _STW_timer.stop();
- if (gc_cause != GCCause::_java_lang_system_gc ||
- UseAdaptiveSizePolicyWithSystemGC) {
- // Total initial mark pause + remark pause.
- _latest_cms_remark_start_to_end_time_secs = _STW_timer.seconds();
- double STW_time_in_seconds = _latest_cms_initial_mark_start_to_end_time_secs +
- _latest_cms_remark_start_to_end_time_secs;
- double STW_time_in_ms = STW_time_in_seconds * MILLIUNITS;
-
- avg_remark_pause()->sample(_latest_cms_remark_start_to_end_time_secs);
-
- // Sample total for initial mark + remark
- avg_cms_STW_time()->sample(STW_time_in_seconds);
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("cmsAdaptiveSizePolicy::checkpoint_roots_final_end: "
- "remark pause: %f", _latest_cms_remark_start_to_end_time_secs);
- }
-
- }
- // Don't start the STW times here because the concurrent
- // sweep and reset has not happened.
- // Keep the old comment above in case I don't understand
- // what is going on but now
- // Start the STW timer because it is used by ms_collection_begin()
- // and ms_collection_end() to get the sweep time if a MS is being
- // done in the foreground.
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::msc_collection_begin() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print(" ");
- gclog_or_tty->stamp();
- gclog_or_tty->print(": msc_collection_begin ");
- }
- _STW_timer.stop();
- _latest_cms_msc_end_to_msc_start_time_secs = _STW_timer.seconds();
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::msc_collection_begin: "
- "mutator time %f",
- _latest_cms_msc_end_to_msc_start_time_secs);
- }
- avg_msc_interval()->sample(_latest_cms_msc_end_to_msc_start_time_secs);
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::msc_collection_end(GCCause::Cause gc_cause) {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print(" ");
- gclog_or_tty->stamp();
- gclog_or_tty->print(": msc_collection_end ");
- }
- _STW_timer.stop();
- if (gc_cause != GCCause::_java_lang_system_gc ||
- UseAdaptiveSizePolicyWithSystemGC) {
- double msc_pause_in_seconds = _STW_timer.seconds();
- if ((_latest_cms_msc_end_to_msc_start_time_secs > 0.0) &&
- (msc_pause_in_seconds > 0.0)) {
- avg_msc_pause()->sample(msc_pause_in_seconds);
- double mutator_time_in_seconds = 0.0;
- if (_latest_cms_collection_end_to_collection_start_secs == 0.0) {
- // This assertion may fail because of time stamp granularity.
- // Comment it out and investigate it at a later time. The large
- // time stamp granularity occurs on some older linux systems.
-#ifndef CLOCK_GRANULARITY_TOO_LARGE
- assert((_latest_cms_concurrent_marking_time_secs == 0.0) &&
- (_latest_cms_concurrent_precleaning_time_secs == 0.0) &&
- (_latest_cms_concurrent_sweeping_time_secs == 0.0),
- "There should not be any concurrent time");
-#endif
- // A concurrent collection did not start. Mutator time
- // between collections comes from the STW MSC timer.
- mutator_time_in_seconds = _latest_cms_msc_end_to_msc_start_time_secs;
- } else {
- // The concurrent collection did start so count the mutator
- // time to the start of the concurrent collection. In this
- // case the _latest_cms_msc_end_to_msc_start_time_secs measures
- // the time between the initial mark or remark and the
- // start of the MSC. That has no real meaning.
- mutator_time_in_seconds = _latest_cms_collection_end_to_collection_start_secs;
- }
-
- double latest_cms_sum_concurrent_phases_time_secs =
- concurrent_collection_time();
- double interval_in_seconds =
- mutator_time_in_seconds +
- _latest_cms_initial_mark_start_to_end_time_secs +
- _latest_cms_remark_start_to_end_time_secs +
- latest_cms_sum_concurrent_phases_time_secs +
- msc_pause_in_seconds;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" interval_in_seconds %f \n"
- " mutator_time_in_seconds %f \n"
- " _latest_cms_initial_mark_start_to_end_time_secs %f\n"
- " _latest_cms_remark_start_to_end_time_secs %f\n"
- " latest_cms_sum_concurrent_phases_time_secs %f\n"
- " msc_pause_in_seconds %f\n",
- interval_in_seconds,
- mutator_time_in_seconds,
- _latest_cms_initial_mark_start_to_end_time_secs,
- _latest_cms_remark_start_to_end_time_secs,
- latest_cms_sum_concurrent_phases_time_secs,
- msc_pause_in_seconds);
- }
-
- // The concurrent cost is wasted cost but it should be
- // included.
- double concurrent_cost = concurrent_collection_cost(interval_in_seconds);
-
- // Initial mark and remark, also wasted.
- double STW_time_in_seconds = _latest_cms_initial_mark_start_to_end_time_secs +
- _latest_cms_remark_start_to_end_time_secs;
- double STW_collection_cost =
- collection_cost(STW_time_in_seconds, interval_in_seconds) +
- concurrent_cost;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" msc_collection_end:\n"
- "_latest_cms_collection_end_to_collection_start_secs %f\n"
- "_latest_cms_msc_end_to_msc_start_time_secs %f\n"
- "_latest_cms_initial_mark_start_to_end_time_secs %f\n"
- "_latest_cms_remark_start_to_end_time_secs %f\n"
- "latest_cms_sum_concurrent_phases_time_secs %f\n",
- _latest_cms_collection_end_to_collection_start_secs,
- _latest_cms_msc_end_to_msc_start_time_secs,
- _latest_cms_initial_mark_start_to_end_time_secs,
- _latest_cms_remark_start_to_end_time_secs,
- latest_cms_sum_concurrent_phases_time_secs);
-
- gclog_or_tty->print_cr(" msc_collection_end: \n"
- "latest_cms_sum_concurrent_phases_time_secs %f\n"
- "STW_time_in_seconds %f\n"
- "msc_pause_in_seconds %f\n",
- latest_cms_sum_concurrent_phases_time_secs,
- STW_time_in_seconds,
- msc_pause_in_seconds);
- }
-
- double cost = concurrent_cost + STW_collection_cost +
- collection_cost(msc_pause_in_seconds, interval_in_seconds);
-
- _avg_msc_gc_cost->sample(cost);
-
- // Average this ms cost into all the other types gc costs
- avg_major_gc_cost()->sample(cost);
-
- // Sample for performance counter
- _avg_msc_interval->sample(interval_in_seconds);
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("cmsAdaptiveSizePolicy::msc_collection_end: "
- "MSC gc cost: %f average: %f", cost,
- _avg_msc_gc_cost->average());
-
- double msc_pause_in_ms = msc_pause_in_seconds * MILLIUNITS;
- gclog_or_tty->print_cr(" MSC pause: %f (ms) MSC period %f (ms)",
- msc_pause_in_ms, (double) interval_in_seconds * MILLIUNITS);
- }
- }
- }
-
- clear_internal_time_intervals();
-
- // Can this call be put into the epilogue?
- set_first_after_collection();
-
- // The concurrent phases keeps track of it's own mutator interval
- // with this timer. This allows the stop-the-world phase to
- // be included in the mutator time so that the stop-the-world time
- // is not double counted. Reset and start it.
- _concurrent_timer.stop();
- _concurrent_timer.reset();
- _concurrent_timer.start();
-
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::ms_collection_begin() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print(" ");
- gclog_or_tty->stamp();
- gclog_or_tty->print(": ms_collection_begin ");
- }
- _STW_timer.stop();
- _latest_cms_ms_end_to_ms_start = _STW_timer.seconds();
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::ms_collection_begin: "
- "mutator time %f",
- _latest_cms_ms_end_to_ms_start);
- }
- avg_ms_interval()->sample(_STW_timer.seconds());
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::ms_collection_end(GCCause::Cause gc_cause) {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print(" ");
- gclog_or_tty->stamp();
- gclog_or_tty->print(": ms_collection_end ");
- }
- _STW_timer.stop();
- if (gc_cause != GCCause::_java_lang_system_gc ||
- UseAdaptiveSizePolicyWithSystemGC) {
- // The MS collection is a foreground collection that does all
- // the parts of a mostly concurrent collection.
- //
- // For this collection include the cost of the
- // initial mark
- // remark
- // all concurrent time (scaled down by the
- // concurrent_processor_fraction). Some
- // may be zero if the baton was passed before
- // it was reached.
- // concurrent marking
- // sweeping
- // resetting
- // STW after baton was passed (STW_in_foreground_in_seconds)
- double STW_in_foreground_in_seconds = _STW_timer.seconds();
-
- double latest_cms_sum_concurrent_phases_time_secs =
- concurrent_collection_time();
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("\nCMSAdaptiveSizePolicy::ms_collection_end "
- "STW_in_foreground_in_seconds %f "
- "_latest_cms_initial_mark_start_to_end_time_secs %f "
- "_latest_cms_remark_start_to_end_time_secs %f "
- "latest_cms_sum_concurrent_phases_time_secs %f "
- "_latest_cms_ms_marking_start_to_end_time_secs %f "
- "_latest_cms_ms_end_to_ms_start %f",
- STW_in_foreground_in_seconds,
- _latest_cms_initial_mark_start_to_end_time_secs,
- _latest_cms_remark_start_to_end_time_secs,
- latest_cms_sum_concurrent_phases_time_secs,
- _latest_cms_ms_marking_start_to_end_time_secs,
- _latest_cms_ms_end_to_ms_start);
- }
-
- double STW_marking_in_seconds = _latest_cms_initial_mark_start_to_end_time_secs +
- _latest_cms_remark_start_to_end_time_secs;
-#ifndef CLOCK_GRANULARITY_TOO_LARGE
- assert(_latest_cms_ms_marking_start_to_end_time_secs == 0.0 ||
- latest_cms_sum_concurrent_phases_time_secs == 0.0,
- "marking done twice?");
-#endif
- double ms_time_in_seconds = STW_marking_in_seconds +
- STW_in_foreground_in_seconds +
- _latest_cms_ms_marking_start_to_end_time_secs +
- scaled_concurrent_collection_time();
- avg_ms_pause()->sample(ms_time_in_seconds);
- // Use the STW costs from the initial mark and remark plus
- // the cost of the concurrent phase to calculate a
- // collection cost.
- double cost = 0.0;
- if ((_latest_cms_ms_end_to_ms_start > 0.0) &&
- (ms_time_in_seconds > 0.0)) {
- double interval_in_seconds =
- _latest_cms_ms_end_to_ms_start + ms_time_in_seconds;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("\n ms_time_in_seconds %f "
- "latest_cms_sum_concurrent_phases_time_secs %f "
- "interval_in_seconds %f",
- ms_time_in_seconds,
- latest_cms_sum_concurrent_phases_time_secs,
- interval_in_seconds);
- }
-
- cost = collection_cost(ms_time_in_seconds, interval_in_seconds);
-
- _avg_ms_gc_cost->sample(cost);
- // Average this ms cost into all the other types gc costs
- avg_major_gc_cost()->sample(cost);
-
- // Sample for performance counter
- _avg_ms_interval->sample(interval_in_seconds);
- }
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print("cmsAdaptiveSizePolicy::ms_collection_end: "
- "MS gc cost: %f average: %f", cost, _avg_ms_gc_cost->average());
-
- double ms_time_in_ms = ms_time_in_seconds * MILLIUNITS;
- gclog_or_tty->print_cr(" MS pause: %f (ms) MS period %f (ms)",
- ms_time_in_ms,
- _latest_cms_ms_end_to_ms_start * MILLIUNITS);
- }
- }
-
- // Consider putting this code (here to end) into a
- // method for convenience.
- clear_internal_time_intervals();
-
- set_first_after_collection();
-
- // The concurrent phases keeps track of it's own mutator interval
- // with this timer. This allows the stop-the-world phase to
- // be included in the mutator time so that the stop-the-world time
- // is not double counted. Reset and start it.
- _concurrent_timer.stop();
- _concurrent_timer.reset();
- _concurrent_timer.start();
-
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::clear_internal_time_intervals() {
- _latest_cms_reset_end_to_initial_mark_start_secs = 0.0;
- _latest_cms_initial_mark_end_to_remark_start_secs = 0.0;
- _latest_cms_collection_end_to_collection_start_secs = 0.0;
- _latest_cms_concurrent_marking_time_secs = 0.0;
- _latest_cms_concurrent_precleaning_time_secs = 0.0;
- _latest_cms_concurrent_sweeping_time_secs = 0.0;
- _latest_cms_msc_end_to_msc_start_time_secs = 0.0;
- _latest_cms_ms_end_to_ms_start = 0.0;
- _latest_cms_remark_start_to_end_time_secs = 0.0;
- _latest_cms_initial_mark_start_to_end_time_secs = 0.0;
- _latest_cms_ms_marking_start_to_end_time_secs = 0.0;
-}
-
-void CMSAdaptiveSizePolicy::clear_generation_free_space_flags() {
- AdaptiveSizePolicy::clear_generation_free_space_flags();
-
- set_change_young_gen_for_maj_pauses(0);
-}
-
-void CMSAdaptiveSizePolicy::concurrent_phases_resume() {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->stamp();
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::concurrent_phases_resume()");
- }
- _concurrent_timer.start();
-}
-
-double CMSAdaptiveSizePolicy::time_since_major_gc() const {
- _concurrent_timer.stop();
- double time_since_cms_gc = _concurrent_timer.seconds();
- _concurrent_timer.start();
- _STW_timer.stop();
- double time_since_STW_gc = _STW_timer.seconds();
- _STW_timer.start();
-
- return MIN2(time_since_cms_gc, time_since_STW_gc);
-}
-
-double CMSAdaptiveSizePolicy::major_gc_interval_average_for_decay() const {
- double cms_interval = _avg_concurrent_interval->average();
- double msc_interval = _avg_msc_interval->average();
- double ms_interval = _avg_ms_interval->average();
-
- return MAX3(cms_interval, msc_interval, ms_interval);
-}
-
-double CMSAdaptiveSizePolicy::cms_gc_cost() const {
- return avg_major_gc_cost()->average();
-}
-
-void CMSAdaptiveSizePolicy::ms_collection_marking_begin() {
- _STW_timer.stop();
- // Start accumulating time for the marking in the STW timer.
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-void CMSAdaptiveSizePolicy::ms_collection_marking_end(
- GCCause::Cause gc_cause) {
- _STW_timer.stop();
- if (gc_cause != GCCause::_java_lang_system_gc ||
- UseAdaptiveSizePolicyWithSystemGC) {
- _latest_cms_ms_marking_start_to_end_time_secs = _STW_timer.seconds();
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("CMSAdaptiveSizePolicy::"
- "msc_collection_marking_end: mutator time %f",
- _latest_cms_ms_marking_start_to_end_time_secs);
- }
- }
- _STW_timer.reset();
- _STW_timer.start();
-}
-
-double CMSAdaptiveSizePolicy::gc_cost() const {
- double cms_gen_cost = cms_gc_cost();
- double result = MIN2(1.0, minor_gc_cost() + cms_gen_cost);
- assert(result >= 0.0, "Both minor and major costs are non-negative");
- return result;
-}
-
-// Cost of collection (unit-less)
-double CMSAdaptiveSizePolicy::collection_cost(double pause_in_seconds,
- double interval_in_seconds) {
- // Cost of collection (unit-less)
- double cost = 0.0;
- if ((interval_in_seconds > 0.0) &&
- (pause_in_seconds > 0.0)) {
- cost =
- pause_in_seconds / interval_in_seconds;
- }
- return cost;
-}
-
-size_t CMSAdaptiveSizePolicy::adjust_eden_for_pause_time(size_t cur_eden) {
- size_t change = 0;
- size_t desired_eden = cur_eden;
-
- // reduce eden size
- change = eden_decrement_aligned_down(cur_eden);
- desired_eden = cur_eden - change;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::adjust_eden_for_pause_time "
- "adjusting eden for pause time. "
- " starting eden size " SIZE_FORMAT
- " reduced eden size " SIZE_FORMAT
- " eden delta " SIZE_FORMAT,
- cur_eden, desired_eden, change);
- }
-
- return desired_eden;
-}
-
-size_t CMSAdaptiveSizePolicy::adjust_eden_for_throughput(size_t cur_eden) {
-
- size_t desired_eden = cur_eden;
-
- set_change_young_gen_for_throughput(increase_young_gen_for_througput_true);
-
- size_t change = eden_increment_aligned_up(cur_eden);
- size_t scaled_change = scale_by_gen_gc_cost(change, minor_gc_cost());
-
- if (cur_eden + scaled_change > cur_eden) {
- desired_eden = cur_eden + scaled_change;
- }
-
- _young_gen_change_for_minor_throughput++;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::adjust_eden_for_throughput "
- "adjusting eden for throughput. "
- " starting eden size " SIZE_FORMAT
- " increased eden size " SIZE_FORMAT
- " eden delta " SIZE_FORMAT,
- cur_eden, desired_eden, scaled_change);
- }
-
- return desired_eden;
-}
-
-size_t CMSAdaptiveSizePolicy::adjust_eden_for_footprint(size_t cur_eden) {
-
- set_decrease_for_footprint(decrease_young_gen_for_footprint_true);
-
- size_t change = eden_decrement(cur_eden);
- size_t desired_eden_size = cur_eden - change;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::adjust_eden_for_footprint "
- "adjusting eden for footprint. "
- " starting eden size " SIZE_FORMAT
- " reduced eden size " SIZE_FORMAT
- " eden delta " SIZE_FORMAT,
- cur_eden, desired_eden_size, change);
- }
- return desired_eden_size;
-}
-
-// The eden and promo versions should be combined if possible.
-// They are the same except that the sizes of the decrement
-// and increment are different for eden and promo.
-size_t CMSAdaptiveSizePolicy::eden_decrement_aligned_down(size_t cur_eden) {
- size_t delta = eden_decrement(cur_eden);
- return align_size_down(delta, generation_alignment());
-}
-
-size_t CMSAdaptiveSizePolicy::eden_increment_aligned_up(size_t cur_eden) {
- size_t delta = eden_increment(cur_eden);
- return align_size_up(delta, generation_alignment());
-}
-
-size_t CMSAdaptiveSizePolicy::promo_decrement_aligned_down(size_t cur_promo) {
- size_t delta = promo_decrement(cur_promo);
- return align_size_down(delta, generation_alignment());
-}
-
-size_t CMSAdaptiveSizePolicy::promo_increment_aligned_up(size_t cur_promo) {
- size_t delta = promo_increment(cur_promo);
- return align_size_up(delta, generation_alignment());
-}
-
-
-void CMSAdaptiveSizePolicy::compute_eden_space_size(size_t cur_eden,
- size_t max_eden_size)
-{
- size_t desired_eden_size = cur_eden;
- size_t eden_limit = max_eden_size;
-
- // Printout input
- if (PrintGC && PrintAdaptiveSizePolicy) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::compute_eden_space_size: "
- "cur_eden " SIZE_FORMAT,
- cur_eden);
- }
-
- // Used for diagnostics
- clear_generation_free_space_flags();
-
- if (_avg_minor_pause->padded_average() > gc_pause_goal_sec()) {
- if (minor_pause_young_estimator()->decrement_will_decrease()) {
- // If the minor pause is too long, shrink the young gen.
- set_change_young_gen_for_min_pauses(
- decrease_young_gen_for_min_pauses_true);
- desired_eden_size = adjust_eden_for_pause_time(desired_eden_size);
- }
- } else if ((avg_remark_pause()->padded_average() > gc_pause_goal_sec()) ||
- (avg_initial_pause()->padded_average() > gc_pause_goal_sec())) {
- // The remark or initial pauses are not meeting the goal. Should
- // the generation be shrunk?
- if (get_and_clear_first_after_collection() &&
- ((avg_remark_pause()->padded_average() > gc_pause_goal_sec() &&
- remark_pause_young_estimator()->decrement_will_decrease()) ||
- (avg_initial_pause()->padded_average() > gc_pause_goal_sec() &&
- initial_pause_young_estimator()->decrement_will_decrease()))) {
-
- set_change_young_gen_for_maj_pauses(
- decrease_young_gen_for_maj_pauses_true);
-
- // If the remark or initial pause is too long and this is the
- // first young gen collection after a cms collection, shrink
- // the young gen.
- desired_eden_size = adjust_eden_for_pause_time(desired_eden_size);
- }
- // If not the first young gen collection after a cms collection,
- // don't do anything. In this case an adjustment has already
- // been made and the results of the adjustment has not yet been
- // measured.
- } else if ((minor_gc_cost() >= 0.0) &&
- (adjusted_mutator_cost() < _throughput_goal)) {
- desired_eden_size = adjust_eden_for_throughput(desired_eden_size);
- } else {
- desired_eden_size = adjust_eden_for_footprint(desired_eden_size);
- }
-
- if (PrintGC && PrintAdaptiveSizePolicy) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::compute_eden_space_size limits:"
- " desired_eden_size: " SIZE_FORMAT
- " old_eden_size: " SIZE_FORMAT,
- desired_eden_size, cur_eden);
- }
-
- set_eden_size(desired_eden_size);
-}
-
-size_t CMSAdaptiveSizePolicy::adjust_promo_for_pause_time(size_t cur_promo) {
- size_t change = 0;
- size_t desired_promo = cur_promo;
- // Move this test up to caller like the adjust_eden_for_pause_time()
- // call.
- if ((AdaptiveSizePausePolicy == 0) &&
- ((avg_remark_pause()->padded_average() > gc_pause_goal_sec()) ||
- (avg_initial_pause()->padded_average() > gc_pause_goal_sec()))) {
- set_change_old_gen_for_maj_pauses(decrease_old_gen_for_maj_pauses_true);
- change = promo_decrement_aligned_down(cur_promo);
- desired_promo = cur_promo - change;
- } else if ((AdaptiveSizePausePolicy > 0) &&
- (((avg_remark_pause()->padded_average() > gc_pause_goal_sec()) &&
- remark_pause_old_estimator()->decrement_will_decrease()) ||
- ((avg_initial_pause()->padded_average() > gc_pause_goal_sec()) &&
- initial_pause_old_estimator()->decrement_will_decrease()))) {
- set_change_old_gen_for_maj_pauses(decrease_old_gen_for_maj_pauses_true);
- change = promo_decrement_aligned_down(cur_promo);
- desired_promo = cur_promo - change;
- }
-
- if ((change != 0) &&PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::adjust_promo_for_pause_time "
- "adjusting promo for pause time. "
- " starting promo size " SIZE_FORMAT
- " reduced promo size " SIZE_FORMAT
- " promo delta " SIZE_FORMAT,
- cur_promo, desired_promo, change);
- }
-
- return desired_promo;
-}
-
-// Try to share this with PS.
-size_t CMSAdaptiveSizePolicy::scale_by_gen_gc_cost(size_t base_change,
- double gen_gc_cost) {
-
- // Calculate the change to use for the tenured gen.
- size_t scaled_change = 0;
- // Can the increment to the generation be scaled?
- if (gc_cost() >= 0.0 && gen_gc_cost >= 0.0) {
- double scale_by_ratio = gen_gc_cost / gc_cost();
- scaled_change =
- (size_t) (scale_by_ratio * (double) base_change);
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "Scaled tenured increment: " SIZE_FORMAT " by %f down to "
- SIZE_FORMAT,
- base_change, scale_by_ratio, scaled_change);
- }
- } else if (gen_gc_cost >= 0.0) {
- // Scaling is not going to work. If the major gc time is the
- // larger than the other GC costs, give it a full increment.
- if (gen_gc_cost >= (gc_cost() - gen_gc_cost)) {
- scaled_change = base_change;
- }
- } else {
- // Don't expect to get here but it's ok if it does
- // in the product build since the delta will be 0
- // and nothing will change.
- assert(false, "Unexpected value for gc costs");
- }
-
- return scaled_change;
-}
-
-size_t CMSAdaptiveSizePolicy::adjust_promo_for_throughput(size_t cur_promo) {
-
- size_t desired_promo = cur_promo;
-
- set_change_old_gen_for_throughput(increase_old_gen_for_throughput_true);
-
- size_t change = promo_increment_aligned_up(cur_promo);
- size_t scaled_change = scale_by_gen_gc_cost(change, major_gc_cost());
-
- if (cur_promo + scaled_change > cur_promo) {
- desired_promo = cur_promo + scaled_change;
- }
-
- _old_gen_change_for_major_throughput++;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::adjust_promo_for_throughput "
- "adjusting promo for throughput. "
- " starting promo size " SIZE_FORMAT
- " increased promo size " SIZE_FORMAT
- " promo delta " SIZE_FORMAT,
- cur_promo, desired_promo, scaled_change);
- }
-
- return desired_promo;
-}
-
-size_t CMSAdaptiveSizePolicy::adjust_promo_for_footprint(size_t cur_promo,
- size_t cur_eden) {
-
- set_decrease_for_footprint(decrease_young_gen_for_footprint_true);
-
- size_t change = promo_decrement(cur_promo);
- size_t desired_promo_size = cur_promo - change;
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::adjust_promo_for_footprint "
- "adjusting promo for footprint. "
- " starting promo size " SIZE_FORMAT
- " reduced promo size " SIZE_FORMAT
- " promo delta " SIZE_FORMAT,
- cur_promo, desired_promo_size, change);
- }
- return desired_promo_size;
-}
-
-void CMSAdaptiveSizePolicy::compute_tenured_generation_free_space(
- size_t cur_tenured_free,
- size_t max_tenured_available,
- size_t cur_eden) {
- // This can be bad if the desired value grows/shrinks without
- // any connection to the read free space
- size_t desired_promo_size = promo_size();
- size_t tenured_limit = max_tenured_available;
-
- // Printout input
- if (PrintGC && PrintAdaptiveSizePolicy) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::compute_tenured_generation_free_space: "
- "cur_tenured_free " SIZE_FORMAT
- " max_tenured_available " SIZE_FORMAT,
- cur_tenured_free, max_tenured_available);
- }
-
- // Used for diagnostics
- clear_generation_free_space_flags();
-
- set_decide_at_full_gc(decide_at_full_gc_true);
- if (avg_remark_pause()->padded_average() > gc_pause_goal_sec() ||
- avg_initial_pause()->padded_average() > gc_pause_goal_sec()) {
- desired_promo_size = adjust_promo_for_pause_time(cur_tenured_free);
- } else if (avg_minor_pause()->padded_average() > gc_pause_goal_sec()) {
- // Nothing to do since the minor collections are too large and
- // this method only deals with the cms generation.
- } else if ((cms_gc_cost() >= 0.0) &&
- (adjusted_mutator_cost() < _throughput_goal)) {
- desired_promo_size = adjust_promo_for_throughput(cur_tenured_free);
- } else {
- desired_promo_size = adjust_promo_for_footprint(cur_tenured_free,
- cur_eden);
- }
-
- if (PrintGC && PrintAdaptiveSizePolicy) {
- gclog_or_tty->print_cr(
- "CMSAdaptiveSizePolicy::compute_tenured_generation_free_space limits:"
- " desired_promo_size: " SIZE_FORMAT
- " old_promo_size: " SIZE_FORMAT,
- desired_promo_size, cur_tenured_free);
- }
-
- set_promo_size(desired_promo_size);
-}
-
-uint CMSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold(
- bool is_survivor_overflow,
- uint tenuring_threshold,
- size_t survivor_limit) {
- assert(survivor_limit >= generation_alignment(),
- "survivor_limit too small");
- assert((size_t)align_size_down(survivor_limit, generation_alignment())
- == survivor_limit, "survivor_limit not aligned");
-
- // Change UsePSAdaptiveSurvivorSizePolicy -> UseAdaptiveSurvivorSizePolicy?
- if (!UsePSAdaptiveSurvivorSizePolicy ||
- !young_gen_policy_is_ready()) {
- return tenuring_threshold;
- }
-
- // We'll decide whether to increase or decrease the tenuring
- // threshold based partly on the newly computed survivor size
- // (if we hit the maximum limit allowed, we'll always choose to
- // decrement the threshold).
- bool incr_tenuring_threshold = false;
- bool decr_tenuring_threshold = false;
-
- set_decrement_tenuring_threshold_for_gc_cost(false);
- set_increment_tenuring_threshold_for_gc_cost(false);
- set_decrement_tenuring_threshold_for_survivor_limit(false);
-
- if (!is_survivor_overflow) {
- // Keep running averages on how much survived
-
- // We use the tenuring threshold to equalize the cost of major
- // and minor collections.
- // ThresholdTolerance is used to indicate how sensitive the
- // tenuring threshold is to differences in cost between the
- // collection types.
-
- // Get the times of interest. This involves a little work, so
- // we cache the values here.
- const double major_cost = major_gc_cost();
- const double minor_cost = minor_gc_cost();
-
- if (minor_cost > major_cost * _threshold_tolerance_percent) {
- // Minor times are getting too long; lower the threshold so
- // less survives and more is promoted.
- decr_tenuring_threshold = true;
- set_decrement_tenuring_threshold_for_gc_cost(true);
- } else if (major_cost > minor_cost * _threshold_tolerance_percent) {
- // Major times are too long, so we want less promotion.
- incr_tenuring_threshold = true;
- set_increment_tenuring_threshold_for_gc_cost(true);
- }
-
- } else {
- // Survivor space overflow occurred, so promoted and survived are
- // not accurate. We'll make our best guess by combining survived
- // and promoted and count them as survivors.
- //
- // We'll lower the tenuring threshold to see if we can correct
- // things. Also, set the survivor size conservatively. We're
- // trying to avoid many overflows from occurring if defnew size
- // is just too small.
-
- decr_tenuring_threshold = true;
- }
-
- // The padded average also maintains a deviation from the average;
- // we use this to see how good of an estimate we have of what survived.
- // We're trying to pad the survivor size as little as possible without
- // overflowing the survivor spaces.
- size_t target_size = align_size_up((size_t)_avg_survived->padded_average(),
- generation_alignment());
- target_size = MAX2(target_size, generation_alignment());
-
- if (target_size > survivor_limit) {
- // Target size is bigger than we can handle. Let's also reduce
- // the tenuring threshold.
- target_size = survivor_limit;
- decr_tenuring_threshold = true;
- set_decrement_tenuring_threshold_for_survivor_limit(true);
- }
-
- // Finally, increment or decrement the tenuring threshold, as decided above.
- // We test for decrementing first, as we might have hit the target size
- // limit.
- if (decr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
- if (tenuring_threshold > 1) {
- tenuring_threshold--;
- }
- } else if (incr_tenuring_threshold && !(AlwaysTenure || NeverTenure)) {
- if (tenuring_threshold < MaxTenuringThreshold) {
- tenuring_threshold++;
- }
- }
-
- // We keep a running average of the amount promoted which is used
- // to decide when we should collect the old generation (when
- // the amount of old gen free space is less than what we expect to
- // promote).
-
- if (PrintAdaptiveSizePolicy) {
- // A little more detail if Verbose is on
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- if (Verbose) {
- gclog_or_tty->print( " avg_survived: %f"
- " avg_deviation: %f",
- _avg_survived->average(),
- _avg_survived->deviation());
- }
-
- gclog_or_tty->print( " avg_survived_padded_avg: %f",
- _avg_survived->padded_average());
-
- if (Verbose) {
- gclog_or_tty->print( " avg_promoted_avg: %f"
- " avg_promoted_dev: %f",
- gch->gc_stats(1)->avg_promoted()->average(),
- gch->gc_stats(1)->avg_promoted()->deviation());
- }
-
- gclog_or_tty->print( " avg_promoted_padded_avg: %f"
- " avg_pretenured_padded_avg: %f"
- " tenuring_thresh: %u"
- " target_size: " SIZE_FORMAT
- " survivor_limit: " SIZE_FORMAT,
- gch->gc_stats(1)->avg_promoted()->padded_average(),
- _avg_pretenured->padded_average(),
- tenuring_threshold, target_size, survivor_limit);
- gclog_or_tty->cr();
- }
-
- set_survivor_size(target_size);
-
- return tenuring_threshold;
-}
-
-bool CMSAdaptiveSizePolicy::get_and_clear_first_after_collection() {
- bool result = _first_after_collection;
- _first_after_collection = false;
- return result;
-}
-
-bool CMSAdaptiveSizePolicy::print_adaptive_size_policy_on(
- outputStream* st) const {
-
- if (!UseAdaptiveSizePolicy) {
- return false;
- }
-
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- Generation* young = gch->get_gen(0);
- DefNewGeneration* def_new = young->as_DefNewGeneration();
- return AdaptiveSizePolicy::print_adaptive_size_policy_on(
- st,
- def_new->tenuring_threshold());
-}
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp Thu Jun 26 16:01:07 2014 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,477 +0,0 @@
-/*
- * Copyright (c) 2004, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSADAPTIVESIZEPOLICY_HPP
-#define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSADAPTIVESIZEPOLICY_HPP
-
-#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
-#include "runtime/timer.hpp"
-
-// This class keeps statistical information and computes the
-// size of the heap for the concurrent mark sweep collector.
-//
-// Cost for garbage collector include cost for
-// minor collection
-// concurrent collection
-// stop-the-world component
-// concurrent component
-// major compacting collection
-// uses decaying cost
-
-// Forward decls
-class elapsedTimer;
-
-class CMSAdaptiveSizePolicy : public AdaptiveSizePolicy {
- friend class CMSGCAdaptivePolicyCounters;
- friend class CMSCollector;
- private:
-
- // Total number of processors available
- int _processor_count;
- // Number of processors used by the concurrent phases of GC
- // This number is assumed to be the same for all concurrent
- // phases.
- int _concurrent_processor_count;
-
- // Time that the mutators run exclusive of a particular
- // phase. For example, the time the mutators run excluding
- // the time during which the cms collector runs concurrently
- // with the mutators.
- // Between end of most recent cms reset and start of initial mark
- // This may be redundant
- double _latest_cms_reset_end_to_initial_mark_start_secs;
- // Between end of the most recent initial mark and start of remark
- double _latest_cms_initial_mark_end_to_remark_start_secs;
- // Between end of most recent collection and start of
- // a concurrent collection
- double _latest_cms_collection_end_to_collection_start_secs;
- // Times of the concurrent phases of the most recent
- // concurrent collection
- double _latest_cms_concurrent_marking_time_secs;
- double _latest_cms_concurrent_precleaning_time_secs;
- double _latest_cms_concurrent_sweeping_time_secs;
- // Between end of most recent STW MSC and start of next STW MSC
- double _latest_cms_msc_end_to_msc_start_time_secs;
- // Between end of most recent MS and start of next MS
- // This does not include any time spent during a concurrent
- // collection.
- double _latest_cms_ms_end_to_ms_start;
- // Between start and end of the initial mark of the most recent
- // concurrent collection.
- double _latest_cms_initial_mark_start_to_end_time_secs;
- // Between start and end of the remark phase of the most recent
- // concurrent collection
- double _latest_cms_remark_start_to_end_time_secs;
- // Between start and end of the most recent MS STW marking phase
- double _latest_cms_ms_marking_start_to_end_time_secs;
-
- // Pause time timers
- static elapsedTimer _STW_timer;
- // Concurrent collection timer. Used for total of all concurrent phases
- // during 1 collection cycle.
- static elapsedTimer _concurrent_timer;
-
- // When the size of the generation is changed, the size
- // of the change will rounded up or down (depending on the
- // type of change) by this value.
- size_t _generation_alignment;
-
- // If this variable is true, the size of the young generation
- // may be changed in order to reduce the pause(s) of the
- // collection of the tenured generation in order to meet the
- // pause time goal. It is common to change the size of the
- // tenured generation in order to meet the pause time goal
- // for the tenured generation. With the CMS collector for
- // the tenured generation, the size of the young generation
- // can have an significant affect on the pause times for collecting the
- // tenured generation.
- // This is a duplicate of a variable in PSAdaptiveSizePolicy. It
- // is duplicated because it is not clear that it is general enough
- // to go into AdaptiveSizePolicy.
- int _change_young_gen_for_maj_pauses;
-
- // Variable that is set to true after a collection.
- bool _first_after_collection;
-
- // Fraction of collections that are of each type
- double concurrent_fraction() const;
- double STW_msc_fraction() const;
- double STW_ms_fraction() const;
-
- // This call cannot be put into the epilogue as long as some
- // of the counters can be set during concurrent phases.
- virtual void clear_generation_free_space_flags();
-
- void set_first_after_collection() { _first_after_collection = true; }
-
- protected:
- // Average of the sum of the concurrent times for
- // one collection in seconds.
- AdaptiveWeightedAverage* _avg_concurrent_time;
- // Average time between concurrent collections in seconds.
- AdaptiveWeightedAverage* _avg_concurrent_interval;
- // Average cost of the concurrent part of a collection
- // in seconds.
- AdaptiveWeightedAverage* _avg_concurrent_gc_cost;
-
- // Average of the initial pause of a concurrent collection in seconds.
- AdaptivePaddedAverage* _avg_initial_pause;
- // Average of the remark pause of a concurrent collection in seconds.
- AdaptivePaddedAverage* _avg_remark_pause;
-
- // Average of the stop-the-world (STW) (initial mark + remark)
- // times in seconds for concurrent collections.
- AdaptiveWeightedAverage* _avg_cms_STW_time;
- // Average of the STW collection cost for concurrent collections.
- AdaptiveWeightedAverage* _avg_cms_STW_gc_cost;
-
- // Average of the bytes free at the start of the sweep.
- AdaptiveWeightedAverage* _avg_cms_free_at_sweep;
- // Average of the bytes free at the end of the collection.
- AdaptiveWeightedAverage* _avg_cms_free;
- // Average of the bytes promoted between cms collections.
- AdaptiveWeightedAverage* _avg_cms_promo;
-
- // stop-the-world (STW) mark-sweep-compact
- // Average of the pause time in seconds for STW mark-sweep-compact
- // collections.
- AdaptiveWeightedAverage* _avg_msc_pause;
- // Average of the interval in seconds between STW mark-sweep-compact
- // collections.
- AdaptiveWeightedAverage* _avg_msc_interval;
- // Average of the collection costs for STW mark-sweep-compact
- // collections.
- AdaptiveWeightedAverage* _avg_msc_gc_cost;
-
- // Averages for mark-sweep collections.
- // The collection may have started as a background collection
- // that completes in a stop-the-world (STW) collection.
- // Average of the pause time in seconds for mark-sweep
- // collections.
- AdaptiveWeightedAverage* _avg_ms_pause;
- // Average of the interval in seconds between mark-sweep
- // collections.
- AdaptiveWeightedAverage* _avg_ms_interval;
- // Average of the collection costs for mark-sweep
- // collections.
- AdaptiveWeightedAverage* _avg_ms_gc_cost;
-
- // These variables contain a linear fit of
- // a generation size as the independent variable
- // and a pause time as the dependent variable.
- // For example _remark_pause_old_estimator
- // is a fit of the old generation size as the
- // independent variable and the remark pause
- // as the dependent variable.
- // remark pause time vs. cms gen size
- LinearLeastSquareFit* _remark_pause_old_estimator;
- // initial pause time vs. cms gen size
- LinearLeastSquareFit* _initial_pause_old_estimator;
- // remark pause time vs. young gen size
- LinearLeastSquareFit* _remark_pause_young_estimator;
- // initial pause time vs. young gen size
- LinearLeastSquareFit* _initial_pause_young_estimator;
-
- // Accessors
- int processor_count() const { return _processor_count; }
- int concurrent_processor_count() const { return _concurrent_processor_count; }
-
- AdaptiveWeightedAverage* avg_concurrent_time() const {
- return _avg_concurrent_time;
- }
-
- AdaptiveWeightedAverage* avg_concurrent_interval() const {
- return _avg_concurrent_interval;
- }
-
- AdaptiveWeightedAverage* avg_concurrent_gc_cost() const {
- return _avg_concurrent_gc_cost;
- }
-
- AdaptiveWeightedAverage* avg_cms_STW_time() const {
- return _avg_cms_STW_time;
- }
-
- AdaptiveWeightedAverage* avg_cms_STW_gc_cost() const {
- return _avg_cms_STW_gc_cost;
- }
-
- AdaptivePaddedAverage* avg_initial_pause() const {
- return _avg_initial_pause;
- }
-
- AdaptivePaddedAverage* avg_remark_pause() const {
- return _avg_remark_pause;
- }
-
- AdaptiveWeightedAverage* avg_cms_free() const {
- return _avg_cms_free;
- }
-
- AdaptiveWeightedAverage* avg_cms_free_at_sweep() const {
- return _avg_cms_free_at_sweep;
- }
-
- AdaptiveWeightedAverage* avg_msc_pause() const {
- return _avg_msc_pause;
- }
-
- AdaptiveWeightedAverage* avg_msc_interval() const {
- return _avg_msc_interval;
- }
-
- AdaptiveWeightedAverage* avg_msc_gc_cost() const {
- return _avg_msc_gc_cost;
- }
-
- AdaptiveWeightedAverage* avg_ms_pause() const {
- return _avg_ms_pause;
- }
-
- AdaptiveWeightedAverage* avg_ms_interval() const {
- return _avg_ms_interval;
- }
-
- AdaptiveWeightedAverage* avg_ms_gc_cost() const {
- return _avg_ms_gc_cost;
- }
-
- LinearLeastSquareFit* remark_pause_old_estimator() {
- return _remark_pause_old_estimator;
- }
- LinearLeastSquareFit* initial_pause_old_estimator() {
- return _initial_pause_old_estimator;
- }
- LinearLeastSquareFit* remark_pause_young_estimator() {
- return _remark_pause_young_estimator;
- }
- LinearLeastSquareFit* initial_pause_young_estimator() {
- return _initial_pause_young_estimator;
- }
-
- // These *slope() methods return the slope
- // m for the linear fit of an independent
- // variable vs. a dependent variable. For
- // example
- // remark_pause = m * old_generation_size + c
- // These may be used to determine if an
- // adjustment should be made to achieve a goal.
- // For example, if remark_pause_old_slope() is
- // positive, a reduction of the old generation
- // size has on average resulted in the reduction
- // of the remark pause.
- float remark_pause_old_slope() {
- return _remark_pause_old_estimator->slope();
- }
-
- float initial_pause_old_slope() {
- return _initial_pause_old_estimator->slope();
- }
-
- float remark_pause_young_slope() {
- return _remark_pause_young_estimator->slope();
- }
-
- float initial_pause_young_slope() {
- return _initial_pause_young_estimator->slope();
- }
-
- // Update estimators
- void update_minor_pause_old_estimator(double minor_pause_in_ms);
-
- // Fraction of processors used by the concurrent phases.
- double concurrent_processor_fraction();
-
- // Returns the total times for the concurrent part of the
- // latest collection in seconds.
- double concurrent_collection_time();
-
- // Return the total times for the concurrent part of the
- // latest collection in seconds where the times of the various
- // concurrent phases are scaled by the processor fraction used
- // during the phase.
- double scaled_concurrent_collection_time();
-
- // Dimensionless concurrent GC cost for all the concurrent phases.
- double concurrent_collection_cost(double interval_in_seconds);
-
- // Dimensionless GC cost
- double collection_cost(double pause_in_seconds, double interval_in_seconds);
-
- virtual GCPolicyKind kind() const { return _gc_cms_adaptive_size_policy; }
-
- virtual double time_since_major_gc() const;
-
- // This returns the maximum average for the concurrent, ms, and
- // msc collections. This is meant to be used for the calculation
- // of the decayed major gc cost and is not in general the
- // average of all the different types of major collections.
- virtual double major_gc_interval_average_for_decay() const;
-
- public:
- CMSAdaptiveSizePolicy(size_t init_eden_size,
- size_t init_promo_size,
- size_t init_survivor_size,
- double max_gc_minor_pause_sec,
- double max_gc_pause_sec,
- uint gc_cost_ratio);
-
- // The timers for the stop-the-world phases measure a total
- // stop-the-world time. The timer is started and stopped
- // for each phase but is only reset after the final checkpoint.
- void checkpoint_roots_initial_begin();
- void checkpoint_roots_initial_end(GCCause::Cause gc_cause);
- void checkpoint_roots_final_begin();
- void checkpoint_roots_final_end(GCCause::Cause gc_cause);
-
- // Methods for gathering information about the
- // concurrent marking phase of the collection.
- // Records the mutator times and
- // resets the concurrent timer.
- void concurrent_marking_begin();
- // Resets concurrent phase timer in the begin methods and
- // saves the time for a phase in the end methods.
- void concurrent_marking_end();
- void concurrent_sweeping_begin();
- void concurrent_sweeping_end();
- // Similar to the above (e.g., concurrent_marking_end()) and
- // is used for both the precleaning an abortable precleaning
- // phases.
- void concurrent_precleaning_begin();
- void concurrent_precleaning_end();
- // Stops the concurrent phases time. Gathers
- // information and resets the timer.
- void concurrent_phases_end(GCCause::Cause gc_cause,
- size_t cur_eden,
- size_t cur_promo);
-
- // Methods for gather information about STW Mark-Sweep-Compact
- void msc_collection_begin();
- void msc_collection_end(GCCause::Cause gc_cause);
-
- // Methods for gather information about Mark-Sweep done
- // in the foreground.
- void ms_collection_begin();
- void ms_collection_end(GCCause::Cause gc_cause);
-
- // Cost for a mark-sweep tenured gen collection done in the foreground
- double ms_gc_cost() const {
- return MAX2(0.0F, _avg_ms_gc_cost->average());
- }
-
- // Cost of collecting the tenured generation. Includes
- // concurrent collection and STW collection costs
- double cms_gc_cost() const;
-
- // Cost of STW mark-sweep-compact tenured gen collection.
- double msc_gc_cost() const {
- return MAX2(0.0F, _avg_msc_gc_cost->average());
- }
-
- //
- double compacting_gc_cost() const {
- double result = MIN2(1.0, minor_gc_cost() + msc_gc_cost());
- assert(result >= 0.0, "Both minor and major costs are non-negative");
- return result;
- }
-
- // Restarts the concurrent phases timer.
- void concurrent_phases_resume();
-
- // Time beginning and end of the marking phase for
- // a synchronous MS collection. A MS collection
- // that finishes in the foreground can have started
- // in the background. These methods capture the
- // completion of the marking (after the initial
- // marking) that is done in the foreground.
- void ms_collection_marking_begin();
- void ms_collection_marking_end(GCCause::Cause gc_cause);
-
- static elapsedTimer* concurrent_timer_ptr() {
- return &_concurrent_timer;
- }
-
- AdaptiveWeightedAverage* avg_cms_promo() const {
- return _avg_cms_promo;
- }
-
- int change_young_gen_for_maj_pauses() {
- return _change_young_gen_for_maj_pauses;
- }
- void set_change_young_gen_for_maj_pauses(int v) {
- _change_young_gen_for_maj_pauses = v;
- }
-
- void clear_internal_time_intervals();
-
-
- // Either calculated_promo_size_in_bytes() or promo_size()
- // should be deleted.
- size_t promo_size() { return _promo_size; }
- void set_promo_size(size_t v) { _promo_size = v; }
-
- // Cost of GC for all types of collections.
- virtual double gc_cost() const;
-
- size_t generation_alignment() { return _generation_alignment; }
-
- virtual void compute_eden_space_size(size_t cur_eden,
- size_t max_eden_size);
- // Calculates new survivor space size; returns a new tenuring threshold
- // value. Stores new survivor size in _survivor_size.
- virtual uint compute_survivor_space_size_and_threshold(
- bool is_survivor_overflow,
- uint tenuring_threshold,
- size_t survivor_limit);
-
- virtual void compute_tenured_generation_free_space(size_t cur_tenured_free,
- size_t max_tenured_available,
- size_t cur_eden);
-
- size_t eden_decrement_aligned_down(size_t cur_eden);
- size_t eden_increment_aligned_up(size_t cur_eden);
-
- size_t adjust_eden_for_pause_time(size_t cur_eden);
- size_t adjust_eden_for_throughput(size_t cur_eden);
- size_t adjust_eden_for_footprint(size_t cur_eden);
-
- size_t promo_decrement_aligned_down(size_t cur_promo);
- size_t promo_increment_aligned_up(size_t cur_promo);
-
- size_t adjust_promo_for_pause_time(size_t cur_promo);
- size_t adjust_promo_for_throughput(size_t cur_promo);
- size_t adjust_promo_for_footprint(size_t cur_promo, size_t cur_eden);
-
- // Scale down the input size by the ratio of the cost to collect the
- // generation to the total GC cost.
- size_t scale_by_gen_gc_cost(size_t base_change, double gen_gc_cost);
-
- // Return the value and clear it.
- bool get_and_clear_first_after_collection();
-
- // Printing support
- virtual bool print_adaptive_size_policy_on(outputStream* st) const;
-};
-
-#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSADAPTIVESIZEPOLICY_HPP
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -23,9 +23,8 @@
*/
#include "precompiled.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
+#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
#include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
#include "gc_implementation/parNew/parNewGeneration.hpp"
#include "gc_implementation/shared/gcPolicyCounters.hpp"
#include "gc_implementation/shared/vmGCOperations.hpp"
@@ -57,25 +56,12 @@
if (_generations == NULL)
vm_exit_during_initialization("Unable to allocate gen spec");
- if (UseParNewGC) {
- if (UseAdaptiveSizePolicy) {
- _generations[0] = new GenerationSpec(Generation::ASParNew,
- _initial_young_size, _max_young_size);
- } else {
- _generations[0] = new GenerationSpec(Generation::ParNew,
- _initial_young_size, _max_young_size);
- }
- } else {
- _generations[0] = new GenerationSpec(Generation::DefNew,
- _initial_young_size, _max_young_size);
- }
- if (UseAdaptiveSizePolicy) {
- _generations[1] = new GenerationSpec(Generation::ASConcurrentMarkSweep,
- _initial_old_size, _max_old_size);
- } else {
- _generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep,
- _initial_old_size, _max_old_size);
- }
+ Generation::Name yg_name =
+ UseParNewGC ? Generation::ParNew : Generation::DefNew;
+ _generations[0] = new GenerationSpec(yg_name, _initial_young_size,
+ _max_young_size);
+ _generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep,
+ _initial_old_size, _max_old_size);
if (_generations[0] == NULL || _generations[1] == NULL) {
vm_exit_during_initialization("Unable to allocate gen spec");
@@ -85,14 +71,12 @@
void ConcurrentMarkSweepPolicy::initialize_size_policy(size_t init_eden_size,
size_t init_promo_size,
size_t init_survivor_size) {
- double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
- _size_policy = new CMSAdaptiveSizePolicy(init_eden_size,
- init_promo_size,
- init_survivor_size,
- max_gc_minor_pause_sec,
- max_gc_pause_sec,
- GCTimeRatio);
+ _size_policy = new AdaptiveSizePolicy(init_eden_size,
+ init_promo_size,
+ init_survivor_size,
+ max_gc_pause_sec,
+ GCTimeRatio);
}
void ConcurrentMarkSweepPolicy::initialize_gc_policy_counters() {
@@ -110,22 +94,3 @@
{
return CMSIncrementalMode;
}
-
-
-//
-// ASConcurrentMarkSweepPolicy methods
-//
-
-void ASConcurrentMarkSweepPolicy::initialize_gc_policy_counters() {
-
- assert(size_policy() != NULL, "A size policy is required");
- // initialize the policy counters - 2 collectors, 3 generations
- if (UseParNewGC) {
- _gc_policy_counters = new CMSGCAdaptivePolicyCounters("ParNew:CMS", 2, 3,
- size_policy());
- }
- else {
- _gc_policy_counters = new CMSGCAdaptivePolicyCounters("Copy:CMS", 2, 3,
- size_policy());
- }
-}
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp Thu Jun 26 13:30:43 2014 -0700
@@ -47,19 +47,4 @@
virtual bool has_soft_ended_eden();
};
-class ASConcurrentMarkSweepPolicy : public ConcurrentMarkSweepPolicy {
- public:
-
- // Initialize the jstat counters. This method requires a
- // size policy. The size policy is expected to be created
- // after the generations are fully initialized so the
- // initialization of the counters need to be done post
- // the initialization of the generations.
- void initialize_gc_policy_counters();
-
- virtual CollectorPolicy::Name kind() {
- return CollectorPolicy::ASConcurrentMarkSweepPolicyKind;
- }
-};
-
#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSCOLLECTORPOLICY_HPP
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.cpp Thu Jun 26 16:01:07 2014 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,303 +0,0 @@
-/*
- * Copyright (c) 2004, 2010, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
-#include "memory/resourceArea.hpp"
-
-CMSGCAdaptivePolicyCounters::CMSGCAdaptivePolicyCounters(const char* name_arg,
- int collectors,
- int generations,
- AdaptiveSizePolicy* size_policy_arg)
- : GCAdaptivePolicyCounters(name_arg,
- collectors,
- generations,
- size_policy_arg) {
- if (UsePerfData) {
- EXCEPTION_MARK;
- ResourceMark rm;
-
- const char* cname =
- PerfDataManager::counter_name(name_space(), "cmsCapacity");
- _cms_capacity_counter = PerfDataManager::create_variable(SUN_GC, cname,
- PerfData::U_Bytes, (jlong) OldSize, CHECK);
-#ifdef NOT_PRODUCT
- cname =
- PerfDataManager::counter_name(name_space(), "initialPause");
- _initial_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_initial_pause()->last_sample(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "remarkPause");
- _remark_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_remark_pause()->last_sample(),
- CHECK);
-#endif
- cname =
- PerfDataManager::counter_name(name_space(), "avgInitialPause");
- _avg_initial_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_initial_pause()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgRemarkPause");
- _avg_remark_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_remark_pause()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgSTWGcCost");
- _avg_cms_STW_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_cms_STW_gc_cost()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgSTWTime");
- _avg_cms_STW_time_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_cms_STW_time()->average(),
- CHECK);
-
-
- cname = PerfDataManager::counter_name(name_space(), "avgConcurrentTime");
- _avg_concurrent_time_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_concurrent_time()->average(),
- CHECK);
-
- cname =
- PerfDataManager::counter_name(name_space(), "avgConcurrentInterval");
- _avg_concurrent_interval_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_concurrent_interval()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgConcurrentGcCost");
- _avg_concurrent_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_concurrent_gc_cost()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgCMSFreeAtSweep");
- _avg_cms_free_at_sweep_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_cms_free_at_sweep()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgCMSFree");
- _avg_cms_free_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_cms_free()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgCMSPromo");
- _avg_cms_promo_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_cms_promo()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgMscPause");
- _avg_msc_pause_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_msc_pause()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgMscInterval");
- _avg_msc_interval_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_msc_interval()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "mscGcCost");
- _msc_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_msc_gc_cost()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgMsPause");
- _avg_ms_pause_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_ms_pause()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgMsInterval");
- _avg_ms_interval_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_ms_interval()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "msGcCost");
- _ms_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
- cname,
- PerfData::U_Ticks,
- (jlong) cms_size_policy()->avg_ms_gc_cost()->average(),
- CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "majorGcCost");
- _major_gc_cost_counter = PerfDataManager::create_variable(SUN_GC, cname,
- PerfData::U_Ticks, (jlong) cms_size_policy()->cms_gc_cost(), CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgPromotedAvg");
- _promoted_avg_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
- cms_size_policy()->calculated_promo_size_in_bytes(), CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgPromotedDev");
- _promoted_avg_dev_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
- (jlong) 0 , CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "avgPromotedPaddedAvg");
- _promoted_padded_avg_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
- cms_size_policy()->calculated_promo_size_in_bytes(), CHECK);
-
- cname = PerfDataManager::counter_name(name_space(),
- "changeYoungGenForMajPauses");
- _change_young_gen_for_maj_pauses_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,
- (jlong)0, CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "remarkPauseOldSlope");
- _remark_pause_old_slope_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
- (jlong) cms_size_policy()->remark_pause_old_slope(), CHECK);
-
- cname = PerfDataManager::counter_name(name_space(), "initialPauseOldSlope");
- _initial_pause_old_slope_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
- (jlong) cms_size_policy()->initial_pause_old_slope(), CHECK);
-
- cname =
- PerfDataManager::counter_name(name_space(), "remarkPauseYoungSlope") ;
- _remark_pause_young_slope_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
- (jlong) cms_size_policy()->remark_pause_young_slope(), CHECK);
-
- cname =
- PerfDataManager::counter_name(name_space(), "initialPauseYoungSlope");
- _initial_pause_young_slope_counter =
- PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
- (jlong) cms_size_policy()->initial_pause_young_slope(), CHECK);
-
-
- }
- assert(size_policy()->is_gc_cms_adaptive_size_policy(),
- "Wrong type of size policy");
-}
-
-void CMSGCAdaptivePolicyCounters::update_counters() {
- if (UsePerfData) {
- GCAdaptivePolicyCounters::update_counters_from_policy();
- update_counters_from_policy();
- }
-}
-
-void CMSGCAdaptivePolicyCounters::update_counters(CMSGCStats* gc_stats) {
- if (UsePerfData) {
- update_counters();
- update_promoted((size_t) gc_stats->avg_promoted()->last_sample());
- update_avg_promoted_avg(gc_stats);
- update_avg_promoted_dev(gc_stats);
- update_avg_promoted_padded_avg(gc_stats);
- }
-}
-
-void CMSGCAdaptivePolicyCounters::update_counters_from_policy() {
- if (UsePerfData && (cms_size_policy() != NULL)) {
-
- GCAdaptivePolicyCounters::update_counters_from_policy();
-
- update_major_gc_cost_counter();
- update_mutator_cost_counter();
-
- update_eden_size();
- update_promo_size();
-
- // If these updates from the last_sample() work,
- // revise the update methods for these counters
- // (both here and in PS).
- update_survived((size_t) cms_size_policy()->avg_survived()->last_sample());
-
- update_avg_concurrent_time_counter();
- update_avg_concurrent_interval_counter();
- update_avg_concurrent_gc_cost_counter();
-#ifdef NOT_PRODUCT
- update_initial_pause_counter();
- update_remark_pause_counter();
-#endif
- update_avg_initial_pause_counter();
- update_avg_remark_pause_counter();
-
- update_avg_cms_STW_time_counter();
- update_avg_cms_STW_gc_cost_counter();
-
- update_avg_cms_free_counter();
- update_avg_cms_free_at_sweep_counter();
- update_avg_cms_promo_counter();
-
- update_avg_msc_pause_counter();
- update_avg_msc_interval_counter();
- update_msc_gc_cost_counter();
-
- update_avg_ms_pause_counter();
- update_avg_ms_interval_counter();
- update_ms_gc_cost_counter();
-
- update_avg_old_live_counter();
-
- update_survivor_size_counters();
- update_avg_survived_avg_counters();
- update_avg_survived_dev_counters();
-
- update_decrement_tenuring_threshold_for_gc_cost();
- update_increment_tenuring_threshold_for_gc_cost();
- update_decrement_tenuring_threshold_for_survivor_limit();
-
- update_change_young_gen_for_maj_pauses();
-
- update_major_collection_slope_counter();
- update_remark_pause_old_slope_counter();
- update_initial_pause_old_slope_counter();
- update_remark_pause_young_slope_counter();
- update_initial_pause_young_slope_counter();
-
- update_decide_at_full_gc_counter();
- }
-}
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp Thu Jun 26 16:01:07 2014 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,308 +0,0 @@
-/*
- * Copyright (c) 2004, 2010, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSGCADAPTIVEPOLICYCOUNTERS_HPP
-#define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSGCADAPTIVEPOLICYCOUNTERS_HPP
-
-#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
-#include "gc_implementation/shared/gcAdaptivePolicyCounters.hpp"
-#include "gc_implementation/shared/gcStats.hpp"
-#include "runtime/perfData.hpp"
-
-// CMSGCAdaptivePolicyCounters is a holder class for performance counters
-// that track the data and decisions for the ergonomics policy for the
-// concurrent mark sweep collector
-
-class CMSGCAdaptivePolicyCounters : public GCAdaptivePolicyCounters {
- friend class VMStructs;
-
- private:
-
- // Capacity of tenured generation recorded at the end of
- // any collection.
- PerfVariable* _cms_capacity_counter; // Make this common with PS _old_capacity
-
- // Average stop-the-world pause time for both initial and
- // remark pauses sampled at the end of the checkpointRootsFinalWork.
- PerfVariable* _avg_cms_STW_time_counter;
- // Average stop-the-world (STW) GC cost for the STW pause time
- // _avg_cms_STW_time_counter.
- PerfVariable* _avg_cms_STW_gc_cost_counter;
-
-#ifdef NOT_PRODUCT
- // These are useful to see how the most recent values of these
- // counters compare to their respective averages but
- // do not control behavior.
- PerfVariable* _initial_pause_counter;
- PerfVariable* _remark_pause_counter;
-#endif
-
- // Average of the initial marking pause for a concurrent collection.
- PerfVariable* _avg_initial_pause_counter;
- // Average of the remark pause for a concurrent collection.
- PerfVariable* _avg_remark_pause_counter;
-
- // Average for the sum of all the concurrent times per collection.
- PerfVariable* _avg_concurrent_time_counter;
- // Average for the time between the most recent end of a
- // concurrent collection and the beginning of the next
- // concurrent collection.
- PerfVariable* _avg_concurrent_interval_counter;
- // Average of the concurrent GC costs based on _avg_concurrent_time_counter
- // and _avg_concurrent_interval_counter.
- PerfVariable* _avg_concurrent_gc_cost_counter;
-
- // Average of the free space in the tenured generation at the
- // end of the sweep of the tenured generation.
- PerfVariable* _avg_cms_free_counter;
- // Average of the free space in the tenured generation at the
- // start of the sweep of the tenured generation.
- PerfVariable* _avg_cms_free_at_sweep_counter;
- // Average of the free space in the tenured generation at the
- // after any resizing of the tenured generation at the end
- // of a collection of the tenured generation.
- PerfVariable* _avg_cms_promo_counter;
-
- // Average of the mark-sweep-compact (MSC) pause time for a collection
- // of the tenured generation.
- PerfVariable* _avg_msc_pause_counter;
- // Average for the time between the most recent end of a
- // MSC collection and the beginning of the next MSC collection.
- PerfVariable* _avg_msc_interval_counter;
- // Average for the GC cost of a MSC collection based on
- // _avg_msc_pause_counter and _avg_msc_interval_counter.
- PerfVariable* _msc_gc_cost_counter;
-
- // Average of the mark-sweep (MS) pause time for a collection
- // of the tenured generation.
- PerfVariable* _avg_ms_pause_counter;
- // Average for the time between the most recent end of a
- // MS collection and the beginning of the next MS collection.
- PerfVariable* _avg_ms_interval_counter;
- // Average for the GC cost of a MS collection based on
- // _avg_ms_pause_counter and _avg_ms_interval_counter.
- PerfVariable* _ms_gc_cost_counter;
-
- // Average of the bytes promoted per minor collection.
- PerfVariable* _promoted_avg_counter;
- // Average of the deviation of the promoted average.
- PerfVariable* _promoted_avg_dev_counter;
- // Padded average of the bytes promoted per minor collection.
- PerfVariable* _promoted_padded_avg_counter;
-
- // See description of the _change_young_gen_for_maj_pauses
- // variable recently in cmsAdaptiveSizePolicy.hpp.
- PerfVariable* _change_young_gen_for_maj_pauses_counter;
-
- // See descriptions of _remark_pause_old_slope, _initial_pause_old_slope,
- // etc. variables recently in cmsAdaptiveSizePolicy.hpp.
- PerfVariable* _remark_pause_old_slope_counter;
- PerfVariable* _initial_pause_old_slope_counter;
- PerfVariable* _remark_pause_young_slope_counter;
- PerfVariable* _initial_pause_young_slope_counter;
-
- CMSAdaptiveSizePolicy* cms_size_policy() {
- assert(_size_policy->kind() ==
- AdaptiveSizePolicy::_gc_cms_adaptive_size_policy,
- "Wrong size policy");
- return (CMSAdaptiveSizePolicy*)_size_policy;
- }
-
- inline void update_avg_cms_STW_time_counter() {
- _avg_cms_STW_time_counter->set_value(
- (jlong) (cms_size_policy()->avg_cms_STW_time()->average() *
- (double) MILLIUNITS));
- }
-
- inline void update_avg_cms_STW_gc_cost_counter() {
- _avg_cms_STW_gc_cost_counter->set_value(
- (jlong) (cms_size_policy()->avg_cms_STW_gc_cost()->average() * 100.0));
- }
-
- inline void update_avg_initial_pause_counter() {
- _avg_initial_pause_counter->set_value(
- (jlong) (cms_size_policy()->avg_initial_pause()->average() *
- (double) MILLIUNITS));
- }
-#ifdef NOT_PRODUCT
- inline void update_avg_remark_pause_counter() {
- _avg_remark_pause_counter->set_value(
- (jlong) (cms_size_policy()-> avg_remark_pause()->average() *
- (double) MILLIUNITS));
- }
-
- inline void update_initial_pause_counter() {
- _initial_pause_counter->set_value(
- (jlong) (cms_size_policy()->avg_initial_pause()->average() *
- (double) MILLIUNITS));
- }
-#endif
- inline void update_remark_pause_counter() {
- _remark_pause_counter->set_value(
- (jlong) (cms_size_policy()-> avg_remark_pause()->last_sample() *
- (double) MILLIUNITS));
- }
-
- inline void update_avg_concurrent_time_counter() {
- _avg_concurrent_time_counter->set_value(
- (jlong) (cms_size_policy()->avg_concurrent_time()->last_sample() *
- (double) MILLIUNITS));
- }
-
- inline void update_avg_concurrent_interval_counter() {
- _avg_concurrent_interval_counter->set_value(
- (jlong) (cms_size_policy()->avg_concurrent_interval()->average() *
- (double) MILLIUNITS));
- }
-
- inline void update_avg_concurrent_gc_cost_counter() {
- _avg_concurrent_gc_cost_counter->set_value(
- (jlong) (cms_size_policy()->avg_concurrent_gc_cost()->average() * 100.0));
- }
-
- inline void update_avg_cms_free_counter() {
- _avg_cms_free_counter->set_value(
- (jlong) cms_size_policy()->avg_cms_free()->average());
- }
-
- inline void update_avg_cms_free_at_sweep_counter() {
- _avg_cms_free_at_sweep_counter->set_value(
- (jlong) cms_size_policy()->avg_cms_free_at_sweep()->average());
- }
-
- inline void update_avg_cms_promo_counter() {
- _avg_cms_promo_counter->set_value(
- (jlong) cms_size_policy()->avg_cms_promo()->average());
- }
-
- inline void update_avg_old_live_counter() {
- _avg_old_live_counter->set_value(
- (jlong)(cms_size_policy()->avg_old_live()->average())
- );
- }
-
- inline void update_avg_msc_pause_counter() {
- _avg_msc_pause_counter->set_value(
- (jlong) (cms_size_policy()->avg_msc_pause()->average() *
- (double) MILLIUNITS));
- }
-
- inline void update_avg_msc_interval_counter() {
- _avg_msc_interval_counter->set_value(
- (jlong) (cms_size_policy()->avg_msc_interval()->average() *
- (double) MILLIUNITS));
- }
-
- inline void update_msc_gc_cost_counter() {
- _msc_gc_cost_counter->set_value(
- (jlong) (cms_size_policy()->avg_msc_gc_cost()->average() * 100.0));
- }
-
- inline void update_avg_ms_pause_counter() {
- _avg_ms_pause_counter->set_value(
- (jlong) (cms_size_policy()->avg_ms_pause()->average() *
- (double) MILLIUNITS));
- }
-
- inline void update_avg_ms_interval_counter() {
- _avg_ms_interval_counter->set_value(
- (jlong) (cms_size_policy()->avg_ms_interval()->average() *
- (double) MILLIUNITS));
- }
-
- inline void update_ms_gc_cost_counter() {
- _ms_gc_cost_counter->set_value(
- (jlong) (cms_size_policy()->avg_ms_gc_cost()->average() * 100.0));
- }
-
- inline void update_major_gc_cost_counter() {
- _major_gc_cost_counter->set_value(
- (jlong)(cms_size_policy()->cms_gc_cost() * 100.0)
- );
- }
- inline void update_mutator_cost_counter() {
- _mutator_cost_counter->set_value(
- (jlong)(cms_size_policy()->mutator_cost() * 100.0)
- );
- }
-
- inline void update_avg_promoted_avg(CMSGCStats* gc_stats) {
- _promoted_avg_counter->set_value(
- (jlong)(gc_stats->avg_promoted()->average())
- );
- }
- inline void update_avg_promoted_dev(CMSGCStats* gc_stats) {
- _promoted_avg_dev_counter->set_value(
- (jlong)(gc_stats->avg_promoted()->deviation())
- );
- }
- inline void update_avg_promoted_padded_avg(CMSGCStats* gc_stats) {
- _promoted_padded_avg_counter->set_value(
- (jlong)(gc_stats->avg_promoted()->padded_average())
- );
- }
- inline void update_remark_pause_old_slope_counter() {
- _remark_pause_old_slope_counter->set_value(
- (jlong)(cms_size_policy()->remark_pause_old_slope() * 1000)
- );
- }
- inline void update_initial_pause_old_slope_counter() {
- _initial_pause_old_slope_counter->set_value(
- (jlong)(cms_size_policy()->initial_pause_old_slope() * 1000)
- );
- }
- inline void update_remark_pause_young_slope_counter() {
- _remark_pause_young_slope_counter->set_value(
- (jlong)(cms_size_policy()->remark_pause_young_slope() * 1000)
- );
- }
- inline void update_initial_pause_young_slope_counter() {
- _initial_pause_young_slope_counter->set_value(
- (jlong)(cms_size_policy()->initial_pause_young_slope() * 1000)
- );
- }
- inline void update_change_young_gen_for_maj_pauses() {
- _change_young_gen_for_maj_pauses_counter->set_value(
- cms_size_policy()->change_young_gen_for_maj_pauses());
- }
-
- public:
- CMSGCAdaptivePolicyCounters(const char* name, int collectors, int generations,
- AdaptiveSizePolicy* size_policy);
-
- // update counters
- void update_counters();
- void update_counters(CMSGCStats* gc_stats);
- void update_counters_from_policy();
-
- inline void update_cms_capacity_counter(size_t size_in_bytes) {
- _cms_capacity_counter->set_value(size_in_bytes);
- }
-
- virtual GCPolicyCounters::Name kind() const {
- return GCPolicyCounters::CMSGCAdaptivePolicyCountersKind;
- }
-};
-
-#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSGCADAPTIVEPOLICYCOUNTERS_HPP
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp Thu Jun 26 13:30:43 2014 -0700
@@ -70,7 +70,6 @@
class CompactibleFreeListSpace: public CompactibleSpace {
friend class VMStructs;
friend class ConcurrentMarkSweepGeneration;
- friend class ASConcurrentMarkSweepGeneration;
friend class CMSCollector;
// Local alloc buffer for promotion into this space.
friend class CFLS_LAB;
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -27,9 +27,8 @@
#include "classfile/stringTable.hpp"
#include "classfile/systemDictionary.hpp"
#include "code/codeCache.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
+#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
#include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
#include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
#include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp"
@@ -319,26 +318,12 @@
}
}
-CMSAdaptiveSizePolicy* CMSCollector::size_policy() {
+AdaptiveSizePolicy* CMSCollector::size_policy() {
GenCollectedHeap* gch = GenCollectedHeap::heap();
assert(gch->kind() == CollectedHeap::GenCollectedHeap,
"Wrong type of heap");
- CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*)
- gch->gen_policy()->size_policy();
- assert(sp->is_gc_cms_adaptive_size_policy(),
- "Wrong type of size policy");
- return sp;
-}
-
-CMSGCAdaptivePolicyCounters* CMSCollector::gc_adaptive_policy_counters() {
- CMSGCAdaptivePolicyCounters* results =
- (CMSGCAdaptivePolicyCounters*) collector_policy()->counters();
- assert(
- results->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind,
- "Wrong gc policy counter kind");
- return results;
-}
-
+ return gch->gen_policy()->size_policy();
+}
void ConcurrentMarkSweepGeneration::initialize_performance_counters() {
@@ -2031,11 +2016,6 @@
"collections passed to foreground collector", _full_gcs_since_conc_gc);
}
- // Sample collection interval time and reset for collection pause.
- if (UseAdaptiveSizePolicy) {
- size_policy()->msc_collection_begin();
- }
-
// Temporarily widen the span of the weak reference processing to
// the entire heap.
MemRegion new_span(GenCollectedHeap::heap()->reserved_region());
@@ -2111,11 +2091,6 @@
_inter_sweep_timer.reset();
_inter_sweep_timer.start();
- // Sample collection pause time and reset for collection interval.
- if (UseAdaptiveSizePolicy) {
- size_policy()->msc_collection_end(gch->gc_cause());
- }
-
gc_timer->register_gc_end();
gc_tracer->report_gc_end(gc_timer->gc_end(), gc_timer->time_partitions());
@@ -2373,26 +2348,14 @@
}
break;
case Precleaning:
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_precleaning_begin();
- }
// marking from roots in markFromRoots has been completed
preclean();
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_precleaning_end();
- }
assert(_collectorState == AbortablePreclean ||
_collectorState == FinalMarking,
"Collector state should have changed");
break;
case AbortablePreclean:
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_phases_resume();
- }
abortable_preclean();
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_precleaning_end();
- }
assert(_collectorState == FinalMarking, "Collector state should "
"have changed");
break;
@@ -2406,23 +2369,12 @@
assert(_foregroundGCShouldWait, "block post-condition");
break;
case Sweeping:
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_sweeping_begin();
- }
// final marking in checkpointRootsFinal has been completed
sweep(true);
assert(_collectorState == Resizing, "Collector state change "
"to Resizing must be done under the free_list_lock");
_full_gcs_since_conc_gc = 0;
- // Stop the timers for adaptive size policy for the concurrent phases
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_sweeping_end();
- size_policy()->concurrent_phases_end(gch->gc_cause(),
- gch->prev_gen(_cmsGen)->capacity(),
- _cmsGen->free());
- }
-
case Resizing: {
// Sweeping has been completed...
// At this point the background collection has completed.
@@ -2539,9 +2491,6 @@
const GCId gc_id = _collectorState == InitialMarking ? GCId::peek() : _gc_tracer_cm->gc_id();
NOT_PRODUCT(GCTraceTime t("CMS:MS (foreground) ", PrintGCDetails && Verbose,
true, NULL, gc_id);)
- if (UseAdaptiveSizePolicy) {
- size_policy()->ms_collection_begin();
- }
COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact);
HandleMark hm; // Discard invalid handles created during verification
@@ -2633,11 +2582,6 @@
}
}
- if (UseAdaptiveSizePolicy) {
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- size_policy()->ms_collection_end(gch->gc_cause());
- }
-
if (VerifyAfterGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
Universe::verify();
@@ -3687,9 +3631,6 @@
NOT_PRODUCT(GCTraceTime t("\ncheckpointRootsInitialWork",
PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
- if (UseAdaptiveSizePolicy) {
- size_policy()->checkpoint_roots_initial_begin();
- }
// Reset all the PLAB chunk arrays if necessary.
if (_survivor_plab_array != NULL && !CMSPLABRecordAlways) {
@@ -3769,9 +3710,6 @@
// Save the end of the used_region of the constituent generations
// to be used to limit the extent of sweep in each generation.
save_sweep_limits();
- if (UseAdaptiveSizePolicy) {
- size_policy()->checkpoint_roots_initial_end(gch->gc_cause());
- }
verify_overflow_empty();
}
@@ -3788,15 +3726,6 @@
bool res;
if (asynch) {
-
- // Start the timers for adaptive size policy for the concurrent phases
- // Do it here so that the foreground MS can use the concurrent
- // timer since a foreground MS might has the sweep done concurrently
- // or STW.
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_marking_begin();
- }
-
// Weak ref discovery note: We may be discovering weak
// refs in this generation concurrent (but interleaved) with
// weak ref discovery by a younger generation collector.
@@ -3814,22 +3743,12 @@
gclog_or_tty->print_cr("bailing out to foreground collection");
}
}
- if (UseAdaptiveSizePolicy) {
- size_policy()->concurrent_marking_end();
- }
} else {
assert(SafepointSynchronize::is_at_safepoint(),
"inconsistent with asynch == false");
- if (UseAdaptiveSizePolicy) {
- size_policy()->ms_collection_marking_begin();
- }
// already have locks
res = markFromRootsWork(asynch);
_collectorState = FinalMarking;
- if (UseAdaptiveSizePolicy) {
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- size_policy()->ms_collection_marking_end(gch->gc_cause());
- }
}
verify_overflow_empty();
return res;
@@ -4705,8 +4624,7 @@
if (clean_survivor) { // preclean the active survivor space(s)
assert(_young_gen->kind() == Generation::DefNew ||
- _young_gen->kind() == Generation::ParNew ||
- _young_gen->kind() == Generation::ASParNew,
+ _young_gen->kind() == Generation::ParNew,
"incorrect type for cast");
DefNewGeneration* dng = (DefNewGeneration*)_young_gen;
PushAndMarkClosure pam_cl(this, _span, ref_processor(),
@@ -5077,10 +4995,6 @@
assert(haveFreelistLocks(), "must have free list locks");
assert_lock_strong(bitMapLock());
- if (UseAdaptiveSizePolicy) {
- size_policy()->checkpoint_roots_final_begin();
- }
-
ResourceMark rm;
HandleMark hm;
@@ -5214,9 +5128,6 @@
"Should be clear by end of the final marking");
assert(_ct->klass_rem_set()->mod_union_is_clear(),
"Should be clear by end of the final marking");
- if (UseAdaptiveSizePolicy) {
- size_policy()->checkpoint_roots_final_end(gch->gc_cause());
- }
}
void CMSParInitialMarkTask::work(uint worker_id) {
@@ -6329,7 +6240,6 @@
_inter_sweep_timer.stop();
_inter_sweep_estimate.sample(_inter_sweep_timer.seconds());
- size_policy()->avg_cms_free_at_sweep()->sample(_cmsGen->free());
assert(!_intra_sweep_timer.is_active(), "Should not be active");
_intra_sweep_timer.reset();
@@ -6454,17 +6364,6 @@
}
}
-CMSAdaptiveSizePolicy* ConcurrentMarkSweepGeneration::size_policy() {
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- assert(gch->kind() == CollectedHeap::GenCollectedHeap,
- "Wrong type of heap");
- CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*)
- gch->gen_policy()->size_policy();
- assert(sp->is_gc_cms_adaptive_size_policy(),
- "Wrong type of size policy");
- return sp;
-}
-
void ConcurrentMarkSweepGeneration::rotate_debug_collection_type() {
if (PrintGCDetails && Verbose) {
gclog_or_tty->print("Rotate from %d ", _debug_collection_type);
@@ -6540,9 +6439,6 @@
// Reset CMS data structures (for now just the marking bit map)
// preparatory for the next cycle.
void CMSCollector::reset(bool asynch) {
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- CMSAdaptiveSizePolicy* sp = size_policy();
- AdaptiveSizePolicyOutput(sp, gch->total_collections());
if (asynch) {
CMSTokenSyncWithLocks ts(true, bitMapLock());
@@ -6597,7 +6493,7 @@
// Because only the full (i.e., concurrent mode failure) collections
// are being measured for gc overhead limits, clean the "near" flag
// and count.
- sp->reset_gc_overhead_limit_count();
+ size_policy()->reset_gc_overhead_limit_count();
_collectorState = Idling;
} else {
// already have the lock
@@ -7064,7 +6960,6 @@
ConcurrentMarkSweepThread::desynchronize(true);
ConcurrentMarkSweepThread::acknowledge_yield_request();
_collector->stopTimer();
- GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
if (PrintCMSStatistics != 0) {
_collector->incrementYields();
}
@@ -7225,7 +7120,6 @@
ConcurrentMarkSweepThread::desynchronize(true);
ConcurrentMarkSweepThread::acknowledge_yield_request();
_collector->stopTimer();
- GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
if (PrintCMSStatistics != 0) {
_collector->incrementYields();
}
@@ -7298,7 +7192,6 @@
ConcurrentMarkSweepThread::desynchronize(true);
ConcurrentMarkSweepThread::acknowledge_yield_request();
_collector->stopTimer();
- GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
if (PrintCMSStatistics != 0) {
_collector->incrementYields();
}
@@ -7457,7 +7350,6 @@
ConcurrentMarkSweepThread::desynchronize(true);
ConcurrentMarkSweepThread::acknowledge_yield_request();
_collector->stopTimer();
- GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
if (PrintCMSStatistics != 0) {
_collector->incrementYields();
}
@@ -8099,7 +7991,6 @@
ConcurrentMarkSweepThread::acknowledge_yield_request();
_collector->stopTimer();
- GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
if (PrintCMSStatistics != 0) {
_collector->incrementYields();
}
@@ -8780,7 +8671,6 @@
ConcurrentMarkSweepThread::desynchronize(true);
ConcurrentMarkSweepThread::acknowledge_yield_request();
_collector->stopTimer();
- GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
if (PrintCMSStatistics != 0) {
_collector->incrementYields();
}
@@ -9327,172 +9217,6 @@
}
#endif
-CMSAdaptiveSizePolicy* ASConcurrentMarkSweepGeneration::cms_size_policy() const
-{
- GenCollectedHeap* gch = (GenCollectedHeap*) GenCollectedHeap::heap();
- CMSAdaptiveSizePolicy* size_policy =
- (CMSAdaptiveSizePolicy*) gch->gen_policy()->size_policy();
- assert(size_policy->is_gc_cms_adaptive_size_policy(),
- "Wrong type for size policy");
- return size_policy;
-}
-
-void ASConcurrentMarkSweepGeneration::resize(size_t cur_promo_size,
- size_t desired_promo_size) {
- if (cur_promo_size < desired_promo_size) {
- size_t expand_bytes = desired_promo_size - cur_promo_size;
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize "
- "Expanding tenured generation by " SIZE_FORMAT " (bytes)",
- expand_bytes);
- }
- expand(expand_bytes,
- MinHeapDeltaBytes,
- CMSExpansionCause::_adaptive_size_policy);
- } else if (desired_promo_size < cur_promo_size) {
- size_t shrink_bytes = cur_promo_size - desired_promo_size;
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize "
- "Shrinking tenured generation by " SIZE_FORMAT " (bytes)",
- shrink_bytes);
- }
- shrink(shrink_bytes);
- }
-}
-
-CMSGCAdaptivePolicyCounters* ASConcurrentMarkSweepGeneration::gc_adaptive_policy_counters() {
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- CMSGCAdaptivePolicyCounters* counters =
- (CMSGCAdaptivePolicyCounters*) gch->collector_policy()->counters();
- assert(counters->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind,
- "Wrong kind of counters");
- return counters;
-}
-
-
-void ASConcurrentMarkSweepGeneration::update_counters() {
- if (UsePerfData) {
- _space_counters->update_all();
- _gen_counters->update_all();
- CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters();
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats();
- assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind,
- "Wrong gc statistics type");
- counters->update_counters(gc_stats_l);
- }
-}
-
-void ASConcurrentMarkSweepGeneration::update_counters(size_t used) {
- if (UsePerfData) {
- _space_counters->update_used(used);
- _space_counters->update_capacity();
- _gen_counters->update_all();
-
- CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters();
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats();
- assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind,
- "Wrong gc statistics type");
- counters->update_counters(gc_stats_l);
- }
-}
-
-void ASConcurrentMarkSweepGeneration::shrink_by(size_t desired_bytes) {
- assert_locked_or_safepoint(Heap_lock);
- assert_lock_strong(freelistLock());
- HeapWord* old_end = _cmsSpace->end();
- HeapWord* unallocated_start = _cmsSpace->unallocated_block();
- assert(old_end >= unallocated_start, "Miscalculation of unallocated_start");
- FreeChunk* chunk_at_end = find_chunk_at_end();
- if (chunk_at_end == NULL) {
- // No room to shrink
- if (PrintGCDetails && Verbose) {
- gclog_or_tty->print_cr("No room to shrink: old_end "
- PTR_FORMAT " unallocated_start " PTR_FORMAT
- " chunk_at_end " PTR_FORMAT,
- old_end, unallocated_start, chunk_at_end);
- }
- return;
- } else {
-
- // Find the chunk at the end of the space and determine
- // how much it can be shrunk.
- size_t shrinkable_size_in_bytes = chunk_at_end->size();
- size_t aligned_shrinkable_size_in_bytes =
- align_size_down(shrinkable_size_in_bytes, os::vm_page_size());
- assert(unallocated_start <= (HeapWord*) chunk_at_end->end(),
- "Inconsistent chunk at end of space");
- size_t bytes = MIN2(desired_bytes, aligned_shrinkable_size_in_bytes);
- size_t word_size_before = heap_word_size(_virtual_space.committed_size());
-
- // Shrink the underlying space
- _virtual_space.shrink_by(bytes);
- if (PrintGCDetails && Verbose) {
- gclog_or_tty->print_cr("ConcurrentMarkSweepGeneration::shrink_by:"
- " desired_bytes " SIZE_FORMAT
- " shrinkable_size_in_bytes " SIZE_FORMAT
- " aligned_shrinkable_size_in_bytes " SIZE_FORMAT
- " bytes " SIZE_FORMAT,
- desired_bytes, shrinkable_size_in_bytes,
- aligned_shrinkable_size_in_bytes, bytes);
- gclog_or_tty->print_cr(" old_end " SIZE_FORMAT
- " unallocated_start " SIZE_FORMAT,
- old_end, unallocated_start);
- }
-
- // If the space did shrink (shrinking is not guaranteed),
- // shrink the chunk at the end by the appropriate amount.
- if (((HeapWord*)_virtual_space.high()) < old_end) {
- size_t new_word_size =
- heap_word_size(_virtual_space.committed_size());
-
- // Have to remove the chunk from the dictionary because it is changing
- // size and might be someplace elsewhere in the dictionary.
-
- // Get the chunk at end, shrink it, and put it
- // back.
- _cmsSpace->removeChunkFromDictionary(chunk_at_end);
- size_t word_size_change = word_size_before - new_word_size;
- size_t chunk_at_end_old_size = chunk_at_end->size();
- assert(chunk_at_end_old_size >= word_size_change,
- "Shrink is too large");
- chunk_at_end->set_size(chunk_at_end_old_size -
- word_size_change);
- _cmsSpace->freed((HeapWord*) chunk_at_end->end(),
- word_size_change);
-
- _cmsSpace->returnChunkToDictionary(chunk_at_end);
-
- MemRegion mr(_cmsSpace->bottom(), new_word_size);
- _bts->resize(new_word_size); // resize the block offset shared array
- Universe::heap()->barrier_set()->resize_covered_region(mr);
- _cmsSpace->assert_locked();
- _cmsSpace->set_end((HeapWord*)_virtual_space.high());
-
- NOT_PRODUCT(_cmsSpace->dictionary()->verify());
-
- // update the space and generation capacity counters
- if (UsePerfData) {
- _space_counters->update_capacity();
- _gen_counters->update_all();
- }
-
- if (Verbose && PrintGCDetails) {
- size_t new_mem_size = _virtual_space.committed_size();
- size_t old_mem_size = new_mem_size + bytes;
- gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K",
- name(), old_mem_size/K, bytes/K, new_mem_size/K);
- }
- }
-
- assert(_cmsSpace->unallocated_block() <= _cmsSpace->end(),
- "Inconsistency at end of space");
- assert(chunk_at_end->end() == (uintptr_t*) _cmsSpace->end(),
- "Shrinking is inconsistent");
- return;
- }
-}
// Transfer some number of overflown objects to usual marking
// stack. Return true if some objects were transferred.
bool MarkRefsIntoAndScanClosure::take_from_overflow_list() {
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Thu Jun 26 13:30:43 2014 -0700
@@ -52,7 +52,7 @@
// Concurrent mode failures are currently handled by
// means of a sliding mark-compact.
-class CMSAdaptiveSizePolicy;
+class AdaptiveSizePolicy;
class CMSConcMarkingTask;
class CMSGCAdaptivePolicyCounters;
class CMSTracer;
@@ -1009,8 +1009,7 @@
void icms_wait(); // Called at yield points.
// Adaptive size policy
- CMSAdaptiveSizePolicy* size_policy();
- CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters();
+ AdaptiveSizePolicy* size_policy();
static void print_on_error(outputStream* st);
@@ -1150,9 +1149,6 @@
virtual Generation::Name kind() { return Generation::ConcurrentMarkSweep; }
- // Adaptive size policy
- CMSAdaptiveSizePolicy* size_policy();
-
void set_did_compact(bool v) { _did_compact = v; }
bool refs_discovery_is_atomic() const { return false; }
@@ -1346,37 +1342,6 @@
void rotate_debug_collection_type();
};
-class ASConcurrentMarkSweepGeneration : public ConcurrentMarkSweepGeneration {
-
- // Return the size policy from the heap's collector
- // policy casted to CMSAdaptiveSizePolicy*.
- CMSAdaptiveSizePolicy* cms_size_policy() const;
-
- // Resize the generation based on the adaptive size
- // policy.
- void resize(size_t cur_promo, size_t desired_promo);
-
- // Return the GC counters from the collector policy
- CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters();
-
- virtual void shrink_by(size_t bytes);
-
- public:
- ASConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size,
- int level, CardTableRS* ct,
- bool use_adaptive_freelists,
- FreeBlockDictionary<FreeChunk>::DictionaryChoice
- dictionaryChoice) :
- ConcurrentMarkSweepGeneration(rs, initial_byte_size, level, ct,
- use_adaptive_freelists, dictionaryChoice) {}
-
- virtual const char* short_name() const { return "ASCMS"; }
- virtual Generation::Name kind() { return Generation::ASConcurrentMarkSweep; }
-
- virtual void update_counters();
- virtual void update_counters(size_t used);
-};
-
//
// Closures of various sorts used by CMS to accomplish its work
//
--- a/hotspot/src/share/vm/gc_implementation/parNew/asParNewGeneration.cpp Thu Jun 26 16:01:07 2014 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,657 +0,0 @@
-/*
- * Copyright (c) 2005, 2014, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
-#include "gc_implementation/parNew/asParNewGeneration.hpp"
-#include "gc_implementation/parNew/parNewGeneration.hpp"
-#include "gc_implementation/shared/markSweep.inline.hpp"
-#include "gc_implementation/shared/spaceDecorator.hpp"
-#include "memory/defNewGeneration.inline.hpp"
-#include "memory/referencePolicy.hpp"
-#include "oops/markOop.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
-
-ASParNewGeneration::ASParNewGeneration(ReservedSpace rs,
- size_t initial_byte_size,
- size_t min_byte_size,
- int level) :
- ParNewGeneration(rs, initial_byte_size, level),
- _min_gen_size(min_byte_size) {}
-
-const char* ASParNewGeneration::name() const {
- return "adaptive size par new generation";
-}
-
-void ASParNewGeneration::adjust_desired_tenuring_threshold() {
- assert(UseAdaptiveSizePolicy,
- "Should only be used with UseAdaptiveSizePolicy");
-}
-
-void ASParNewGeneration::resize(size_t eden_size, size_t survivor_size) {
- // Resize the generation if needed. If the generation resize
- // reports false, do not attempt to resize the spaces.
- if (resize_generation(eden_size, survivor_size)) {
- // Then we lay out the spaces inside the generation
- resize_spaces(eden_size, survivor_size);
-
- space_invariants();
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("Young generation size: "
- "desired eden: " SIZE_FORMAT " survivor: " SIZE_FORMAT
- " used: " SIZE_FORMAT " capacity: " SIZE_FORMAT
- " gen limits: " SIZE_FORMAT " / " SIZE_FORMAT,
- eden_size, survivor_size, used(), capacity(),
- max_gen_size(), min_gen_size());
- }
- }
-}
-
-size_t ASParNewGeneration::available_to_min_gen() {
- assert(virtual_space()->committed_size() >= min_gen_size(), "Invariant");
- return virtual_space()->committed_size() - min_gen_size();
-}
-
-// This method assumes that from-space has live data and that
-// any shrinkage of the young gen is limited by location of
-// from-space.
-size_t ASParNewGeneration::available_to_live() const {
-#undef SHRINKS_AT_END_OF_EDEN
-#ifdef SHRINKS_AT_END_OF_EDEN
- size_t delta_in_survivor = 0;
- ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
- const size_t space_alignment = heap->intra_heap_alignment();
- const size_t gen_alignment = heap->object_heap_alignment();
-
- MutableSpace* space_shrinking = NULL;
- if (from_space()->end() > to_space()->end()) {
- space_shrinking = from_space();
- } else {
- space_shrinking = to_space();
- }
-
- // Include any space that is committed but not included in
- // the survivor spaces.
- assert(((HeapWord*)virtual_space()->high()) >= space_shrinking->end(),
- "Survivor space beyond high end");
- size_t unused_committed = pointer_delta(virtual_space()->high(),
- space_shrinking->end(), sizeof(char));
-
- if (space_shrinking->is_empty()) {
- // Don't let the space shrink to 0
- assert(space_shrinking->capacity_in_bytes() >= space_alignment,
- "Space is too small");
- delta_in_survivor = space_shrinking->capacity_in_bytes() - space_alignment;
- } else {
- delta_in_survivor = pointer_delta(space_shrinking->end(),
- space_shrinking->top(),
- sizeof(char));
- }
-
- size_t delta_in_bytes = unused_committed + delta_in_survivor;
- delta_in_bytes = align_size_down(delta_in_bytes, gen_alignment);
- return delta_in_bytes;
-#else
- // The only space available for shrinking is in to-space if it
- // is above from-space.
- if (to()->bottom() > from()->bottom()) {
- const size_t alignment = os::vm_page_size();
- if (to()->capacity() < alignment) {
- return 0;
- } else {
- return to()->capacity() - alignment;
- }
- } else {
- return 0;
- }
-#endif
-}
-
-// Return the number of bytes available for resizing down the young
-// generation. This is the minimum of
-// input "bytes"
-// bytes to the minimum young gen size
-// bytes to the size currently being used + some small extra
-size_t ASParNewGeneration::limit_gen_shrink (size_t bytes) {
- // Allow shrinkage into the current eden but keep eden large enough
- // to maintain the minimum young gen size
- bytes = MIN3(bytes, available_to_min_gen(), available_to_live());
- return align_size_down(bytes, os::vm_page_size());
-}
-
-// Note that the the alignment used is the OS page size as
-// opposed to an alignment associated with the virtual space
-// (as is done in the ASPSYoungGen/ASPSOldGen)
-bool ASParNewGeneration::resize_generation(size_t eden_size,
- size_t survivor_size) {
- const size_t alignment = os::vm_page_size();
- size_t orig_size = virtual_space()->committed_size();
- bool size_changed = false;
-
- // There used to be this guarantee there.
- // guarantee ((eden_size + 2*survivor_size) <= _max_gen_size, "incorrect input arguments");
- // Code below forces this requirement. In addition the desired eden
- // size and desired survivor sizes are desired goals and may
- // exceed the total generation size.
-
- assert(min_gen_size() <= orig_size && orig_size <= max_gen_size(),
- "just checking");
-
- // Adjust new generation size
- const size_t eden_plus_survivors =
- align_size_up(eden_size + 2 * survivor_size, alignment);
- size_t desired_size = MAX2(MIN2(eden_plus_survivors, max_gen_size()),
- min_gen_size());
- assert(desired_size <= max_gen_size(), "just checking");
-
- if (desired_size > orig_size) {
- // Grow the generation
- size_t change = desired_size - orig_size;
- assert(change % alignment == 0, "just checking");
- if (expand(change)) {
- return false; // Error if we fail to resize!
- }
- size_changed = true;
- } else if (desired_size < orig_size) {
- size_t desired_change = orig_size - desired_size;
- assert(desired_change % alignment == 0, "just checking");
-
- desired_change = limit_gen_shrink(desired_change);
-
- if (desired_change > 0) {
- virtual_space()->shrink_by(desired_change);
- reset_survivors_after_shrink();
-
- size_changed = true;
- }
- } else {
- if (Verbose && PrintGC) {
- if (orig_size == max_gen_size()) {
- gclog_or_tty->print_cr("ASParNew generation size at maximum: "
- SIZE_FORMAT "K", orig_size/K);
- } else if (orig_size == min_gen_size()) {
- gclog_or_tty->print_cr("ASParNew generation size at minium: "
- SIZE_FORMAT "K", orig_size/K);
- }
- }
- }
-
- if (size_changed) {
- MemRegion cmr((HeapWord*)virtual_space()->low(),
- (HeapWord*)virtual_space()->high());
- GenCollectedHeap::heap()->barrier_set()->resize_covered_region(cmr);
-
- if (Verbose && PrintGC) {
- size_t current_size = virtual_space()->committed_size();
- gclog_or_tty->print_cr("ASParNew generation size changed: "
- SIZE_FORMAT "K->" SIZE_FORMAT "K",
- orig_size/K, current_size/K);
- }
- }
-
- guarantee(eden_plus_survivors <= virtual_space()->committed_size() ||
- virtual_space()->committed_size() == max_gen_size(), "Sanity");
-
- return true;
-}
-
-void ASParNewGeneration::reset_survivors_after_shrink() {
-
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- HeapWord* new_end = (HeapWord*)virtual_space()->high();
-
- if (from()->end() > to()->end()) {
- assert(new_end >= from()->end(), "Shrinking past from-space");
- } else {
- assert(new_end >= to()->bottom(), "Shrink was too large");
- // Was there a shrink of the survivor space?
- if (new_end < to()->end()) {
- MemRegion mr(to()->bottom(), new_end);
- to()->initialize(mr,
- SpaceDecorator::DontClear,
- SpaceDecorator::DontMangle);
- }
- }
-}
-void ASParNewGeneration::resize_spaces(size_t requested_eden_size,
- size_t requested_survivor_size) {
- assert(UseAdaptiveSizePolicy, "sanity check");
- assert(requested_eden_size > 0 && requested_survivor_size > 0,
- "just checking");
- CollectedHeap* heap = Universe::heap();
- assert(heap->kind() == CollectedHeap::GenCollectedHeap, "Sanity");
-
-
- // We require eden and to space to be empty
- if ((!eden()->is_empty()) || (!to()->is_empty())) {
- return;
- }
-
- size_t cur_eden_size = eden()->capacity();
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr("ASParNew::resize_spaces(requested_eden_size: "
- SIZE_FORMAT
- ", requested_survivor_size: " SIZE_FORMAT ")",
- requested_eden_size, requested_survivor_size);
- gclog_or_tty->print_cr(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") "
- SIZE_FORMAT,
- p2i(eden()->bottom()),
- p2i(eden()->end()),
- pointer_delta(eden()->end(),
- eden()->bottom(),
- sizeof(char)));
- gclog_or_tty->print_cr(" from: [" PTR_FORMAT ".." PTR_FORMAT ") "
- SIZE_FORMAT,
- p2i(from()->bottom()),
- p2i(from()->end()),
- pointer_delta(from()->end(),
- from()->bottom(),
- sizeof(char)));
- gclog_or_tty->print_cr(" to: [" PTR_FORMAT ".." PTR_FORMAT ") "
- SIZE_FORMAT,
- p2i(to()->bottom()),
- p2i(to()->end()),
- pointer_delta( to()->end(),
- to()->bottom(),
- sizeof(char)));
- }
-
- // There's nothing to do if the new sizes are the same as the current
- if (requested_survivor_size == to()->capacity() &&
- requested_survivor_size == from()->capacity() &&
- requested_eden_size == eden()->capacity()) {
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" capacities are the right sizes, returning");
- }
- return;
- }
-
- char* eden_start = (char*)eden()->bottom();
- char* eden_end = (char*)eden()->end();
- char* from_start = (char*)from()->bottom();
- char* from_end = (char*)from()->end();
- char* to_start = (char*)to()->bottom();
- char* to_end = (char*)to()->end();
-
- const size_t alignment = os::vm_page_size();
- const bool maintain_minimum =
- (requested_eden_size + 2 * requested_survivor_size) <= min_gen_size();
-
- // Check whether from space is below to space
- if (from_start < to_start) {
- // Eden, from, to
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" Eden, from, to:");
- }
-
- // Set eden
- // "requested_eden_size" is a goal for the size of eden
- // and may not be attainable. "eden_size" below is
- // calculated based on the location of from-space and
- // the goal for the size of eden. from-space is
- // fixed in place because it contains live data.
- // The calculation is done this way to avoid 32bit
- // overflow (i.e., eden_start + requested_eden_size
- // may too large for representation in 32bits).
- size_t eden_size;
- if (maintain_minimum) {
- // Only make eden larger than the requested size if
- // the minimum size of the generation has to be maintained.
- // This could be done in general but policy at a higher
- // level is determining a requested size for eden and that
- // should be honored unless there is a fundamental reason.
- eden_size = pointer_delta(from_start,
- eden_start,
- sizeof(char));
- } else {
- eden_size = MIN2(requested_eden_size,
- pointer_delta(from_start, eden_start, sizeof(char)));
- }
-
- eden_size = align_size_down(eden_size, alignment);
- eden_end = eden_start + eden_size;
- assert(eden_end >= eden_start, "addition overflowed");
-
- // To may resize into from space as long as it is clear of live data.
- // From space must remain page aligned, though, so we need to do some
- // extra calculations.
-
- // First calculate an optimal to-space
- to_end = (char*)virtual_space()->high();
- to_start = (char*)pointer_delta(to_end, (char*)requested_survivor_size,
- sizeof(char));
-
- // Does the optimal to-space overlap from-space?
- if (to_start < (char*)from()->end()) {
- // Calculate the minimum offset possible for from_end
- size_t from_size = pointer_delta(from()->top(), from_start, sizeof(char));
-
- // Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
- if (from_size == 0) {
- from_size = alignment;
- } else {
- from_size = align_size_up(from_size, alignment);
- }
-
- from_end = from_start + from_size;
- assert(from_end > from_start, "addition overflow or from_size problem");
-
- guarantee(from_end <= (char*)from()->end(), "from_end moved to the right");
-
- // Now update to_start with the new from_end
- to_start = MAX2(from_end, to_start);
- } else {
- // If shrinking, move to-space down to abut the end of from-space
- // so that shrinking will move to-space down. If not shrinking
- // to-space is moving up to allow for growth on the next expansion.
- if (requested_eden_size <= cur_eden_size) {
- to_start = from_end;
- if (to_start + requested_survivor_size > to_start) {
- to_end = to_start + requested_survivor_size;
- }
- }
- // else leave to_end pointing to the high end of the virtual space.
- }
-
- guarantee(to_start != to_end, "to space is zero sized");
-
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" [eden_start .. eden_end): "
- "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- p2i(eden_start),
- p2i(eden_end),
- pointer_delta(eden_end, eden_start, sizeof(char)));
- gclog_or_tty->print_cr(" [from_start .. from_end): "
- "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- p2i(from_start),
- p2i(from_end),
- pointer_delta(from_end, from_start, sizeof(char)));
- gclog_or_tty->print_cr(" [ to_start .. to_end): "
- "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- p2i(to_start),
- p2i(to_end),
- pointer_delta( to_end, to_start, sizeof(char)));
- }
- } else {
- // Eden, to, from
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" Eden, to, from:");
- }
-
- // Calculate the to-space boundaries based on
- // the start of from-space.
- to_end = from_start;
- to_start = (char*)pointer_delta(from_start,
- (char*)requested_survivor_size,
- sizeof(char));
- // Calculate the ideal eden boundaries.
- // eden_end is already at the bottom of the generation
- assert(eden_start == virtual_space()->low(),
- "Eden is not starting at the low end of the virtual space");
- if (eden_start + requested_eden_size >= eden_start) {
- eden_end = eden_start + requested_eden_size;
- } else {
- eden_end = to_start;
- }
-
- // Does eden intrude into to-space? to-space
- // gets priority but eden is not allowed to shrink
- // to 0.
- if (eden_end > to_start) {
- eden_end = to_start;
- }
-
- // Don't let eden shrink down to 0 or less.
- eden_end = MAX2(eden_end, eden_start + alignment);
- assert(eden_start + alignment >= eden_start, "Overflow");
-
- size_t eden_size;
- if (maintain_minimum) {
- // Use all the space available.
- eden_end = MAX2(eden_end, to_start);
- eden_size = pointer_delta(eden_end, eden_start, sizeof(char));
- eden_size = MIN2(eden_size, cur_eden_size);
- } else {
- eden_size = pointer_delta(eden_end, eden_start, sizeof(char));
- }
- eden_size = align_size_down(eden_size, alignment);
- assert(maintain_minimum || eden_size <= requested_eden_size,
- "Eden size is too large");
- assert(eden_size >= alignment, "Eden size is too small");
- eden_end = eden_start + eden_size;
-
- // Move to-space down to eden.
- if (requested_eden_size < cur_eden_size) {
- to_start = eden_end;
- if (to_start + requested_survivor_size > to_start) {
- to_end = MIN2(from_start, to_start + requested_survivor_size);
- } else {
- to_end = from_start;
- }
- }
-
- // eden_end may have moved so again make sure
- // the to-space and eden don't overlap.
- to_start = MAX2(eden_end, to_start);
-
- // from-space
- size_t from_used = from()->used();
- if (requested_survivor_size > from_used) {
- if (from_start + requested_survivor_size >= from_start) {
- from_end = from_start + requested_survivor_size;
- }
- if (from_end > virtual_space()->high()) {
- from_end = virtual_space()->high();
- }
- }
-
- assert(to_start >= eden_end, "to-space should be above eden");
- if (PrintAdaptiveSizePolicy && Verbose) {
- gclog_or_tty->print_cr(" [eden_start .. eden_end): "
- "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- p2i(eden_start),
- p2i(eden_end),
- pointer_delta(eden_end, eden_start, sizeof(char)));
- gclog_or_tty->print_cr(" [ to_start .. to_end): "
- "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- p2i(to_start),
- p2i(to_end),
- pointer_delta( to_end, to_start, sizeof(char)));
- gclog_or_tty->print_cr(" [from_start .. from_end): "
- "[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- p2i(from_start),
- p2i(from_end),
- pointer_delta(from_end, from_start, sizeof(char)));
- }
- }
-
-
- guarantee((HeapWord*)from_start <= from()->bottom(),
- "from start moved to the right");
- guarantee((HeapWord*)from_end >= from()->top(),
- "from end moved into live data");
- assert(is_object_aligned((intptr_t)eden_start), "checking alignment");
- assert(is_object_aligned((intptr_t)from_start), "checking alignment");
- assert(is_object_aligned((intptr_t)to_start), "checking alignment");
-
- MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
- MemRegion toMR ((HeapWord*)to_start, (HeapWord*)to_end);
- MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
-
- // Let's make sure the call to initialize doesn't reset "top"!
- HeapWord* old_from_top = from()->top();
-
- // For PrintAdaptiveSizePolicy block below
- size_t old_from = from()->capacity();
- size_t old_to = to()->capacity();
-
- // If not clearing the spaces, do some checking to verify that
- // the spaces are already mangled.
-
- // Must check mangling before the spaces are reshaped. Otherwise,
- // the bottom or end of one space may have moved into another
- // a failure of the check may not correctly indicate which space
- // is not properly mangled.
- if (ZapUnusedHeapArea) {
- HeapWord* limit = (HeapWord*) virtual_space()->high();
- eden()->check_mangled_unused_area(limit);
- from()->check_mangled_unused_area(limit);
- to()->check_mangled_unused_area(limit);
- }
-
- // The call to initialize NULL's the next compaction space
- eden()->initialize(edenMR,
- SpaceDecorator::Clear,
- SpaceDecorator::DontMangle);
- eden()->set_next_compaction_space(from());
- to()->initialize(toMR ,
- SpaceDecorator::Clear,
- SpaceDecorator::DontMangle);
- from()->initialize(fromMR,
- SpaceDecorator::DontClear,
- SpaceDecorator::DontMangle);
-
- assert(from()->top() == old_from_top, "from top changed!");
-
- if (PrintAdaptiveSizePolicy) {
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- assert(gch->kind() == CollectedHeap::GenCollectedHeap, "Sanity");
-
- gclog_or_tty->print("AdaptiveSizePolicy::survivor space sizes: "
- "collection: %d "
- "(" SIZE_FORMAT ", " SIZE_FORMAT ") -> "
- "(" SIZE_FORMAT ", " SIZE_FORMAT ") ",
- gch->total_collections(),
- old_from, old_to,
- from()->capacity(),
- to()->capacity());
- gclog_or_tty->cr();
- }
-}
-
-void ASParNewGeneration::compute_new_size() {
- GenCollectedHeap* gch = GenCollectedHeap::heap();
- assert(gch->kind() == CollectedHeap::GenCollectedHeap,
- "not a CMS generational heap");
-
-
- CMSAdaptiveSizePolicy* size_policy =
- (CMSAdaptiveSizePolicy*)gch->gen_policy()->size_policy();
- assert(size_policy->is_gc_cms_adaptive_size_policy(),
- "Wrong type of size policy");
-
- size_t survived = from()->used();
- if (!survivor_overflow()) {
- // Keep running averages on how much survived
- size_policy->avg_survived()->sample(survived);
- } else {
- size_t promoted =
- (size_t) next_gen()->gc_stats()->avg_promoted()->last_sample();
- assert(promoted < gch->capacity(), "Conversion problem?");
- size_t survived_guess = survived + promoted;
- size_policy->avg_survived()->sample(survived_guess);
- }
-
- size_t survivor_limit = max_survivor_size();
- _tenuring_threshold =
- size_policy->compute_survivor_space_size_and_threshold(
- _survivor_overflow,
- _tenuring_threshold,
- survivor_limit);
- size_policy->avg_young_live()->sample(used());
- size_policy->avg_eden_live()->sample(eden()->used());
-
- size_policy->compute_eden_space_size(eden()->capacity(), max_gen_size());
-
- resize(size_policy->calculated_eden_size_in_bytes(),
- size_policy->calculated_survivor_size_in_bytes());
-
- if (UsePerfData) {
- CMSGCAdaptivePolicyCounters* counters =
- (CMSGCAdaptivePolicyCounters*) gch->collector_policy()->counters();
- assert(counters->kind() ==
- GCPolicyCounters::CMSGCAdaptivePolicyCountersKind,
- "Wrong kind of counters");
- counters->update_tenuring_threshold(_tenuring_threshold);
- counters->update_survivor_overflowed(_survivor_overflow);
- counters->update_young_capacity(capacity());
- }
-}
-
-
-#ifndef PRODUCT
-// Changes from PSYoungGen version
-// value of "alignment"
-void ASParNewGeneration::space_invariants() {
- const size_t alignment = os::vm_page_size();
-
- // Currently, our eden size cannot shrink to zero
- guarantee(eden()->capacity() >= alignment, "eden too small");
- guarantee(from()->capacity() >= alignment, "from too small");
- guarantee(to()->capacity() >= alignment, "to too small");
-
- // Relationship of spaces to each other
- char* eden_start = (char*)eden()->bottom();
- char* eden_end = (char*)eden()->end();
- char* from_start = (char*)from()->bottom();
- char* from_end = (char*)from()->end();
- char* to_start = (char*)to()->bottom();
- char* to_end = (char*)to()->end();
-
- guarantee(eden_start >= virtual_space()->low(), "eden bottom");
- guarantee(eden_start < eden_end, "eden space consistency");
- guarantee(from_start < from_end, "from space consistency");
- guarantee(to_start < to_end, "to space consistency");
-
- // Check whether from space is below to space
- if (from_start < to_start) {
- // Eden, from, to
- guarantee(eden_end <= from_start, "eden/from boundary");
- guarantee(from_end <= to_start, "from/to boundary");
- guarantee(to_end <= virtual_space()->high(), "to end");
- } else {
- // Eden, to, from
- guarantee(eden_end <= to_start, "eden/to boundary");
- guarantee(to_end <= from_start, "to/from boundary");
- guarantee(from_end <= virtual_space()->high(), "from end");
- }
-
- // More checks that the virtual space is consistent with the spaces
- assert(virtual_space()->committed_size() >=
- (eden()->capacity() +
- to()->capacity() +
- from()->capacity()), "Committed size is inconsistent");
- assert(virtual_space()->committed_size() <= virtual_space()->reserved_size(),
- "Space invariant");
- char* eden_top = (char*)eden()->top();
- char* from_top = (char*)from()->top();
- char* to_top = (char*)to()->top();
- assert(eden_top <= virtual_space()->high(), "eden top");
- assert(from_top <= virtual_space()->high(), "from top");
- assert(to_top <= virtual_space()->high(), "to top");
-}
-#endif
--- a/hotspot/src/share/vm/gc_implementation/parNew/asParNewGeneration.hpp Thu Jun 26 16:01:07 2014 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2005, 2010, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#ifndef SHARE_VM_GC_IMPLEMENTATION_PARNEW_ASPARNEWGENERATION_HPP
-#define SHARE_VM_GC_IMPLEMENTATION_PARNEW_ASPARNEWGENERATION_HPP
-
-#include "gc_implementation/parNew/parNewGeneration.hpp"
-#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
-
-// A Generation that does parallel young-gen collection extended
-// for adaptive size policy.
-
-// Division of generation into spaces
-// done by DefNewGeneration::compute_space_boundaries()
-// +---------------+
-// | uncommitted |
-// |---------------|
-// | ss0 |
-// |---------------|
-// | ss1 |
-// |---------------|
-// | |
-// | eden |
-// | |
-// +---------------+ <-- low end of VirtualSpace
-//
-class ASParNewGeneration: public ParNewGeneration {
-
- size_t _min_gen_size;
-
- // Resize the generation based on the desired sizes of
- // the constituent spaces.
- bool resize_generation(size_t eden_size, size_t survivor_size);
- // Resize the spaces based on their desired sizes but
- // respecting the maximum size of the generation.
- void resize_spaces(size_t eden_size, size_t survivor_size);
- // Return the byte size remaining to the minimum generation size.
- size_t available_to_min_gen();
- // Return the byte size remaining to the live data in the generation.
- size_t available_to_live() const;
- // Return the byte size that the generation is allowed to shrink.
- size_t limit_gen_shrink(size_t bytes);
- // Reset the size of the spaces after a shrink of the generation.
- void reset_survivors_after_shrink();
-
- // Accessor
- VirtualSpace* virtual_space() { return &_virtual_space; }
-
- virtual void adjust_desired_tenuring_threshold();
-
- public:
-
- ASParNewGeneration(ReservedSpace rs,
- size_t initial_byte_size,
- size_t min_byte_size,
- int level);
-
- virtual const char* short_name() const { return "ASParNew"; }
- virtual const char* name() const;
- virtual Generation::Name kind() { return ASParNew; }
-
- // Change the sizes of eden and the survivor spaces in
- // the generation. The parameters are desired sizes
- // and are not guaranteed to be met. For example, if
- // the total is larger than the generation.
- void resize(size_t eden_size, size_t survivor_size);
-
- virtual void compute_new_size();
-
- size_t max_gen_size() { return _reserved.byte_size(); }
- size_t min_gen_size() const { return _min_gen_size; }
-
- // Space boundary invariant checker
- void space_invariants() PRODUCT_RETURN;
-};
-
-#endif // SHARE_VM_GC_IMPLEMENTATION_PARNEW_ASPARNEWGENERATION_HPP
--- a/hotspot/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp Thu Jun 26 13:30:43 2014 -0700
@@ -507,7 +507,7 @@
// always fail (never do the print based on the interval test).
return PrintGCDetails &&
UseAdaptiveSizePolicy &&
- (UseParallelGC || UseConcMarkSweepGC) &&
+ UseParallelGC &&
(AdaptiveSizePolicyOutputInterval > 0) &&
((count == 0) ||
((count % AdaptiveSizePolicyOutputInterval) == 0));
--- a/hotspot/src/share/vm/gc_implementation/shared/gcUtil.hpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/gc_implementation/shared/gcUtil.hpp Thu Jun 26 13:30:43 2014 -0700
@@ -216,16 +216,4 @@
bool increment_will_decrease();
};
-class GCPauseTimer : StackObj {
- elapsedTimer* _timer;
- public:
- GCPauseTimer(elapsedTimer* timer) {
- _timer = timer;
- _timer->stop();
- }
- ~GCPauseTimer() {
- _timer->start();
- }
-};
-
#endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_GCUTIL_HPP
--- a/hotspot/src/share/vm/memory/collectorPolicy.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/memory/collectorPolicy.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -40,10 +40,6 @@
#include "runtime/thread.inline.hpp"
#include "runtime/vmThread.hpp"
#include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
-#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
-#endif // INCLUDE_ALL_GCS
// CollectorPolicy methods
--- a/hotspot/src/share/vm/memory/collectorPolicy.hpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/memory/collectorPolicy.hpp Thu Jun 26 13:30:43 2014 -0700
@@ -115,7 +115,6 @@
CollectorPolicyKind,
GenCollectorPolicyKind,
ConcurrentMarkSweepPolicyKind,
- ASConcurrentMarkSweepPolicyKind,
G1CollectorPolicyKind
};
--- a/hotspot/src/share/vm/memory/genCollectedHeap.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -202,13 +202,11 @@
guarantee(policy->is_generation_policy(), "Illegal policy type");
DefNewGeneration* def_new_gen = (DefNewGeneration*) get_gen(0);
assert(def_new_gen->kind() == Generation::DefNew ||
- def_new_gen->kind() == Generation::ParNew ||
- def_new_gen->kind() == Generation::ASParNew,
+ def_new_gen->kind() == Generation::ParNew,
"Wrong generation kind");
Generation* old_gen = get_gen(1);
assert(old_gen->kind() == Generation::ConcurrentMarkSweep ||
- old_gen->kind() == Generation::ASConcurrentMarkSweep ||
old_gen->kind() == Generation::MarkSweepCompact,
"Wrong generation kind");
@@ -573,9 +571,6 @@
}
}
- AdaptiveSizePolicy* sp = gen_policy()->size_policy();
- AdaptiveSizePolicyOutput(sp, total_collections());
-
print_heap_after_gc();
#ifdef TRACESPINNING
@@ -724,8 +719,7 @@
#if INCLUDE_ALL_GCS
bool GenCollectedHeap::create_cms_collector() {
- assert(((_gens[1]->kind() == Generation::ConcurrentMarkSweep) ||
- (_gens[1]->kind() == Generation::ASConcurrentMarkSweep)),
+ assert(_gens[1]->kind() == Generation::ConcurrentMarkSweep,
"Unexpected generation kinds");
// Skip two header words in the block content verification
NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();)
--- a/hotspot/src/share/vm/memory/generation.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/memory/generation.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -154,8 +154,7 @@
DefNewGeneration* Generation::as_DefNewGeneration() {
assert((kind() == Generation::DefNew) ||
- (kind() == Generation::ParNew) ||
- (kind() == Generation::ASParNew),
+ (kind() == Generation::ParNew),
"Wrong youngest generation type");
return (DefNewGeneration*) this;
}
--- a/hotspot/src/share/vm/memory/generation.hpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/memory/generation.hpp Thu Jun 26 13:30:43 2014 -0700
@@ -131,8 +131,6 @@
public:
// The set of possible generation kinds.
enum Name {
- ASParNew,
- ASConcurrentMarkSweep,
DefNew,
ParNew,
MarkSweepCompact,
--- a/hotspot/src/share/vm/memory/generationSpec.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/memory/generationSpec.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -32,7 +32,6 @@
#include "runtime/java.hpp"
#include "utilities/macros.hpp"
#if INCLUDE_ALL_GCS
-#include "gc_implementation/parNew/asParNewGeneration.hpp"
#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
#include "gc_implementation/parNew/parNewGeneration.hpp"
#endif // INCLUDE_ALL_GCS
@@ -50,12 +49,6 @@
case Generation::ParNew:
return new ParNewGeneration(rs, init_size(), level);
- case Generation::ASParNew:
- return new ASParNewGeneration(rs,
- init_size(),
- init_size() /* min size */,
- level);
-
case Generation::ConcurrentMarkSweep: {
assert(UseConcMarkSweepGC, "UseConcMarkSweepGC should be set");
CardTableRS* ctrs = remset->as_CardTableRS();
@@ -75,26 +68,6 @@
return g;
}
-
- case Generation::ASConcurrentMarkSweep: {
- assert(UseConcMarkSweepGC, "UseConcMarkSweepGC should be set");
- CardTableRS* ctrs = remset->as_CardTableRS();
- if (ctrs == NULL) {
- vm_exit_during_initialization("Rem set incompatibility.");
- }
- // Otherwise
- // The constructor creates the CMSCollector if needed,
- // else registers with an existing CMSCollector
-
- ASConcurrentMarkSweepGeneration* g = NULL;
- g = new ASConcurrentMarkSweepGeneration(rs,
- init_size(), level, ctrs, UseCMSAdaptiveFreeLists,
- (FreeBlockDictionary<FreeChunk>::DictionaryChoice)CMSDictionaryChoice);
-
- g->initialize_performance_counters();
-
- return g;
- }
#endif // INCLUDE_ALL_GCS
default:
--- a/hotspot/src/share/vm/memory/universe.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/memory/universe.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -72,7 +72,7 @@
#include "utilities/preserveException.hpp"
#include "utilities/macros.hpp"
#if INCLUDE_ALL_GCS
-#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
+#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
#include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
@@ -802,13 +802,9 @@
gc_policy = new MarkSweepPolicy();
} else if (UseConcMarkSweepGC) {
#if INCLUDE_ALL_GCS
- if (UseAdaptiveSizePolicy) {
- gc_policy = new ASConcurrentMarkSweepPolicy();
- } else {
- gc_policy = new ConcurrentMarkSweepPolicy();
- }
+ gc_policy = new ConcurrentMarkSweepPolicy();
#else // INCLUDE_ALL_GCS
- fatal("UseConcMarkSweepGC not supported in this VM.");
+ fatal("UseConcMarkSweepGC not supported in this VM.");
#endif // INCLUDE_ALL_GCS
} else { // default old generation
gc_policy = new MarkSweepPolicy();
--- a/hotspot/src/share/vm/services/memoryService.cpp Thu Jun 26 16:01:07 2014 +0200
+++ b/hotspot/src/share/vm/services/memoryService.cpp Thu Jun 26 13:30:43 2014 -0700
@@ -136,7 +136,6 @@
break;
#if INCLUDE_ALL_GCS
case Generation::ParNew:
- case Generation::ASParNew:
_minor_gc_manager = MemoryManager::get_parnew_memory_manager();
break;
#endif // INCLUDE_ALL_GCS
@@ -268,7 +267,6 @@
#if INCLUDE_ALL_GCS
case Generation::ParNew:
- case Generation::ASParNew:
{
assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
// Add a memory pool for each space and young gen doesn't
@@ -300,7 +298,6 @@
#if INCLUDE_ALL_GCS
case Generation::ConcurrentMarkSweep:
- case Generation::ASConcurrentMarkSweep:
{
assert(major_mgr != NULL && minor_mgr == NULL, "Should have only one manager");
ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*) gen;
@@ -548,23 +545,20 @@
// GC manager type depends on the type of Generation. Depending on the space
// availablity and vm options the gc uses major gc manager or minor gc
// manager or both. The type of gc manager depends on the generation kind.
-// For DefNew, ParNew and ASParNew generation doing scavenge gc uses minor
-// gc manager (so _fullGC is set to false ) and for other generation kinds
-// doing mark-sweep-compact uses major gc manager (so _fullGC is set
-// to true).
+// For DefNew and ParNew generation doing scavenge gc uses minor gc manager (so
+// _fullGC is set to false ) and for other generation kinds doing
+// mark-sweep-compact uses major gc manager (so _fullGC is set to true).
TraceMemoryManagerStats::TraceMemoryManagerStats(Generation::Name kind, GCCause::Cause cause) {
switch (kind) {
case Generation::DefNew:
#if INCLUDE_ALL_GCS
case Generation::ParNew:
- case Generation::ASParNew:
#endif // INCLUDE_ALL_GCS
_fullGC=false;
break;
case Generation::MarkSweepCompact:
#if INCLUDE_ALL_GCS
case Generation::ConcurrentMarkSweep:
- case Generation::ASConcurrentMarkSweep:
#endif // INCLUDE_ALL_GCS
_fullGC=true;
break;