graal-compiler: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.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	b632e80fc9dc
children	f7a8920427a6

comparison

equal deleted inserted replaced

-:dde53abda3d6
+:720b6a76dd9d
 }
 bool YoungList::check_list_well_formed() {
 bool ret = true;
-size_t length = 0;
+uint length = 0;
 HeapRegion* curr = _head;
 HeapRegion* last = NULL;
 while (curr != NULL) {
 if (!curr->is_young()) {
 gclog_or_tty->print_cr("### YOUNG REGION "PTR_FORMAT"-"PTR_FORMAT" "
 }
 ret = ret && (length == _length);
 if (!ret) {
 gclog_or_tty->print_cr("### YOUNG LIST seems not well formed!");
-gclog_or_tty->print_cr("###   list has %d entries, _length is %d",
+gclog_or_tty->print_cr("###   list has %u entries, _length is %u",
 length, _length);
 }
 return ret;
 }
 bool YoungList::check_list_empty(bool check_sample) {
 bool ret = true;
 if (_length != 0) {
-gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %d",
+gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %u",
 _length);
 ret = false;
 }
 if (check_sample && _last_sampled_rs_lengths != 0) {
 gclog_or_tty->print_cr("### YOUNG LIST has non-zero last sampled RS lengths");
 // the incremental collection set for the next evacuation
 // pause.
 _g1h->g1_policy()->add_region_to_incremental_cset_rhs(curr);
 young_index_in_cset += 1;
 }
-assert((size_t) young_index_in_cset == _survivor_length,
+assert((uint) young_index_in_cset == _survivor_length, "post-condition");
-"post-condition");
 _g1h->g1_policy()->note_stop_adding_survivor_regions();
 _head   = _survivor_head;
 _length = _survivor_length;
 if (_survivor_head != NULL) {
 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
 while (!_secondary_free_list.is_empty() || free_regions_coming()) {
 if (!_secondary_free_list.is_empty()) {
 if (G1ConcRegionFreeingVerbose) {
 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : "
-"secondary_free_list has "SIZE_FORMAT" entries",
+"secondary_free_list has %u entries",
 _secondary_free_list.length());
 }
 // It looks as if there are free regions available on the
 // secondary_free_list. Let's move them to the free_list and try
 // again to allocate from it.
 }
 }
 return res;
 }
-size_t G1CollectedHeap::humongous_obj_allocate_find_first(size_t num_regions,
+uint G1CollectedHeap::humongous_obj_allocate_find_first(uint num_regions,
 size_t word_size) {
 assert(isHumongous(word_size), "word_size should be humongous");
 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition");
-size_t first = G1_NULL_HRS_INDEX;
+uint first = G1_NULL_HRS_INDEX;
 if (num_regions == 1) {
 // Only one region to allocate, no need to go through the slower
 // path. The caller will attempt the expasion if this fails, so
 // let's not try to expand here too.
 HeapRegion* hr = new_region(word_size, false /* do_expand */);
 append_secondary_free_list_if_not_empty_with_lock();
 if (free_regions() >= num_regions) {
 first = _hrs.find_contiguous(num_regions);
 if (first != G1_NULL_HRS_INDEX) {
-for (size_t i = first; i < first + num_regions; ++i) {
+for (uint i = first; i < first + num_regions; ++i) {
 HeapRegion* hr = region_at(i);
 assert(hr->is_empty(), "sanity");
 assert(is_on_master_free_list(hr), "sanity");
 hr->set_pending_removal(true);
 }
 }
 return first;
 }
 HeapWord*
-G1CollectedHeap::humongous_obj_allocate_initialize_regions(size_t first,
+G1CollectedHeap::humongous_obj_allocate_initialize_regions(uint first,
-size_t num_regions,
+uint num_regions,
 size_t word_size) {
 assert(first != G1_NULL_HRS_INDEX, "pre-condition");
 assert(isHumongous(word_size), "word_size should be humongous");
 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition");
 // Index of last region in the series + 1.
-size_t last = first + num_regions;
+uint last = first + num_regions;
 // We need to initialize the region(s) we just discovered. This is
 // a bit tricky given that it can happen concurrently with
 // refinement threads refining cards on these regions and
 // potentially wanting to refine the BOT as they are scanning
 // those cards (this can happen shortly after a cleanup; see CR
 // 6991377). So we have to set up the region(s) carefully and in
 // a specific order.
 // The word size sum of all the regions we will allocate.
-size_t word_size_sum = num_regions * HeapRegion::GrainWords;
+size_t word_size_sum = (size_t) num_regions * HeapRegion::GrainWords;
 assert(word_size <= word_size_sum, "sanity");
 // This will be the "starts humongous" region.
 HeapRegion* first_hr = region_at(first);
 // The header of the new object will be placed at the bottom of
 first_hr->set_startsHumongous(new_top, new_end);
 // Then, if there are any, we will set up the "continues
 // humongous" regions.
 HeapRegion* hr = NULL;
-for (size_t i = first + 1; i < last; ++i) {
+for (uint i = first + 1; i < last; ++i) {
 hr = region_at(i);
 hr->set_continuesHumongous(first_hr);
 }
 // If we have "continues humongous" regions (hr != NULL), then the
 // end of the last one should match new_end.
 // fields here. The way we set top for all regions (i.e., top ==
 // end for all regions but the last one, top == new_top for the
 // last one) is actually used when we will free up the humongous
 // region in free_humongous_region().
 hr = NULL;
-for (size_t i = first + 1; i < last; ++i) {
+for (uint i = first + 1; i < last; ++i) {
 hr = region_at(i);
 if ((i + 1) == last) {
 // last continues humongous region
 assert(hr->bottom() < new_top && new_top <= hr->end(),
 "new_top should fall on this region");
 HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size) {
 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
 verify_region_sets_optional();
-size_t num_regions =
+size_t word_size_rounded = round_to(word_size, HeapRegion::GrainWords);
-round_to(word_size, HeapRegion::GrainWords) / HeapRegion::GrainWords;
+uint num_regions = (uint) (word_size_rounded / HeapRegion::GrainWords);
-size_t x_size = expansion_regions();
+uint x_num = expansion_regions();
-size_t fs = _hrs.free_suffix();
+uint fs = _hrs.free_suffix();
-size_t first = humongous_obj_allocate_find_first(num_regions, word_size);
+uint first = humongous_obj_allocate_find_first(num_regions, word_size);
 if (first == G1_NULL_HRS_INDEX) {
 // The only thing we can do now is attempt expansion.
-if (fs + x_size >= num_regions) {
+if (fs + x_num >= num_regions) {
 // If the number of regions we're trying to allocate for this
 // object is at most the number of regions in the free suffix,
 // then the call to humongous_obj_allocate_find_first() above
 // should have succeeded and we wouldn't be here.
 //
 size_t old_mem_size = _g1_storage.committed_size();
 size_t aligned_shrink_bytes =
 ReservedSpace::page_align_size_down(shrink_bytes);
 aligned_shrink_bytes = align_size_down(aligned_shrink_bytes,
 HeapRegion::GrainBytes);
-size_t num_regions_deleted = 0;
+uint num_regions_deleted = 0;
 MemRegion mr = _hrs.shrink_by(aligned_shrink_bytes, &num_regions_deleted);
 HeapWord* old_end = (HeapWord*) _g1_storage.high();
 assert(mr.end() == old_end, "post-condition");
 ergo_verbose3(ErgoHeapSizing,
 // happen in asserts: DLD.)
 _reserved.set_word_size(0);
 _reserved.set_start((HeapWord*)heap_rs.base());
 _reserved.set_end((HeapWord*)(heap_rs.base() + heap_rs.size()));
-_expansion_regions = max_byte_size/HeapRegion::GrainBytes;
+_expansion_regions = (uint) (max_byte_size / HeapRegion::GrainBytes);
 // Create the gen rem set (and barrier set) for the entire reserved region.
 _rem_set = collector_policy()->create_rem_set(_reserved, 2);
 set_barrier_set(rem_set()->bs());
 if (barrier_set()->is_a(BarrierSet::ModRef)) {
 (HeapWord*) _g1_reserved.end(),
 _expansion_regions);
 // 6843694 - ensure that the maximum region index can fit
 // in the remembered set structures.
-const size_t max_region_idx = ((size_t)1 << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1;
+const uint max_region_idx = (1U << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1;
 guarantee((max_regions() - 1) <= max_region_idx, "too many regions");
 size_t max_cards_per_region = ((size_t)1 << (sizeof(CardIdx_t)*BitsPerByte-1)) - 1;
 guarantee(HeapRegion::CardsPerRegion > 0, "make sure it's initialized");
 guarantee(HeapRegion::CardsPerRegion < max_cards_per_region,
 heap_word_size(init_byte_size));
 _g1h = this;
 _in_cset_fast_test_length = max_regions();
-_in_cset_fast_test_base = NEW_C_HEAP_ARRAY(bool, _in_cset_fast_test_length);
+_in_cset_fast_test_base =
+NEW_C_HEAP_ARRAY(bool, (size_t) _in_cset_fast_test_length);
 // We're biasing _in_cset_fast_test to avoid subtracting the
 // beginning of the heap every time we want to index; basically
 // it's the same with what we do with the card table.
 _in_cset_fast_test = _in_cset_fast_test_base -
-((size_t) _g1_reserved.start() >> HeapRegion::LogOfHRGrainBytes);
+((uintx) _g1_reserved.start() >> HeapRegion::LogOfHRGrainBytes);
 // Clear the _cset_fast_test bitmap in anticipation of adding
 // regions to the incremental collection set for the first
 // evacuation pause.
 clear_cset_fast_test();
 // Create the ConcurrentMark data structure and thread.
 // (Must do this late, so that "max_regions" is defined.)
-_cm       = new ConcurrentMark(heap_rs, (int) max_regions());
+_cm       = new ConcurrentMark(heap_rs, max_regions());
 _cmThread = _cm->cmThread();
 // Initialize the from_card cache structure of HeapRegionRemSet.
 HeapRegionRemSet::init_heap(max_regions());
 void
 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl,
 uint worker,
 uint no_of_par_workers,
 jint claim_value) {
-const size_t regions = n_regions();
+const uint regions = n_regions();
 const uint max_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
 no_of_par_workers :
 1);
 assert(UseDynamicNumberOfGCThreads ||
 no_of_par_workers == workers()->total_workers(),
 "Non dynamic should use fixed number of workers");
 // try to spread out the starting points of the workers
-const size_t start_index = regions / max_workers * (size_t) worker;
+const uint start_index = regions / max_workers * worker;
 // each worker will actually look at all regions
-for (size_t count = 0; count < regions; ++count) {
+for (uint count = 0; count < regions; ++count) {
-const size_t index = (start_index + count) % regions;
+const uint index = (start_index + count) % regions;
 assert(0 <= index && index < regions, "sanity");
 HeapRegion* r = region_at(index);
 // we'll ignore "continues humongous" regions (we'll process them
 // when we come across their corresponding "start humongous"
 // region) and regions already claimed
 // closure on the "starts humongous" region might de-allocate
 // and clear all its "continues humongous" regions and, as a
 // result, we might end up processing them twice. So, we'll do
 // them first (notice: most closures will ignore them anyway) and
 // then we'll do the "starts humongous" region.
-for (size_t ch_index = index + 1; ch_index < regions; ++ch_index) {
+for (uint ch_index = index + 1; ch_index < regions; ++ch_index) {
 HeapRegion* chr = region_at(ch_index);
 // if the region has already been claimed or it's not
 // "continues humongous" we're done
 if (chr->claim_value() == claim_value ||
 // regions is correct.
 class CheckClaimValuesClosure : public HeapRegionClosure {
 private:
 jint _claim_value;
-size_t _failures;
+uint _failures;
 HeapRegion* _sh_region;
 public:
 CheckClaimValuesClosure(jint claim_value) :
 _claim_value(claim_value), _failures(0), _sh_region(NULL) { }
 bool doHeapRegion(HeapRegion* r) {
 if (r->claim_value() != _claim_value) {
 ++_failures;
 }
 }
 return false;
 }
-size_t failures() {
+uint failures() { return _failures; }
-return _failures;
-}
 };
 bool G1CollectedHeap::check_heap_region_claim_values(jint claim_value) {
 CheckClaimValuesClosure cl(claim_value);
 heap_region_iterate(&cl);
 return cl.failures() == 0;
 }
 class CheckClaimValuesInCSetHRClosure: public HeapRegionClosure {
-jint   _claim_value;
+private:
-size_t _failures;
+jint _claim_value;
+uint _failures;
 public:
 CheckClaimValuesInCSetHRClosure(jint claim_value) :
-_claim_value(claim_value),
+_claim_value(claim_value), _failures(0) { }
-_failures(0) { }
+uint failures() { return _failures; }
-size_t failures() {
-return _failures;
-}
 bool doHeapRegion(HeapRegion* hr) {
 assert(hr->in_collection_set(), "how?");
 assert(!hr->isHumongous(), "H-region in CSet");
 if (hr->claim_value() != _claim_value) {
 //          p threads
 // Then thread t will start at region floor ((t * n) / p)
 result = g1_policy()->collection_set();
 if (G1CollectedHeap::use_parallel_gc_threads()) {
-size_t cs_size = g1_policy()->cset_region_length();
+uint cs_size = g1_policy()->cset_region_length();
 uint active_workers = workers()->active_workers();
 assert(UseDynamicNumberOfGCThreads ||
 active_workers == workers()->total_workers(),
 "Unless dynamic should use total workers");
-size_t end_ind   = (cs_size * worker_i) / active_workers;
+uint end_ind   = (cs_size * worker_i) / active_workers;
-size_t start_ind = 0;
+uint start_ind = 0;
 if (worker_i > 0 &&
 _worker_cset_start_region_time_stamp[worker_i - 1] == gc_time_stamp) {
 // Previous workers starting region is valid
 // so let's iterate from there
 start_ind = (cs_size * (worker_i - 1)) / active_workers;
 result = _worker_cset_start_region[worker_i - 1];
 }
-for (size_t i = start_ind; i < end_ind; i++) {
+for (uint i = start_ind; i < end_ind; i++) {
 result = result->next_in_collection_set();
 }
 }
 // Note: the calculated starting heap region may be NULL
 _g1_storage.low_boundary(),
 _g1_storage.high(),
 _g1_storage.high_boundary());
 st->cr();
 st->print("  region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K);
-size_t young_regions = _young_list->length();
+uint young_regions = _young_list->length();
-st->print(SIZE_FORMAT " young (" SIZE_FORMAT "K), ",
+st->print("%u young (" SIZE_FORMAT "K), ", young_regions,
-young_regions, young_regions * HeapRegion::GrainBytes / K);
+(size_t) young_regions * HeapRegion::GrainBytes / K);
-size_t survivor_regions = g1_policy()->recorded_survivor_regions();
+uint survivor_regions = g1_policy()->recorded_survivor_regions();
-st->print(SIZE_FORMAT " survivors (" SIZE_FORMAT "K)",
+st->print("%u survivors (" SIZE_FORMAT "K)", survivor_regions,
-survivor_regions, survivor_regions * HeapRegion::GrainBytes / K);
+(size_t) survivor_regions * HeapRegion::GrainBytes / K);
 st->cr();
 perm()->as_gen()->print_on(st);
 }
 void G1CollectedHeap::print_extended_on(outputStream* st) const {
 print_on(st);
 // Print the per-region information.
 st->cr();
-st->print_cr("Heap Regions: (Y=young(eden), SU=young(survivor), HS=humongous(starts), HC=humongous(continues), CS=collection set, F=free, TS=gc time stamp, PTAMS=previous top-at-mark-start, NTAMS=next top-at-mark-start)");
+st->print_cr("Heap Regions: (Y=young(eden), SU=young(survivor), "
+"HS=humongous(starts), HC=humongous(continues), "
+"CS=collection set, F=free, TS=gc time stamp, "
+"PTAMS=previous top-at-mark-start, "
+"NTAMS=next top-at-mark-start)");
 PrintRegionClosure blk(st);
 heap_region_iterate(&blk);
 }
 void G1CollectedHeap::print_gc_threads_on(outputStream* st) const {
 return g1_rem_set()->cardsScanned();
 }
 void
 G1CollectedHeap::setup_surviving_young_words() {
-guarantee( _surviving_young_words == NULL, "pre-condition" );
+assert(_surviving_young_words == NULL, "pre-condition");
-size_t array_length = g1_policy()->young_cset_region_length();
+uint array_length = g1_policy()->young_cset_region_length();
-_surviving_young_words = NEW_C_HEAP_ARRAY(size_t, array_length);
+_surviving_young_words = NEW_C_HEAP_ARRAY(size_t, (size_t) array_length);
 if (_surviving_young_words == NULL) {
 vm_exit_out_of_memory(sizeof(size_t) * array_length,
 "Not enough space for young surv words summary.");
 }
-memset(_surviving_young_words, 0, array_length * sizeof(size_t));
+memset(_surviving_young_words, 0, (size_t) array_length * sizeof(size_t));
 #ifdef ASSERT
-for (size_t i = 0;  i < array_length; ++i) {
+for (uint i = 0;  i < array_length; ++i) {
 assert( _surviving_young_words[i] == 0, "memset above" );
 }
 #endif // !ASSERT
 }
 void
 G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) {
 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
-size_t array_length = g1_policy()->young_cset_region_length();
+uint array_length = g1_policy()->young_cset_region_length();
-for (size_t i = 0; i < array_length; ++i)
+for (uint i = 0; i < array_length; ++i) {
 _surviving_young_words[i] += surv_young_words[i];
+}
 }
 void
 G1CollectedHeap::cleanup_surviving_young_words() {
 guarantee( _surviving_young_words != NULL, "pre-condition" );
 // we allocate G1YoungSurvRateNumRegions plus one entries, since
 // we "sacrifice" entry 0 to keep track of surviving bytes for
 // non-young regions (where the age is -1)
 // We also add a few elements at the beginning and at the end in
 // an attempt to eliminate cache contention
-size_t real_length = 1 + _g1h->g1_policy()->young_cset_region_length();
+uint real_length = 1 + _g1h->g1_policy()->young_cset_region_length();
-size_t array_length = PADDING_ELEM_NUM +
+uint array_length = PADDING_ELEM_NUM +
 real_length +
 PADDING_ELEM_NUM;
 _surviving_young_words_base = NEW_C_HEAP_ARRAY(size_t, array_length);
 if (_surviving_young_words_base == NULL)
 vm_exit_out_of_memory(array_length * sizeof(size_t),
 "Not enough space for young surv histo.");
 _surviving_young_words = _surviving_young_words_base + PADDING_ELEM_NUM;
-memset(_surviving_young_words, 0, real_length * sizeof(size_t));
+memset(_surviving_young_words, 0, (size_t) real_length * sizeof(size_t));
 _alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer;
 _alloc_buffers[GCAllocForTenured]  = &_tenured_alloc_buffer;
 _start = os::elapsedTime();
 }
 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object>
 oop G1ParCopyClosure<do_gen_barrier, barrier, do_mark_object>
 ::copy_to_survivor_space(oop old) {
-size_t    word_sz = old->size();
+size_t word_sz = old->size();
 HeapRegion* from_region = _g1->heap_region_containing_raw(old);
 // +1 to make the -1 indexes valid...
 int       young_index = from_region->young_index_in_cset()+1;
 assert( (from_region->is_young() && young_index >  0) ||
 (!from_region->is_young() && young_index == 0), "invariant" );
 size_t hr_pre_used = 0;
 _humongous_set.remove_with_proxy(hr, humongous_proxy_set);
 hr->set_notHumongous();
 free_region(hr, &hr_pre_used, free_list, par);
-size_t i = hr->hrs_index() + 1;
+uint i = hr->hrs_index() + 1;
-size_t num = 1;
+uint num = 1;
 while (i < n_regions()) {
 HeapRegion* curr_hr = region_at(i);
 if (!curr_hr->continuesHumongous()) {
 break;
 }
 cur->set_in_collection_set(false);
 if (cur->is_young()) {
 int index = cur->young_index_in_cset();
 assert(index != -1, "invariant");
-assert((size_t) index < policy->young_cset_region_length(), "invariant");
+assert((uint) index < policy->young_cset_region_length(), "invariant");
 size_t words_survived = _surviving_young_words[index];
 cur->record_surv_words_in_group(words_survived);
 // At this point the we have 'popped' cur from the collection set
 // (linked via next_in_collection_set()) but it is still in the
 }
 // Methods for the GC alloc regions
 HeapRegion* G1CollectedHeap::new_gc_alloc_region(size_t word_size,
-size_t count,
+uint count,
 GCAllocPurpose ap) {
 assert(FreeList_lock->owned_by_self(), "pre-condition");
 if (count < g1_policy()->max_regions(ap)) {
 HeapRegion* new_alloc_region = new_region(word_size,
 class VerifyRegionListsClosure : public HeapRegionClosure {
 private:
 FreeRegionList*     _free_list;
 OldRegionSet*       _old_set;
 HumongousRegionSet* _humongous_set;
-size_t              _region_count;
+uint                _region_count;
 public:
 VerifyRegionListsClosure(OldRegionSet* old_set,
 HumongousRegionSet* humongous_set,
 FreeRegionList* free_list) :
 _old_set(old_set), _humongous_set(humongous_set),
 _free_list(free_list), _region_count(0) { }
-size_t region_count()      { return _region_count;      }
+uint region_count() { return _region_count; }
 bool doHeapRegion(HeapRegion* hr) {
 _region_count += 1;
 if (hr->continuesHumongous()) {
 }
 return false;
 }
 };
-HeapRegion* G1CollectedHeap::new_heap_region(size_t hrs_index,
+HeapRegion* G1CollectedHeap::new_heap_region(uint hrs_index,
 HeapWord* bottom) {
 HeapWord* end = bottom + HeapRegion::GrainWords;
 MemRegion mr(bottom, end);
 assert(_g1_reserved.contains(mr), "invariant");
 // This might return NULL if the allocation fails

Mercurial > hg > graal-compiler

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