jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp

-:a6128a8ed624
+:4f41766176cf
 bool _full_young_gcs;
 // if true, then it tries to dynamically adjust the length of the
 // young list
 bool _adaptive_young_list_length;
-size_t _young_list_min_length;
 size_t _young_list_target_length;
 size_t _young_list_fixed_length;
 // The max number of regions we can extend the eden by while the GC
 // locker is active. This should be >= _young_list_target_length;
 SurvRateGroup*        _short_lived_surv_rate_group;
 SurvRateGroup*        _survivor_surv_rate_group;
 // add here any more surv rate groups
 double                _gc_overhead_perc;
+double _reserve_factor;
+size_t _reserve_regions;
 bool during_marking() {
 return _during_marking;
 }
 double predict_base_elapsed_time_ms(size_t pending_cards);
 double predict_base_elapsed_time_ms(size_t pending_cards,
 size_t scanned_cards);
 size_t predict_bytes_to_copy(HeapRegion* hr);
 double predict_region_elapsed_time_ms(HeapRegion* hr, bool young);
-// for use by: calculate_young_list_target_length(rs_length)
-bool predict_will_fit(size_t young_region_num,
-double base_time_ms,
-size_t init_free_regions,
-double target_pause_time_ms);
 void start_recording_regions();
 void record_cset_region_info(HeapRegion* hr, bool young);
 void record_non_young_cset_region(HeapRegion* hr);
 double _cur_mark_stop_world_time_ms;
 double _mark_remark_start_sec;
 double _mark_cleanup_start_sec;
 double _mark_closure_time_ms;
-void   calculate_young_list_min_length();
+// Update the young list target length either by setting it to the
-void   calculate_young_list_target_length();
+// desired fixed value or by calculating it using G1's pause
-void   calculate_young_list_target_length(size_t rs_lengths);
+// prediction model. If no rs_lengths parameter is passed, predict
+// the RS lengths using the prediction model, otherwise use the
+// given rs_lengths as the prediction.
+void update_young_list_target_length(size_t rs_lengths = (size_t) -1);
+// Calculate and return the minimum desired young list target
+// length. This is the minimum desired young list length according
+// to the user's inputs.
+size_t calculate_young_list_desired_min_length(size_t base_min_length);
+// Calculate and return the maximum desired young list target
+// length. This is the maximum desired young list length according
+// to the user's inputs.
+size_t calculate_young_list_desired_max_length();
+// Calculate and return the maximum young list target length that
+// can fit into the pause time goal. The parameters are: rs_lengths
+// represent the prediction of how large the young RSet lengths will
+// be, base_min_length is the alreay existing number of regions in
+// the young list, min_length and max_length are the desired min and
+// max young list length according to the user's inputs.
+size_t calculate_young_list_target_length(size_t rs_lengths,
+size_t base_min_length,
+size_t desired_min_length,
+size_t desired_max_length);
+// Check whether a given young length (young_length) fits into the
+// given target pause time and whether the prediction for the amount
+// of objects to be copied for the given length will fit into the
+// given free space (expressed by base_free_regions).  It is used by
+// calculate_young_list_target_length().
+bool predict_will_fit(size_t young_length, double base_time_ms,
+size_t base_free_regions, double target_pause_time_ms);
 public:
 G1CollectorPolicy();
 virtual CollectorPolicy::Name kind() {
 return CollectorPolicy::G1CollectorPolicyKind;
 }
-void check_prediction_validity();
+// Check the current value of the young list RSet lengths and
+// compare it against the last prediction. If the current value is
+// higher, recalculate the young list target length prediction.
+void revise_young_list_target_length_if_necessary();
 size_t bytes_in_collection_set() {
 return _bytes_in_collection_set_before_gc;
 }
 unsigned calc_gc_alloc_time_stamp() {
 return _all_pause_times_ms->num() + 1;
 }
+// Recalculate the reserve region number. This should be called
+// after the heap is resized.
+void calculate_reserve(size_t all_regions);
 protected:
 // Count the number of bytes used in the CS.
 void count_CS_bytes_used();
 void record_thread_age_table(ageTable* age_table)
 {
 _survivors_age_table.merge_par(age_table);
 }
-void calculate_max_gc_locker_expansion();
+void update_max_gc_locker_expansion();
 // Calculates survivor space parameters.
-void calculate_survivors_policy();
+void update_survivors_policy();
 };
 // This encapsulates a particular strategy for a g1 Collector.
 //

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp

src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp