diff a/src/hotspot/share/runtime/perfData.hpp b/src/hotspot/share/runtime/perfData.hpp
--- a/src/hotspot/share/runtime/perfData.hpp
+++ b/src/hotspot/share/runtime/perfData.hpp
@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2001, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2024, Oracle and/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.
@@ -415,10 +415,11 @@
 
   public:
     inline void inc() { (*(jlong*)_valuep)++; }
     inline void inc(jlong val) { (*(jlong*)_valuep) += val; }
     inline void dec(jlong val) { inc(-val); }
+    inline void reset() { (*(jlong*)_valuep) = 0; }
 };
 
 /*
  * The PerfLongCounter class, and its alias PerfCounter, implement
  * a PerfData subtype that holds a jlong data value that can (should)
@@ -621,10 +622,43 @@
     // some form of iterator to provide a cleaner abstraction for
     // iteration over the container.
     inline PerfData* at(int index);
 };
 
+class PerfTickCounters : public CHeapObj<mtInternal> {
+private:
+  const char* _name;
+  PerfCounter* const _elapsed_counter;
+  PerfCounter* const _thread_counter;
+public:
+  PerfTickCounters(const char* name, PerfCounter* elapsed_counter, PerfCounter* thread_counter) :
+                   _name(name), _elapsed_counter(elapsed_counter), _thread_counter(thread_counter) {
+  }
+
+  const char* name() { return _name; }
+
+  PerfCounter* elapsed_counter() const {
+    return _elapsed_counter;
+  }
+  long elapsed_counter_value() const {
+    return _elapsed_counter->get_value();
+  }
+  inline long elapsed_counter_value_ms() const;
+
+  PerfCounter* thread_counter() const {
+    return _thread_counter;
+  }
+  long thread_counter_value() const {
+    return _thread_counter->get_value();
+  }
+  inline long thread_counter_value_ms() const;
+
+  void reset() {
+    _elapsed_counter->reset();
+    _thread_counter->reset();
+  }
+};
 
 /*
  * The PerfDataManager class is responsible for creating PerfData
  * subtypes via a set a factory methods and for managing lists
  * of the various PerfData types.
@@ -785,10 +819,22 @@
                                        PerfData::Units u,
                                        PerfSampleHelper* sh, TRAPS) {
       return create_long_counter(ns, name, u, sh, THREAD);
     }
 
+    static PerfTickCounters* create_tick_counters(CounterNS ns,
+                                                  const char* counter_name,
+                                                  const char* elapsed_counter_name,
+                                                  const char* thread_counter_name,
+                                                  PerfData::Units u, TRAPS) {
+      PerfCounter* elapsed_counter = create_long_counter(ns, elapsed_counter_name, u, (jlong)0, THREAD);
+      PerfCounter* thread_counter = create_long_counter(ns, thread_counter_name, u, (jlong)0, THREAD);
+
+      PerfTickCounters* counters = new PerfTickCounters(counter_name, elapsed_counter, thread_counter);
+      return counters;
+    }
+
     static void destroy();
     static bool has_PerfData() { return _has_PerfData; }
 };
 
 // Useful macros to create the performance counters
@@ -802,72 +848,188 @@
 
 #define NEWPERFBYTECOUNTER(counter, counter_ns, counter_name)  \
   {counter = PerfDataManager::create_counter(counter_ns, counter_name, \
                                              PerfData::U_Bytes,CHECK);}
 
+#define NEWPERFTICKCOUNTERS(counter, counter_ns, counter_name)  \
+  {counter = PerfDataManager::create_tick_counters(counter_ns, counter_name, counter_name "_elapsed_time", \
+                                             counter_name "_thread_time", PerfData::U_Ticks,CHECK);}
+
 // Utility Classes
 
-/*
- * this class will administer a PerfCounter used as a time accumulator
+/* PerfTraceElapsedTime and PerfTraceThreadTime will administer a PerfCounter used as a time accumulator
  * for a basic block much like the TraceTime class.
+ * PerfTraceElapsedTime uses elapsedTimer to measure time which reflects the elapsed time,
+ * and PerfTraceThreadTime uses ThreadTimer which reflects thread cpu time.
  *
  * Example:
  *
  *    static PerfCounter* my_time_counter = PerfDataManager::create_counter("my.time.counter", PerfData::U_Ticks, 0LL, CHECK);
  *
  *    {
- *      PerfTraceTime ptt(my_time_counter);
+ *      PerfTraceElapsedTime ptt(my_time_counter);
  *      // perform the operation you want to measure
  *    }
  *
  * Note: use of this class does not need to occur within a guarded
  * block. The UsePerfData guard is used with the implementation
  * of this class.
  */
