hotspot/src/share/vm/gc/g1/concurrentMark.cpp
changeset 35204 78a0fd90a70f
parent 35065 b4ff0249c092
child 35211 3771329165d4
equal deleted inserted replaced
35202:506ccf1717fd 35204:78a0fd90a70f
   434   _has_overflown(false),
   434   _has_overflown(false),
   435   _concurrent(false),
   435   _concurrent(false),
   436   _has_aborted(false),
   436   _has_aborted(false),
   437   _restart_for_overflow(false),
   437   _restart_for_overflow(false),
   438   _concurrent_marking_in_progress(false),
   438   _concurrent_marking_in_progress(false),
       
   439   _concurrent_phase_started(false),
   439 
   440 
   440   // _verbose_level set below
   441   // _verbose_level set below
   441 
   442 
   442   _init_times(),
   443   _init_times(),
   443   _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
   444   _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
   998 
   999 
   999     // It's possible that has_aborted() is true here without actually
  1000     // It's possible that has_aborted() is true here without actually
  1000     // aborting the survivor scan earlier. This is OK as it's
  1001     // aborting the survivor scan earlier. This is OK as it's
  1001     // mainly used for sanity checking.
  1002     // mainly used for sanity checking.
  1002     root_regions()->scan_finished();
  1003     root_regions()->scan_finished();
       
  1004   }
       
  1005 }
       
  1006 
       
  1007 void ConcurrentMark::register_concurrent_phase_start(const char* title) {
       
  1008   assert(!_concurrent_phase_started, "Sanity");
       
  1009   _concurrent_phase_started = true;
       
  1010   _g1h->gc_timer_cm()->register_gc_concurrent_start(title);
       
  1011 }
       
  1012 
       
  1013 void ConcurrentMark::register_concurrent_phase_end() {
       
  1014   if (_concurrent_phase_started) {
       
  1015     _concurrent_phase_started = false;
       
  1016     _g1h->gc_timer_cm()->register_gc_concurrent_end();
  1003   }
  1017   }
  1004 }
  1018 }
  1005 
  1019 
  1006 void ConcurrentMark::markFromRoots() {
  1020 void ConcurrentMark::markFromRoots() {
  1007   // we might be tempted to assert that:
  1021   // we might be tempted to assert that:
  2607   satb_mq_set.set_active_all_threads(
  2621   satb_mq_set.set_active_all_threads(
  2608                                  false, /* new active value */
  2622                                  false, /* new active value */
  2609                                  satb_mq_set.is_active() /* expected_active */);
  2623                                  satb_mq_set.is_active() /* expected_active */);
  2610 
  2624 
  2611   _g1h->trace_heap_after_concurrent_cycle();
  2625   _g1h->trace_heap_after_concurrent_cycle();
       
  2626 
       
  2627   // Close any open concurrent phase timing
       
  2628   register_concurrent_phase_end();
       
  2629 
  2612   _g1h->register_concurrent_cycle_end();
  2630   _g1h->register_concurrent_cycle_end();
  2613 }
  2631 }
  2614 
  2632 
  2615 static void print_ms_time_info(const char* prefix, const char* name,
  2633 static void print_ms_time_info(const char* prefix, const char* name,
  2616                                NumberSeq& ns) {
  2634                                NumberSeq& ns) {