src/hotspot/share/utilities/ticks.cpp

rev 49619 : JEP 328 : Flight Recorder open source preview

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2018, 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.

@@ -24,45 +24,110 @@
 
 #include "precompiled.hpp"
 #include "runtime/os.hpp"
 #include "utilities/ticks.inline.hpp"
 
-#ifdef ASSERT
- const jlong Ticks::invalid_time_stamp = -2; // 0xFFFF FFFF`FFFF FFFE
+#ifdef X86
+#include "rdtsc_x86.hpp"
 #endif
 
-void Ticks::stamp() {
-  _stamp_ticks = os::elapsed_counter();
+#include OS_CPU_HEADER(os)
+
+ElapsedCounterStamped::ElapsedCounterStamped() : ElapsedCounter(os::elapsed_counter()) {}
+
+void ElapsedCounter::stamp() {
+  _instant = now().value();
+}
+
+ElapsedCounter ElapsedCounter::now() {
+  return ElapsedCounterStamped();
+}
+
+#ifdef X86
+FastElapsedCounterStamped::FastElapsedCounterStamped() : FastElapsedCounter(Rdtsc::elapsed_counter()) {}
+#else
+FastElapsedCounterStamped::FastElapsedCounterStamped() : FastElapsedCounter(os::elapsed_counter()) {}
+#endif
+
+void FastElapsedCounter::stamp() {
+  _instant = now().value();
+}
+
+FastElapsedCounter FastElapsedCounter::now() {
+  return FastElapsedCounterStamped();
+}
+
+TraceElapsedInterval::TraceElapsedInterval(const TraceElapsedCounter& end, const TraceElapsedCounter& start) :
+  _elapsed_interval(end.value() - start.value())
+#ifdef X86
+  , _ft_elapsed_interval(end.ft_value() - start.ft_value())
+#endif
+  {}
+
+TraceElapsedInterval::TraceElapsedInterval(jlong interval) :
+  _elapsed_interval(interval)
+#ifdef X86
+  , _ft_elapsed_interval(interval)
+#endif
+  {}
+
+TraceElapsedInterval& TraceElapsedInterval::operator+=(const TraceElapsedInterval& rhs) {
+  _elapsed_interval += rhs._elapsed_interval;
+  X86_ONLY(_ft_elapsed_interval += rhs._ft_elapsed_interval;)
+  return *this;
 }
 
-const Ticks Ticks::now() {
-  Ticks t;
-  t.stamp();
-  return t;
+TraceElapsedInterval& TraceElapsedInterval::operator-=(const TraceElapsedInterval& rhs) {
+  _elapsed_interval -= rhs._elapsed_interval;
+  X86_ONLY(_ft_elapsed_interval -= rhs._ft_elapsed_interval;)
+  return *this;
 }
 
-Tickspan::Tickspan(const Ticks& end, const Ticks& start) {
-  assert(end.value() != Ticks::invalid_time_stamp, "end is unstamped!");
-  assert(start.value() != Ticks::invalid_time_stamp, "start is unstamped!");
+jlong TraceElapsedInterval::ft_value() const {
+#ifdef X86
+  return _ft_elapsed_interval.value();
+#else
+  return _elapsed_interval.value();
+#endif
+}
 
-  assert(end >= start, "negative time!");
+TraceElapsedCounter::TraceElapsedCounter(jlong stamp) :
+  _elapsed(stamp)
+#ifdef X86
+  , _ft_elapsed(stamp)
+#endif
+  {}
 
-  _span_ticks = end.value() - start.value();
+TraceElapsedCounter TraceElapsedCounter::now() {
+  TraceElapsedCounterStamped dec;
+  return dec;
 }
 
-template <typename ReturnType>
-static ReturnType time_conversion(const Tickspan& span, TicksToTimeHelper::Unit unit) {
-  assert(TicksToTimeHelper::SECONDS == unit ||
-         TicksToTimeHelper::MILLISECONDS == unit, "invalid unit!");
+TraceElapsedCounter& TraceElapsedCounter::operator+=(const TraceElapsedInterval& rhs) {
+  _elapsed += rhs.value();
+  X86_ONLY(_ft_elapsed += rhs.ft_value();)
+  return *this;
+}
 
-  ReturnType frequency_per_unit = (ReturnType)os::elapsed_frequency() / (ReturnType)unit;
+TraceElapsedCounter& TraceElapsedCounter::operator-=(const TraceElapsedInterval& rhs) {
+  _elapsed -= rhs.value();
+  X86_ONLY(_ft_elapsed -= rhs.ft_value();)
+  return *this;
+}
 
-  return (ReturnType) ((ReturnType)span.value() / frequency_per_unit);
+void TraceElapsedCounter::stamp() {
+  _elapsed.stamp();
+  X86_ONLY(_ft_elapsed.stamp();)
 }
 
-double TicksToTimeHelper::seconds(const Tickspan& span) {
-  return time_conversion<double>(span, SECONDS);
+jlong TraceElapsedCounter::ft_value() const {
+#ifdef X86
+  return _ft_elapsed.value();
+#else
+  return _elapsed.value();
+#endif
 }
 
-jlong TicksToTimeHelper::milliseconds(const Tickspan& span) {
-  return time_conversion<jlong>(span, MILLISECONDS);
+TraceElapsedCounterStamped::TraceElapsedCounterStamped() : TraceElapsedCounter() {
+  _elapsed.stamp();
+  X86_ONLY(_ft_elapsed.stamp());
 }