benchmark-perf 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23be9b198b35a0cd2ba9fce98fe449cc11bf603d85361fd296fce4d25c4e6fcb
-  data.tar.gz: 4e88b12e133ad01323eca2dbae4aa1a36cfcc44390ef9883785fa9df14009618
+  metadata.gz: c08c05dd2a152d8300d4973077f12564e771b2086c0deb4978a67b513d4364c5
+  data.tar.gz: 9bc2a4b6745a303ec61e21e474f347591b9c32298dbddbff99e6812c847bdd80
 SHA512:
-  metadata.gz: 8cc2086bbfcedfa67021a9cd6fdc9ea0a6b04bbedf1457cd8a1921d28dde118a328b95568a0d361313ae0c4f16f18187fc023f76e6f82b185cb28355859d941b
-  data.tar.gz: '0962f8911d08ec0be76097fc7bb7a225031ed943214c6be85dfebd909e606168463061013bd22cfc2e18c782861f6e3b5f12c51f935eec300e5923b63a8e0016'
+  metadata.gz: 543685961edfd985bdbba67b79e11f742211dc0a74d4a2d5ce8b3c66b603b06e44bc5f29545eb52fbf8763199c99198f5bf75d5bc589e2ec5f8c24512aa7be5c
+  data.tar.gz: 8f5b0ac7b3dacbb1a24dcdef567c421a8c3d1e0adaad7de4436848f17164787488c1d4b81f6662329eba93b1fd7077d285321f37cc768e82994b7a0fa0f3bd0f

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Change log
 
+## [v0.6.0] - 2020-02-24
+
+### Added
+* Add Clock for monotonic time measuring
+* Add Stats for arithmetic operations
+* Add Perf#ips and Perf#cpu helper methods
+* Add IPSResult to capture measurements and stats for iterations
+* Add CPUResult to capture measurements and stats for execution
+
+### Changed
+* Change to fix Ruby 2.7 warnings
+* Change to remove benchmark requirement
+* Change to remove #assert_perform_ips & #assert_perform_under
+* Change module name from ExecutionTime to Execution
+* Change Iteration#run to measure only work elapsed time
+
+### Fixed
+* Fix Iteration#run providing no measurements when warmup time exceeds bench time
+
 ## [v0.5.0] - 2019-04-21
 
 ### Added
@@ -59,6 +78,8 @@
 
 Initial release
 
+[v0.6.0]: https://github.com/piotrmurach/benchmark-perf/compare/v0.5.0...v0.6.0
+[v0.5.0]: https://github.com/piotrmurach/benchmark-perf/compare/v0.4.0...v0.5.0
 [v0.4.0]: https://github.com/piotrmurach/benchmark-perf/compare/v0.3.0...v0.4.0
 [v0.3.0]: https://github.com/piotrmurach/benchmark-perf/compare/v0.2.1...v0.3.0
 [v0.2.1]: https://github.com/piotrmurach/benchmark-perf/compare/v0.2.0...v0.2.1

data/README.md

@@ -43,44 +43,73 @@ Or install it yourself as:
 
 ## 1. Usage
 
-To see how long it takes to execute a piece of code:
+To see how long it takes to execute a piece of code do:
 
 ```ruby
-mean, stddev = Benchmark::Perf::ExecutionTime.run { ... }
+result = Benchmark::Perf.cpu { ... }
 ```
 
-or to see how many iterations per second a piece of code can achieve:
+The result will have information about:
 
 ```ruby
-mean, stddev, iter, elapsed_time = Benchmark::Perf::Iteration.run { ... }
+result.avg    # => average time in sec
+result.stdev  # => standard deviation in sec
+result.dt     # => elapsed time in sec
+```
+
+Or to see how many iterations per second a piece of code takes do:
+
+```ruby
+result = Benchmark::Perf.ips { ... }
+```
+
+Then you can query result for:
+
+```ruby
+result.avg    # => average ips
+result.stdev  # => ips stadard deviation
+result.iter   # => number of iterations
+result.dt     # => elapsed time
 ```
 
 ## 2. API
 
 ### 2.1 Execution time
 
-By default `1` measurement is taken, and `1` warmup cycle is run. If you need to change number of measurements taken use `:repeat`:
+By default `1` measurement is taken, and before that `1` warmup cycle is run.
+
+If you need to change how many measurements are taken, use the `:repeat` option:
+
+```ruby
+result = Benchmark::Perf.cpu(repeat: 10) { ... }
+```
+
+Then you can query result for the following information:
 
 ```ruby
-mean, std_dev = Benchmark::Perf::ExecutionTime.run(repeat: 10) { ... }
+result.avg    # => average time in sec
+result.stdev  # => standard deviation in sec
+result.dt     # => elapsed time in sec
 ```
 
-And to change number of warmup cycles use `:warmup` keyword like so:
+Increasing the number of measurements will lead to more stable results at the price of longer runtime.
+
+To change how many warmup cycles are done before measuring, use `:warmup` option like so:
 
 ```ruby
-Benchmark::Perf::ExecutionTime.run(warmup: 2) { ... }
+Benchmark::Perf.cpu(warmup: 2) { ... }
 ```
 
-If you're interested in having debug output to see exact measurements for each iteration specify stream with `:io`:
+If you're interested in having debug output to see exact measurements for each measurement sample use the `:io` option and pass alternative stream:
 
 ```ruby
-Benchmark::Perf::ExecutionTime.run(io: $stdout) { ... }
+Benchmark::Perf.cpu(io: $stdout) { ... }
 ```
 
-By default all measurements are done in subprocess to isolate them from other process activities. This may have negative consequences, for example when your code uses database connections and transactions. To switch this behaviour off use `:subprocess` option.
+By default all measurements are done in subprocess to isolate the measured code from other process activities. Sometimes this may have some unintended consequences. For example, when code uses database connections and transactions, this may lead to lost connections. To switch running in subprocess off, use the `:subprocess` option:
 
 ```ruby
-Benchmark::Perf::ExeuctionTime.run(subprocess: false) { ... }
+Benchmark::Perf.cpu(subprocess: false) { ... }
 ```
 
 Or use the environment variable `RUN_IN_SUBPROCESS` to toggle the behaviour.
@@ -90,19 +119,34 @@ Or use the environment variable `RUN_IN_SUBPROCESS` to toggle the behaviour.
 In order to check how many iterations per second a given code takes do:
 
 ```ruby
-mean, stddev, iter, elapsed_time = Benchmark::Perf::Iteration.run { ... }
+reuslt = Benchmark::Perf.ips { ... }
+```
+
+The result contains measurements that you can query:
+
+```ruby
+result.avg    # => average ips
+result.stdev  # => ips stadard deviation
+result.iter   # => number of iterations
+result.dt     # => elapsed time
+```
+
+Alternatively, the result can be deconstructed into variables:
+
+```ruby
+avg, stdev, iter, dt = *result
 ```
 
-By default `1` second is spent warming up Ruby VM, you change this passing `:warmup` :
+By default `1` second is spent warming up Ruby VM, you can change this with the `:warmup` option that expects time value in seconds:
 
 ```ruby
-Benchmark::Perf::Itertion.run(warmup: 1.45) { ... } # 1.45 second
+Benchmark::Perf.ips(warmup: 1.45) { ... } # 1.45 second
 ```
 
-The measurements as sampled for `2` seconds, you can change this value to increase precision using `:time`:
+The measurements are sampled for `2` seconds by default. You can change this value to increase precision using `:time` option:
 
 ```ruby
-Benchmark::Perf::Iteration.run(time: 3.5) { ... } # 3.5 seconds
+Benchmark::Perf.ips(time: 3.5) { ... } # 3.5 seconds
 ```
 
 ## Contributing

data/lib/benchmark/perf.rb

@@ -1,106 +1,48 @@
 # frozen_string_literal: true
 
-require 'benchmark'
-
-require_relative 'perf/execution_time'
-require_relative 'perf/iteration'
-require_relative 'perf/version'
+require_relative "perf/execution"
+require_relative "perf/iteration"
+require_relative "perf/version"
 
 module Benchmark
   module Perf
-    # Calculate arithemtic average of measurements
-    #
-    # @param [Array[Float]] measurements
-    #
-    # @return [Float]
-    #   the average of given measurements
-    #
-    # @api public
-    def average(measurements)
-      return 0 if measurements.empty?
-
-      measurements.reduce(&:+).to_f / measurements.size
-    end
-    module_function :average
-
-    # Calculate variance of measurements
-    #
-    # @param [Array[Float]] measurements
+    # Measure iterations a work could take in a second
     #
-    # @return [Float]
+    # @example
+    #   Benchmark::Perf.ips { "foo" + "bar" }
     #
-    # @api public
-    def variance(measurements)
-      return 0 if measurements.empty?
-
-      avg = average(measurements)
-      total = measurements.reduce(0) do |sum, x|
-        sum + (x - avg)**2
-      end
-      total.to_f / measurements.size
-    end
-    module_function :variance
-
-    # Calculate standard deviation
+    # @param [Numeric] time
+    #   the time to run measurements in seconds
+    # @param [Numeric] warmup
+    #   the warmup time in seconds
     #
-    # @param [Array[Float]] measurements
+    # @return [Array[Integer, Integer, Integer, Float]]
+    #   the average, standard deviation, iterations and time
     #
     # @api public
-    def std_dev(measurements)
-      return 0 if measurements.empty?
-
-      Math.sqrt(variance(measurements))
+    def ips(**options, &work)
+      Iteration.run(**options, &work)
     end
-    module_function :std_dev
+    module_function :ips
 
-    # Run given work and gather time statistics
-    #
-    # @param [Float] threshold
+    # Measure execution time(a.k.a cpu time) of a given work
     #
-    # @return [Boolean]
-    #
-    # @api public
-    def assert_perform_under(threshold, options = {}, &work)
-      actual, _ = ExecutionTime.run(options, &work)
-      actual <= threshold
-    end
-    module_function :assert_perform_under
-
-    # Assert work is performed within expected iterations per second
+    # @example
+    #   Benchmark::Perf.cpu { "foo" + "bar" }
     #
-    # @param [Integer] iterations
+    # @param [Numeric] time
+    #   the time to run measurements in seconds
+    # @param [Numeric] warmup
+    #   the warmup time in seconds
+    # @param [Integer] repeat
+    #   how many times to repeat measurements
     #
-    # @return [Boolean]
+    # @return [Array[Float, Float]]
     #
     # @api public
-    def assert_perform_ips(iterations, options = {}, &work)
-      mean, stddev, _ = Iteration.run(options, &work)
-      iterations <= (mean + 3 * stddev)
-    end
-    module_function :assert_perform_ips
-
-    if defined?(Process::CLOCK_MONOTONIC)
-      # Object representing current time
-      def time_now
-        Process.clock_gettime Process::CLOCK_MONOTONIC
-      end
-    else
-      # Object represeting current time
-      def time_now
-        Time.now
-      end
-    end
-    module_function :time_now
-
-    # Measure time elapsed with a monotonic clock
-    #
-    # @public
-    def clock_time
-      before = time_now
-      yield
-      after = time_now
-      after - before
+    def cpu(**options, &work)
+      Execution.run(**options, &work)
     end
-    module_function :clock_time
+    module_function :cpu
   end # Perf
 end # Benchmark

data/lib/benchmark/perf/clock.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Benchmark
+  module Perf
+    # Clock that represents monotonic time
+    module Clock
+      # Microseconds per second
+      MICROSECONDS_PER_SECOND = 1_000_000
+
+      # Microseconds per 100ms
+      MICROSECONDS_PER_100MS = 100_000
+
+      class_definition = Class.new do
+        def initialize
+          super()
+          @last_time = Time.now.to_f
+          @lock = Mutex.new
+        end
+
+        if defined?(Process::CLOCK_MONOTONIC)
+          # @api private
+          def now
+            Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          end
+        else
+          # @api private
+          def now
+            @lock.synchronize do
+              current = Time.now.to_f
+              if @last_time < current
+                @last_time = current
+              else # clock moved back in time
+                @last_time += 0.000_001
+              end
+            end
+          end
+        end
+      end
+
+      MONOTONIC_CLOCK = class_definition.new
+      private_constant :MONOTONIC_CLOCK
+
+      # Current monotonic time
+      #
+      # @return [Float]
+      #
+      # @api public
+      def now
+        MONOTONIC_CLOCK.now
+      end
+      module_function :now
+
+      # Measure time elapsed with a monotonic clock
+      #
+      # @return [Float]
+      #
+      # @public
+      def measure
+        before = now
+        yield
+        after = now
+        after - before
+      end
+      module_function :measure
+    end # Clock
+  end # Perf
+end # Benchmark

data/lib/benchmark/perf/cpu_result.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "stats"
+
+module Benchmark
+  module Perf
+    class CPUResult
+      # Indicate no value
+      NO_VALUE = Module.new
+
+      # Create storage for ips results
+      #
+      # @api private
+      def initialize
+        @avg = NO_VALUE
+        @stdev = NO_VALUE
+        @dt = NO_VALUE
+        @measurements = []
+      end
+
+      # @api private
+      def add(time_s)
+        @measurements << time_s
+        @avg = NO_VALUE
+        @stdev = NO_VALUE
+        @dt = NO_VALUE
+      end
+      alias << add
+
+      # Average ips
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def avg
+        return @avg unless @avg == NO_VALUE
+
+        @avg = Stats.average(@measurements)
+      end
+
+      # The ips standard deviation
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def stdev
+        return @stdev unless @stdev == NO_VALUE
+
+        @stdev = Stats.stdev(@measurements)
+      end
+
+      # The time elapsed
+      #
+      # @return [Float]
+      #
+      # @api public
+      def dt
+        return @dt unless @dt == NO_VALUE
+
+        @dt = @measurements.reduce(0, :+)
+      end
+      alias elapsed_time dt
+
+      # @api public
+      def to_a
+        [avg, stdev, dt]
+      end
+      alias to_ary to_a
+
+      # A string representation of this instance
+      #
+      # @api public
+      def inspect
+        "#<#{self.class.name} @avg=#{avg} @stdev=#{stdev} @dt=#{dt}>"
+      end
+    end # IPSResult
+  end # Perf
+end # Benchmark

data/lib/benchmark/perf/{execution_time.rb → execution.rb}

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "clock"
+require_relative "cpu_result"
+
 module Benchmark
   module Perf
     # Measure length of time the work could take on average
     #
     # @api public
-    module ExecutionTime
+    module Execution
       # Check if measurements need to run in subprocess
       #
       # @api private
@@ -69,7 +72,7 @@ module Benchmark
 
         warmup.times do
           run_in_subprocess(io: io, subprocess: subprocess) do
-            Perf.clock_time(&work)
+            Clock.measure(&work)
           end
         end
       end
@@ -81,7 +84,7 @@ module Benchmark
       #   how many times to repeat the code measuremenets
       #
       # @example
-      #   ExecutionTime.run(times: 10) { ... }
+      #   ExecutionTime.run(repeat: 10) { ... }
       #
       # @return [Array[Float, Float]]
       #   average and standard deviation
@@ -89,19 +92,21 @@ module Benchmark
       # @api public
       def run(repeat: 1, io: nil, warmup: 1, subprocess: true, &work)
         check_greater(repeat, 0)
-        measurements = []
+
+        result = CPUResult.new
 
         run_warmup(warmup: warmup, io: io, subprocess: subprocess, &work)
 
         repeat.times do
           GC.start
-          measurements << run_in_subprocess(io: io, subprocess: subprocess) do
-            Perf.clock_time(&work)
+          result << run_in_subprocess(io: io, subprocess: subprocess) do
+            Clock.measure(&work)
           end
         end
+
         io.puts if io
 
-        [Perf.average(measurements), Perf.std_dev(measurements)]
+        result
       end
       module_function :run
 

data/lib/benchmark/perf/ips_result.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "stats"
+
+module Benchmark
+  module Perf
+    class IPSResult
+      # Indicate no value
+      NO_VALUE = Module.new
+
+      attr_reader :ips
+
+      attr_reader :iter
+
+      # Create storage for ips results
+      #
+      # @api private
+      def initialize
+        @avg = NO_VALUE
+        @stdev = NO_VALUE
+        @dt = NO_VALUE
+        @measurements = []
+        @ips = []
+        @iter = 0
+      end
+
+      # @api private
+      def add(time_s, cycles_in_100ms)
+        @measurements << time_s
+        @iter += cycles_in_100ms
+        @ips << cycles_in_100ms.to_f / time_s.to_f
+        @avg = NO_VALUE
+        @stdev = NO_VALUE
+        @dt = NO_VALUE
+      end
+
+      # Average ips
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def avg
+        return @avg unless @avg == NO_VALUE
+
+        @avg = Stats.average(ips).round
+      end
+
+      # The ips standard deviation
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def stdev
+        return @stdev unless @stdev == NO_VALUE
+
+        @stdev = Stats.stdev(ips).round
+      end
+
+      # The time elapsed
+      #
+      # @return [Float]
+      #
+      # @api public
+      def dt
+        return @dt unless @dt == NO_VALUE
+
+        @dt = @measurements.reduce(0, :+)
+      end
+      alias elapsed_time dt
+
+      # @api public
+      def to_a
+        [avg, stdev, iter, dt]
+      end
+      alias to_ary to_a
+
+      # A string representation of this instance
+      #
+      # @api public
+      def inspect
+        "#<#{self.class.name} @avg=#{avg} @stdev=#{stdev} @iter=#{iter} @dt=#{dt}>"
+      end
+    end # IPSResult
+  end # Perf
+end # Benchmark

data/lib/benchmark/perf/iteration.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "clock"
+require_relative "stats"
+require_relative "ips_result"
+
 module Benchmark
   module Perf
     # Measure number of iterations a work could take in a second
     #
     # @api private
     module Iteration
-      MICROSECONDS_PER_SECOND = 1_000_000
-      MICROSECONDS_PER_100MS = 100_000
-
       # Call work by given times
       #
       # @param [Integer] times
@@ -30,15 +31,17 @@ module Benchmark
       # Calcualte the number of cycles needed for 100ms
       #
       # @param [Integer] iterations
-      # @param [Float] elapsed_time
-      #   the total time for all iterations
+      # @param [Float] time_s
+      #   the total time for all iterations in seconds
       #
       # @return [Integer]
       #   the cycles per 100ms
       #
       # @api private
-      def cycles_per_100ms(iterations, elapsed_time)
-        cycles = (iterations * (MICROSECONDS_PER_100MS / elapsed_time)).to_i
+      def cycles_per_100ms(iterations, time_s)
+        cycles = iterations * Clock::MICROSECONDS_PER_100MS
+        cycles /= time_s * Clock::MICROSECONDS_PER_SECOND
+        cycles = cycles.to_i
         cycles <= 0 ? 1 : cycles
       end
       module_function :cycles_per_100ms
@@ -51,50 +54,47 @@ module Benchmark
       # @api private
       def run_warmup(warmup: 1, &work)
         GC.start
-        target = Perf.time_now + warmup
+
+        target = Clock.now + warmup
         iter = 0
 
-        elapsed_time = Perf.clock_time do
-          while Perf.time_now < target
+        time_s = Clock.measure do
+          while Clock.now < target
             call_times(1, &work)
             iter += 1
           end
         end
 
-        elapsed_time *= MICROSECONDS_PER_SECOND
-        cycles_per_100ms(iter, elapsed_time)
+        cycles_per_100ms(iter, time_s)
       end
       module_function :run_warmup
 
       # Run measurements
       #
       # @param [Numeric] time
-      #   the time to run measurements for
+      #   the time to run measurements in seconds
+      # @param [Numeric] warmup
+      #   the warmup time in seconds
       #
       # @api public
       def run(time: 2, warmup: 1, &work)
-        target = Time.now + time
-        iter = 0
-        measurements = []
-        cycles = run_warmup(warmup: warmup, &work)
+        cycles_in_100ms = run_warmup(warmup: warmup, &work)
 
         GC.start
 
-        while Time.now < target
-          bench_time = Perf.clock_time { call_times(cycles, &work) }
-          next if bench_time <= 0.0 # Iteration took no time
-          iter += cycles
-          measurements << bench_time * MICROSECONDS_PER_SECOND
-        end
+        result = IPSResult.new
 
