jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp

equal deleted inserted replaced

-:7a72e5ed1d10
+:34e2a243d69a
 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
 _scanned_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),
-_pause_time_target_ms((double) G1MaxPauseTimeMS),
+_pause_time_target_ms((double) MaxGCPauseMillis),
 // </NEW PREDICTION>
 _in_young_gc_mode(false),
 _full_young_gcs(true),
 _par_last_obj_copy_times_ms = new double[_parallel_gc_threads];
 _par_last_termination_times_ms = new double[_parallel_gc_threads];
 // start conservatively
-_expensive_region_limit_ms = 0.5 * (double) G1MaxPauseTimeMS;
+_expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis;
 // <NEW PREDICTION>
 int index;
 if (ParallelGCThreads == 0)
 _non_young_other_cost_per_region_ms_seq->add(
 non_young_other_cost_per_region_ms_defaults[index]);
 // </NEW PREDICTION>
-double time_slice  = (double) G1TimeSliceMS / 1000.0;
+double time_slice  = (double) GCPauseIntervalMillis / 1000.0;
-double max_gc_time = (double) G1MaxPauseTimeMS / 1000.0;
+double max_gc_time = (double) MaxGCPauseMillis / 1000.0;
 guarantee(max_gc_time < time_slice,
 "Max GC time should not be greater than the time slice");
 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time);
-_sigma = (double) G1ConfidencePerc / 100.0;
+_sigma = (double) G1ConfidencePercent / 100.0;
 // start conservatively (around 50ms is about right)
 _concurrent_mark_init_times_ms->add(0.05);
 _concurrent_mark_remark_times_ms->add(0.05);
 _concurrent_mark_cleanup_times_ms->add(0.20);
 _tenuring_threshold = MaxTenuringThreshold;
