src/share/vm/gc/g1/concurrentMark.cpp

@@ -434,10 +434,11 @@
   _has_overflown(false),
   _concurrent(false),
   _has_aborted(false),
   _restart_for_overflow(false),
   _concurrent_marking_in_progress(false),
+  _concurrent_marking_from_roots(false),
 
   // _verbose_level set below
 
   _init_times(),
   _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),

@@ -1001,18 +1002,32 @@
     // mainly used for sanity checking.
     root_regions()->scan_finished();
   }
 }
 
+void ConcurrentMark::register_mark_from_roots_phase_start() {
+  _concurrent_marking_from_roots = true;
+  _g1h->gc_timer_cm()->register_gc_concurrent_start("Concurrent Mark");
+}
+
+void ConcurrentMark::register_mark_from_roots_phase_end() {
+  _concurrent_marking_from_roots = false;
+  if (!has_aborted()) {
+    _g1h->gc_timer_cm()->register_gc_concurrent_end();
+  }
+}
+
 void ConcurrentMark::markFromRoots() {
   // we might be tempted to assert that:
   // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
   //        "inconsistent argument?");
   // However that wouldn't be right, because it's possible that
   // a safepoint is indeed in progress as a younger generation
   // stop-the-world GC happens even as we mark in this generation.
 
+  register_mark_from_roots_phase_start();
+
   _restart_for_overflow = false;
 
   // _g1h has _n_par_threads
   _parallel_marking_threads = calc_parallel_marking_threads();
   assert(parallel_marking_threads() <= max_parallel_marking_threads(),

@@ -1025,10 +1040,13 @@
   set_concurrency_and_phase(active_workers, true /* concurrent */);
 
   CMConcurrentMarkingTask markingTask(this, cmThread());
   _parallel_workers->set_active_workers(active_workers);
   _parallel_workers->run_task(&markingTask);
+
+  register_mark_from_roots_phase_end();
+
   print_stats();
 }
 
 void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
   // world is stopped at this checkpoint