src/hotspot/share/utilities/ticks.cpp

rev 49619 : JEP 328 : Flight Recorder open source preview

*** 1,7 ****
  /*
!  * Copyright (c) 2013, 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.
--- 1,7 ----
  /*
!  * 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,68 ****
  
  #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
  #endif
  
! void Ticks::stamp() {
!   _stamp_ticks = os::elapsed_counter();
  }
  
! const Ticks Ticks::now() {
!   Ticks t;
!   t.stamp();
!   return t;
  }
  
! 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!");
  
!   assert(end >= start, "negative time!");
  
!   _span_ticks = end.value() - start.value();
  }
  
! template <typename ReturnType>
! static ReturnType time_conversion(const Tickspan& span, TicksToTimeHelper::Unit unit) {
!   assert(TicksToTimeHelper::SECONDS == unit ||
!          TicksToTimeHelper::MILLISECONDS == unit, "invalid unit!");
  
!   ReturnType frequency_per_unit = (ReturnType)os::elapsed_frequency() / (ReturnType)unit;
  
!   return (ReturnType) ((ReturnType)span.value() / frequency_per_unit);
  }
  
! double TicksToTimeHelper::seconds(const Tickspan& span) {
!   return time_conversion<double>(span, SECONDS);
  }
  
! jlong TicksToTimeHelper::milliseconds(const Tickspan& span) {
!   return time_conversion<jlong>(span, MILLISECONDS);
  }
--- 24,133 ----
  
  #include "precompiled.hpp"
  #include "runtime/os.hpp"
  #include "utilities/ticks.inline.hpp"
  
! #ifdef X86
! #include "rdtsc_x86.hpp"
  #endif
  
! #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;
  }
  
! 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
  }
  
! TraceElapsedCounterStamped::TraceElapsedCounterStamped() : TraceElapsedCounter() {
!   _elapsed.stamp();
!   X86_ONLY(_ft_elapsed.stamp());
  }