-if (G1UseSurvivorSpace) {
+if (G1UseSurvivorSpaces) {
 // if G1FixedSurvivorSpaceSize is 0 which means the size is not
 // fixed, then _max_survivor_regions will be calculated at
 // calculate_young_list_target_config during initialization
 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes;
 } else {
 void G1CollectorPolicy::calculate_young_list_target_config(size_t rs_lengths) {
 guarantee( adaptive_young_list_length(), "pre-condition" );
 double start_time_sec = os::elapsedTime();
-size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1MinReservePerc);
+size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1MinReservePercent);
 min_reserve_perc = MIN2((size_t) 50, min_reserve_perc);
 size_t reserve_regions =
 (size_t) ((double) min_reserve_perc * (double) _g1->n_regions() / 100.0);
 if (full_young_gcs() && _free_regions_at_end_of_collection > 0) {
 _short_lived_surv_rate_group->stop_adding_regions();
 size_t short_lived_so_length = _young_list_so_prefix_length;
 _short_lived_surv_rate_group->record_scan_only_prefix(short_lived_so_length);
 tag_scan_only(short_lived_so_length);
-if (G1UseSurvivorSpace) {
+if (G1UseSurvivorSpaces) {
 _survivors_age_table.clear();
 }
 assert( verify_young_ages(), "region age verification" );
 }
 _pending_cards_seq->add((double) _pending_cards);
 _scanned_cards_seq->add((double) cards_scanned);
 _rs_lengths_seq->add((double) _max_rs_lengths);
 double expensive_region_limit_ms =
-(double) G1MaxPauseTimeMS - predict_constant_other_time_ms();
+(double) MaxGCPauseMillis - predict_constant_other_time_ms();
 if (expensive_region_limit_ms < 0.0) {
 // this means that the other time was predicted to be longer than
 // than the max pause time
-expensive_region_limit_ms = (double) G1MaxPauseTimeMS;
+expensive_region_limit_ms = (double) MaxGCPauseMillis;
 }
 _expensive_region_limit_ms = expensive_region_limit_ms;
 if (PREDICTIONS_VERBOSE) {
 gclog_or_tty->print_cr("");
 _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec);
 _prev_collection_pause_end_ms = end_time_sec * 1000.0;
 }
 double G1CollectorPolicy::recent_avg_time_for_pauses_ms() {
-if (_recent_pause_times_ms->num() == 0) return (double) G1MaxPauseTimeMS;
+if (_recent_pause_times_ms->num() == 0) return (double) MaxGCPauseMillis;
 else return _recent_pause_times_ms->avg();
 }
 double G1CollectorPolicy::recent_avg_time_for_CH_strong_ms() {
 if (_recent_CH_strong_roots_times_ms->num() == 0)
-return (double)G1MaxPauseTimeMS/3.0;
+return (double)MaxGCPauseMillis/3.0;
 else return _recent_CH_strong_roots_times_ms->avg();
 }
 double G1CollectorPolicy::recent_avg_time_for_G1_strong_ms() {
 if (_recent_G1_strong_roots_times_ms->num() == 0)
-return (double)G1MaxPauseTimeMS/3.0;
+return (double)MaxGCPauseMillis/3.0;
 else return _recent_G1_strong_roots_times_ms->avg();
 }
 double G1CollectorPolicy::recent_avg_time_for_evac_ms() {
-if (_recent_evac_times_ms->num() == 0) return (double)G1MaxPauseTimeMS/3.0;
+if (_recent_evac_times_ms->num() == 0) return (double)MaxGCPauseMillis/3.0;
 else return _recent_evac_times_ms->avg();
 }
 int G1CollectorPolicy::number_of_recent_gcs() {
 assert(_recent_CH_strong_roots_times_ms->num() ==
 res = MIN2(res, 1.0);
 return res;
 }
 size_t G1CollectorPolicy::expansion_amount() {
-if ((int)(recent_avg_pause_time_ratio() * 100.0) > G1GCPct) {
+if ((int)(recent_avg_pause_time_ratio() * 100.0) > G1GCPercent) {
-// We will double the existing space, or take G1ExpandByPctOfAvail % of
+// We will double the existing space, or take
-// the available expansion space, whichever is smaller, bounded below
+// G1ExpandByPercentOfAvailable % of the available expansion
-// by a minimum expansion (unless that's all that's left.)
+// space, whichever is smaller, bounded below by a minimum
+// expansion (unless that's all that's left.)
 const size_t min_expand_bytes = 1*M;
 size_t reserved_bytes = _g1->g1_reserved_obj_bytes();
 size_t committed_bytes = _g1->capacity();
 size_t uncommitted_bytes = reserved_bytes - committed_bytes;
 size_t expand_bytes;
 size_t expand_bytes_via_pct =
-uncommitted_bytes * G1ExpandByPctOfAvail / 100;
+uncommitted_bytes * G1ExpandByPercentOfAvailable / 100;
 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes);
 expand_bytes = MAX2(expand_bytes, min_expand_bytes);
 expand_bytes = MIN2(expand_bytes, uncommitted_bytes);
 if (G1PolicyVerbose > 1) {
 gclog_or_tty->print("Decided to expand: ratio = %5.2f, "
 }
 // Calculates survivor space parameters.
 void G1CollectorPolicy::calculate_survivors_policy()
 {
-if (!G1UseSurvivorSpace) {
+if (!G1UseSurvivorSpaces) {
 return;
 }
 if (G1FixedSurvivorSpaceSize == 0) {
 _max_survivor_regions = _young_list_target_length / SurvivorRatio;
 } else {
 // Add the heap region to the collection set and return the conservative
 // estimate of the number of live bytes.
 void G1CollectorPolicy::
 add_to_collection_set(HeapRegion* hr) {
-if (G1TraceRegions) {
+if (G1PrintRegions) {
 gclog_or_tty->print_cr("added region to cset %d:["PTR_FORMAT", "PTR_FORMAT"], "
 "top "PTR_FORMAT", young %s",
 hr->hrs_index(), hr->bottom(), hr->end(),
 hr->top(), (hr->is_young()) ? "YES" : "NO");
 }

changeset 2741	34e2a243d69a
parent 2344	f2e09ba7ceab
child 2881	74a1337e4acc