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

equal deleted inserted replaced

-:7bad9c9efdf3
+:a3453bbd5418
 // incremental collection set and then start rebuilding it afresh
 // after this full GC.
 abandon_collection_set(collection_set());
 tear_down_region_sets(false /* free_list_only */);
-collector_state()->set_gcs_are_young(true);
 }
 void G1CollectedHeap::verify_before_full_collection(bool explicit_gc) {
 assert(!GCCause::is_user_requested_gc(gc_cause()) || explicit_gc, "invariant");
 assert(used() == recalculate_used(), "Should be equal");
 _verifier->verify_dirty_young_regions();
 // We should not be doing initial mark unless the conc mark thread is running
 if (!_cmThread->should_terminate()) {
 // This call will decide whether this pause is an initial-mark
-// pause. If it is, during_initial_mark_pause() will return true
+// pause. If it is, in_initial_mark_gc() will return true
 // for the duration of this pause.
 g1_policy()->decide_on_conc_mark_initiation();
 }
 // We do not allow initial-mark to be piggy-backed on a mixed GC.
-assert(!collector_state()->during_initial_mark_pause() ||
+assert(!collector_state()->in_initial_mark_gc() ||
-collector_state()->gcs_are_young(), "sanity");
+collector_state()->in_young_only_phase(), "sanity");
 // We also do not allow mixed GCs during marking.
-assert(!collector_state()->mark_in_progress() || collector_state()->gcs_are_young(), "sanity");
+assert(!collector_state()->mark_or_rebuild_in_progress() || collector_state()->in_young_only_phase(), "sanity");
 // Record whether this pause is an initial mark. When the current
 // thread has completed its logging output and it's safe to signal
 // the CM thread, the flag's value in the policy has been reset.
-bool should_start_conc_mark = collector_state()->during_initial_mark_pause();
+bool should_start_conc_mark = collector_state()->in_initial_mark_gc();
 // Inner scope for scope based logging, timers, and stats collection
 {
 EvacuationInfo evacuation_info;
-if (collector_state()->during_initial_mark_pause()) {
+if (collector_state()->in_initial_mark_gc()) {
 // We are about to start a marking cycle, so we increment the
 // full collection counter.
 increment_old_marking_cycles_started();
 _cm->gc_tracer_cm()->set_gc_cause(gc_cause());
 }
 GCTraceCPUTime tcpu;
 G1HeapVerifier::G1VerifyType verify_type;
 FormatBuffer<> gc_string("Pause ");
-if (collector_state()->during_initial_mark_pause()) {
+if (collector_state()->in_initial_mark_gc()) {
 gc_string.append("Initial Mark");
 verify_type = G1HeapVerifier::G1VerifyInitialMark;
-} else if (collector_state()->gcs_are_young()) {
+} else if (collector_state()->in_young_only_phase()) {
 gc_string.append("Young");
 verify_type = G1HeapVerifier::G1VerifyYoungOnly;
 } else {
 gc_string.append("Mixed");
 verify_type = G1HeapVerifier::G1VerifyMixed;
 // the possible verification above.
 double sample_start_time_sec = os::elapsedTime();
 g1_policy()->record_collection_pause_start(sample_start_time_sec);
-if (collector_state()->during_initial_mark_pause()) {
+if (collector_state()->in_initial_mark_gc()) {
 concurrent_mark()->checkpoint_roots_initial_pre();
 }
 g1_policy()->finalize_collection_set(target_pause_time_ms, &_survivor);
 // The "used" of the the collection set have already been subtracted
 // when they were freed.  Add in the bytes evacuated.
 increase_used(g1_policy()->bytes_copied_during_gc());
 }
-if (collector_state()->during_initial_mark_pause()) {
+if (collector_state()->in_initial_mark_gc()) {
 // We have to do this before we notify the CM threads that
 // they can start working to make sure that all the
 // appropriate initialization is done on the CM object.
 concurrent_mark()->checkpoint_roots_initial_post();
-collector_state()->set_mark_in_progress(true);
 // Note that we don't actually trigger the CM thread at
 // this point. We do that later when we're sure that
 // the current thread has completed its logging output.
 }
 rp->verify_no_references_recorded();
 assert(!rp->discovery_enabled(), "should have been disabled");
 // If during an initial mark pause we install a pending list head which is not otherwise reachable
 // ensure that it is marked in the bitmap for concurrent marking to discover.
-if (collector_state()->during_initial_mark_pause()) {
+if (collector_state()->in_initial_mark_gc()) {
 oop pll_head = Universe::reference_pending_list();
 if (pll_head != NULL) {
 // Any valid worker id is fine here as we are in the VM thread and single-threaded.
 _cm->mark_in_next_bitmap(0 /* worker_id */, pll_head);
 }
 _preserved_marks_set.assert_empty();
 G1GCPhaseTimes* phase_times = g1_policy()->phase_times();
 // InitialMark needs claim bits to keep track of the marked-through CLDs.
-if (collector_state()->during_initial_mark_pause()) {
+if (collector_state()->in_initial_mark_gc()) {
 double start_clear_claimed_marks = os::elapsedTime();
 ClassLoaderDataGraph::clear_claimed_marks();
 double recorded_clear_claimed_marks_time_ms = (os::elapsedTime() - start_clear_claimed_marks) * 1000.0;
 new_alloc_region->set_old();
 _verifier->check_bitmaps("Old Region Allocation", new_alloc_region);
 }
 _g1_policy->remset_tracker()->update_at_allocate(new_alloc_region);
 _hr_printer.alloc(new_alloc_region);
-bool during_im = collector_state()->during_initial_mark_pause();
+bool during_im = collector_state()->in_initial_mark_gc();
 new_alloc_region->note_start_of_copying(during_im);
 return new_alloc_region;
 }
 return NULL;
 }
 void G1CollectedHeap::retire_gc_alloc_region(HeapRegion* alloc_region,
 size_t allocated_bytes,
 InCSetState dest) {
-bool during_im = collector_state()->during_initial_mark_pause();
+bool during_im = collector_state()->in_initial_mark_gc();
 alloc_region->note_end_of_copying(during_im);
 g1_policy()->record_bytes_copied_during_gc(allocated_bytes);
 if (dest.is_old()) {
 _old_set.add(alloc_region);
 }

changeset 49643	a3453bbd5418
parent 49635	e79bbf1635da
child 49644	50a01910e00a