graal-jvmci-8: src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @ 3919:4f41766176cf

7084509: G1: fix inconsistencies and mistakes in the young list target length calculations Summary: Fixed inconsistencies and mistakes in the young list target length calculations so that a) the calculated target length is optimal (before, it was not), b) other parameters like max survivor size and max gc locker eden expansion are always consistent with the calculated target length (before, they were not always), and c) the resulting target length was always bound by desired min and max values (before, it was not). Reviewed-by: brutisso, johnc

author	tonyp
date	Thu, 08 Sep 2011 05:16:49 -0400
parents	20213c8a3c40
children	af2ab04e0038

comparison

equal deleted inserted replaced

-: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 > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @ 3919:4f41766176cf