duke@435: /*
mikael@4153:  * Copyright (c) 2004, 2012, Oracle and/or its affiliates. All rights reserved.
duke@435:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435:  *
duke@435:  * This code is free software; you can redistribute it and/or modify it
duke@435:  * under the terms of the GNU General Public License version 2 only, as
duke@435:  * published by the Free Software Foundation.
duke@435:  *
duke@435:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@435:  * version 2 for more details (a copy is included in the LICENSE file that
duke@435:  * accompanied this code).
duke@435:  *
duke@435:  * You should have received a copy of the GNU General Public License version
duke@435:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@435:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435:  *
trims@1907:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907:  * or visit www.oracle.com if you need additional information or have any
trims@1907:  * questions.
duke@435:  *
duke@435:  */
duke@435: 
stefank@2314: #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_ADAPTIVESIZEPOLICY_HPP
stefank@2314: #define SHARE_VM_GC_IMPLEMENTATION_SHARED_ADAPTIVESIZEPOLICY_HPP
stefank@2314: 
stefank@2314: #include "gc_implementation/shared/gcUtil.hpp"
stefank@2314: #include "gc_interface/collectedHeap.hpp"
stefank@2314: #include "gc_interface/gcCause.hpp"
stefank@2314: #include "memory/allocation.hpp"
stefank@2314: #include "memory/universe.hpp"
stefank@2314: 
duke@435: // This class keeps statistical information and computes the
duke@435: // size of the heap.
duke@435: 
duke@435: // Forward decls
duke@435: class elapsedTimer;
jmasa@1822: class CollectorPolicy;
duke@435: 
zgu@3900: class AdaptiveSizePolicy : public CHeapObj<mtGC> {
duke@435:  friend class GCAdaptivePolicyCounters;
duke@435:  friend class PSGCAdaptivePolicyCounters;
duke@435:  friend class CMSGCAdaptivePolicyCounters;
duke@435:  protected:
duke@435: 
duke@435:   enum GCPolicyKind {
duke@435:     _gc_adaptive_size_policy,
duke@435:     _gc_ps_adaptive_size_policy,
duke@435:     _gc_cms_adaptive_size_policy
duke@435:   };
duke@435:   virtual GCPolicyKind kind() const { return _gc_adaptive_size_policy; }
duke@435: 
duke@435:   enum SizePolicyTrueValues {
duke@435:     decrease_old_gen_for_throughput_true = -7,
duke@435:     decrease_young_gen_for_througput_true = -6,
duke@435: 
duke@435:     increase_old_gen_for_min_pauses_true = -5,
duke@435:     decrease_old_gen_for_min_pauses_true = -4,
duke@435:     decrease_young_gen_for_maj_pauses_true = -3,
duke@435:     increase_young_gen_for_min_pauses_true = -2,
duke@435:     increase_old_gen_for_maj_pauses_true = -1,
duke@435: 
duke@435:     decrease_young_gen_for_min_pauses_true = 1,
duke@435:     decrease_old_gen_for_maj_pauses_true = 2,
duke@435:     increase_young_gen_for_maj_pauses_true = 3,
duke@435: 
duke@435:     increase_old_gen_for_throughput_true = 4,
duke@435:     increase_young_gen_for_througput_true = 5,
duke@435: 
duke@435:     decrease_young_gen_for_footprint_true = 6,
duke@435:     decrease_old_gen_for_footprint_true = 7,
duke@435:     decide_at_full_gc_true = 8
duke@435:   };
duke@435: 
duke@435:   // Goal for the fraction of the total time during which application
duke@435:   // threads run.
duke@435:   const double _throughput_goal;
duke@435: 
duke@435:   // Last calculated sizes, in bytes, and aligned
duke@435:   size_t _eden_size;        // calculated eden free space in bytes
duke@435:   size_t _promo_size;       // calculated cms gen free space in bytes
duke@435: 
duke@435:   size_t _survivor_size;    // calculated survivor size in bytes
duke@435: 
duke@435:   // This is a hint for the heap:  we've detected that gc times
duke@435:   // are taking longer than GCTimeLimit allows.
jmasa@1822:   bool _gc_overhead_limit_exceeded;
jmasa@1822:   // Use for diagnostics only.  If UseGCOverheadLimit is false,
duke@435:   // this variable is still set.
jmasa@1822:   bool _print_gc_overhead_limit_would_be_exceeded;
duke@435:   // Count of consecutive GC that have exceeded the
duke@435:   // GC time limit criterion.
jmasa@1822:   uint _gc_overhead_limit_count;
jmasa@1822:   // This flag signals that GCTimeLimit is being exceeded
jmasa@1822:   // but may not have done so for the required number of consequetive
jmasa@1822:   // collections.
duke@435: 
duke@435:   // Minor collection timers used to determine both
duke@435:   // pause and interval times for collections.
duke@435:   static elapsedTimer _minor_timer;
duke@435: 
duke@435:   // Major collection timers, used to determine both
duke@435:   // pause and interval times for collections
duke@435:   static elapsedTimer _major_timer;
duke@435: 
duke@435:   // Time statistics
duke@435:   AdaptivePaddedAverage*   _avg_minor_pause;
duke@435:   AdaptiveWeightedAverage* _avg_minor_interval;
duke@435:   AdaptiveWeightedAverage* _avg_minor_gc_cost;
duke@435: 
duke@435:   AdaptiveWeightedAverage* _avg_major_interval;
duke@435:   AdaptiveWeightedAverage* _avg_major_gc_cost;
duke@435: 
duke@435:   // Footprint statistics
duke@435:   AdaptiveWeightedAverage* _avg_young_live;
duke@435:   AdaptiveWeightedAverage* _avg_eden_live;
duke@435:   AdaptiveWeightedAverage* _avg_old_live;
duke@435: 
duke@435:   // Statistics for survivor space calculation for young generation
duke@435:   AdaptivePaddedAverage*   _avg_survived;
duke@435: 
duke@435:   // Objects that have been directly allocated in the old generation.
duke@435:   AdaptivePaddedNoZeroDevAverage*   _avg_pretenured;
duke@435: 
duke@435:   // Variable for estimating the major and minor pause times.
duke@435:   // These variables represent linear least-squares fits of
duke@435:   // the data.
duke@435:   //   minor pause time vs. old gen size
duke@435:   LinearLeastSquareFit* _minor_pause_old_estimator;
duke@435:   //   minor pause time vs. young gen size
duke@435:   LinearLeastSquareFit* _minor_pause_young_estimator;
duke@435: 
duke@435:   // Variables for estimating the major and minor collection costs
duke@435:   //   minor collection time vs. young gen size
duke@435:   LinearLeastSquareFit* _minor_collection_estimator;
duke@435:   //   major collection time vs. cms gen size
duke@435:   LinearLeastSquareFit* _major_collection_estimator;
duke@435: 
duke@435:   // These record the most recent collection times.  They
duke@435:   // are available as an alternative to using the averages
duke@435:   // for making ergonomic decisions.
duke@435:   double _latest_minor_mutator_interval_seconds;
duke@435: 
duke@435:   // Allowed difference between major and minor gc times, used
duke@435:   // for computing tenuring_threshold.
duke@435:   const double _threshold_tolerance_percent;
duke@435: 
duke@435:   const double _gc_pause_goal_sec; // goal for maximum gc pause
duke@435: 
duke@435:   // Flag indicating that the adaptive policy is ready to use
duke@435:   bool _young_gen_policy_is_ready;
duke@435: 
duke@435:   // decrease/increase the young generation for minor pause time
duke@435:   int _change_young_gen_for_min_pauses;
duke@435: 
duke@435:   // decrease/increase the old generation for major pause time
duke@435:   int _change_old_gen_for_maj_pauses;
duke@435: 
duke@435:   //   change old geneneration for throughput
duke@435:   int _change_old_gen_for_throughput;
duke@435: 
duke@435:   //   change young generation for throughput
duke@435:   int _change_young_gen_for_throughput;
duke@435: 
duke@435:   // Flag indicating that the policy would
duke@435:   //   increase the tenuring threshold because of the total major gc cost
duke@435:   //   is greater than the total minor gc cost
duke@435:   bool _increment_tenuring_threshold_for_gc_cost;
duke@435:   //   decrease the tenuring threshold because of the the total minor gc
duke@435:   //   cost is greater than the total major gc cost
duke@435:   bool _decrement_tenuring_threshold_for_gc_cost;
duke@435:   //   decrease due to survivor size limit
duke@435:   bool _decrement_tenuring_threshold_for_survivor_limit;
duke@435: 
duke@435:   //   decrease generation sizes for footprint
duke@435:   int _decrease_for_footprint;
duke@435: 
duke@435:   // Set if the ergonomic decisions were made at a full GC.
duke@435:   int _decide_at_full_gc;
duke@435: 
duke@435:   // Changing the generation sizing depends on the data that is
duke@435:   // gathered about the effects of changes on the pause times and
duke@435:   // throughput.  These variable count the number of data points
duke@435:   // gathered.  The policy may use these counters as a threshhold
duke@435:   // for reliable data.
duke@435:   julong _young_gen_change_for_minor_throughput;
duke@435:   julong _old_gen_change_for_major_throughput;
duke@435: 
jmasa@3294:   static const uint GCWorkersPerJavaThread  = 2;
jmasa@3294: 
duke@435:   // Accessors
duke@435: 
duke@435:   double gc_pause_goal_sec() const { return _gc_pause_goal_sec; }
duke@435:   // The value returned is unitless:  it's the proportion of time
duke@435:   // spent in a particular collection type.
duke@435:   // An interval time will be 0.0 if a collection type hasn't occurred yet.
duke@435:   // The 1.4.2 implementation put a floor on the values of major_gc_cost
duke@435:   // and minor_gc_cost.  This was useful because of the way major_gc_cost
duke@435:   // and minor_gc_cost was used in calculating the sizes of the generations.
duke@435:   // Do not use a floor in this implementation because any finite value
duke@435:   // will put a limit on the throughput that can be achieved and any
duke@435:   // throughput goal above that limit will drive the generations sizes
duke@435:   // to extremes.
duke@435:   double major_gc_cost() const {
duke@435:     return MAX2(0.0F, _avg_major_gc_cost->average());
duke@435:   }
duke@435: 
duke@435:   // The value returned is unitless:  it's the proportion of time
duke@435:   // spent in a particular collection type.
duke@435:   // An interval time will be 0.0 if a collection type hasn't occurred yet.
duke@435:   // The 1.4.2 implementation put a floor on the values of major_gc_cost
duke@435:   // and minor_gc_cost.  This was useful because of the way major_gc_cost
duke@435:   // and minor_gc_cost was used in calculating the sizes of the generations.
duke@435:   // Do not use a floor in this implementation because any finite value
duke@435:   // will put a limit on the throughput that can be achieved and any
duke@435:   // throughput goal above that limit will drive the generations sizes
duke@435:   // to extremes.
duke@435: 
duke@435:   double minor_gc_cost() const {
duke@435:     return MAX2(0.0F, _avg_minor_gc_cost->average());
duke@435:   }
duke@435: 
duke@435:   // Because we're dealing with averages, gc_cost() can be
duke@435:   // larger than 1.0 if just the sum of the minor cost the
duke@435:   // the major cost is used.  Worse than that is the
duke@435:   // fact that the minor cost and the major cost each
duke@435:   // tend toward 1.0 in the extreme of high gc costs.
duke@435:   // Limit the value of gc_cost to 1.0 so that the mutator
duke@435:   // cost stays non-negative.
duke@435:   virtual double gc_cost() const {
duke@435:     double result = MIN2(1.0, minor_gc_cost() + major_gc_cost());
duke@435:     assert(result >= 0.0, "Both minor and major costs are non-negative");
duke@435:     return result;
duke@435:   }
duke@435: 
duke@435:   // Elapsed time since the last major collection.
duke@435:   virtual double time_since_major_gc() const;
duke@435: 
duke@435:   // Average interval between major collections to be used
duke@435:   // in calculating the decaying major gc cost.  An overestimate
duke@435:   // of this time would be a conservative estimate because
duke@435:   // this time is used to decide if the major GC cost
duke@435:   // should be decayed (i.e., if the time since the last
duke@435:   // major gc is long compared to the time returned here,
duke@435:   // then the major GC cost will be decayed).  See the
duke@435:   // implementations for the specifics.
duke@435:   virtual double major_gc_interval_average_for_decay() const {
duke@435:     return _avg_major_interval->average();
duke@435:   }
duke@435: 
duke@435:   // Return the cost of the GC where the major gc cost
duke@435:   // has been decayed based on the time since the last
duke@435:   // major collection.
duke@435:   double decaying_gc_cost() const;
duke@435: 
duke@435:   // Decay the major gc cost.  Use this only for decisions on
duke@435:   // whether to adjust, not to determine by how much to adjust.
duke@435:   // This approximation is crude and may not be good enough for the
duke@435:   // latter.
duke@435:   double decaying_major_gc_cost() const;
duke@435: 
duke@435:   // Return the mutator cost using the decayed
duke@435:   // GC cost.
duke@435:   double adjusted_mutator_cost() const {
duke@435:     double result = 1.0 - decaying_gc_cost();
duke@435:     assert(result >= 0.0, "adjusted mutator cost calculation is incorrect");
duke@435:     return result;
duke@435:   }
duke@435: 
duke@435:   virtual double mutator_cost() const {
duke@435:     double result = 1.0 - gc_cost();
duke@435:     assert(result >= 0.0, "mutator cost calculation is incorrect");
duke@435:     return result;
duke@435:   }
duke@435: 
duke@435: 
duke@435:   bool young_gen_policy_is_ready() { return _young_gen_policy_is_ready; }
duke@435: 
duke@435:   void update_minor_pause_young_estimator(double minor_pause_in_ms);
duke@435:   virtual void update_minor_pause_old_estimator(double minor_pause_in_ms) {
duke@435:     // This is not meaningful for all policies but needs to be present
duke@435:     // to use minor_collection_end() in its current form.
duke@435:   }
duke@435: 
duke@435:   virtual size_t eden_increment(size_t cur_eden);
duke@435:   virtual size_t eden_increment(size_t cur_eden, uint percent_change);
duke@435:   virtual size_t eden_decrement(size_t cur_eden);
duke@435:   virtual size_t promo_increment(size_t cur_eden);
duke@435:   virtual size_t promo_increment(size_t cur_eden, uint percent_change);
duke@435:   virtual size_t promo_decrement(size_t cur_eden);
duke@435: 
duke@435:   virtual void clear_generation_free_space_flags();
duke@435: 
duke@435:   int change_old_gen_for_throughput() const {
duke@435:     return _change_old_gen_for_throughput;
duke@435:   }
duke@435:   void set_change_old_gen_for_throughput(int v) {
duke@435:     _change_old_gen_for_throughput = v;
duke@435:   }
duke@435:   int change_young_gen_for_throughput() const {
duke@435:     return _change_young_gen_for_throughput;
duke@435:   }
duke@435:   void set_change_young_gen_for_throughput(int v) {
duke@435:     _change_young_gen_for_throughput = v;
duke@435:   }
duke@435: 
duke@435:   int change_old_gen_for_maj_pauses() const {
duke@435:     return _change_old_gen_for_maj_pauses;
duke@435:   }
duke@435:   void set_change_old_gen_for_maj_pauses(int v) {
duke@435:     _change_old_gen_for_maj_pauses = v;
duke@435:   }
duke@435: 
duke@435:   bool decrement_tenuring_threshold_for_gc_cost() const {
duke@435:     return _decrement_tenuring_threshold_for_gc_cost;
duke@435:   }
duke@435:   void set_decrement_tenuring_threshold_for_gc_cost(bool v) {
duke@435:     _decrement_tenuring_threshold_for_gc_cost = v;
duke@435:   }
duke@435:   bool increment_tenuring_threshold_for_gc_cost() const {
duke@435:     return _increment_tenuring_threshold_for_gc_cost;
duke@435:   }
duke@435:   void set_increment_tenuring_threshold_for_gc_cost(bool v) {
duke@435:     _increment_tenuring_threshold_for_gc_cost = v;
duke@435:   }
duke@435:   bool decrement_tenuring_threshold_for_survivor_limit() const {
duke@435:     return _decrement_tenuring_threshold_for_survivor_limit;
duke@435:   }
duke@435:   void set_decrement_tenuring_threshold_for_survivor_limit(bool v) {
duke@435:     _decrement_tenuring_threshold_for_survivor_limit = v;
duke@435:   }
duke@435:   // Return true if the policy suggested a change.
duke@435:   bool tenuring_threshold_change() const;
duke@435: 
jmasa@3294:   static bool _debug_perturbation;
jmasa@3294: 
duke@435:  public:
duke@435:   AdaptiveSizePolicy(size_t init_eden_size,
duke@435:                      size_t init_promo_size,
duke@435:                      size_t init_survivor_size,
duke@435:                      double gc_pause_goal_sec,
duke@435:                      uint gc_cost_ratio);
duke@435: 
jmasa@3294:   // Return number default  GC threads to use in the next GC.
jmasa@3294:   static int calc_default_active_workers(uintx total_workers,
jmasa@3294:                                          const uintx min_workers,
jmasa@3294:                                          uintx active_workers,
jmasa@3294:                                          uintx application_workers);
jmasa@3294: 
jmasa@3294:   // Return number of GC threads to use in the next GC.
jmasa@3294:   // This is called sparingly so as not to change the
jmasa@3294:   // number of GC workers gratuitously.
jmasa@3294:   //   For ParNew collections
jmasa@3294:   //   For PS scavenge and ParOld collections
jmasa@3294:   //   For G1 evacuation pauses (subject to update)
jmasa@3294:   // Other collection phases inherit the number of
jmasa@3294:   // GC workers from the calls above.  For example,
jmasa@3294:   // a CMS parallel remark uses the same number of GC
jmasa@3294:   // workers as the most recent ParNew collection.
jmasa@3294:   static int calc_active_workers(uintx total_workers,
jmasa@3294:                                  uintx active_workers,
jmasa@3294:                                  uintx application_workers);
jmasa@3294: 
jmasa@3294:   // Return number of GC threads to use in the next concurrent GC phase.
jmasa@3294:   static int calc_active_conc_workers(uintx total_workers,
jmasa@3294:                                       uintx active_workers,
jmasa@3294:                                       uintx application_workers);
jmasa@3294: 
duke@435:   bool is_gc_cms_adaptive_size_policy() {
duke@435:     return kind() == _gc_cms_adaptive_size_policy;
duke@435:   }
duke@435:   bool is_gc_ps_adaptive_size_policy() {
duke@435:     return kind() == _gc_ps_adaptive_size_policy;
duke@435:   }
duke@435: 
duke@435:   AdaptivePaddedAverage*   avg_minor_pause() const { return _avg_minor_pause; }
duke@435:   AdaptiveWeightedAverage* avg_minor_interval() const {
duke@435:     return _avg_minor_interval;
duke@435:   }
duke@435:   AdaptiveWeightedAverage* avg_minor_gc_cost() const {
duke@435:     return _avg_minor_gc_cost;
duke@435:   }
duke@435: 
duke@435:   AdaptiveWeightedAverage* avg_major_gc_cost() const {
duke@435:     return _avg_major_gc_cost;
duke@435:   }
duke@435: 
duke@435:   AdaptiveWeightedAverage* avg_young_live() const { return _avg_young_live; }
duke@435:   AdaptiveWeightedAverage* avg_eden_live() const { return _avg_eden_live; }
duke@435:   AdaptiveWeightedAverage* avg_old_live() const { return _avg_old_live; }
duke@435: 
duke@435:   AdaptivePaddedAverage*  avg_survived() const { return _avg_survived; }
duke@435:   AdaptivePaddedNoZeroDevAverage*  avg_pretenured() { return _avg_pretenured; }
duke@435: 
duke@435:   // Methods indicating events of interest to the adaptive size policy,
duke@435:   // called by GC algorithms. It is the responsibility of users of this
duke@435:   // policy to call these methods at the correct times!
duke@435:   virtual void minor_collection_begin();
duke@435:   virtual void minor_collection_end(GCCause::Cause gc_cause);
duke@435:   virtual LinearLeastSquareFit* minor_pause_old_estimator() const {
duke@435:     return _minor_pause_old_estimator;
duke@435:   }
duke@435: 
duke@435:   LinearLeastSquareFit* minor_pause_young_estimator() {
duke@435:     return _minor_pause_young_estimator;
duke@435:   }
duke@435:   LinearLeastSquareFit* minor_collection_estimator() {
duke@435:     return _minor_collection_estimator;
duke@435:   }
duke@435: 
duke@435:   LinearLeastSquareFit* major_collection_estimator() {
duke@435:     return _major_collection_estimator;
duke@435:   }
duke@435: 
duke@435:   float minor_pause_young_slope() {
duke@435:     return _minor_pause_young_estimator->slope();
duke@435:   }
duke@435: 
duke@435:   float minor_collection_slope() { return _minor_collection_estimator->slope();}
duke@435:   float major_collection_slope() { return _major_collection_estimator->slope();}
duke@435: 
duke@435:   float minor_pause_old_slope() {
duke@435:     return _minor_pause_old_estimator->slope();
duke@435:   }
duke@435: 
duke@435:   void set_eden_size(size_t new_size) {
duke@435:     _eden_size = new_size;
duke@435:   }
duke@435:   void set_survivor_size(size_t new_size) {
duke@435:     _survivor_size = new_size;
duke@435:   }
duke@435: 
duke@435:   size_t calculated_eden_size_in_bytes() const {
duke@435:     return _eden_size;
duke@435:   }
duke@435: 
duke@435:   size_t calculated_promo_size_in_bytes() const {
duke@435:     return _promo_size;
duke@435:   }
duke@435: 
duke@435:   size_t calculated_survivor_size_in_bytes() const {
duke@435:     return _survivor_size;
duke@435:   }
duke@435: 
duke@435:   // This is a hint for the heap:  we've detected that gc times
duke@435:   // are taking longer than GCTimeLimit allows.
duke@435:   // Most heaps will choose to throw an OutOfMemoryError when
duke@435:   // this occurs but it is up to the heap to request this information
duke@435:   // of the policy
jmasa@1822:   bool gc_overhead_limit_exceeded() {
jmasa@1822:     return _gc_overhead_limit_exceeded;
duke@435:   }
jmasa@1822:   void set_gc_overhead_limit_exceeded(bool v) {
jmasa@1822:     _gc_overhead_limit_exceeded = v;
duke@435:   }
duke@435: 
jmasa@1822:   // Tests conditions indicate the GC overhead limit is being approached.
jmasa@1822:   bool gc_overhead_limit_near() {
jmasa@1822:     return gc_overhead_limit_count() >=
jmasa@1822:         (AdaptiveSizePolicyGCTimeLimitThreshold - 1);
jmasa@1822:   }
jmasa@1822:   uint gc_overhead_limit_count() { return _gc_overhead_limit_count; }
jmasa@1822:   void reset_gc_overhead_limit_count() { _gc_overhead_limit_count = 0; }
jmasa@1822:   void inc_gc_overhead_limit_count() { _gc_overhead_limit_count++; }
duke@435:   // accessors for flags recording the decisions to resize the
duke@435:   // generations to meet the pause goal.
duke@435: 
duke@435:   int change_young_gen_for_min_pauses() const {
duke@435:     return _change_young_gen_for_min_pauses;
duke@435:   }
duke@435:   void set_change_young_gen_for_min_pauses(int v) {
duke@435:     _change_young_gen_for_min_pauses = v;
duke@435:   }
duke@435:   void set_decrease_for_footprint(int v) { _decrease_for_footprint = v; }
duke@435:   int decrease_for_footprint() const { return _decrease_for_footprint; }
duke@435:   int decide_at_full_gc() { return _decide_at_full_gc; }
duke@435:   void set_decide_at_full_gc(int v) { _decide_at_full_gc = v; }
duke@435: 
jmasa@1822:   // Check the conditions for an out-of-memory due to excessive GC time.
jmasa@1822:   // Set _gc_overhead_limit_exceeded if all the conditions have been met.
jmasa@1822:   void check_gc_overhead_limit(size_t young_live,
jmasa@1822:                                size_t eden_live,
jmasa@1822:                                size_t max_old_gen_size,
jmasa@1822:                                size_t max_eden_size,
jmasa@1822:                                bool   is_full_gc,
jmasa@1822:                                GCCause::Cause gc_cause,
jmasa@1822:                                CollectorPolicy* collector_policy);
jmasa@1822: 
duke@435:   // Printing support
duke@435:   virtual bool print_adaptive_size_policy_on(outputStream* st) const;
jwilhelm@4129:   bool print_adaptive_size_policy_on(outputStream* st,
jwilhelm@4129:                                      uint tenuring_threshold) const;
duke@435: };
duke@435: 
duke@435: // Class that can be used to print information about the
duke@435: // adaptive size policy at intervals specified by
duke@435: // AdaptiveSizePolicyOutputInterval.  Only print information
duke@435: // if an adaptive size policy is in use.
duke@435: class AdaptiveSizePolicyOutput : StackObj {
duke@435:   AdaptiveSizePolicy* _size_policy;
duke@435:   bool _do_print;
duke@435:   bool print_test(uint count) {
duke@435:     // A count of zero is a special value that indicates that the
duke@435:     // interval test should be ignored.  An interval is of zero is
duke@435:     // a special value that indicates that the interval test should
duke@435:     // always fail (never do the print based on the interval test).
duke@435:     return PrintGCDetails &&
duke@435:            UseAdaptiveSizePolicy &&
duke@435:            (UseParallelGC || UseConcMarkSweepGC) &&
duke@435:            (AdaptiveSizePolicyOutputInterval > 0) &&
duke@435:            ((count == 0) ||
duke@435:              ((count % AdaptiveSizePolicyOutputInterval) == 0));
duke@435:   }
duke@435:  public:
duke@435:   // The special value of a zero count can be used to ignore
duke@435:   // the count test.
duke@435:   AdaptiveSizePolicyOutput(uint count) {
duke@435:     if (UseAdaptiveSizePolicy && (AdaptiveSizePolicyOutputInterval > 0)) {
duke@435:       CollectedHeap* heap = Universe::heap();
duke@435:       _size_policy = heap->size_policy();
duke@435:       _do_print = print_test(count);
duke@435:     } else {
duke@435:       _size_policy = NULL;
duke@435:       _do_print = false;
duke@435:     }
duke@435:   }
duke@435:   AdaptiveSizePolicyOutput(AdaptiveSizePolicy* size_policy,
duke@435:                            uint count) :
duke@435:     _size_policy(size_policy) {
duke@435:     if (UseAdaptiveSizePolicy && (AdaptiveSizePolicyOutputInterval > 0)) {
duke@435:       _do_print = print_test(count);
duke@435:     } else {
duke@435:       _do_print = false;
duke@435:     }
duke@435:   }
duke@435:   ~AdaptiveSizePolicyOutput() {
duke@435:     if (_do_print) {
duke@435:       assert(UseAdaptiveSizePolicy, "Should not be in use");
duke@435:       _size_policy->print_adaptive_size_policy_on(gclog_or_tty);
duke@435:     }
duke@435:   }
duke@435: };
stefank@2314: 
stefank@2314: #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_ADAPTIVESIZEPOLICY_HPP