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

equal deleted inserted replaced

-:4ba0436b3b29
+:0cfe4d79060c
 assert(hr->get_next_young_region() == NULL, "cause it should!");
 hr->set_next_young_region(_head);
 _head = hr;
-hr->set_young();
+_g1h->g1_policy()->set_region_eden(hr, (int) _length);
-double yg_surv_rate = _g1h->g1_policy()->predict_yg_surv_rate((int)_length);
 ++_length;
 }
 void YoungList::add_survivor_region(HeapRegion* hr) {
 assert(hr->is_survivor(), "should be flagged as survivor region");
 hr->set_next_young_region(_survivor_head);
 if (_survivor_head == NULL) {
 _survivor_tail = hr;
 }
 _survivor_head = hr;
 ++_survivor_length;
 }
 void YoungList::empty_list(HeapRegion* list) {
 while (list != NULL) {
 // Add survivor regions to SurvRateGroup.
 _g1h->g1_policy()->note_start_adding_survivor_regions();
 _g1h->g1_policy()->finished_recalculating_age_indexes(true /* is_survivors */);
+int young_index_in_cset = 0;
 for (HeapRegion* curr = _survivor_head;
 curr != NULL;
 curr = curr->get_next_young_region()) {
-_g1h->g1_policy()->set_region_survivors(curr);
+_g1h->g1_policy()->set_region_survivor(curr, young_index_in_cset);
 // The region is a non-empty survivor so let's add it to
 // 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,
+"post-condition");
 _g1h->g1_policy()->note_stop_adding_survivor_regions();
 _head   = _survivor_head;
 _length = _survivor_length;
 if (_survivor_head != NULL) {
 _cmThread->set_started();
 CGC_lock->notify();
 }
 }
-// <NEW PREDICTION>
 double G1CollectedHeap::predict_region_elapsed_time_ms(HeapRegion *hr,
 bool young) {
 return _g1_policy->predict_region_elapsed_time_ms(hr, young);
 }
 }
 void
 G1CollectedHeap::setup_surviving_young_words() {
 guarantee( _surviving_young_words == NULL, "pre-condition" );
-size_t array_length = g1_policy()->young_cset_length();
+size_t array_length = g1_policy()->young_cset_region_length();
 _surviving_young_words = NEW_C_HEAP_ARRAY(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.");
 }
 }
 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_length();
+size_t array_length = g1_policy()->young_cset_region_length();
 for (size_t 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" );
 FREE_C_HEAP_ARRAY(size_t, _surviving_young_words);
 _surviving_young_words = NULL;
 }
-// </NEW PREDICTION>
 #ifdef ASSERT
 class VerifyCSetClosure: public HeapRegionClosure {
 public:
 bool doHeapRegion(HeapRegion* hr) {
 // 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_length();
+size_t real_length = 1 + _g1h->g1_policy()->young_cset_region_length();
 size_t 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)
 cur->set_next_in_collection_set(NULL);
 cur->set_in_collection_set(false);
 if (cur->is_young()) {
 int index = cur->young_index_in_cset();
-guarantee( index != -1, "invariant" );
+assert(index != -1, "invariant");
-guarantee( (size_t)index < policy->young_cset_length(), "invariant" );
+assert((size_t) 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
 // young list (linked via next_young_region()). Clear the
 // _next_young_region field.
 cur->set_next_young_region(NULL);
 } else {
 int index = cur->young_index_in_cset();
-guarantee( index == -1, "invariant" );
+assert(index == -1, "invariant");
 }
 assert( (cur->is_young() && cur->young_index_in_cset() > -1) ||
 (!cur->is_young() && cur->young_index_in_cset() == -1),
 "invariant" );
 // And the region is empty.
 assert(!cur->is_empty(), "Should not have empty regions in a CS.");
 free_region(cur, &pre_used, &local_free_list, false /* par */);
 } else {
 cur->uninstall_surv_rate_group();
-if (cur->is_young())
+if (cur->is_young()) {
 cur->set_young_index_in_cset(-1);
+}
 cur->set_not_young();
 cur->set_evacuation_failed(false);
 // The region is now considered to be old.
 _old_set.add(cur);
 }
 void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) {
 assert(heap_lock_held_for_gc(),
 "the heap lock should already be held by or for this thread");
 _young_list->push_region(hr);
-g1_policy()->set_region_short_lived(hr);
 }
 class NoYoungRegionsClosure: public HeapRegionClosure {
 private:
 bool _success;
 bool young_list_full = g1_policy()->is_young_list_full();
 if (force || !young_list_full) {
 HeapRegion* new_alloc_region = new_region(word_size,
 false /* do_expand */);
 if (new_alloc_region != NULL) {
-g1_policy()->update_region_num(true /* next_is_young */);
 set_region_short_lived_locked(new_alloc_region);
 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Eden, young_list_full);
 return new_alloc_region;
 }
 }

changeset 11169	0cfe4d79060c
parent 10997	0be4b3be7197
child 11174	fccee5238e70