src/share/vm/gc/g1/g1ConcurrentMark.hpp

*** 350,361 ****
    // point when all the tasks complete their work. It is really used
    // to determine the points between the end of concurrent marking and
    // time of remark.
    volatile bool           _concurrent_marking_in_progress;
  
!   // Keep track of whether we have started concurrent phase or not.
!   bool                    _concurrent_phase_started;
  
    // All of these times are in ms
    NumberSeq _init_times;
    NumberSeq _remark_times;
    NumberSeq _remark_mark_times;
--- 350,370 ----
    // point when all the tasks complete their work. It is really used
    // to determine the points between the end of concurrent marking and
    // time of remark.
    volatile bool           _concurrent_marking_in_progress;
  
!   // There would be a race between ConcurrentMarkThread and VMThread(ConcurrentMark::abort())
!   // to call ConcurrentGCTimer::register_gc_concurrent_end().
!   // And this variable is used to keep track of concurrent phase.
!   volatile uint           _concurrent_phase_status;
!   // Concurrent phase is not yet started.
!   static const uint       ConcPhaseNotStarted = 0;
!   // Concurrent phase is started.
!   static const uint       ConcPhaseStarted = 1;
!   // Caller thread of ConcurrentGCTimer::register_gc_concurrent_end() is ending concurrent phase.
!   // So other thread should wait until the status to be changed to ConcPhaseNotStarted.
!   static const uint       ConcPhaseStopping = 2;
  
    // All of these times are in ms
    NumberSeq _init_times;
    NumberSeq _remark_times;
    NumberSeq _remark_mark_times;
*** 483,492 ****
--- 492,504 ----
    intptr_t _heap_bottom_card_num;
  
    // Set to true when initialization is complete
    bool _completed_initialization;
  
+   // end_timer, true to end gc timer after ending concurrent phase.
+   void register_concurrent_phase_end_common(bool end_timer);
+ 
  public:
    // Manipulation of the global mark stack.
    // The push and pop operations are used by tasks for transfers
    // between task-local queues and the global mark stack, and use
    // locking for concurrency safety.
*** 518,527 ****
--- 530,541 ----
      _concurrent_marking_in_progress = false;
    }
  
    void register_concurrent_phase_start(const char* title);
    void register_concurrent_phase_end();
+   // Ends both concurrent phase and timer.
+   void register_concurrent_gc_end();
  
    void update_accum_task_vtime(int i, double vtime) {
      _accum_task_vtime[i] += vtime;
    }