--- old/src/share/vm/utilities/ticks.cpp	2019-01-28 17:45:01.000000000 +0800
+++ new/src/share/vm/utilities/ticks.cpp	2019-01-28 17:45:01.000000000 +0800
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2019, 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
@@ -26,43 +26,140 @@
 #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();
+#ifdef TARGET_OS_ARCH_linux_x86
+# include "os_linux_x86.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_linux_sparc
+# include "os_linux_sparc.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_linux_zero
+# include "os_linux_zero.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_solaris_x86
+# include "os_solaris_x86.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_solaris_sparc
+# include "os_solaris_sparc.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_windows_x86
+# include "os_windows_x86.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_linux_arm
+# include "os_linux_arm.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_linux_ppc
+# include "os_linux_ppc.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_aix_ppc
+# include "os_aix_ppc.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_bsd_x86
+# include "os_bsd_x86.hpp"
+#endif
+#ifdef TARGET_OS_ARCH_bsd_zero
+# include "os_bsd_zero.hpp"
+#endif
+
+ElapsedCounterStamped::ElapsedCounterStamped() : ElapsedCounter(os::elapsed_counter()) {}
+
+void ElapsedCounter::stamp() {
+  _instant = now().value();
 }
 
-const Ticks Ticks::now() {
-  Ticks t;
-  t.stamp();
-  return t;
+ElapsedCounter ElapsedCounter::now() {
+  return ElapsedCounterStamped();
 }
 
-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!");
+#ifdef X86
+FastElapsedCounterStamped::FastElapsedCounterStamped() : FastElapsedCounter(Rdtsc::elapsed_counter()) {}
+#else
+FastElapsedCounterStamped::FastElapsedCounterStamped() : FastElapsedCounter(os::elapsed_counter()) {}
+#endif
 
-  assert(end >= start, "negative time!");
+void FastElapsedCounter::stamp() {
+  _instant = now().value();
+}
 
-  _span_ticks = end.value() - start.value();
+FastElapsedCounter FastElapsedCounter::now() {
+  return FastElapsedCounterStamped();
 }
 
-template <typename ReturnType>
-static ReturnType time_conversion(const Tickspan& span, TicksToTimeHelper::Unit unit) {
-  assert(TicksToTimeHelper::SECONDS == unit ||
-         TicksToTimeHelper::MILLISECONDS == unit, "invalid unit!");
+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
+  {}
 
-  ReturnType frequency_per_unit = (ReturnType)os::elapsed_frequency() / (ReturnType)unit;
+TraceElapsedInterval::TraceElapsedInterval(jlong interval) :
+  _elapsed_interval(interval)
+#ifdef X86
+  , _ft_elapsed_interval(interval)
+#endif
+  {}
 
-  return (ReturnType) ((ReturnType)span.value() / frequency_per_unit);
+TraceElapsedInterval& TraceElapsedInterval::operator+=(const TraceElapsedInterval& rhs) {
+  _elapsed_interval += rhs._elapsed_interval;
+  X86_ONLY(_ft_elapsed_interval += rhs._ft_elapsed_interval;)
+  return *this;
 }
 
-double TicksToTimeHelper::seconds(const Tickspan& span) {
-  return time_conversion<double>(span, SECONDS);
+TraceElapsedInterval& TraceElapsedInterval::operator-=(const TraceElapsedInterval& rhs) {
+  _elapsed_interval -= rhs._elapsed_interval;
+  X86_ONLY(_ft_elapsed_interval -= rhs._ft_elapsed_interval;)
+  return *this;
+}
+
+jlong TraceElapsedInterval::ft_value() const {
+#ifdef X86
+  return _ft_elapsed_interval.value();
+#else
+  return _elapsed_interval.value();
+#endif
+}
+
+TraceElapsedCounter::TraceElapsedCounter(jlong stamp) :
+  _elapsed(stamp)
+#ifdef X86
+  , _ft_elapsed(stamp)
+#endif
+  {}
+
+TraceElapsedCounter TraceElapsedCounter::now() {
+  TraceElapsedCounterStamped dec;
+  return dec;
+}
+
+TraceElapsedCounter& TraceElapsedCounter::operator+=(const TraceElapsedInterval& rhs) {
+  _elapsed += rhs.value();
+  X86_ONLY(_ft_elapsed += rhs.ft_value();)
+  return *this;
+}
+
+TraceElapsedCounter& TraceElapsedCounter::operator-=(const TraceElapsedInterval& rhs) {
+  _elapsed -= rhs.value();
+  X86_ONLY(_ft_elapsed -= rhs.ft_value();)
+  return *this;
+}
+
+void TraceElapsedCounter::stamp() {
+  _elapsed.stamp();
+  X86_ONLY(_ft_elapsed.stamp();)
+}
+
+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());
 }