/*

 * 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();

}