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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 4097:dc467e8b2c5e

7112743: G1: Reduce overhead of marking closure during evacuation pauses Summary: Parallelize the serial code that was used to mark objects reachable from survivor objects in the collection set. Some minor improvments in the timers used to track the freeing of the collection set along with some tweaks to PrintGCDetails. Reviewed-by: tonyp, brutisso

author	johnc
date	Thu, 17 Nov 2011 12:40:15 -0800
parents	bca17e38de00
children	3c648b9ad052

comparison

equal deleted inserted replaced

-: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 > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 4097:dc467e8b2c5e