1.1 --- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Wed Apr 11 16:18:45 2012 +0200
1.2 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Wed Apr 18 07:21:15 2012 -0400
1.3 @@ -431,31 +431,36 @@
1.4 }
1.5
1.6 if (FLAG_IS_CMDLINE(NewSize)) {
1.7 - _min_desired_young_length = MAX2((size_t) 1, NewSize / HeapRegion::GrainBytes);
1.8 + _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes),
1.9 + 1U);
1.10 if (FLAG_IS_CMDLINE(MaxNewSize)) {
1.11 - _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes);
1.12 + _max_desired_young_length =
1.13 + MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
1.14 + 1U);
1.15 _sizer_kind = SizerMaxAndNewSize;
1.16 _adaptive_size = _min_desired_young_length == _max_desired_young_length;
1.17 } else {
1.18 _sizer_kind = SizerNewSizeOnly;
1.19 }
1.20 } else if (FLAG_IS_CMDLINE(MaxNewSize)) {
1.21 - _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes);
1.22 + _max_desired_young_length =
1.23 + MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
1.24 + 1U);
1.25 _sizer_kind = SizerMaxNewSizeOnly;
1.26 }
1.27 }
1.28
1.29 -size_t G1YoungGenSizer::calculate_default_min_length(size_t new_number_of_heap_regions) {
1.30 - size_t default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100;
1.31 - return MAX2((size_t)1, default_value);
1.32 +uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) {
1.33 + uint default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100;
1.34 + return MAX2(1U, default_value);
1.35 }
1.36
1.37 -size_t G1YoungGenSizer::calculate_default_max_length(size_t new_number_of_heap_regions) {
1.38 - size_t default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100;
1.39 - return MAX2((size_t)1, default_value);
1.40 +uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) {
1.41 + uint default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100;
1.42 + return MAX2(1U, default_value);
1.43 }
1.44
1.45 -void G1YoungGenSizer::heap_size_changed(size_t new_number_of_heap_regions) {
1.46 +void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) {
1.47 assert(new_number_of_heap_regions > 0, "Heap must be initialized");
1.48
1.49 switch (_sizer_kind) {
1.50 @@ -512,16 +517,16 @@
1.51 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3);
1.52 }
1.53
1.54 -bool G1CollectorPolicy::predict_will_fit(size_t young_length,
1.55 +bool G1CollectorPolicy::predict_will_fit(uint young_length,
1.56 double base_time_ms,
1.57 - size_t base_free_regions,
1.58 + uint base_free_regions,
1.59 double target_pause_time_ms) {
1.60 if (young_length >= base_free_regions) {
1.61 // end condition 1: not enough space for the young regions
1.62 return false;
1.63 }
1.64
1.65 - double accum_surv_rate = accum_yg_surv_rate_pred((int)(young_length - 1));
1.66 + double accum_surv_rate = accum_yg_surv_rate_pred((int) young_length - 1);
1.67 size_t bytes_to_copy =
1.68 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);
1.69 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);
1.70 @@ -533,7 +538,7 @@
1.71 }
1.72
1.73 size_t free_bytes =
1.74 - (base_free_regions - young_length) * HeapRegion::GrainBytes;
1.75 + (base_free_regions - young_length) * HeapRegion::GrainBytes;
1.76 if ((2.0 * sigma()) * (double) bytes_to_copy > (double) free_bytes) {
1.77 // end condition 3: out-of-space (conservatively!)
1.78 return false;
1.79 @@ -543,25 +548,25 @@
1.80 return true;
1.81 }
1.82
1.83 -void G1CollectorPolicy::record_new_heap_size(size_t new_number_of_regions) {
1.84 +void G1CollectorPolicy::record_new_heap_size(uint new_number_of_regions) {
1.85 // re-calculate the necessary reserve
1.86 double reserve_regions_d = (double) new_number_of_regions * _reserve_factor;
1.87 // We use ceiling so that if reserve_regions_d is > 0.0 (but
1.88 // smaller than 1.0) we'll get 1.
1.89 - _reserve_regions = (size_t) ceil(reserve_regions_d);
1.90 + _reserve_regions = (uint) ceil(reserve_regions_d);
1.91
1.92 _young_gen_sizer->heap_size_changed(new_number_of_regions);
1.93 }
1.94
1.95 -size_t G1CollectorPolicy::calculate_young_list_desired_min_length(
1.96 - size_t base_min_length) {
1.97 - size_t desired_min_length = 0;
1.98 +uint G1CollectorPolicy::calculate_young_list_desired_min_length(
1.99 + uint base_min_length) {
1.100 + uint desired_min_length = 0;
1.101 if (adaptive_young_list_length()) {
1.102 if (_alloc_rate_ms_seq->num() > 3) {
1.103 double now_sec = os::elapsedTime();
1.104 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0;
1.105 double alloc_rate_ms = predict_alloc_rate_ms();
1.106 - desired_min_length = (size_t) ceil(alloc_rate_ms * when_ms);
1.107 + desired_min_length = (uint) ceil(alloc_rate_ms * when_ms);
1.108 } else {
1.109 // otherwise we don't have enough info to make the prediction
1.110 }
1.111 @@ -571,7 +576,7 @@
1.112 return MAX2(_young_gen_sizer->min_desired_young_length(), desired_min_length);
1.113 }
1.114
1.115 -size_t G1CollectorPolicy::calculate_young_list_desired_max_length() {
1.116 +uint G1CollectorPolicy::calculate_young_list_desired_max_length() {
1.117 // Here, we might want to also take into account any additional
1.118 // constraints (i.e., user-defined minimum bound). Currently, we
1.119 // effectively don't set this bound.
1.120 @@ -588,11 +593,11 @@
1.121 // Calculate the absolute and desired min bounds.
1.122
1.123 // This is how many young regions we already have (currently: the survivors).
1.124 - size_t base_min_length = recorded_survivor_regions();
1.125 + uint base_min_length = recorded_survivor_regions();
1.126 // This is the absolute minimum young length, which ensures that we
1.127 // can allocate one eden region in the worst-case.
1.128 - size_t absolute_min_length = base_min_length + 1;
1.129 - size_t desired_min_length =
1.130 + uint absolute_min_length = base_min_length + 1;
1.131 + uint desired_min_length =
1.132 calculate_young_list_desired_min_length(base_min_length);
1.133 if (desired_min_length < absolute_min_length) {
1.134 desired_min_length = absolute_min_length;
1.135 @@ -601,16 +606,16 @@
1.136 // Calculate the absolute and desired max bounds.
1.137
1.138 // We will try our best not to "eat" into the reserve.
1.139 - size_t absolute_max_length = 0;
1.140 + uint absolute_max_length = 0;
1.141 if (_free_regions_at_end_of_collection > _reserve_regions) {
1.142 absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions;
1.143 }
1.144 - size_t desired_max_length = calculate_young_list_desired_max_length();
1.145 + uint desired_max_length = calculate_young_list_desired_max_length();
1.146 if (desired_max_length > absolute_max_length) {
1.147 desired_max_length = absolute_max_length;
1.148 }
1.149
1.150 - size_t young_list_target_length = 0;
1.151 + uint young_list_target_length = 0;
1.152 if (adaptive_young_list_length()) {
1.153 if (gcs_are_young()) {
1.154 young_list_target_length =
1.155 @@ -648,11 +653,11 @@
1.156 update_max_gc_locker_expansion();
1.157 }
1.158
1.159 -size_t
1.160 +uint
1.161 G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths,
1.162 - size_t base_min_length,
1.163 - size_t desired_min_length,
1.164 - size_t desired_max_length) {
1.165 + uint base_min_length,
1.166 + uint desired_min_length,
1.167 + uint desired_max_length) {
1.168 assert(adaptive_young_list_length(), "pre-condition");
1.169 assert(gcs_are_young(), "only call this for young GCs");
1.170
1.171 @@ -667,9 +672,9 @@
1.172 // will be reflected in the predictions by the
1.173 // survivor_regions_evac_time prediction.
1.174 assert(desired_min_length > base_min_length, "invariant");
1.175 - size_t min_young_length = desired_min_length - base_min_length;
1.176 + uint min_young_length = desired_min_length - base_min_length;
1.177 assert(desired_max_length > base_min_length, "invariant");
1.178 - size_t max_young_length = desired_max_length - base_min_length;
1.179 + uint max_young_length = desired_max_length - base_min_length;
1.180
1.181 double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0;
1.182 double survivor_regions_evac_time = predict_survivor_regions_evac_time();
1.183 @@ -679,8 +684,8 @@
1.184 double base_time_ms =
1.185 predict_base_elapsed_time_ms(pending_cards, scanned_cards) +
1.186 survivor_regions_evac_time;
1.187 - size_t available_free_regions = _free_regions_at_end_of_collection;
1.188 - size_t base_free_regions = 0;
1.189 + uint available_free_regions = _free_regions_at_end_of_collection;
1.190 + uint base_free_regions = 0;
1.191 if (available_free_regions > _reserve_regions) {
1.192 base_free_regions = available_free_regions - _reserve_regions;
1.193 }
1.194 @@ -717,9 +722,9 @@
1.195 // the new max. This way we maintain the loop invariants.
1.196
1.197 assert(min_young_length < max_young_length, "invariant");
1.198 - size_t diff = (max_young_length - min_young_length) / 2;
1.199 + uint diff = (max_young_length - min_young_length) / 2;
1.200 while (diff > 0) {
1.201 - size_t young_length = min_young_length + diff;
1.202 + uint young_length = min_young_length + diff;
1.203 if (predict_will_fit(young_length, base_time_ms,
1.204 base_free_regions, target_pause_time_ms)) {
1.205 min_young_length = young_length;
1.206 @@ -1322,7 +1327,7 @@
1.207 // given that humongous object allocations do not really affect
1.208 // either the pause's duration nor when the next pause will take
1.209 // place we can safely ignore them here.
1.210 - size_t regions_allocated = eden_cset_region_length();
1.211 + uint regions_allocated = eden_cset_region_length();
1.212 double alloc_rate_ms = (double) regions_allocated / app_time_ms;
1.213 _alloc_rate_ms_seq->add(alloc_rate_ms);
1.214
1.215 @@ -1506,8 +1511,9 @@
1.216 double pause_time_ms = elapsed_ms;
1.217
1.218 size_t diff = 0;
1.219 - if (_max_pending_cards >= _pending_cards)
1.220 + if (_max_pending_cards >= _pending_cards) {
1.221 diff = _max_pending_cards - _pending_cards;
1.222 + }
1.223 _pending_card_diff_seq->add((double) diff);
1.224
1.225 double cost_per_card_ms = 0.0;
1.226 @@ -1741,8 +1747,7 @@
1.227 return region_elapsed_time_ms;
1.228 }
1.229
1.230 -size_t
1.231 -G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
1.232 +size_t G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
1.233 size_t bytes_to_copy;
1.234 if (hr->is_marked())
1.235 bytes_to_copy = hr->max_live_bytes();
1.236 @@ -1756,8 +1761,8 @@
1.237 }
1.238
1.239 void
1.240 -G1CollectorPolicy::init_cset_region_lengths(size_t eden_cset_region_length,
1.241 - size_t survivor_cset_region_length) {
1.242 +G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length,
1.243 + uint survivor_cset_region_length) {
1.244 _eden_cset_region_length = eden_cset_region_length;
1.245 _survivor_cset_region_length = survivor_cset_region_length;
1.246 _old_cset_region_length = 0;
1.247 @@ -2021,7 +2026,7 @@
1.248 }
1.249 #endif // PRODUCT
1.250
1.251 -size_t G1CollectorPolicy::max_regions(int purpose) {
1.252 +uint G1CollectorPolicy::max_regions(int purpose) {
1.253 switch (purpose) {
1.254 case GCAllocForSurvived:
1.255 return _max_survivor_regions;
1.256 @@ -2034,13 +2039,13 @@
1.257 }
1.258
1.259 void G1CollectorPolicy::update_max_gc_locker_expansion() {
1.260 - size_t expansion_region_num = 0;
1.261 + uint expansion_region_num = 0;
1.262 if (GCLockerEdenExpansionPercent > 0) {
1.263 double perc = (double) GCLockerEdenExpansionPercent / 100.0;
1.264 double expansion_region_num_d = perc * (double) _young_list_target_length;
1.265 // We use ceiling so that if expansion_region_num_d is > 0.0 (but
1.266 // less than 1.0) we'll get 1.
1.267 - expansion_region_num = (size_t) ceil(expansion_region_num_d);
1.268 + expansion_region_num = (uint) ceil(expansion_region_num_d);
1.269 } else {
1.270 assert(expansion_region_num == 0, "sanity");
1.271 }
1.272 @@ -2054,7 +2059,7 @@
1.273 (double) _young_list_target_length / (double) SurvivorRatio;
1.274 // We use ceiling so that if max_survivor_regions_d is > 0.0 (but
1.275 // smaller than 1.0) we'll get 1.
1.276 - _max_survivor_regions = (size_t) ceil(max_survivor_regions_d);
1.277 + _max_survivor_regions = (uint) ceil(max_survivor_regions_d);
1.278
1.279 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold(
1.280 HeapRegion::GrainWords * _max_survivor_regions);
1.281 @@ -2288,27 +2293,25 @@
1.282 (clear_marked_end_sec - start_sec) * 1000.0);
1.283 }
1.284
1.285 + uint region_num = _g1->n_regions();
1.286 if (G1CollectedHeap::use_parallel_gc_threads()) {
1.287 - const size_t OverpartitionFactor = 4;
1.288 - size_t WorkUnit;
1.289 + const uint OverpartitionFactor = 4;
1.290 + uint WorkUnit;
1.291 // The use of MinChunkSize = 8 in the original code
1.292 // causes some assertion failures when the total number of
1.293 // region is less than 8. The code here tries to fix that.
1.294 // Should the original code also be fixed?
1.295 if (no_of_gc_threads > 0) {
1.296 - const size_t MinWorkUnit =
1.297 - MAX2(_g1->n_regions() / no_of_gc_threads, (size_t) 1U);
1.298 - WorkUnit =
1.299 - MAX2(_g1->n_regions() / (no_of_gc_threads * OverpartitionFactor),
1.300 - MinWorkUnit);
1.301 + const uint MinWorkUnit = MAX2(region_num / no_of_gc_threads, 1U);
1.302 + WorkUnit = MAX2(region_num / (no_of_gc_threads * OverpartitionFactor),
1.303 + MinWorkUnit);
1.304 } else {
1.305 assert(no_of_gc_threads > 0,
1.306 "The active gc workers should be greater than 0");
1.307 // In a product build do something reasonable to avoid a crash.
1.308 - const size_t MinWorkUnit =
1.309 - MAX2(_g1->n_regions() / ParallelGCThreads, (size_t) 1U);
1.310 + const uint MinWorkUnit = MAX2(region_num / (uint) ParallelGCThreads, 1U);
1.311 WorkUnit =
1.312 - MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor),
1.313 + MAX2(region_num / (uint) (ParallelGCThreads * OverpartitionFactor),
1.314 MinWorkUnit);
1.315 }
1.316 _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(),
1.317 @@ -2624,8 +2627,8 @@
1.318 // pause are appended to the RHS of the young list, i.e.
1.319 // [Newly Young Regions ++ Survivors from last pause].
1.320
1.321 - size_t survivor_region_length = young_list->survivor_length();
1.322 - size_t eden_region_length = young_list->length() - survivor_region_length;
1.323 + uint survivor_region_length = young_list->survivor_length();
1.324 + uint eden_region_length = young_list->length() - survivor_region_length;
1.325 init_cset_region_lengths(eden_region_length, survivor_region_length);
1.326 hr = young_list->first_survivor_region();
1.327 while (hr != NULL) {
1.328 @@ -2664,10 +2667,10 @@
1.329 if (!gcs_are_young()) {
1.330 CollectionSetChooser* cset_chooser = _collectionSetChooser;
1.331 assert(cset_chooser->verify(), "CSet Chooser verification - pre");
1.332 - const size_t min_old_cset_length = cset_chooser->calcMinOldCSetLength();
1.333 - const size_t max_old_cset_length = cset_chooser->calcMaxOldCSetLength();
1.334 -
1.335 - size_t expensive_region_num = 0;
1.336 + const uint min_old_cset_length = cset_chooser->calcMinOldCSetLength();
1.337 + const uint max_old_cset_length = cset_chooser->calcMaxOldCSetLength();
1.338 +
1.339 + uint expensive_region_num = 0;
1.340 bool check_time_remaining = adaptive_young_list_length();
1.341 HeapRegion* hr = cset_chooser->peek();
1.342 while (hr != NULL) {
