src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.hpp

*** 1,7 ***
--- 1,8 ---
  /*
   * Copyright (c) 2021, Red Hat, Inc. All rights reserved.
+  * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

*** 28,10 ***
--- 29,12 ---
  #include "gc/shared/gcCause.hpp"
  #include "gc/shenandoah/shenandoahConcurrentMark.hpp"
  #include "gc/shenandoah/shenandoahGC.hpp"
  #include "gc/shenandoah/shenandoahHeap.hpp"
  
+ class ShenandoahGeneration;
+ 
  class VM_ShenandoahInitMark;
  class VM_ShenandoahFinalMarkStartEvac;
  class VM_ShenandoahInitUpdateRefs;
  class VM_ShenandoahFinalUpdateRefs;
  

*** 40,26 ***
    friend class VM_ShenandoahFinalMarkStartEvac;
    friend class VM_ShenandoahInitUpdateRefs;
    friend class VM_ShenandoahFinalUpdateRefs;
    friend class VM_ShenandoahFinalRoots;
  
  private:
!   ShenandoahConcurrentMark  _mark;
!   ShenandoahDegenPoint      _degen_point;
!   bool                      _abbreviated;
  
  public:
!   ShenandoahConcurrentGC();
!   bool collect(GCCause::Cause cause);
    ShenandoahDegenPoint degen_point() const;
  
    // Return true if this cycle found enough immediate garbage to skip evacuation
    bool abbreviated() const { return _abbreviated; }
  
!   // Cancel ongoing concurrent GC
-   static void cancel();
- private:
    // Entry points to STW GC operations, these cause a related safepoint, that then
    // call the entry method below
    void vmop_entry_init_mark();
    void vmop_entry_final_mark();
    void vmop_entry_init_updaterefs();
--- 43,28 ---
    friend class VM_ShenandoahFinalMarkStartEvac;
    friend class VM_ShenandoahInitUpdateRefs;
    friend class VM_ShenandoahFinalUpdateRefs;
    friend class VM_ShenandoahFinalRoots;
  
+ protected:
+   ShenandoahConcurrentMark    _mark;
+   ShenandoahGeneration* const _generation;
+ 
  private:
!   ShenandoahDegenPoint        _degen_point;
!   bool                        _abbreviated;
!   const bool                  _do_old_gc_bootstrap;
  
  public:
!   ShenandoahConcurrentGC(ShenandoahGeneration* generation, bool do_old_gc_bootstrap);
!   bool collect(GCCause::Cause cause) override;
    ShenandoahDegenPoint degen_point() const;
  
    // Return true if this cycle found enough immediate garbage to skip evacuation
    bool abbreviated() const { return _abbreviated; }
  
! protected:
    // Entry points to STW GC operations, these cause a related safepoint, that then
    // call the entry method below
    void vmop_entry_init_mark();
    void vmop_entry_final_mark();
    void vmop_entry_init_updaterefs();

*** 76,10 ***
--- 81,11 ---
  
    // Entry methods to normally concurrent GC operations. These set up logging, monitoring
    // for concurrent operation.
    void entry_reset();
    void entry_mark_roots();
+   void entry_scan_remembered_set();
    void entry_mark();
    void entry_thread_roots();
    void entry_weak_refs();
    void entry_weak_roots();
    void entry_class_unloading();

*** 88,16 ***
    void entry_evacuate();
    void entry_update_thread_roots();
    void entry_updaterefs();
    void entry_cleanup_complete();
  
    // Actual work for the phases
    void op_reset();
    void op_init_mark();
    void op_mark_roots();
    void op_mark();
!   void op_final_mark();
    void op_thread_roots();
    void op_weak_refs();
    void op_weak_roots();
    void op_class_unloading();
    void op_strong_roots();
--- 94,19 ---
    void entry_evacuate();
    void entry_update_thread_roots();
    void entry_updaterefs();
    void entry_cleanup_complete();
  
+   // Called when the collection set is empty, but the generational mode has regions to promote in place
+   void entry_promote_in_place();
+ 
    // Actual work for the phases
    void op_reset();
    void op_init_mark();
    void op_mark_roots();
    void op_mark();
!   virtual void op_final_mark();
    void op_thread_roots();
    void op_weak_refs();
    void op_weak_roots();
    void op_class_unloading();
    void op_strong_roots();

*** 108,18 ***
    void op_update_thread_roots();
    void op_final_updaterefs();
    void op_final_roots();
    void op_cleanup_complete();
  
    void start_mark();
  
    // Messages for GC trace events, they have to be immortal for
    // passing around the logging/tracing systems
    const char* init_mark_event_message() const;
    const char* final_mark_event_message() const;
    const char* conc_mark_event_message() const;
! 
!   // Check GC cancellation and abort concurrent GC
!   bool check_cancellation_and_abort(ShenandoahDegenPoint point);
  };
  
  #endif // SHARE_GC_SHENANDOAH_SHENANDOAHCONCURRENTGC_HPP
--- 117,26 ---
    void op_update_thread_roots();
    void op_final_updaterefs();
    void op_final_roots();
    void op_cleanup_complete();
  
+   // Check GC cancellation and abort concurrent GC
+   bool check_cancellation_and_abort(ShenandoahDegenPoint point);
+ 
+ private:
    void start_mark();
  
+   static bool has_in_place_promotions(ShenandoahHeap* heap) ;
+ 
    // Messages for GC trace events, they have to be immortal for
    // passing around the logging/tracing systems
    const char* init_mark_event_message() const;
    const char* final_mark_event_message() const;
+   const char* final_roots_event_message() const;
    const char* conc_mark_event_message() const;
!   const char* conc_reset_event_message() const;
!   const char* conc_weak_refs_event_message() const;
!   const char* conc_weak_roots_event_message() const;
+   const char* conc_cleanup_event_message() const;
  };
  
  #endif // SHARE_GC_SHENANDOAH_SHENANDOAHCONCURRENTGC_HPP