-class PerfTraceTime : public StackObj {
 
+class PerfTraceTimeBase : public StackObj {
+  friend class PerfPauseTimer;
+  private:
+    BaseTimer* _t;
+  protected:
+    PerfLongCounter* _counter;
+
+  public:
+    inline PerfTraceTimeBase(BaseTimer* t, PerfLongCounter* counter, bool is_on) : _t(t), _counter(counter) {}
+
+    ~PerfTraceTimeBase();
+
+    jlong active_ticks() { return _t->active_ticks(); }
+
+    const char* name() { return _counter->name(); }
+    BaseTimer* timer() { return _t; }
+};
+
+class PerfTraceElapsedTime: public PerfTraceTimeBase {
   protected:
     elapsedTimer _t;
-    PerfLongCounter* _timerp;
 
   public:
-    inline PerfTraceTime(PerfLongCounter* timerp) : _timerp(timerp) {
-      if (!UsePerfData) return;
-      _t.start();
+    inline PerfTraceElapsedTime(PerfCounter* counter, bool is_on = true) : PerfTraceTimeBase(&_t, counter, is_on) {
+      if (!UsePerfData || !is_on) return;
+      if (counter != nullptr) {
+        _t.start();
+      }
     }
+};
+
+class PerfTraceThreadTime: public PerfTraceTimeBase {
+  protected:
+    ThreadTimer _t;
 
-    ~PerfTraceTime();
+  public:
+    inline PerfTraceThreadTime(PerfCounter* counter, bool is_on = true) : PerfTraceTimeBase(&_t, counter, is_on) {
+      if (!UsePerfData || !is_on || !TraceThreadTime) return;
+      if (counter != nullptr) {
+        _t.start();
+      }
+    }
 };
 
-/* The PerfTraceTimedEvent class is responsible for counting the
+// PerfTraceTime is a utility class to provide the ability to measure both elapsed and thread cpu time using a single object.
+class PerfTraceTime : public StackObj {
+  friend class PerfPauseTimer;
+  private:
+    PerfTickCounters* _counters;
+    PerfTraceElapsedTime _elapsed_timer;
+    PerfTraceThreadTime _thread_timer;
+
+  public:
+    inline PerfTraceTime(PerfTickCounters* counters, bool is_on = true):
+                         _counters(counters),
+                         _elapsed_timer(counters != nullptr ? counters->elapsed_counter() : nullptr, is_on),
+                         _thread_timer(counters != nullptr ? counters->thread_counter() : nullptr, is_on) {}
+
+    const char* name() { return _counters->name(); }
+    PerfTraceTimeBase* elapsed_timer() { return &_elapsed_timer; }
+    PerfTraceTimeBase* thread_timer() { return &_thread_timer; }
+
+    jlong elapsed_timer_active_ticks() {
+      return _elapsed_timer.active_ticks();
+    }
+
+    jlong thread_timer_active_ticks() {
+      return _thread_timer.active_ticks();
+    }
+};
+
+class PerfPauseTimerBase : public StackObj {
+  protected:
+    bool _is_active;
+    BaseTimer* _timer;
+
+  public:
+    inline PerfPauseTimerBase(PerfTraceTimeBase* timer, bool is_on) : _is_active(false), _timer(nullptr) {
+      _is_active = (is_on && timer != nullptr);
+      if (UsePerfData && _is_active) {
+        _timer = timer->timer();
+        _timer->stop(); // pause
+      }
+    }
+
+    inline ~PerfPauseTimerBase() {
+      if (UsePerfData && _is_active) {
+        assert(_timer != nullptr, "");
+        _timer->start(); // resume
+      }
+    }
+};
+
+class PerfPauseTimer : public StackObj {
+  private:
+    PerfPauseTimerBase _elapsed_timer_pause;
+    PerfPauseTimerBase _thread_timer_pause;
+
+  public:
+    inline PerfPauseTimer(PerfTraceTime* timer, bool is_on) :
+                          _elapsed_timer_pause(timer != nullptr ? timer->elapsed_timer() : nullptr, is_on),
+                          _thread_timer_pause(timer != nullptr ? timer->thread_timer() : nullptr, is_on) {}
+};
+
+/* The PerfTraceElapsedTimeEvent class is responsible for counting the
  * occurrence of some event and measuring the elapsed time of
  * the event in two separate PerfCounter instances.
  *
  * Example:
  *
  *    static PerfCounter* my_time_counter = PerfDataManager::create_counter("my.time.counter", PerfData::U_Ticks, CHECK);
  *    static PerfCounter* my_event_counter = PerfDataManager::create_counter("my.event.counter", PerfData::U_Events, CHECK);
  *
  *    {
- *      PerfTraceTimedEvent ptte(my_time_counter, my_event_counter);
+ *      PerfTraceElapsedTimeEvent ptte(my_time_counter, my_event_counter);
  *      // perform the operation you want to count and measure
  *    }
  *
  * Note: use of this class does not need to occur within a guarded
  * block. The UsePerfData guard is used with the implementation
  * of this class.
  *
+ * Similarly, PerfTraceThreadTimeEvent can count the occurrence of some event and measure the thread cpu time of the event.
+ * PerfTraceTimedEvent can count the occurrence of some event and measure both the elapsed time and the thread cpu time of the event.
  */
-class PerfTraceTimedEvent : public PerfTraceTime {
-
+class PerfTraceElapsedTimeEvent: public PerfTraceElapsedTime {
   protected:
     PerfLongCounter* _eventp;
 
   public:
-    inline PerfTraceTimedEvent(PerfLongCounter* timerp, PerfLongCounter* eventp): PerfTraceTime(timerp), _eventp(eventp) {
-      if (!UsePerfData) return;
+    inline PerfTraceElapsedTimeEvent(PerfCounter* counter, PerfLongCounter* eventp, bool is_on = true) : PerfTraceElapsedTime(counter, is_on), _eventp(eventp) {
+      if (!UsePerfData || !is_on) return;
       _eventp->inc();
     }
+};
+
+class PerfTraceThreadTimeEvent: public PerfTraceThreadTime {
+  protected:
+    PerfLongCounter* _eventp;
 
+  public:
+    inline PerfTraceThreadTimeEvent(PerfCounter* counter, PerfLongCounter* eventp, bool is_on = true) : PerfTraceThreadTime(counter, is_on), _eventp(eventp) {
+      if (!UsePerfData || !is_on) return;
+      _eventp->inc();
+    }
 };
 
+class PerfTraceTimedEvent : public PerfTraceTime {
+  protected:
+    PerfLongCounter* _eventp;
+
+  public:
+    inline PerfTraceTimedEvent(PerfTickCounters* counters, PerfLongCounter* eventp, bool is_on = true) : PerfTraceTime(counters, is_on), _eventp(eventp) {
+      if (!UsePerfData || !is_on) return;
+      _eventp->inc();
+    }
+};
 #endif // SHARE_RUNTIME_PERFDATA_HPP
