changeset 6729:89b10a2e5029

8034246: remove CMS and ParNew adaptive size policy code Reviewed-by: tschatzl, jwilhelm, mgerdin
author jcoomes
date Thu, 26 Jun 2014 13:30:43 -0700
parents aaec45ac36d6
children 1d62ae819013
files src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.cpp src/share/vm/gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp src/share/vm/gc_implementation/parNew/asParNewGeneration.cpp src/share/vm/gc_implementation/parNew/asParNewGeneration.hpp src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp src/share/vm/gc_implementation/shared/gcUtil.hpp src/share/vm/memory/collectorPolicy.cpp src/share/vm/memory/collectorPolicy.hpp src/share/vm/memory/genCollectedHeap.cpp src/share/vm/memory/generation.cpp src/share/vm/memory/generation.hpp src/share/vm/memory/generationSpec.cpp src/share/vm/memory/universe.cpp src/share/vm/services/memoryService.cpp
diffstat 21 files changed, 30 insertions(+), 3652 deletions(-) [+]
line wrap: on
line diff
--- a/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/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/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/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/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/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/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/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/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/gc_implementation/shared/gcUtil.hpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/memory/collectorPolicy.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/memory/collectorPolicy.hpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/src/share/vm/memory/collectorPolicy.hpp	Thu Jun 26 13:30:43 2014 -0700
@@ -115,7 +115,6 @@
     CollectorPolicyKind,
     GenCollectorPolicyKind,
     ConcurrentMarkSweepPolicyKind,
-    ASConcurrentMarkSweepPolicyKind,
     G1CollectorPolicyKind
   };
 
--- a/src/share/vm/memory/genCollectedHeap.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/memory/generation.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/memory/generation.hpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/memory/generationSpec.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/memory/universe.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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/src/share/vm/services/memoryService.cpp	Thu Jun 26 16:01:07 2014 +0200
+++ b/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;