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

rev 10493 : [Backport] Shenandoah string deduplication
rev 10504 : [backport] Full GC always comes with liveness data
rev 10531 : [backport] Improve scheduling and interleaving of SATB processing in mark loop
rev 10536 : [backport] Process remaining SATB buffers in final mark/traverse loop instead of separate phase
rev 10561 : [backport] Add task termination and enhanced task queue state tracking + weakrefs
rev 10582 : [backport] Avoid indirection to next-mark-context

@@ -27,11 +27,11 @@
 #include "utilities/taskqueue.hpp"
 #include "utilities/workgroup.hpp"
 #include "gc_implementation/shenandoah/shenandoahTaskqueue.hpp"
 #include "gc_implementation/shenandoah/shenandoahPhaseTimings.hpp"
 
-class ShenandoahConcurrentMark;
+class ShenandoahStrDedupQueue;
 
 class ShenandoahConcurrentMark: public CHeapObj<mtGC> {
 
 private:
   ShenandoahHeap* _heap;

@@ -50,11 +50,11 @@
   // into cache pressure (which is already high during marking), and
   // too many atomic updates. size_t/jint is too large, jbyte is too small.
   jushort** _liveness_local;
 
 private:
-  template <class T, bool COUNT_LIVENESS>
+  template <class T>
   inline void do_task(ShenandoahObjToScanQueue* q, T* cl, jushort* live_data, ShenandoahMarkTask* task);
 
   template <class T>
   inline void do_chunked_array_start(ShenandoahObjToScanQueue* q, T* cl, oop array);
 

@@ -63,52 +63,27 @@
 
   inline void count_liveness(jushort* live_data, oop obj);
   inline void count_liveness_humongous(oop obj);
 
   // Actual mark loop with closures set up
-  template <class T, bool CANCELLABLE, bool DRAIN_SATB, bool COUNT_LIVENESS>
+  template <class T, bool CANCELLABLE>
   void mark_loop_work(T* cl, jushort* live_data, uint worker_id, ParallelTaskTerminator *t);
 
-  template <bool CANCELLABLE, bool DRAIN_SATB, bool COUNT_LIVENESS>
-  void mark_loop_prework(uint w, ParallelTaskTerminator *t, ReferenceProcessor *rp,
-                         bool class_unload, bool update_refs);
-
-  // ------------------------ Currying dynamic arguments to template args ----------------------------
-
-  template <bool CANCELLABLE, bool DRAIN_SATB>
-  void mark_loop_2(uint w, ParallelTaskTerminator* t, ReferenceProcessor* rp,
-                   bool count_liveness,
-                   bool class_unload, bool update_refs) {
-    if (count_liveness) {
-      mark_loop_prework<CANCELLABLE, DRAIN_SATB, true>(w, t, rp, class_unload, update_refs);
-    } else {
-      mark_loop_prework<CANCELLABLE, DRAIN_SATB, false>(w, t, rp, class_unload, update_refs);
-    }
-  };
-
   template <bool CANCELLABLE>
-  void mark_loop_1(uint w, ParallelTaskTerminator* t, ReferenceProcessor* rp,
-                   bool drain_satb, bool count_liveness,
-                   bool class_unload, bool update_refs) {
-    if (drain_satb) {
-      mark_loop_2<CANCELLABLE, true>(w, t, rp, count_liveness, class_unload, update_refs);
-    } else {
-      mark_loop_2<CANCELLABLE, false>(w, t, rp, count_liveness, class_unload, update_refs);
-    }
-  };
+  void mark_loop_prework(uint worker_id, ParallelTaskTerminator *terminator, ReferenceProcessor *rp,
+                         bool class_unload, bool update_refs, bool strdedup);
 
-  // ------------------------ END: Currying dynamic arguments to template args ----------------------------
 public:
   // Mark loop entry.
   // Translates dynamic arguments to template parameters with progressive currying.
   void mark_loop(uint worker_id, ParallelTaskTerminator* terminator, ReferenceProcessor *rp,
-                 bool cancellable, bool drain_satb, bool count_liveness,
-                 bool class_unload, bool update_refs) {
+                 bool cancellable,
+                 bool class_unload, bool update_refs, bool strdedup) {
     if (cancellable) {
-      mark_loop_1<true>(worker_id, terminator, rp, drain_satb, count_liveness, class_unload, update_refs);
+      mark_loop_prework<true>(worker_id, terminator, rp, class_unload, update_refs, strdedup);
     } else {
-      mark_loop_1<false>(worker_id, terminator, rp, drain_satb, count_liveness, class_unload, update_refs);
+      mark_loop_prework<false>(worker_id, terminator, rp, class_unload, update_refs, strdedup);
     }
   }
 
   // We need to do this later when the heap is already created.
   void initialize(uint workers);

@@ -118,11 +93,14 @@
 
   bool claim_codecache();
   void clear_claim_codecache();
 
   template<class T, UpdateRefsMode UPDATE_REFS>
-  static inline void mark_through_ref(T* p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q);
+  static inline void mark_through_ref(T* p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q, ShenandoahMarkingContext* const mark_context);
+
+  template<class T, UpdateRefsMode UPDATE_REFS, bool STRING_DEDUP>
+  static inline void mark_through_ref(T* p, ShenandoahHeap* heap, ShenandoahObjToScanQueue* q, ShenandoahMarkingContext* const mark_context, ShenandoahStrDedupQueue* dq = NULL);
 
   void mark_from_roots();
 
   // Prepares unmarked root objects by marking them and putting
   // them into the marking task queue.

@@ -137,12 +115,10 @@
   inline bool try_queue(ShenandoahObjToScanQueue* q, ShenandoahMarkTask &task);
 
   ShenandoahObjToScanQueue* get_queue(uint worker_id);
   void clear_queue(ShenandoahObjToScanQueue *q);
 
-  inline bool try_draining_satb_buffer(ShenandoahObjToScanQueue *q, ShenandoahMarkTask &task);
-  void drain_satb_buffers(uint worker_id, bool remark = false);
   ShenandoahObjToScanQueueSet* task_queues() { return _task_queues;}
 
   jushort* get_liveness(uint worker_id);
 
   void cancel();

@@ -152,15 +128,8 @@
   void concurrent_scan_code_roots(uint worker_id, ReferenceProcessor* rp, bool update_ref);
 private:
 
   void weak_refs_work(bool full_gc);
   void weak_refs_work_doit(bool full_gc);
-
-#if TASKQUEUE_STATS
-  static void print_taskqueue_stats_hdr(outputStream* const st);
-  void print_taskqueue_stats() const;
-  void reset_taskqueue_stats();
-#endif // TASKQUEUE_STATS
-
 };
 
 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHCONCURRENTMARK_HPP