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

@@ -1,7 +1,8 @@
  /*
   * Copyright (c) 2013, 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.

@@ -55,69 +56,97 @@
  
  class ShenandoahControlThread: public ConcurrentGCThread {
    friend class VMStructs;
  
  private:
-   typedef enum {
-     none,
-     concurrent_normal,
-     stw_degenerated,
-     stw_full
-   } GCMode;
- 
    // While we could have a single lock for these, it may risk unblocking
    // GC waiters when alloc failure GC cycle finishes. We want instead
-   // to make complete explicit cycle for for demanding customers.
+   // to make complete explicit cycle for demanding customers.
    Monitor _alloc_failure_waiters_lock;
    Monitor _gc_waiters_lock;
+   Monitor _control_lock;
+   Monitor _regulator_lock;
    ShenandoahPeriodicTask _periodic_task;
    ShenandoahPeriodicPacerNotify _periodic_pacer_notify_task;
  
  public:
+   typedef enum {
+     none,
+     concurrent_normal,
+     stw_degenerated,
+     stw_full,
+     bootstrapping_old,
+     servicing_old
+   } GCMode;
+ 
    void run_service();
    void stop_service();
  
+   size_t get_gc_id();
+ 
  private:
+   ShenandoahSharedFlag _allow_old_preemption;
+   ShenandoahSharedFlag _preemption_requested;
    ShenandoahSharedFlag _gc_requested;
    ShenandoahSharedFlag _alloc_failure_gc;
+   ShenandoahSharedFlag _humongous_alloc_failure_gc;
    ShenandoahSharedFlag _graceful_shutdown;
-   ShenandoahSharedFlag _heap_changed;
    ShenandoahSharedFlag _do_counters_update;
    ShenandoahSharedFlag _force_counters_update;
    GCCause::Cause       _requested_gc_cause;
+   ShenandoahGenerationType _requested_generation;
    ShenandoahGC::ShenandoahDegenPoint _degen_point;
+   ShenandoahGeneration* _degen_generation;
  
    shenandoah_padding(0);
    volatile size_t _allocs_seen;
    shenandoah_padding(1);
    volatile size_t _gc_id;
    shenandoah_padding(2);
+   volatile GCMode _mode;
+   shenandoah_padding(3);
  
+   // Returns true if the cycle has been cancelled or degenerated.
    bool check_cancellation_or_degen(ShenandoahGC::ShenandoahDegenPoint point);
-   void service_concurrent_normal_cycle(GCCause::Cause cause);
+ 
+   // Returns true if the old generation marking completed (i.e., final mark executed for old generation).
+   bool resume_concurrent_old_cycle(ShenandoahGeneration* generation, GCCause::Cause cause);
+   void service_concurrent_cycle(ShenandoahGeneration* generation, GCCause::Cause cause, bool reset_old_bitmap_specially);
    void service_stw_full_cycle(GCCause::Cause cause);
-   void service_stw_degenerated_cycle(GCCause::Cause cause, ShenandoahGC::ShenandoahDegenPoint point);
+ 
+   // Return true if degenerated cycle finishes normally.  Return false if the degenerated cycle transformed itself
+   // into a full GC.
+   bool service_stw_degenerated_cycle(GCCause::Cause cause, ShenandoahGC::ShenandoahDegenPoint point);
    void service_uncommit(double shrink_before, size_t shrink_until);
  
+   // Return true if setting the flag which indicates allocation failure succeeds.
    bool try_set_alloc_failure_gc();
+   // Notify threads waiting for GC to complete.
    void notify_alloc_failure_waiters();
+   // True if allocation failure flag has been set.
    bool is_alloc_failure_gc();
  
    void reset_gc_id();
    void update_gc_id();
-   size_t get_gc_id();
  
    void notify_gc_waiters();
  
    // Handle GC request.
    // Blocks until GC is over.
    void handle_requested_gc(GCCause::Cause cause);
  
    bool is_explicit_gc(GCCause::Cause cause) const;
+   bool is_implicit_gc(GCCause::Cause cause) const;
  
+   // Returns true if the old generation marking was interrupted to allow a young cycle.
+   bool preempt_old_marking(ShenandoahGenerationType generation);
+ 
+   // Returns true if the soft maximum heap has been changed using management APIs.
    bool check_soft_max_changed() const;
  
+   void process_phase_timings(const ShenandoahHeap* heap);
+ 
  public:
    // Constructor
    ShenandoahControlThread();
    ~ShenandoahControlThread();
  

@@ -128,10 +157,12 @@
    // Handle allocation failure from evacuation path.
    // Optionally blocks while collector is handling the failure.
    void handle_alloc_failure_evac(size_t words);
  
    void request_gc(GCCause::Cause cause);
+   // Return true if the request to start a concurrent GC for the given generation succeeded.
+   bool request_concurrent_gc(ShenandoahGenerationType generation);
  
    void handle_counters_update();
    void handle_force_counters_update();
    void set_forced_counters_update(bool value);
  

@@ -140,8 +171,32 @@
    void pacing_notify_alloc(size_t words);
  
    void start();
    void prepare_for_graceful_shutdown();
    bool in_graceful_shutdown();
+ 
+   void service_concurrent_normal_cycle(ShenandoahHeap* heap,
+                                        const ShenandoahGenerationType generation,
+                                        GCCause::Cause cause);
+ 
+   void service_concurrent_old_cycle(ShenandoahHeap* heap,
+                                     GCCause::Cause &cause);
+ 
+   void set_gc_mode(GCMode new_mode);
+   GCMode gc_mode() {
+     return _mode;
+   }
+ 
+   static ShenandoahGenerationType select_global_generation();
+ 
+  private:
+   static const char* gc_mode_name(GCMode mode);
+   void notify_control_thread();
+ 
+   void service_concurrent_cycle(ShenandoahHeap* heap,
+                                 ShenandoahGeneration* generation,
+                                 GCCause::Cause &cause,
+                                 bool do_old_gc_bootstrap);
+ 
  };
  
  #endif // SHARE_GC_SHENANDOAH_SHENANDOAHCONTROLTHREAD_HPP