truffle: src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 6010:720b6a76dd9d

7157073: G1: type change size_t -> uint for region counts / indexes Summary: Change the type of fields / variables / etc. that represent region counts and indeces from size_t to uint. Reviewed-by: iveresov, brutisso, jmasa, jwilhelm

author	tonyp
date	Wed, 18 Apr 2012 07:21:15 -0400
parents	5c86f8211d1e
children	f7a8920427a6

comparison

equal deleted inserted replaced

-:dde53abda3d6
+:720b6a76dd9d
 return;
 }
 }
 if (FLAG_IS_CMDLINE(NewSize)) {
-_min_desired_young_length = MAX2((size_t) 1, NewSize / HeapRegion::GrainBytes);
+_min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes),
+1U);
 if (FLAG_IS_CMDLINE(MaxNewSize)) {
-_max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes);
+_max_desired_young_length =
+MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
+1U);
 _sizer_kind = SizerMaxAndNewSize;
 _adaptive_size = _min_desired_young_length == _max_desired_young_length;
 } else {
 _sizer_kind = SizerNewSizeOnly;
 }
 } else if (FLAG_IS_CMDLINE(MaxNewSize)) {
-_max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes);
+_max_desired_young_length =
+MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
+1U);
 _sizer_kind = SizerMaxNewSizeOnly;
 }
 }
-size_t G1YoungGenSizer::calculate_default_min_length(size_t new_number_of_heap_regions) {
+uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) {
-size_t default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100;
+uint default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100;
-return MAX2((size_t)1, default_value);
+return MAX2(1U, default_value);
 }
-size_t G1YoungGenSizer::calculate_default_max_length(size_t new_number_of_heap_regions) {
+uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) {
-size_t default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100;
+uint default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100;
-return MAX2((size_t)1, default_value);
+return MAX2(1U, default_value);
 }
-void G1YoungGenSizer::heap_size_changed(size_t new_number_of_heap_regions) {
+void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) {
 assert(new_number_of_heap_regions > 0, "Heap must be initialized");
 switch (_sizer_kind) {
 case SizerDefaults:
 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions);
 // Create the jstat counters for the policy.
 void G1CollectorPolicy::initialize_gc_policy_counters() {
 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3);
 }
-bool G1CollectorPolicy::predict_will_fit(size_t young_length,
+bool G1CollectorPolicy::predict_will_fit(uint young_length,
 double base_time_ms,
-size_t base_free_regions,
+uint base_free_regions,
 double target_pause_time_ms) {
 if (young_length >= base_free_regions) {
 // end condition 1: not enough space for the young regions
 return false;
 }
-double accum_surv_rate = accum_yg_surv_rate_pred((int)(young_length - 1));
+double accum_surv_rate = accum_yg_surv_rate_pred((int) young_length - 1);
 size_t bytes_to_copy =
 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes);
 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy);
 double young_other_time_ms = predict_young_other_time_ms(young_length);
 double pause_time_ms = base_time_ms + copy_time_ms + young_other_time_ms;
 // end condition 2: prediction is over the target pause time
 return false;
 }
 size_t free_bytes =
 (base_free_regions - young_length) * HeapRegion::GrainBytes;
 if ((2.0 * sigma()) * (double) bytes_to_copy > (double) free_bytes) {
 // end condition 3: out-of-space (conservatively!)
 return false;
 }
 // success!
 return true;
 }
