8354555: Add generic JFR events for TaskTerminator

src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

@@ -488,7 +488,7 @@ G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h,
   // _tasks set inside the constructor
 
   _task_queues(new G1CMTaskQueueSet(_max_num_tasks)),
-  _terminator(_max_num_tasks, _task_queues),
+  _terminator(_max_num_tasks, _task_queues, TERMINATION_EVENT_NAME("Concurrent Marking")),
 
   _first_overflow_barrier_sync(),
   _second_overflow_barrier_sync(),
@@ -1811,6 +1811,7 @@ class G1RemarkThreadsClosure : public ThreadClosure {
 
 class G1CMRemarkTask : public WorkerTask {
   G1ConcurrentMark* _cm;
+  TaskTerminatorReuseMark _ttmr;
 public:
   void work(uint worker_id) {
     G1CMTask* task = _cm->task(worker_id);
@@ -1833,9 +1834,8 @@ class G1CMRemarkTask : public WorkerTask {
   }
 
   G1CMRemarkTask(G1ConcurrentMark* cm, uint active_workers) :
-    WorkerTask("Par Remark"), _cm(cm) {
-    _cm->terminator()->reset_for_reuse(active_workers);
-  }
+    WorkerTask("Par Remark"), _cm(cm),
+    _ttmr(cm->terminator(), active_workers, TERMINATION_EVENT_NAME("Par Remark")) {}
 };
 
 void G1ConcurrentMark::finalize_marking() {

src/hotspot/share/gc/g1/g1FullGCMarkTask.cpp

@@ -34,7 +34,7 @@
 G1FullGCMarkTask::G1FullGCMarkTask(G1FullCollector* collector) :
     G1FullGCTask("G1 Parallel Marking Task", collector),
     _root_processor(G1CollectedHeap::heap(), collector->workers()),
-    _terminator(collector->workers(), collector->array_queue_set()) {
+    _terminator(collector->workers(), collector->array_queue_set(), TERMINATION_EVENT_NAME("Parallel Marking")) {
 }
 
 void G1FullGCMarkTask::work(uint worker_id) {

src/hotspot/share/gc/g1/g1YoungCollector.cpp

@@ -553,12 +553,10 @@ class G1ParEvacuateFollowersClosure : public VoidClosure {
   TaskTerminator*         terminator()     { return _terminator; }
 
   inline bool offer_termination() {
-    EventGCPhaseParallel event;
     G1ParScanThreadState* const pss = par_scan_state();
     start_term_time();
     const bool res = (terminator() == nullptr) ? true : terminator()->offer_termination();
     end_term_time();
-    event.commit(GCId::current(), pss->worker_id(), G1GCPhaseTimes::phase_name(G1GCPhaseTimes::Termination));
     return res;
   }
 
@@ -667,7 +665,7 @@ class G1EvacuateRegionsBaseTask : public WorkerTask {
     _g1h(G1CollectedHeap::heap()),
     _per_thread_states(per_thread_states),
     _task_queues(task_queues),
-    _terminator(num_workers, _task_queues),
+    _terminator(num_workers, _task_queues, G1GCPhaseTimes::phase_name(G1GCPhaseTimes::Termination)),
     _pinned_regions_recorded(false)
   { }
 
@@ -940,7 +938,7 @@ class G1STWRefProcProxyTask : public RefProcProxyTask {
     : RefProcProxyTask("G1STWRefProcProxyTask", max_workers),
       _g1h(g1h),
       _pss(pss),
-      _terminator(max_workers, &task_queues),
+      _terminator(max_workers, &task_queues, G1GCPhaseTimes::phase_name(G1GCPhaseTimes::Termination)),
       _task_queues(task_queues) {}
 
   void work(uint worker_id) override {

src/hotspot/share/gc/parallel/psParallelCompact.cpp

@@ -1215,7 +1215,7 @@ class MarkFromRootsTask : public WorkerTask {
   MarkFromRootsTask(uint active_workers) :
       WorkerTask("MarkFromRootsTask"),
       _strong_roots_scope(active_workers),
-      _terminator(active_workers, ParCompactionManager::marking_stacks()),
+      _terminator(active_workers, ParCompactionManager::marking_stacks(), TERMINATION_EVENT_NAME("Mark")),
       _active_workers(active_workers) {}
 
   virtual void work(uint worker_id) {
@@ -1253,7 +1253,7 @@ class ParallelCompactRefProcProxyTask : public RefProcProxyTask {
 public:
   ParallelCompactRefProcProxyTask(uint max_workers)
     : RefProcProxyTask("ParallelCompactRefProcProxyTask", max_workers),
-      _terminator(_max_workers, ParCompactionManager::marking_stacks()) {}
+      _terminator(_max_workers, ParCompactionManager::marking_stacks(), TERMINATION_EVENT_NAME("Reference Processing")) {}
 
   void work(uint worker_id) override {
     assert(worker_id < _max_workers, "sanity");
@@ -1789,7 +1789,7 @@ class FillDensePrefixAndCompactionTask: public WorkerTask {
   FillDensePrefixAndCompactionTask(uint active_workers) :
       WorkerTask("FillDensePrefixAndCompactionTask"),
       _num_workers(active_workers),
-      _terminator(active_workers, ParCompactionManager::region_task_queues()) {
+      _terminator(active_workers, ParCompactionManager::region_task_queues(), TERMINATION_EVENT_NAME("Par Compact")) {
   }
 
   virtual void work(uint worker_id) {

src/hotspot/share/gc/parallel/psScavenge.cpp

@@ -203,7 +203,7 @@ class ParallelScavengeRefProcProxyTask : public RefProcProxyTask {
 public:
   ParallelScavengeRefProcProxyTask(uint max_workers)
     : RefProcProxyTask("ParallelScavengeRefProcProxyTask", max_workers),
-      _terminator(max_workers, ParCompactionManager::marking_stacks()) {}
+      _terminator(max_workers, ParCompactionManager::marking_stacks(), TERMINATION_EVENT_NAME("Reference Processing")) {}
 
   void work(uint worker_id) override {
     assert(worker_id < _max_workers, "sanity");
@@ -258,7 +258,7 @@ class ScavengeRootsTask : public WorkerTask {
     _gen_top(old_gen->object_space()->top()),
     _active_workers(active_workers),
     _is_old_gen_empty(old_gen->object_space()->is_empty()),
-    _terminator(active_workers, PSPromotionManager::vm_thread_promotion_manager()->stack_array_depth()) {
+    _terminator(active_workers, PSPromotionManager::vm_thread_promotion_manager()->stack_array_depth(), TERMINATION_EVENT_NAME("Scavenge")) {
     if (!_is_old_gen_empty) {
       PSCardTable* card_table = ParallelScavengeHeap::heap()->card_table();
       card_table->pre_scavenge(active_workers);

src/hotspot/share/gc/shared/taskTerminator.cpp

@@ -26,10 +26,12 @@
 #include "gc/shared/gc_globals.hpp"
 #include "gc/shared/taskqueue.hpp"
 #include "gc/shared/taskTerminator.hpp"
+#include "jfr/jfrEvents.hpp"
 #include "logging/log.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/javaThread.hpp"
 #include "runtime/mutexLocker.hpp"
+#include "workerThread.hpp"
 
 TaskTerminator::DelayContext::DelayContext() {
   _yield_count = 0;
@@ -67,9 +69,10 @@ void TaskTerminator::DelayContext::do_step() {
   }
 }
 
-TaskTerminator::TaskTerminator(uint n_threads, TaskQueueSetSuper* queue_set) :
+TaskTerminator::TaskTerminator(uint n_threads, TaskQueueSetSuper* queue_set, const char* termination_event_name) :
   _n_threads(n_threads),
   _queue_set(queue_set),
+  _termination_event_name(termination_event_name),
   _offered_termination(0),
   _blocker(Mutex::nosafepoint, "TaskTerminator_lock"),
   _spin_master(nullptr) { }
@@ -102,6 +105,14 @@ void TaskTerminator::reset_for_reuse(uint n_threads) {
   _n_threads = n_threads;
 }
 
+const char* TaskTerminator::termination_event_name() {
+  return _termination_event_name;
+}
+
+void TaskTerminator::set_termination_event_name(const char* termination_event_name) {
+  _termination_event_name = termination_event_name;
+}
+
 bool TaskTerminator::exit_termination(size_t tasks, TerminatorTerminator* terminator) {
   return tasks > 0 || (terminator != nullptr && terminator->should_exit_termination());
 }
@@ -128,10 +139,27 @@ void TaskTerminator::prepare_for_return(Thread* this_thread, size_t tasks) {
   }
 }
 
+class TaskTerminationTracker :public StackObj {
+  TaskTerminator* const _terminator;
+  uint const _worker_id;
+  EventGCPhaseParallel _event;
+public:
+  TaskTerminationTracker(TaskTerminator* task_terminator, uint worker_id):
+  _terminator(task_terminator),
+  _worker_id(worker_id) { }
+
+  ~TaskTerminationTracker() {
+    if (_event.should_commit()) {
+      _event.commit(GCId::current(), _terminator->threads() > 1 ? _worker_id : 0, _terminator->termination_event_name());
+    }
+  }
+};
+
 bool TaskTerminator::offer_termination(TerminatorTerminator* terminator) {
   assert(_n_threads > 0, "Initialization is incorrect");
   assert(_offered_termination < _n_threads, "Invariant");
 
+  TaskTerminationTracker termination_tracker(this, WorkerThread::worker_id());
   // Single worker, done
   if (_n_threads == 1) {
     _offered_termination = 1;

src/hotspot/share/gc/shared/taskTerminator.hpp

@@ -33,6 +33,11 @@ class TaskQueueSetSuper;
 class TerminatorTerminator;
 class Thread;
 
+#define TERMINATION_EVENT_NAME_PREFIX "Termination"
+#define TERMINATION_EVENT_NAME(name) "" TERMINATION_EVENT_NAME_PREFIX ": " name ""
+
+class TaskTerminationTracker;
+
 /*
  * Provides a task termination protocol.
  *
@@ -71,6 +76,7 @@ class TaskTerminator : public CHeapObj<mtGC> {
 
   uint _n_threads;
   TaskQueueSetSuper* _queue_set;
+  const char* _termination_event_name;
 
   DEFINE_PAD_MINUS_SIZE(0, DEFAULT_PADDING_SIZE, 0);
   volatile uint _offered_termination;
@@ -94,7 +100,7 @@ class TaskTerminator : public CHeapObj<mtGC> {
   NONCOPYABLE(TaskTerminator);
 
 public:
-  TaskTerminator(uint n_threads, TaskQueueSetSuper* queue_set);
+  TaskTerminator(uint n_threads, TaskQueueSetSuper* queue_set, const char* termination_event_name = TERMINATION_EVENT_NAME_PREFIX);
   ~TaskTerminator();
 
   // The current thread has no work, and is ready to terminate if everyone
@@ -118,6 +124,32 @@ class TaskTerminator : public CHeapObj<mtGC> {
   // Same as above but the number of parallel threads is set to the
   // given number.
   void reset_for_reuse(uint n_threads);
+
+  // Get termination event name
+  const char* termination_event_name();
+  // Set termination event name
+  void set_termination_event_name(const char* termination_event_name);
+
+  uint threads() {
+    return _n_threads;
+  }
+};
+
+class TaskTerminatorReuseMark : public StackObj {
+private:
+  TaskTerminator* const _terminator;
+  const char* _original_event_name;
+
+public:
+  TaskTerminatorReuseMark(TaskTerminator* terminator, uint active_workers, const char* event_name) :
+    _terminator(terminator) {
+    _terminator->reset_for_reuse(active_workers);
+    _original_event_name = _terminator->termination_event_name();
+    _terminator->set_termination_event_name(event_name);
+  };
+  ~TaskTerminatorReuseMark() {
+    _terminator->set_termination_event_name(_original_event_name);
+  }
 };
 
 #endif // SHARE_GC_SHARED_TASKTERMINATOR_HPP

src/hotspot/share/gc/shared/workerThread.hpp

@@ -26,6 +26,7 @@
 #define SHARE_GC_SHARED_WORKERTHREAD_HPP
 
 #include "gc/shared/gcId.hpp"
+#include "gc/shared/taskTerminator.hpp"
 #include "memory/allocation.hpp"
 #include "runtime/nonJavaThread.hpp"
 #include "runtime/semaphore.hpp"
@@ -35,6 +36,7 @@
 class ThreadClosure;
 class WorkerTaskDispatcher;
 class WorkerThread;
+class TaskTerminator;
 
 // An task to be worked on by worker threads
 class WorkerTask : public CHeapObj<mtInternal> {

src/hotspot/share/gc/shenandoah/shenandoahConcurrentMark.cpp

@@ -221,28 +221,25 @@ void ShenandoahConcurrentMark::concurrent_mark() {
   ShenandoahGenerationType gen_type = _generation->type();
   ShenandoahSATBMarkQueueSet& qset = ShenandoahBarrierSet::satb_mark_queue_set();
   ShenandoahFlushSATBHandshakeClosure flush_satb(qset);
+  TaskTerminator terminator(nworkers, task_queues(), TERMINATION_EVENT_NAME("Concurrent Mark"));
   for (uint flushes = 0; flushes < ShenandoahMaxSATBBufferFlushes; flushes++) {
     switch (gen_type) {
       case YOUNG: {
-        TaskTerminator terminator(nworkers, task_queues());
         ShenandoahConcurrentMarkingTask<YOUNG> task(this, &terminator);
         workers->run_task(&task);
         break;
       }
       case OLD: {
-        TaskTerminator terminator(nworkers, task_queues());
         ShenandoahConcurrentMarkingTask<OLD> task(this, &terminator);
         workers->run_task(&task);
         break;
       }
       case GLOBAL: {
-        TaskTerminator terminator(nworkers, task_queues());
         ShenandoahConcurrentMarkingTask<GLOBAL> task(this, &terminator);
         workers->run_task(&task);
         break;
       }
       case NON_GEN: {
-        TaskTerminator terminator(nworkers, task_queues());
         ShenandoahConcurrentMarkingTask<NON_GEN> task(this, &terminator);
         workers->run_task(&task);
         break;
@@ -267,6 +264,7 @@ void ShenandoahConcurrentMark::concurrent_mark() {
       // No more retries needed, break out.
       break;
     }
+    terminator.reset_for_reuse();
   }
   assert(task_queues()->is_empty() || heap->cancelled_gc(), "Should be empty when not cancelled");
 }
@@ -298,7 +296,7 @@ void ShenandoahConcurrentMark::finish_mark_work() {
   task_queues()->reserve(nworkers);
 
   StrongRootsScope scope(nworkers);
-  TaskTerminator terminator(nworkers, task_queues());
+  TaskTerminator terminator(nworkers, task_queues(), TERMINATION_EVENT_NAME("Final Mark"));
 
   switch (_generation->type()) {
     case YOUNG:{

test/jdk/jdk/jfr/event/gc/collection/TestG1ParallelPhases.java

@@ -119,7 +119,10 @@ public static void main(String[] args) throws IOException {
             "RebuildFreeList",
             "SampleCandidates",
             "ResetMarkingState",
-            "NoteStartOfMark"
+            "NoteStartOfMark",
+            "Termination: Parallel Marking",
+            "Termination: Concurrent Marking",
+            "Termination: Par Remark"
         );
 
         // Some GC phases may or may not occur depending on environment. Filter them out