-        ips = measurements.map do |time_ms|
-          (cycles / time_ms) * MICROSECONDS_PER_SECOND
-        end
+        target = (before = Clock.now) + time
+
+        while Clock.now < target
+          time_s = Clock.measure { call_times(cycles_in_100ms, &work) }
 
-        final_time = Time.now
-        elapsed_time = (final_time - target).abs
+          next if time_s <= 0.0 # Iteration took no time
+
+          result.add(time_s, cycles_in_100ms)
+        end
 
-        [Perf.average(ips).round, Perf.std_dev(ips).round, iter, elapsed_time]
+        result
       end
       module_function :run
     end # Iteration

data/lib/benchmark/perf/stats.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Benchmark
+  module Perf
+    module Stats
+      # Calculate arithemtic average of measurements
+      #
+      # @param [Array[Float]] measurements
+      #
+      # @return [Float]
+      #   the average of given measurements
+      #
+      # @api public
+      def average(measurements)
+        return 0 if measurements.empty?
+
+        measurements.reduce(&:+).to_f / measurements.size
+      end
+      module_function :average
+
+      # Calculate variance of measurements
+      #
+      # @param [Array[Float]] measurements
+      #
+      # @return [Float]
+      #
+      # @api public
+      def variance(measurements)
+        return 0 if measurements.empty?
+
+        avg = average(measurements)
+        total = measurements.reduce(0) do |sum, x|
+          sum + (x - avg)**2
+        end
+        total.to_f / measurements.size
+      end
+      module_function :variance
+
+      # Calculate standard deviation
+      #
+      # @param [Array[Float]] measurements
+      #
+      # @api public
+      def stdev(measurements)
+        return 0 if measurements.empty?
+
+        Math.sqrt(variance(measurements))
+      end
+      module_function :stdev
+    end # Stats
+  end # Perf
+end # Benchmark

data/lib/benchmark/perf/version.rb

@@ -2,6 +2,6 @@
 
 module Benchmark
   module Perf
-    VERSION = "0.5.0"
+    VERSION = "0.6.0"
   end # Perf
 end # Benchmark

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: benchmark-perf
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-21 00:00:00.000000000 Z
+date: 2020-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -38,49 +38,38 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Execution time and iteration performance benchmarking
 email:
-- me@piotrmurach.com
+- piotr@piotrmurach.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+- LICENSE.txt
 files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- benchmark-perf.gemspec
 - lib/benchmark-perf.rb
 - lib/benchmark/perf.rb
-- lib/benchmark/perf/execution_time.rb
+- lib/benchmark/perf/clock.rb
+- lib/benchmark/perf/cpu_result.rb
+- lib/benchmark/perf/execution.rb
+- lib/benchmark/perf/ips_result.rb
 - lib/benchmark/perf/iteration.rb
+- lib/benchmark/perf/stats.rb
 - lib/benchmark/perf/version.rb
-- spec/spec_helper.rb
-- spec/unit/arithmetic_spec.rb
-- spec/unit/assertions_spec.rb
-- spec/unit/execution_time_spec.rb
-- spec/unit/iteration_spec.rb
-- tasks/console.rake
-- tasks/coverage.rake
-- tasks/spec.rake
-homepage: ''
+homepage: https://github.com/piotrmurach/benchmark-perf
 licenses:
 - MIT
-metadata: {}
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/piotrmurach/benchmark-perf/issues
+  changelog_uri: https://github.com/piotrmurach/benchmark-perf/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/benchmark-perf
+  homepage_uri: https://github.com/piotrmurach/benchmark-perf
+  source_code_uri: https://github.com/piotrmurach/benchmark-perf
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -96,13 +85,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Execution time and iteration performance benchmarking
-test_files:
-- spec/spec_helper.rb
-- spec/unit/arithmetic_spec.rb
-- spec/unit/assertions_spec.rb
-- spec/unit/execution_time_spec.rb
-- spec/unit/iteration_spec.rb
+test_files: []

data/Rakefile

@@ -1,8 +0,0 @@
-require "bundler/gem_tasks"
-
-FileList['tasks/**/*.rake'].each(&method(:import))
-
-desc 'Run all specs'
-task ci: %w[ spec ]
-
-task default: :spec

data/benchmark-perf.gemspec

@@ -1,27 +0,0 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'benchmark/perf/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "benchmark-perf"
-  spec.version       = Benchmark::Perf::VERSION
-  spec.authors       = ["Piotr Murach"]
-  spec.email         = ["me@piotrmurach.com"]
-  spec.summary       = %q{Execution time and iteration performance benchmarking}
-  spec.description   = %q{Execution time and iteration performance benchmarking}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = Dir['{lib,spec}/**/*.rb']
-  spec.files        += Dir['tasks/*', 'benchmark-perf.gemspec']
-  spec.files        += Dir['README.md', 'CHANGELOG.md', 'LICENSE.txt', 'Rakefile']
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^spec/})
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = '>= 2.0.0'
-
-  spec.add_development_dependency 'bundler', '>= 1.16'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rake'
-end

data/spec/spec_helper.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-if ENV['COVERAGE'] || ENV['TRAVIS']
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    command_name 'spec'
-    add_filter 'spec'
-  end
-end
-
-require "benchmark-perf"
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  config.disable_monkey_patching!
-
-  config.warnings = true
-
-  if config.files_to_run.one?
-    config.default_formatter = 'doc'
-  end
-
-  config.profile_examples = 2
-
-  config.order = :random
-
-  Kernel.srand config.seed
-end

data/spec/unit/arithmetic_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Benchmark::Perf, 'arithmetic' do
-  context '#average' do
-    it "calculates average without measurements" do
-      expect(Benchmark::Perf.average([])).to eq(0)
-    end
-
-    it "calculates average with measurements" do
-      expect(Benchmark::Perf.average([1,2,3])).to eq(2.0)
-    end
-  end
-
-  context '#variance' do
-    it "calculates variance of no measurements" do
-      expect(Benchmark::Perf.variance([])).to eq(0)
-    end
-
-    it "calculates variance of measurements" do
-      expect(Benchmark::Perf.variance([1,2,3])).to eq(2.to_f/3)
-    end
-  end
-
-  context '#std_dev' do
-    it "calculates standard deviation of no measurements" do
-      expect(Benchmark::Perf.std_dev([])).to eq(0)
-    end
-
-    it "calculates standard deviation of measurements" do
-      expect(Benchmark::Perf.std_dev([1,2,3])).to eq(Math.sqrt(2.to_f/3))
-    end
-  end
-end

data/spec/unit/assertions_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Benchmark::Perf, 'assertions' do
-  it "passes asertion by performing under threshold" do
-    bench = Benchmark::Perf
-    assertion = bench.assert_perform_under(0.01, repeat: 2) { 'x' * 1_024 }
-    expect(assertion).to eq(true)
-  end
-
-  it "passes asertion by performing 10K ips" do
-    bench = Benchmark::Perf
-    assertion = bench.assert_perform_ips(10_000, warmup: 1.3) { 'x' * 1_024 }
-    expect(assertion).to eq(true)
-  end
-end

