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

rev 9733 : [mq]: webrev.00
rev 9734 : [mq]: webrev.01
rev 9735 : [mq]: webrev.02

*** 434,443 ****
--- 434,444 ----
    _has_overflown(false),
    _concurrent(false),
    _has_aborted(false),
    _restart_for_overflow(false),
    _concurrent_marking_in_progress(false),
+   _concurrent_phase_started(false),
  
    // _verbose_level set below
  
    _init_times(),
    _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
*** 1001,1010 ****
--- 1002,1024 ----
      // mainly used for sanity checking.
      root_regions()->scan_finished();
    }
  }
  
+ void ConcurrentMark::register_concurrent_phase_start(const char* title) {
+   assert(!_concurrent_phase_started, "Sanity");
+   _concurrent_phase_started = true;
+   _g1h->gc_timer_cm()->register_gc_concurrent_start(title);
+ }
+ 
+ void ConcurrentMark::register_concurrent_phase_end() {
+   if (_concurrent_phase_started) {
+     _concurrent_phase_started = false;
+     _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
*** 2607,2616 ****
--- 2621,2634 ----
    satb_mq_set.set_active_all_threads(
                                   false, /* new active value */
                                   satb_mq_set.is_active() /* expected_active */);
  
    _g1h->trace_heap_after_concurrent_cycle();
+ 
+   // Close any open concurrent phase timing
+   register_concurrent_phase_end();
+ 
    _g1h->register_concurrent_cycle_end();
  }
  
  static void print_ms_time_info(const char* prefix, const char* name,
                                 NumberSeq& ns) {