jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp

-:00dd86e542eb
+:dc467e8b2c5e
 public:
 CheckClaimValuesClosure(jint claim_value) :
 _claim_value(claim_value), _failures(0), _sh_region(NULL) { }
 bool doHeapRegion(HeapRegion* r) {
 if (r->claim_value() != _claim_value) {
-gclog_or_tty->print_cr("Region ["PTR_FORMAT","PTR_FORMAT"), "
+gclog_or_tty->print_cr("Region " HR_FORMAT ", "
 "claim value = %d, should be %d",
-r->bottom(), r->end(), r->claim_value(),
+HR_FORMAT_PARAMS(r),
-_claim_value);
+r->claim_value(), _claim_value);
 ++_failures;
 }
 if (!r->isHumongous()) {
 _sh_region = NULL;
 } else if (r->startsHumongous()) {
 _sh_region = r;
 } else if (r->continuesHumongous()) {
 if (r->humongous_start_region() != _sh_region) {
-gclog_or_tty->print_cr("Region ["PTR_FORMAT","PTR_FORMAT"), "
+gclog_or_tty->print_cr("Region " HR_FORMAT ", "
 "HS = "PTR_FORMAT", should be "PTR_FORMAT,
-r->bottom(), r->end(),
+HR_FORMAT_PARAMS(r),
 r->humongous_start_region(),
 _sh_region);
 ++_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;
+size_t _failures;
+public:
+CheckClaimValuesInCSetHRClosure(jint claim_value) :
+_claim_value(claim_value),
+_failures(0) { }
+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) {
+gclog_or_tty->print_cr("CSet Region " HR_FORMAT ", "
+"claim value = %d, should be %d",
+HR_FORMAT_PARAMS(hr),
+hr->claim_value(), _claim_value);
+_failures += 1;
+}
+return false;
+}
+};
+bool G1CollectedHeap::check_cset_heap_region_claim_values(jint claim_value) {
+CheckClaimValuesInCSetHRClosure cl(claim_value);
+collection_set_iterate(&cl);
+return cl.failures() == 0;
+}
 #endif // ASSERT
+// We want the parallel threads to start their collection
+// set iteration at different collection set regions to
+// avoid contention.
+// If we have:
+//          n collection set regions
+//          p threads
+// Then thread t will start at region t * floor (n/p)
+HeapRegion* G1CollectedHeap::start_cset_region_for_worker(int worker_i) {
+HeapRegion* result = g1_policy()->collection_set();
+if (G1CollectedHeap::use_parallel_gc_threads()) {
+size_t cs_size = g1_policy()->cset_region_length();
+int n_workers = workers()->total_workers();
+size_t cs_spans = cs_size / n_workers;
+size_t ind      = cs_spans * worker_i;
+for (size_t i = 0; i < ind; i++) {
+result = result->next_in_collection_set();
+}
+}
+return result;
+}
 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) {
 HeapRegion* r = g1_policy()->collection_set();
 while (r != NULL) {
 HeapRegion* next = r->next_in_collection_set();
 concurrent_g1_refine()->clear_hot_cache();
 concurrent_g1_refine()->set_use_cache(true);
 finalize_for_evac_failure();
-// Must do this before removing self-forwarding pointers, which clears
+// Must do this before clearing the per-region evac-failure flags
-// the per-region evac-failure flags.
+// (which is currently done when we free the collection set).
+// We also only do this if marking is actually in progress and so
+// have to do this before we set the mark_in_progress flag at the
+// end of an initial mark pause.
 concurrent_mark()->complete_marking_in_collection_set();
 if (evacuation_failed()) {
 remove_self_forwarding_pointers();
 if (PrintGCDetails) {
 int age_bound = -1;
 size_t rs_lengths = 0;
 while (cur != NULL) {
 assert(!is_on_master_free_list(cur), "sanity");
 if (non_young) {
 if (cur->is_young()) {
 double end_sec = os::elapsedTime();
 double elapsed_ms = (end_sec - start_sec) * 1000.0;
 non_young_time_ms += elapsed_ms;
 start_sec = os::elapsedTime();
 non_young = false;
 }
 } else {
-double end_sec = os::elapsedTime();
+if (!cur->is_young()) {
-double elapsed_ms = (end_sec - start_sec) * 1000.0;
+double end_sec = os::elapsedTime();
-young_time_ms += elapsed_ms;
+double elapsed_ms = (end_sec - start_sec) * 1000.0;
+young_time_ms += elapsed_ms;
-start_sec = os::elapsedTime();
-non_young = true;
+start_sec = os::elapsedTime();
+non_young = true;
+}
 }
 rs_lengths += cur->rem_set()->occupied();
 HeapRegion* next = cur->next_in_collection_set();
 assert( (cur->is_young() && cur->young_index_in_cset() > -1) ||
 (!cur->is_young() && cur->young_index_in_cset() == -1),
 "invariant" );
 if (!cur->evacuation_failed()) {
+MemRegion used_mr = cur->used_region();
 // And the region is empty.
-assert(!cur->is_empty(), "Should not have empty regions in a CS.");
+assert(!used_mr.is_empty(), "Should not have empty regions in a CS.");
+// If marking is in progress then clear any objects marked in
+// the current region. Note mark_in_progress() returns false,
+// even during an initial mark pause, until the set_marking_started()
+// call which takes place later in the pause.
+if (mark_in_progress()) {
+assert(!g1_policy()->during_initial_mark_pause(), "sanity");
+_cm->nextMarkBitMap()->clearRange(used_mr);
+}
 free_region(cur, &pre_used, &local_free_list, false /* par */);
 } else {
 cur->uninstall_surv_rate_group();
 if (cur->is_young()) {
 cur->set_young_index_in_cset(-1);
 policy->record_max_rs_lengths(rs_lengths);
 policy->cset_regions_freed();
 double end_sec = os::elapsedTime();
 double elapsed_ms = (end_sec - start_sec) * 1000.0;
-if (non_young)
+if (non_young) {
 non_young_time_ms += elapsed_ms;
-else
+} else {
 young_time_ms += elapsed_ms;
+}
 update_sets_after_freeing_regions(pre_used, &local_free_list,
 NULL /* old_proxy_set */,
 NULL /* humongous_proxy_set */,
 false /* par */);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp

src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp