hitimes 1.3.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e479c2fbfddbd9d35a7f9bcc4580b265f43cd9fa46a7a986e1d10401c58b882
-  data.tar.gz: 5751466c5f9a518a607b4f14df5e368dd85d990fccbc665f6d080b5435982b4d
+  metadata.gz: dbcf72d52334876051ff59dbc24a84f2a2be8dbde31979d858819db54eba8f7f
+  data.tar.gz: c19e0e771b17465b6f57a5e229d11e76b132c1d3c170ff3da1428eeb11cac40a
 SHA512:
-  metadata.gz: fabe96db83fec72aac45648908229119bce50fdef39e61fc00f426a7d44ba3da791be416b5e44f0c6bd4cae822e241e152f827c490fb46658946a910ffad6579
-  data.tar.gz: e1ba6e894dbabf0911df83bbae59a9dfd201b2edfd605a2fe9c27f46e2d5d5bf80105918f3a718df02de0fccf975cc36ada85254b53f949ce78036fe9130d050
+  metadata.gz: e1005099d605876d72c5d7147007b051f77b1451c83a9eac420807ed221f1e484098dc276d9d2cbc2c1f74dca19ec032334bdd6e81ab3c9304e5991ba8e7ccb9
+  data.tar.gz: e7b74b1d122348097900175b8e9a422b1cc49782994c82a55e1017f9742de08cadaae70b8ea8b9603f2bc05e0e471278321a0ee76fef06997abde5c6d05561d3

data/CONTRIBUTING.md

@@ -33,17 +33,6 @@ easiest way to contribute.
 * Add yourself to the contributors section below.
 * Submit your [pull request][].
 
-## Building Windows Binaries
-
-This is done using https://github.com/rake-compiler/rake-compiler-dock
-
-1. have VirtualBox installed
-2. have Docker Machine installed (https://docs.docker.com/engine/installation/)
-3. `gem install rake-compiler-dock`
-4. `rake-compiler-dock` (this could take a while)
-5. `bundle`
-6. `rake cross native gem`
-
 # Contributors
 
 * Jeremy Hinegardner

data/HISTORY.md

@@ -1,4 +1,11 @@
-# Hitimes Changelog
+# Hitimes Changeloga
+## Version 2.0.0 2019-09-23
+
+* Remove the C and Java extensions as `Process.clock_gettime()` has the same
+  resolution as what the extensions did.
+* Update all depedencies and resolve deprecations
+* Now usable on truffleruby
+
 ## Version 1.3.1 2019-01-18
 
 * Update jruby extension to not use global runtime state (thanks @kares) (#70)

data/Manifest.txt

@@ -6,20 +6,10 @@ README.md
 Rakefile
 examples/benchmarks.rb
 examples/stats.rb
-ext/hitimes/c/extconf.rb
-ext/hitimes/c/hitimes.c
-ext/hitimes/c/hitimes_instant_clock_gettime.c
-ext/hitimes/c/hitimes_instant_osx.c
-ext/hitimes/c/hitimes_instant_windows.c
-ext/hitimes/c/hitimes_interval.c
-ext/hitimes/c/hitimes_interval.h
-ext/hitimes/c/hitimes_stats.c
-ext/hitimes/c/hitimes_stats.h
-ext/hitimes/java/src/hitimes/Hitimes.java
-ext/hitimes/java/src/hitimes/HitimesInterval.java
-ext/hitimes/java/src/hitimes/HitimesService.java
-ext/hitimes/java/src/hitimes/HitimesStats.java
 lib/hitimes.rb
+lib/hitimes/initialize.rb
+lib/hitimes/instant.rb
+lib/hitimes/interval.rb
 lib/hitimes/metric.rb
 lib/hitimes/mutexed_stats.rb
 lib/hitimes/paths.rb
@@ -40,5 +30,4 @@ spec/timed_value_metric_spec.rb
 spec/value_metric_spec.rb
 spec/version_spec.rb
 tasks/default.rake
-tasks/extension.rake
 tasks/this.rb

data/README.md

@@ -7,7 +7,7 @@
 A fast, high resolution timer library for recording peformance metrics.
 
 * [Homepage](http://github.com/copiousfreetime/hitimes)
-* [Github project](http://github.com.org/copiousfreetime/hitimes)
+* [Github project](http://github.com/copiousfreetime/hitimes)
 * email jeremy at copiousfreetime dot org
 * `git clone url git://github.com/copiousfreetime/hitimes.git`
 
@@ -143,16 +143,9 @@ puts timed_value_metric.value_stats.stddev
 
 ### Implementation details
 
-Hitimes use the appropriate low-level system call for each operating system to
+Hitimes uses the internal ruby `Process::clock_gettime()` to
 get the highest granularity time increment possible. Generally this is
-nanosecond resolution, or whatever the hardware chip in the CPU supports.
-
-It currently supports any of the following systems:
-
-* any system with the POSIX call `clock_gettime()`
-* Mac OS X
-* Windows
-* JRuby
+nanosecond resolution, or whatever the hardware in the CPU supports.
 
 ## Support
 
@@ -164,15 +157,12 @@ The current officially supported versions of Ruby are:
 * MRI Ruby (all platforms) 2.3 - 2.6
 * JRuby 9.1.17.0, 9.2.X.X
 
-Unofficially supported versions, these have been supported in the past when they
-were the primary rubies around. In all likelihood they still work, but are not
-supported.
+Unofficially supported versions, any version of MRI from Ruby 2.1 and up. Sincd
+the C Extension has been removed Hitimes should work with any ruby that is 2.1
+or greater as that is when `Process.clock_gettime()` was implemented.
 
-* MRI Ruby (linux/mac/bsd/unix/etc) - everything from 1.8.7 to 2.2
-* MRI Ruby (windows) - 2.0 and up
-  * Ruby 1.8 and 1.9 for windows are supported in hitimes version 1.2.4 or earlier
-* JRuby - I think everything back to 1.4
-* Rubinius
+For versions of Ruby before 2.1 please use Hitimes 1.3, the extension code is
+still in there and they should still work.
 
 ## Contributing
 

data/Rakefile

@@ -7,22 +7,13 @@ This.email    = "jeremy@copiousfreetime.org"
 This.homepage = "http://github.com/copiousfreetime/#{ This.name }"
 
 This.ruby_gemspec do |spec|
-  spec.add_development_dependency( 'rake'         , '~> 12.0')
+  spec.add_development_dependency( 'rake'         , '~> 12.3')
   spec.add_development_dependency( 'minitest'     , '~> 5.5' )
-  spec.add_development_dependency( 'rdoc'         , '~> 5.0'  )
-  spec.add_development_dependency( 'json'         , '~> 2.0' )
-  spec.add_development_dependency( 'rake-compiler', '~> 1.0' )
-  spec.add_development_dependency( 'rake-compiler-dock', '~> 0.6' )
-  spec.add_development_dependency( 'simplecov'    , '~> 0.14' )
+  spec.add_development_dependency( 'rdoc'         , '~> 6.2' )
+  spec.add_development_dependency( 'json'         , '~> 2.2' )
+  spec.add_development_dependency( 'simplecov'    , '~> 0.17' )
 
-  spec.extensions.concat This.extension_conf_files
   spec.license = "ISC"
 end
 
-This.java_gemspec( This.ruby_gemspec ) do |spec|
-  spec.extensions.clear
-  spec.files << "lib/hitimes/hitimes.jar"
-end
-
 load 'tasks/default.rake'
-load 'tasks/extension.rake'

data/lib/hitimes.rb

@@ -25,36 +25,8 @@ module Hitimes
 end
 require 'hitimes/paths'
 require 'hitimes/version'
-
-# Load the binary extension, try loading one for the specific version of ruby
-# and if that fails, then fall back to one in the top of the library.
-# this is the method recommended by rake-compiler
-
-attempts = [
-  "hitimes/#{RUBY_VERSION.sub(/\.\d+$/,'')}/hitimes",
-  "hitimes/hitimes"
-]
-loaded = false
-
-path_exceptions = []
-attempts.each do |path|
-  begin
-    require path
-    loaded = true
-    break
-  rescue LoadError => load_error
-    full_path = File.expand_path(path)
-    path_exceptions << [ full_path, load_error.message ]
-  end
-end
-
-if !loaded then
-  msg = ["Unable to find binary extension, was hitimes installed correctly? The following paths were tried."]
-  path_exceptions.each do |path, message|
-    msg << "#{path} : #{message}"
-  end
-  raise LoadError, msg.join("\n")
-end
+require 'hitimes/instant'
+require 'hitimes/interval'
 
 require 'hitimes/stats'
 require 'hitimes/mutexed_stats'

data/lib/hitimes/initialize.rb

@@ -0,0 +1,65 @@
+module Hitimes
+
+  # Internal: Internal setup that is done when the library is loaded
+  #
+  # We want to determine what clock to use for this machine. So we need to
+  # intropect the ruby environment and then setup some initial constants. These
+  # methods are used in lib/hitimes/instant.rb to help setup the CLOCK_ID
+  # constant
+  #
+  module Initialize
+
+    # Internal: Return the list of clock ids, in general priority order,
+    # assuming they all have the same resolution.
+    #
+    # On OSX we probably want to use the MACH time first, and then fall back to
+    # CLOCK_... Constants on other machines.
+    #
+    # The one requirement is that they are monotonically increasing clocks
+    #
+    # Returns an array of clock ids
+    def potential_clock_ids
+      Array.new.tap do |clock_ids|
+
+        # if we're on OSX this will add in an additional clock_id, although not
+        # sure why it is just a symbol and not a Process:: constant
+        #
+        begin
+          Process.clock_getres(:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC)
+          clock_ids << :MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC
+        rescue Errno::EINVAL
+          # not on OSX
+        end
+
+        # General monotonic constants in general order of priority assuming they
+        # all have the same resolution
+        #
+        %i[ CLOCK_MONOTONIC_RAW CLOCK_BOOTTIME CLOCK_MONOTONIC_PRECISE CLOCK_MONOTONIC ].each do |c|
+          clock_ids << Process.const_get(c) if Process.const_defined?(c)
+        end
+
+      end
+    end
+    module_function :potential_clock_ids
+
+    # Internal: Determine what clock to use for the machine we are one. We want
+    # the highest resolution clock possible, which should be nanosecond
+    # resolution.
+    #
+    # Get the resolution of each clock id and then return the higest resolution
+    # id from the list
+    #
+    # Returns the clock id to use on this ruby
+    def determine_clock_id
+      ids_and_resolutions = potential_clock_ids.map { |clock_id|
+        [clock_id, Process.clock_getres(clock_id)]
+      }
+
+      # Sort them by the resolution - we want the smallest one first
+      ids_and_resolutions.sort_by! { |pair| pair[1] }
+
+      return ids_and_resolutions.first[0]
+    end
+    module_function :determine_clock_id
+  end
+end

data/lib/hitimes/instant.rb

@@ -0,0 +1,65 @@
+require 'hitimes/initialize'
+
+module Hitimes
+  # Public: The clock_id to use in Process.clock_gettime
+  CLOCK_ID                        = Initialize.determine_clock_id.freeze
+
+  # Public: The resolution of the clock
+  CLOCK_RESOLUTION_NANOSECONDS    = Process.clock_getres(CLOCK_ID, :nanosecond).freeze
+
+  # Internal: The fraction of second of a nanosecond
+  NANOSECONDS_PER_SECOND          = 1e9
+
+  # Public: The smallest fraction of a second hitimes can do
+  CLOCK_RESOLUTION_SECONDS        = CLOCK_RESOLUTION_NANOSECONDS / NANOSECONDS_PER_SECOND
+
+  # Public: The factor used to convert the instant values to fractional seconds
+  #
+  # The raw instant values are divided by this value to get float seconds
+  INSTANT_CONVERSION_FACTOR       = CLOCK_RESOLUTION_NANOSECONDS * NANOSECONDS_PER_SECOND
+
+
+  # Public: Get the raw instant
+  #
+  # Examples:
+  #
+  #    Hitimes.raw_instant
+  #
+  # Returns the raw instant value
+  def raw_instant
+    Process.clock_gettime(::Hitimes::CLOCK_ID, :nanosecond)
+  end
+  module_function :raw_instant
+
+  # Internal: The human readable clock name of the CLOCK_ID as a string
+  #
+  # Returns the clock name as a String
+  def clock_name
+    case CLOCK_ID
+    when Symbol
+      CLOCK_ID.to_s
+    else
+      const = Process.constants.grep(/CLOCK/).find { |c|
+        CLOCK_ID == Process.const_get(c)
+      }
+      "Process::#{const.to_s}"
+    end
+  end
+  module_function :clock_name
+
+  # Internal: The human readable clock resolution
+  #
+  # Returns the clock resolution as a string
+  def clock_resolution_description
+    "#{CLOCK_RESOLUTION_NANOSECONDS}ns"
+  end
+  module_function :clock_resolution_description
+
+  # Internal: The human readable clock description that is used by hitimes
+  #
+  # Returns the clock description as a String
+  def clock_description
+    "#{clock_name} #{clock_resolution_description}"
+  end
+  module_function :clock_description
+end

data/lib/hitimes/interval.rb

@@ -0,0 +1,171 @@
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#
+module Hitimes
+  # This is the lowest level timing mechanism available.  It allows for easy
+  # measuring based upon a block:
+  #
+  #   duration = Interval.measure { ... }
+  #
+  # Or measuring something specifically
+  #
+  #   interval = Interval.new
+  #   interval.start
+  #   duration = interval.stop
+  #
+  # Allocating and starting an interval can be done in one method call with
+  #
+  #   interval = Interval.now
+  #
+  # Interval is useful when you only need to track a single interval of time, or
+  # if you do not want to track statistics about an operation.
+  class Interval
+
+    # Public: The integer representing the start instant of the Interval.  This
+    # valuea is not useful on its own.  It is a platform dependent value.
+    attr_reader :start_instant
+
+    # Public: The integer representing the stop instant of the Interval.  This
+    # value is not useful on its own.  It is a platform dependent value.
+    attr_reader :stop_instant
+
+    def initialize(start = nil, stop = nil)
+      @start_instant = start
+      @stop_instant  = stop
+      @duration      = -Float::INFINITY
+    end
+
+    # call-seq:
+    #    Interval.now -> Interval
+    #
+    # Create an interval that has already started
+    #
+    def self.now
+      Interval.new(Hitimes.raw_instant)
+    end
+
+    # call-seq:
+    #    Interval.measure {  }  -> Float
+    #
+    # Times the execution of the block returning the number of seconds it took
+    def self.measure(&block)
+      raise Error, "No block given to Interval.measure" unless block_given?
+
+      i = Interval.now
+      yield
+      i.stop
+
+      return i.duration
+    end
+
+    # call-seq:
+    #    interval.split -> Interval
+    #
+    # Immediately stop the current interval and start a new interval that has a
+    # start_instant equivalent to the stop_interval of self.
+    def split
+      @stop_instant = ::Hitimes.raw_instant
+      return Interval.new(@stop_instant)
+    end
+
+    # call-seq:
+    #    interval.start -> boolean
+    #
+    # mark the start of the interval.  Calling start on an already started
+    # interval has no effect.  An interval can only be started once.  If the
+    # interval is truely started +true+ is returned otherwise +false+.
+    def start
+      return false if started?
+      @start_instant = ::Hitimes.raw_instant
+      true
+    end
+
+    # call-seq:
+    #    interval.stop -> bool or Float
+    #
+    # mark the stop of the interval.  Calling stop on an already stopped interval
+    # has no effect.  An interval can only be stopped once.  If the interval is
+    # truely stopped then the duration is returned, otherwise +false+.
+    def stop
+      raise Error, "Attempt to stop an interval that has not started" unless started?
+      return false if stopped?
+
+      @stop_instant = ::Hitimes.raw_instant
+
+      return duration
+    end
+
+    # call-seq:
+    #     interval.duration_so_far -> Float or false
+    #
+    # return how the duration so far.  This will return the duration from the time
+    # the Interval was started if the interval is running, otherwise it will return
+    # false.
+    def duration_so_far
+      return false unless running?
+
+      _now = Hitimes.raw_instant
+      calculate_duration(@start_instant, _now)
+    end
+
+    # call-seq:
+    #    interval.started? -> boolean
+    #
+    # returns whether or not the interval has been started
+    def started?
+      !!@start_instant
+    end
+
+    # call-seq:
+    #    interval.stopped? -> boolean
+    #
+    # returns whether or not the interval has been stopped
+    def  stopped?
+      !!@stop_instant
+    end
+
+    # call-seq:
+    #    interval.running? -> boolean
+    #
+    # returns whether or not the interval is running or not.  This means that it
+    # has started, but not stopped.
+    #
+    def running?
+      started? && !stopped?
+    end
+
+    # call-seq:
+    #    interval.duration -> Float
+    #    interval.to_f -> Float
+    #    interval.to_seconds -> Float
+    #    interval.length -> Float
+    #
+    # Returns the Float value of the interval, the value is in seconds.  If the
+    # interval has not had stop called yet, it will report the number of seconds
+    # in the interval up to the current point in time.
+    #
+    # Raises Error if duration is called on an interval that has not started yet.
+    #
+    def duration
+      raise Error, "Attempt to report a duration on an interval that has not started" unless started?
+
+      return duration_so_far unless stopped?
+
+      if @duration < 0 then
+        @duration = calculate_duration(@start_instant, @stop_instant)
+      end
+
+      return @duration
+    end
+
+    alias to_f       duration
+    alias to_seconds duration
+    alias length     duration
+
+    private
+
+    def calculate_duration(start, stop)
+      (stop - start) / ::Hitimes::INSTANT_CONVERSION_FACTOR
+    end
+  end
+end