-void G1CollectorPolicy::record_new_heap_size(size_t new_number_of_regions) {
+void G1CollectorPolicy::record_new_heap_size(uint new_number_of_regions) {
 // re-calculate the necessary reserve
 double reserve_regions_d = (double) new_number_of_regions * _reserve_factor;
 // We use ceiling so that if reserve_regions_d is > 0.0 (but
 // smaller than 1.0) we'll get 1.
-_reserve_regions = (size_t) ceil(reserve_regions_d);
+_reserve_regions = (uint) ceil(reserve_regions_d);
 _young_gen_sizer->heap_size_changed(new_number_of_regions);
 }
-size_t G1CollectorPolicy::calculate_young_list_desired_min_length(
+uint G1CollectorPolicy::calculate_young_list_desired_min_length(
-size_t base_min_length) {
+uint base_min_length) {
-size_t desired_min_length = 0;
+uint desired_min_length = 0;
 if (adaptive_young_list_length()) {
 if (_alloc_rate_ms_seq->num() > 3) {
 double now_sec = os::elapsedTime();
 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0;
 double alloc_rate_ms = predict_alloc_rate_ms();
-desired_min_length = (size_t) ceil(alloc_rate_ms * when_ms);
+desired_min_length = (uint) ceil(alloc_rate_ms * when_ms);
 } else {
 // otherwise we don't have enough info to make the prediction
 }
 }
 desired_min_length += base_min_length;
 // make sure we don't go below any user-defined minimum bound
 return MAX2(_young_gen_sizer->min_desired_young_length(), desired_min_length);
 }
-size_t G1CollectorPolicy::calculate_young_list_desired_max_length() {
+uint G1CollectorPolicy::calculate_young_list_desired_max_length() {
 // Here, we might want to also take into account any additional
 // constraints (i.e., user-defined minimum bound). Currently, we
 // effectively don't set this bound.
 return _young_gen_sizer->max_desired_young_length();
 }
 }
 // Calculate the absolute and desired min bounds.
 // This is how many young regions we already have (currently: the survivors).
-size_t base_min_length = recorded_survivor_regions();
+uint base_min_length = recorded_survivor_regions();
 // This is the absolute minimum young length, which ensures that we
 // can allocate one eden region in the worst-case.
-size_t absolute_min_length = base_min_length + 1;
+uint absolute_min_length = base_min_length + 1;
-size_t desired_min_length =
+uint desired_min_length =
 calculate_young_list_desired_min_length(base_min_length);
 if (desired_min_length < absolute_min_length) {
 desired_min_length = absolute_min_length;
 }
 // Calculate the absolute and desired max bounds.
 // We will try our best not to "eat" into the reserve.
-size_t absolute_max_length = 0;
+uint absolute_max_length = 0;
 if (_free_regions_at_end_of_collection > _reserve_regions) {
 absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions;
 }
-size_t desired_max_length = calculate_young_list_desired_max_length();
+uint desired_max_length = calculate_young_list_desired_max_length();
 if (desired_max_length > absolute_max_length) {
 desired_max_length = absolute_max_length;
 }
-size_t young_list_target_length = 0;
+uint young_list_target_length = 0;
 if (adaptive_young_list_length()) {
 if (gcs_are_young()) {
 young_list_target_length =
 calculate_young_list_target_length(rs_lengths,
 base_min_length,
 _young_list_target_length = young_list_target_length;
 update_max_gc_locker_expansion();
 }
-size_t
+uint
 G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths,
-size_t base_min_length,
+uint base_min_length,
-size_t desired_min_length,
+uint desired_min_length,
-size_t desired_max_length) {
+uint desired_max_length) {
 assert(adaptive_young_list_length(), "pre-condition");
 assert(gcs_are_young(), "only call this for young GCs");
 // In case some edge-condition makes the desired max length too small...
 if (desired_max_length <= desired_min_length) {
 // the already allocated young regions (i.e., so they reflect the
 // min and max eden regions we'll allocate). The base_min_length
 // will be reflected in the predictions by the
 // survivor_regions_evac_time prediction.
 assert(desired_min_length > base_min_length, "invariant");
-size_t min_young_length = desired_min_length - base_min_length;
+uint min_young_length = desired_min_length - base_min_length;
 assert(desired_max_length > base_min_length, "invariant");
-size_t max_young_length = desired_max_length - base_min_length;
+uint max_young_length = desired_max_length - base_min_length;
 double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0;
 double survivor_regions_evac_time = predict_survivor_regions_evac_time();
 size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq);
 size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff();
 size_t scanned_cards = predict_young_card_num(adj_rs_lengths);
 double base_time_ms =
 predict_base_elapsed_time_ms(pending_cards, scanned_cards) +
 survivor_regions_evac_time;
-size_t available_free_regions = _free_regions_at_end_of_collection;
+uint available_free_regions = _free_regions_at_end_of_collection;
-size_t base_free_regions = 0;
+uint base_free_regions = 0;
 if (available_free_regions > _reserve_regions) {
 base_free_regions = available_free_regions - _reserve_regions;
 }
 // Here, we will make sure that the shortest young length that
 // max_young_length fits into the target pause time. If it
 // does, it becomes the new min. If it doesn't, it becomes
 // the new max. This way we maintain the loop invariants.
 assert(min_young_length < max_young_length, "invariant");
-size_t diff = (max_young_length - min_young_length) / 2;
+uint diff = (max_young_length - min_young_length) / 2;
 while (diff > 0) {
-size_t young_length = min_young_length + diff;
+uint young_length = min_young_length + diff;
 if (predict_will_fit(young_length, base_time_ms,
 base_free_regions, target_pause_time_ms)) {
 min_young_length = young_length;
 } else {
 max_young_length = young_length;
 // calculate the application's allocate rate. The only exception
 // to that is humongous objects that are allocated separately. But
 // given that humongous object allocations do not really affect
 // either the pause's duration nor when the next pause will take
 // place we can safely ignore them here.
-size_t regions_allocated = eden_cset_region_length();
+uint regions_allocated = eden_cset_region_length();
 double alloc_rate_ms = (double) regions_allocated / app_time_ms;
 _alloc_rate_ms_seq->add(alloc_rate_ms);
 double interval_ms =
 (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0;
 if (update_stats) {
 double pause_time_ms = elapsed_ms;
 size_t diff = 0;
-if (_max_pending_cards >= _pending_cards)
+if (_max_pending_cards >= _pending_cards) {
 diff = _max_pending_cards - _pending_cards;
+}
 _pending_card_diff_seq->add((double) diff);
 double cost_per_card_ms = 0.0;
 if (_pending_cards > 0) {
 cost_per_card_ms = update_rs_time / (double) _pending_cards;
 region_elapsed_time_ms += predict_non_young_other_time_ms(1);
 return region_elapsed_time_ms;
 }
-size_t
+size_t G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
-G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) {
 size_t bytes_to_copy;
 if (hr->is_marked())
 bytes_to_copy = hr->max_live_bytes();
 else {
 assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant");
 }
 return bytes_to_copy;
 }
 void
-G1CollectorPolicy::init_cset_region_lengths(size_t eden_cset_region_length,
+G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length,
-size_t survivor_cset_region_length) {
+uint survivor_cset_region_length) {
 _eden_cset_region_length     = eden_cset_region_length;
 _survivor_cset_region_length = survivor_cset_region_length;
 _old_cset_region_length      = 0;
 }
 sprintf(buffer, "%7.2lfMB", mbs);
 return buffer;
 }
 #endif // PRODUCT
-size_t G1CollectorPolicy::max_regions(int purpose) {
+uint G1CollectorPolicy::max_regions(int purpose) {
 switch (purpose) {
 case GCAllocForSurvived:
 return _max_survivor_regions;
 case GCAllocForTenured:
 return REGIONS_UNLIMITED;
 return REGIONS_UNLIMITED;
 };
 }
 void G1CollectorPolicy::update_max_gc_locker_expansion() {
-size_t expansion_region_num = 0;
+uint expansion_region_num = 0;
 if (GCLockerEdenExpansionPercent > 0) {
 double perc = (double) GCLockerEdenExpansionPercent / 100.0;
 double expansion_region_num_d = perc * (double) _young_list_target_length;
 // We use ceiling so that if expansion_region_num_d is > 0.0 (but
 // less than 1.0) we'll get 1.
-expansion_region_num = (size_t) ceil(expansion_region_num_d);
+expansion_region_num = (uint) ceil(expansion_region_num_d);
 } else {
 assert(expansion_region_num == 0, "sanity");
 }
 _young_list_max_length = _young_list_target_length + expansion_region_num;
 assert(_young_list_target_length <= _young_list_max_length, "post-condition");
 void G1CollectorPolicy::update_survivors_policy() {
 double max_survivor_regions_d =
 (double) _young_list_target_length / (double) SurvivorRatio;
 // We use ceiling so that if max_survivor_regions_d is > 0.0 (but
 // smaller than 1.0) we'll get 1.
-_max_survivor_regions = (size_t) ceil(max_survivor_regions_d);
+_max_survivor_regions = (uint) ceil(max_survivor_regions_d);
 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold(
 HeapRegion::GrainWords * _max_survivor_regions);
 }
 clear_marked_end_sec = os::elapsedTime();
 gclog_or_tty->print_cr("  clear marked regions: %8.3f ms.",
 (clear_marked_end_sec - start_sec) * 1000.0);
 }
+uint region_num = _g1->n_regions();
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-const size_t OverpartitionFactor = 4;
+const uint OverpartitionFactor = 4;
-size_t WorkUnit;
+uint WorkUnit;
 // The use of MinChunkSize = 8 in the original code
 // causes some assertion failures when the total number of
 // region is less than 8.  The code here tries to fix that.
 // Should the original code also be fixed?
 if (no_of_gc_threads > 0) {
-const size_t MinWorkUnit =
+const uint MinWorkUnit = MAX2(region_num / no_of_gc_threads, 1U);
-MAX2(_g1->n_regions() / no_of_gc_threads, (size_t) 1U);
+WorkUnit = MAX2(region_num / (no_of_gc_threads * OverpartitionFactor),
-WorkUnit =
+MinWorkUnit);
-MAX2(_g1->n_regions() / (no_of_gc_threads * OverpartitionFactor),
-MinWorkUnit);
 } else {
 assert(no_of_gc_threads > 0,
 "The active gc workers should be greater than 0");
 // In a product build do something reasonable to avoid a crash.
-const size_t MinWorkUnit =
+const uint MinWorkUnit = MAX2(region_num / (uint) ParallelGCThreads, 1U);
-MAX2(_g1->n_regions() / ParallelGCThreads, (size_t) 1U);
 WorkUnit =
-MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor),
+MAX2(region_num / (uint) (ParallelGCThreads * OverpartitionFactor),
 MinWorkUnit);
 }
 _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(),
 WorkUnit);
 ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser,
 // The young list is laid with the survivor regions from the previous
 // pause are appended to the RHS of the young list, i.e.
 //   [Newly Young Regions ++ Survivors from last pause].
-size_t survivor_region_length = young_list->survivor_length();
+uint survivor_region_length = young_list->survivor_length();
-size_t eden_region_length = young_list->length() - survivor_region_length;
+uint eden_region_length = young_list->length() - survivor_region_length;
 init_cset_region_lengths(eden_region_length, survivor_region_length);
 hr = young_list->first_survivor_region();
 while (hr != NULL) {
 assert(hr->is_survivor(), "badly formed young list");
 hr->set_young();
 non_young_start_time_sec = young_end_time_sec;
 if (!gcs_are_young()) {
 CollectionSetChooser* cset_chooser = _collectionSetChooser;
 assert(cset_chooser->verify(), "CSet Chooser verification - pre");
-const size_t min_old_cset_length = cset_chooser->calcMinOldCSetLength();
+const uint min_old_cset_length = cset_chooser->calcMinOldCSetLength();
-const size_t max_old_cset_length = cset_chooser->calcMaxOldCSetLength();
+const uint max_old_cset_length = cset_chooser->calcMaxOldCSetLength();
-size_t expensive_region_num = 0;
+uint expensive_region_num = 0;
 bool check_time_remaining = adaptive_young_list_length();
 HeapRegion* hr = cset_chooser->peek();
 while (hr != NULL) {
 if (old_cset_region_length() >= max_old_cset_length) {
 // Added maximum number of old regions to the CSet.

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 6010:720b6a76dd9d