src/hotspot/share/gc/g1/g1ConcurrentMarkThread.hpp

rev 60594 : [mq]: 8240556-abort-conc-mark-new

*** 40,57 ****
  
    G1ConcurrentMark* _cm;
  
    enum ServiceState {
      Idle,
!     Started,
      InProgress
    };
  
    volatile ServiceState _state;
  
!   // Wait for next cycle. Returns true if we should stop the service.
!   bool wait_for_next_cycle();
  
    // Phases for the full concurrent marking cycle in order.
    //
    // We have to ensure that we finish scanning the root regions
    // before the next GC takes place. To ensure this we have to
--- 40,63 ----
  
    G1ConcurrentMark* _cm;
  
    enum ServiceState {
      Idle,
!     StartMark,
!     StartUndo,
      InProgress
    };
  
    volatile ServiceState _state;
  
!   enum Command {
!     Terminate,  // Terminate the thread.
!     MarkCycle,  // Start a (full) marking cycle
!     UndoCycle   // Start an undo cycle, i.e. undo a concurrent mark start pause.
!   };
!   // Wait for next cycle. Returns the type of cycle to start.
!   Command wait_for_next_cycle();
  
    // Phases for the full concurrent marking cycle in order.
    //
    // We have to ensure that we finish scanning the root regions
    // before the next GC takes place. To ensure this we have to
*** 73,85 ****
    bool phase_delay_to_keep_mmu_before_cleanup();
    bool phase_cleanup();
    bool phase_clear_bitmap_for_next_mark();
  
    void concurrent_cycle_start();
!   // Perform a full concurrent cycle.
!   void full_concurrent_cycle_do();
!   void concurrent_cycle_end();
  
    // Delay pauses to meet MMU.
    void delay_to_keep_mmu(bool remark);
    double mmu_delay_end(G1Policy* policy, bool remark);
  
--- 79,93 ----
    bool phase_delay_to_keep_mmu_before_cleanup();
    bool phase_cleanup();
    bool phase_clear_bitmap_for_next_mark();
  
    void concurrent_cycle_start();
!   // Perform a marking concurrent cycle.
!   void mark_concurrent_cycle_do();
!   void undo_concurrent_cycle_do();
! 
!   void concurrent_cycle_end(bool mark_cycle_completed);
  
    // Delay pauses to meet MMU.
    void delay_to_keep_mmu(bool remark);
    double mmu_delay_end(G1Policy* policy, bool remark);
  
*** 95,110 ****
    // Marking virtual time so far this thread and concurrent marking tasks.
    double vtime_mark_accum();
  
    G1ConcurrentMark* cm()   { return _cm; }
  
!   void set_idle()          { assert(_state != Started, "must not be starting a new cycle"); _state = Idle; }
!   bool idle()              { return _state == Idle; }
!   void set_started()       { assert(_state == Idle, "cycle in progress"); _state = Started; }
!   bool started()           { return _state == Started; }
!   void set_in_progress()   { assert(_state == Started, "must be starting a cycle"); _state = InProgress; }
!   bool in_progress()       { return _state == InProgress; }
  
    // Returns true from the moment a marking cycle is
    // initiated (during the concurrent start pause when started() is set)
    // to the moment when the cycle completes (just after the next
    // marking bitmap has been cleared and in_progress() is
--- 103,119 ----
    // Marking virtual time so far this thread and concurrent marking tasks.
    double vtime_mark_accum();
  
    G1ConcurrentMark* cm()   { return _cm; }
  
!   void set_idle();
!   void set_started(bool full_cycle);
!   void set_in_progress();
! 
!   bool idle() const;
!   bool started() const;
!   bool in_progress() const;
  
    // Returns true from the moment a marking cycle is
    // initiated (during the concurrent start pause when started() is set)
    // to the moment when the cycle completes (just after the next
    // marking bitmap has been cleared and in_progress() is