data/spec/unit/execution_time_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Benchmark::Perf::ExecutionTime do
-  it "provides default benchmark range" do
-    allow(described_class).to receive(:run_in_subprocess).and_return(0.1)
-
-    described_class.run(warmup: 0) { 'x' * 1024 }
-
-    expect(described_class).to have_received(:run_in_subprocess).once
-  end
-
-  it "accepts custom number of samples" do
-    allow(described_class).to receive(:run_in_subprocess).and_return(0.1)
-
-    described_class.run(repeat: 12, warmup: 0) { 'x' * 1024 }
-
-    expect(described_class).to have_received(:run_in_subprocess).exactly(12).times
-  end
-
-  it "runs warmup cycles" do
-    allow(described_class).to receive(:run_in_subprocess).and_return(0.1)
-
-    described_class.run(repeat: 1, warmup: 1) { 'x' }
-
-    expect(described_class).to have_received(:run_in_subprocess).twice
-  end
-
-  it "doesn't run in subproces when option :run_in_subprocess is set to false",
-    if: ::Process.respond_to?(:fork) do
-
-    allow(::Process).to receive(:fork)
-
-    described_class.run(subprocess: false) { 'x' * 1024 }
-
-    expect(::Process).to_not have_received(:fork)
-  end
-
-  it "doesn't run in subprocess when RUN_IN_SUBPROCESS env var is set to false",
-    if: ::Process.respond_to?(:fork) do
-
-    allow(::Process).to receive(:fork)
-    allow(ENV).to receive(:[]).with("RUN_IN_SUBPROCESS").and_return('false')
-
-    described_class.run { 'x' * 1024 }
-
-    expect(::Process).to_not have_received(:fork)
-  end
-
-  it "doesn't accept range smaller than 1" do
-    expect {
-      described_class.run(repeat: 0) { 'x' }
-    }.to raise_error(ArgumentError, 'Repeat value: 0 needs to be greater than 0')
-  end
-
-  it "provides measurements for 30 samples by default" do
-    sample = described_class.run { 'x' * 1024 }
-
-    expect(sample).to all(be < 0.01)
-  end
-
-  it "doesn't benchmark raised exception" do
-    expect {
-      described_class.run { raise 'boo' }
-    }.to raise_error(StandardError)
-  end
-
-  it "measures complex object" do
-    sample = described_class.run { {foo: Object.new, bar: :piotr} }
-
-    expect(sample).to all(be < 0.01)
-  end
-
-  it "executes code to warmup ruby vm" do
-    sample = described_class.run_warmup { 'x' * 1_000_000 }
-
-    expect(sample).to eq(1)
-  end
-
-  it "measures work performance for 10 samples" do
-    sample = described_class.run(repeat: 10) { 'x' * 1_000_000 }
-
-    expect(sample.size).to eq(2)
-    expect(sample).to all(be < 0.01)
-  end
-end

data/spec/unit/iteration_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Benchmark::Perf::Iteration do
-  it "defines cycles per 100 microseconds" do
-    sample = described_class.run_warmup { 'x' * 1_000_000 }
-    expect(sample).to be > 25
-  end
-
-  it "measures 10K iterations per second" do
-    sample = described_class.run { 'x' * 1_000_000 }
-
-    expect(sample.size).to eq(4)
-    expect(sample[0]).to be > 250
-    expect(sample[1]).to be > 5
-    expect(sample[2]).to be > 250
-  end
-
-  it "does't measure broken code" do
-    expect {
-      described_class.run { raise 'boo' }
-    }.to raise_error(StandardError, /boo/)
-  end
-end

data/tasks/console.rake

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-desc 'Load gem inside irb console'
-task :console do
-  require 'irb'
-  require 'irb/completion'
-  require_relative '../lib/benchmark-perf'
-  ARGV.clear
-  IRB.start
-end
-task c: %w[ console ]

data/tasks/coverage.rake

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-desc 'Measure code coverage'
-task :coverage do
-  begin
-    original, ENV['COVERAGE'] = ENV['COVERAGE'], 'true'
-    Rake::Task['spec'].invoke
-  ensure
-    ENV['COVERAGE'] = original
-  end
-end

data/tasks/spec.rake

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require 'rspec/core/rake_task'
-
-  desc 'Run all specs'
-  RSpec::Core::RakeTask.new(:spec) do |task|
-    task.pattern = 'spec/{unit,integration}{,/*/**}/*_spec.rb'
-  end
-
-  namespace :spec do
-    desc 'Run unit specs'
-    RSpec::Core::RakeTask.new(:unit) do |task|
-      task.pattern = 'spec/unit{,/*/**}/*_spec.rb'
-    end
-
-    desc 'Run integration specs'
-    RSpec::Core::RakeTask.new(:integration) do |task|
-      task.pattern = 'spec/integration{,/*/**}/*_spec.rb'
-    end
-
-    desc 'Run performance specs'
-    RSpec::Core::RakeTask.new(:perf) do |task|
-      task.pattern = 'spec/performance{,/*/**}/*_spec.rb'
-    end
-  end
-
-rescue LoadError
-  %w[spec spec:unit spec:integration spec:perf].each do |name|
-    task name do
-      $stderr.puts "In order to run #{name}, do `gem install rspec`"
-    end
-  end
-end