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

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

*** 434,444 ****
    _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(),
--- 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(),
*** 1002,1019 ****
      // 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() {
--- 1002,1020 ----
      // 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() {
*** 1022,1033 ****
    //        "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(),
--- 1023,1032 ----
*** 1041,1052 ****
  
    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
--- 1040,1049 ----
*** 2625,2634 ****
--- 2622,2635 ----
    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) {