src/hotspot/share/utilities/ticks.hpp

rev 49619 : JEP 328 : Flight Recorder open source preview

@@ -23,89 +23,105 @@
  */
 
 #ifndef SHARE_VM_UTILITIES_TICKS_HPP
 #define SHARE_VM_UTILITIES_TICKS_HPP
 
+#include "jni.h"
 #include "memory/allocation.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-class Ticks;
-
-class Tickspan {
-  friend class Ticks;
-  friend Tickspan operator-(const Ticks& end, const Ticks& start);
+#include "utilities/macros.hpp"
 
+template <typename InstantType>
+class TimeInterval {
+  template <typename, typename>
+  friend TimeInterval operator-(const InstantType& end, const InstantType& start);
  private:
-  jlong _span_ticks;
-
-  Tickspan(const Ticks& end, const Ticks& start);
-
+  jlong _interval;
+  TimeInterval(const InstantType& end, const InstantType& start) : _interval(end - start) {}
  public:
-  Tickspan() : _span_ticks(0) {}
-
-  Tickspan& operator+=(const Tickspan& rhs) {
-    _span_ticks += rhs._span_ticks;
-    return *this;
-  }
-
-  jlong value() const {
-    return _span_ticks;
-  }
+  TimeInterval(jlong interval = 0) : _interval(interval) {}
+  TimeInterval& operator+=(const TimeInterval& rhs);
+  TimeInterval& operator-=(const TimeInterval& rhs);
+  jlong value() const { return _interval; }
+};
 
+class TimeInstant {
+ protected:
+  jlong _instant;
+ public:
+  TimeInstant(jlong stamp = 0) : _instant(stamp) {}
+  TimeInstant& operator+=(const TimeInterval<TimeInstant>& rhs);
+  TimeInstant& operator-=(const TimeInterval<TimeInstant>& rhs);
+  jlong value() const { return _instant; }
 };
 
-class Ticks {
- private:
-  jlong _stamp_ticks;
+class ElapsedCounter : public TimeInstant {
+ public:
+  ElapsedCounter(jlong stamp = 0) : TimeInstant(stamp) {}
+  static ElapsedCounter now();
+  void stamp();
+};
 
+class ElapsedCounterStamped : public ElapsedCounter {
  public:
-  Ticks() : _stamp_ticks(0) {
-    assert((_stamp_ticks = invalid_time_stamp) == invalid_time_stamp,
-      "initial unstamped time value assignment");
-  }
-
-  Ticks& operator+=(const Tickspan& span) {
-    _stamp_ticks += span.value();
-    return *this;
-  }
-
-  Ticks& operator-=(const Tickspan& span) {
-    _stamp_ticks -= span.value();
-    return *this;
-  }
+  ElapsedCounterStamped();
+};
 
+class FastElapsedCounter : public TimeInstant {
+ public:
+  FastElapsedCounter(jlong stamp = 0) : TimeInstant(stamp) {}
+  static FastElapsedCounter now();
   void stamp();
+};
 
-  jlong value() const {
-    return _stamp_ticks;
-  }
-
-  static const Ticks now();
+class FastElapsedCounterStamped : public FastElapsedCounter {
+ public:
+  FastElapsedCounterStamped();
+};
 
-#ifdef ASSERT
-  static const jlong invalid_time_stamp;
-#endif
+typedef TimeInterval<ElapsedCounter> ElapsedCounterInterval;
+typedef TimeInterval<FastElapsedCounter> FastElapsedCounterInterval;
 
-#ifndef PRODUCT
-  // only for internal use by GC VM tests
-  friend class TimePartitionPhasesIteratorTest;
-  friend class GCTimerTest;
+class TraceElapsedCounter;
 
+class TraceElapsedInterval {
+  friend TraceElapsedInterval operator-(const TraceElapsedCounter& end, const TraceElapsedCounter& start);
  private:
-  // implicit type conversion
-  Ticks(int ticks) : _stamp_ticks(ticks) {}
+  ElapsedCounterInterval _elapsed_interval;
+  FastElapsedCounterInterval _ft_elapsed_interval;
+  TraceElapsedInterval(const TraceElapsedCounter& end, const TraceElapsedCounter& start);
+ public:
+  TraceElapsedInterval(jlong interval = 0);
+  TraceElapsedInterval& operator+=(const TraceElapsedInterval& rhs);
+  TraceElapsedInterval& operator-=(const TraceElapsedInterval& rhs);
+  jlong value() const { return _elapsed_interval.value(); }
+  jlong ft_value() const;
+};
 
-#endif // !PRODUCT
+class TraceElapsedCounter {
+ protected:
+  ElapsedCounter _elapsed;
+  X86_ONLY(FastElapsedCounter _ft_elapsed;)
+ public:
+  TraceElapsedCounter(jlong stamp = 0);
+  TraceElapsedCounter& operator+=(const TraceElapsedInterval& rhs);
+  TraceElapsedCounter& operator-=(const TraceElapsedInterval& rhs);
 
+  static TraceElapsedCounter now();
+  void stamp();
+  jlong value() const { return _elapsed.value(); }
+  jlong ft_value() const;
 };
 
-class TicksToTimeHelper : public AllStatic {
+class TraceElapsedCounterStamped : public TraceElapsedCounter {
  public:
-  enum Unit {
-    SECONDS = 1,
-    MILLISECONDS = 1000
-  };
-  static double seconds(const Tickspan& span);
-  static jlong milliseconds(const Tickspan& span);
+  TraceElapsedCounterStamped();
 };
 
+#if INCLUDE_TRACE
+typedef TraceElapsedCounter  Ticks;
+typedef TraceElapsedInterval Tickspan;
+#else
+typedef ElapsedCounter       Ticks;
+typedef TicksInterval<Ticks> Tickspan;
+#endif
+
 #endif // SHARE_VM_UTILITIES_TICKS_HPP