src/share/vm/gc_implementation/shenandoah/shenandoahHeap.hpp

rev 11461 : [backport] 8226757: Shenandoah: Make traversal and passive modes explicit
rev 11463 : Backport Traversal GC

@@ -47,10 +47,11 @@
 class ShenandoahHeuristics;
 class ShenandoahMarkingContext;
 class ShenandoahMode;
 class ShenandoahPhaseTimings;
 class ShenandoahPacer;
+class ShenandoahTraversalGC;
 class ShenandoahVerifier;
 class ShenandoahWorkGang;
 class VMStructs;
 
 class ShenandoahRegionIterator : public StackObj {

@@ -233,19 +234,23 @@
 
     // Heap is under evacuation: needs WB barriers. (Set together with UNSTABLE)
     EVACUATION_BITPOS = 2,
 
     // Heap is under updating: needs SVRB/SVWB barriers.
-    UPDATEREFS_BITPOS = 3
+    UPDATEREFS_BITPOS = 3,
+
+    // Heap is under traversal collection
+    TRAVERSAL_BITPOS  = 4
   };
 
   enum GCState {
     STABLE        = 0,
     HAS_FORWARDED = 1 << HAS_FORWARDED_BITPOS,
     MARKING       = 1 << MARKING_BITPOS,
     EVACUATION    = 1 << EVACUATION_BITPOS,
-    UPDATEREFS    = 1 << UPDATEREFS_BITPOS
+    UPDATEREFS    = 1 << UPDATEREFS_BITPOS,
+    TRAVERSAL     = 1 << TRAVERSAL_BITPOS
   };
 
 private:
   ShenandoahSharedBitmap _gc_state;
   ShenandoahSharedFlag   _degenerated_gc_in_progress;

@@ -263,30 +268,33 @@
   void set_evacuation_in_progress(bool in_progress);
   void set_update_refs_in_progress(bool in_progress);
   void set_degenerated_gc_in_progress(bool in_progress);
   void set_full_gc_in_progress(bool in_progress);
   void set_full_gc_move_in_progress(bool in_progress);
+  void set_concurrent_traversal_in_progress(bool in_progress);
   void set_has_forwarded_objects(bool cond);
 
   inline bool is_stable() const;
   inline bool is_idle() const;
   inline bool is_concurrent_mark_in_progress() const;
   inline bool is_update_refs_in_progress() const;
   inline bool is_evacuation_in_progress() const;
   inline bool is_degenerated_gc_in_progress() const;
   inline bool is_full_gc_in_progress() const;
   inline bool is_full_gc_move_in_progress() const;
+  inline bool is_concurrent_traversal_in_progress() const;
   inline bool has_forwarded_objects() const;
   inline bool is_gc_in_progress_mask(uint mask) const;
 
 // ---------- GC cancellation and degeneration machinery
 //
 // Cancelled GC flag is used to notify concurrent phases that they should terminate.
 //
 public:
   enum ShenandoahDegenPoint {
     _degenerated_unset,
+    _degenerated_traversal,
     _degenerated_outside_cycle,
     _degenerated_mark,
     _degenerated_evac,
     _degenerated_updaterefs,
     _DEGENERATED_LIMIT

@@ -294,10 +302,12 @@
 
   static const char* degen_point_to_string(ShenandoahDegenPoint point) {
     switch (point) {
       case _degenerated_unset:
         return "<UNSET>";
+      case _degenerated_traversal:
+        return "Traversal";
       case _degenerated_outside_cycle:
         return "Outside of Cycle";
       case _degenerated_mark:
         return "Mark";
       case _degenerated_evac:

@@ -331,20 +341,24 @@
   void vmop_entry_init_mark();
   void vmop_entry_final_mark();
   void vmop_entry_final_evac();
   void vmop_entry_init_updaterefs();
   void vmop_entry_final_updaterefs();
+  void vmop_entry_init_traversal();
+  void vmop_entry_final_traversal();
   void vmop_entry_full(GCCause::Cause cause);
   void vmop_degenerated(ShenandoahDegenPoint point);
 
   // Entry methods to normally STW GC operations. These set up logging, monitoring
   // and workers for net VM operation
   void entry_init_mark();
   void entry_final_mark();
   void entry_final_evac();
   void entry_init_updaterefs();
   void entry_final_updaterefs();
+  void entry_init_traversal();
+  void entry_final_traversal();
   void entry_full(GCCause::Cause cause);
   void entry_degenerated(int point);
 
   // Entry methods to normally concurrent GC operations. These set up logging, monitoring
   // for concurrent operation.

@@ -352,19 +366,22 @@
   void entry_mark();
   void entry_preclean();
   void entry_cleanup();
   void entry_evac();
   void entry_updaterefs();
+  void entry_traversal();
   void entry_uncommit(double shrink_before);
 
 private:
   // Actual work for the phases
   void op_init_mark();
   void op_final_mark();
   void op_final_evac();
   void op_init_updaterefs();
   void op_final_updaterefs();
+  void op_init_traversal();
+  void op_final_traversal();
   void op_full(GCCause::Cause cause);
   void op_degenerated(ShenandoahDegenPoint point);
   void op_degenerated_fail();
   void op_degenerated_futile();
 

@@ -373,10 +390,11 @@
   void op_preclean();
   void op_cleanup();
   void op_conc_evac();
   void op_stw_evac();
   void op_updaterefs();
+  void op_traversal();
   void op_uncommit(double shrink_before);
 
   // Messages for GC trace event, they have to be immortal for
   // passing around the logging/tracing systems
   const char* init_mark_event_message() const;

@@ -391,10 +409,11 @@
   ShenandoahCollectorPolicy* _shenandoah_policy;
   ShenandoahMode*            _gc_mode;
   ShenandoahHeuristics*      _heuristics;
   ShenandoahFreeSet*         _free_set;
   ShenandoahConcurrentMark*  _scm;
+  ShenandoahTraversalGC*     _traversal_gc;
   ShenandoahMarkCompact*     _full_gc;
   ShenandoahPacer*           _pacer;
   ShenandoahVerifier*        _verifier;
 
   ShenandoahAllocTracker*    _alloc_tracker;

@@ -406,10 +425,12 @@
 public:
   ShenandoahCollectorPolicy* shenandoah_policy() const { return _shenandoah_policy; }
   ShenandoahHeuristics*      heuristics()        const { return _heuristics;        }
   ShenandoahFreeSet*         free_set()          const { return _free_set;          }
   ShenandoahConcurrentMark*  concurrent_mark()         { return _scm;               }
+  ShenandoahTraversalGC*     traversal_gc()      const { return _traversal_gc;      }
+  bool                       is_traversal_mode() const { return _traversal_gc != NULL; }
   ShenandoahPacer*           pacer()             const { return _pacer;             }
 
   ShenandoahPhaseTimings*    phase_timings()     const { return _phase_timings;     }
   ShenandoahAllocTracker*    alloc_tracker()     const { return _alloc_tracker;     }
 

@@ -635,10 +656,13 @@
 
 // ---------- Helper functions
 //
 public:
   template <class T>
+  inline oop evac_update_with_forwarded(T* p);
+
+  template <class T>
   inline oop maybe_update_with_forwarded(T* p);
 
   template <class T>
   inline oop maybe_update_with_forwarded_not_null(T* p, oop obj);