hitimes 1.1.1 → 1.2.0

data/ext/hitimes/java/src/hitimes/Hitimes.java

@@ -0,0 +1,54 @@
+package hitimes;
+
+import java.lang.Math;
+import java.lang.System;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyModule;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+
+import org.jruby.exceptions.RaiseException;
+
+
+/**
+ * @author <a href="mailto:jeremy@hinegardner.org">Jeremy Hinegardner</a>
+ */
+@JRubyModule( name = "Hitimes" )
+public class Hitimes {
+
+    public static RubyClass hitimesIntervalClass;
+    /**
+     * Create the Hitimes module and add it to the Ruby runtime.
+     */
+    public static RubyModule createHitimes( Ruby runtime ) {
+        RubyModule mHitimes = runtime.defineModule("Hitimes");
+
+        RubyClass  cStandardError = runtime.getStandardError();
+        RubyClass  cHitimesError  = mHitimes.defineClassUnder("Error", cStandardError, cStandardError.getAllocator());
+
+        RubyClass  cHitimesStats  = mHitimes.defineClassUnder("Stats", runtime.getObject(), HitimesStats.ALLOCATOR );
+        cHitimesStats.defineAnnotatedMethods( HitimesStats.class );
+
+        RubyClass  cHitimesInterval  = mHitimes.defineClassUnder("Interval", runtime.getObject(), HitimesInterval.ALLOCATOR );
+        Hitimes.hitimesIntervalClass = cHitimesInterval;
+        cHitimesInterval.defineAnnotatedMethods( HitimesInterval.class );
+
+        return mHitimes;
+    }
+
+    static RaiseException newHitimesError( Ruby runtime, String message ) {
+        RubyClass errorClass = runtime.getModule("Hitimes").getClass( "Error" );
+        return new RaiseException( RubyException.newException( runtime, errorClass, message ), true );
+    }
+
+
+
+    @JRubyClass( name = "Hitimes::Error", parent = "StandardError" )
+    public static class Error {};
+
+}

data/ext/hitimes/java/src/hitimes/HitimesInterval.java

@@ -0,0 +1,181 @@
+package hitimes;
+
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+
+@JRubyClass( name = "Hitimes::Interval" )
+public class HitimesInterval extends RubyObject {
+
+    /* this is a double to force all division by the conversion factor
+     * to cast to doubles
+     */
+    private static final double INSTANT_CONVERSION_FACTOR = 1000000000d;
+
+    private static final long   INSTANT_NOT_SET  = Long.MIN_VALUE;
+    private static final double DURATION_NOT_SET = Double.NaN;
+
+    public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new HitimesInterval( runtime, klass );
+        }
+    };
+
+    public HitimesInterval( Ruby runtime, RubyClass klass ) {
+        super( runtime, klass );
+    }
+
+    public HitimesInterval( Ruby runtime, RubyClass klass, long start ) {
+        super( runtime, klass );
+        this.start_instant = start;
+    }
+
+
+    private long start_instant = INSTANT_NOT_SET;
+    private long stop_instant  = INSTANT_NOT_SET;
+    private double duration    = DURATION_NOT_SET;
+
+    @JRubyMethod( name = "duration", alias = { "length", "to_f", "to_seconds" } )
+    public IRubyObject duration() {
+
+        /*
+         * if start has not yet been called, then raise an exception.
+         */
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            throw Hitimes.newHitimesError( getRuntime(), "Attempt to report a duration on an interval that has not started");
+        }
+
+        /*
+         * if stop has not yet been called, then return the amount of time so far
+         */
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            double d = ( System.nanoTime() - this.start_instant ) / INSTANT_CONVERSION_FACTOR;
+            return getRuntime().newFloat( d );
+        }
+
+        /*
+         * if stop has been called, then calculate the duration and return
+         */
+        if ( DURATION_NOT_SET == this.duration ) {
+            this.duration = (this.stop_instant - this.start_instant) / INSTANT_CONVERSION_FACTOR;
+        }
+
+        return getRuntime().newFloat( this.duration );
+
+    }
+
+    @JRubyMethod( name = "duration_so_far" )
+    public IRubyObject duration_so_far() {
+        IRubyObject rc = getRuntime().getFalse();
+
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            return rc;
+        }
+
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            double d = ( System.nanoTime() - this.start_instant ) / INSTANT_CONVERSION_FACTOR;
+            return getRuntime().newFloat( d );
+        }
+
+        return rc;
+    }
+
+    @JRubyMethod( name = "started?" )
+    public IRubyObject is_started() {
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            return getRuntime().getFalse();
+        }
+        return getRuntime().getTrue();
+    }
+
+    @JRubyMethod( name = "running?" )
+    public IRubyObject is_running() {
+        if ( ( INSTANT_NOT_SET != this.start_instant ) && ( INSTANT_NOT_SET == this.stop_instant ) ) {
+            return getRuntime().getTrue();
+        }
+        return getRuntime().getFalse();
+    }
+
+    @JRubyMethod( name = "stopped?" )
+    public IRubyObject is_stopped() {
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            return getRuntime().getFalse();
+        }
+        return getRuntime().getTrue();
+    }
+
+    @JRubyMethod( name = "start_instant" )
+    public IRubyObject start_instant() {
+        return getRuntime().newFixnum( this.start_instant );
+    }
+
+    @JRubyMethod( name = "stop_instant" )
+    public IRubyObject stop_instant() {
+        return getRuntime().newFixnum( this.stop_instant );
+    }
+
+    @JRubyMethod( name = "start" )
+    public IRubyObject start() {
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            this.start_instant = System.nanoTime();
+            return getRuntime().getTrue();
+        }
+        return getRuntime().getFalse();
+    }
+
+    @JRubyMethod( name = "stop" )
+    public IRubyObject stop() {
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            throw Hitimes.newHitimesError( getRuntime(), "Attempt to stop an interval that has not started" );
+        }
+
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            this.stop_instant = System.nanoTime();
+            this.duration = (this.stop_instant - this.start_instant) / INSTANT_CONVERSION_FACTOR;
+            return getRuntime().newFloat( this.duration );
+        }
+
+        return getRuntime().getFalse();
+    }
+
+    @JRubyMethod( name = "split" )
+    public IRubyObject split() {
+        this.stop();
+        return new HitimesInterval( getRuntime(), Hitimes.hitimesIntervalClass, this.stop_instant );
+    }
+
+    @JRubyMethod( name = "now", module = true )
+    public static IRubyObject now( IRubyObject self ) {
+        return new HitimesInterval( self.getRuntime(), Hitimes.hitimesIntervalClass, System.nanoTime() );
+    }
+
+    @JRubyMethod( name = "measure", module = true, frame = true )
+    public static IRubyObject measure( IRubyObject self, Block block ) {
+
+        Ruby runtime = self.getRuntime();
+
+        if ( block.isGiven() ) {
+            IRubyObject       nil = runtime.getNil();
+            ThreadContext context = runtime.getCurrentContext();
+
+            HitimesInterval interval = new HitimesInterval( runtime, Hitimes.hitimesIntervalClass );
+
+            interval.start();
+            block.yield( context, nil );
+            interval.stop();
+
+            return interval.duration();
+        } else {
+            throw Hitimes.newHitimesError( runtime, "No block given to Interval.measure" );
+        }
+    }
+}

data/ext/hitimes/java/src/hitimes/HitimesService.java

@@ -0,0 +1,16 @@
+package hitimes;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class HitimesService implements BasicLibraryService {
+    public boolean basicLoad( final Ruby runtime ) throws IOException {
+        Hitimes.createHitimes( runtime );
+        return true;
+    }
+}
+
+

data/ext/hitimes/java/src/hitimes/HitimesStats.java

@@ -0,0 +1,112 @@
+package hitimes;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+
+import org.jruby.RubyNumeric;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ObjectAllocator;
+
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass( name = "Hitimes::Stats" )
+public class HitimesStats extends RubyObject {
+
+    private double min   = 0.0;
+    private double max   = 0.0;
+    private double sum   = 0.0;
+    private double sumsq = 0.0;
+    private long   count = 0;
+
+    public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new HitimesStats( runtime, klass );
+        }
+    };
+
+    public HitimesStats( Ruby runtime, RubyClass klass ) {
+        super( runtime, klass );
+    }
+
+    @JRubyMethod( name = "update", required = 1, argTypes = RubyNumeric.class )
+    public IRubyObject update( IRubyObject val ) {
+        double v = RubyNumeric.num2dbl( val );
+
+        if ( 0 == this.count ) {
+            this.min = this.max = v;
+        } else {
+            this.min = ( v < this.min ) ? v : this.min;
+            this.max = ( v > this.max ) ? v : this.max;
+        }
+
+        this.count += 1;
+        this.sum   += v;
+        this.sumsq += (v * v);
+
+        return val;
+    }
+
+    @JRubyMethod( name = "mean" )
+    public IRubyObject mean() {
+        double mean = 0.0;
+
+        if ( this.count > 0 ) {
+            mean = this.sum / this.count;
+        }
+
+        return getRuntime().newFloat( mean );
+    }
+
+
+    @JRubyMethod( name = "rate" )
+    public IRubyObject rate() {
+        double rate = 0.0;
+
+        if ( this.sum > 0.0 ) {
+            rate = this.count / this.sum ;
+        }
+
+        return getRuntime().newFloat( rate );
+    }
+
+    @JRubyMethod( name = "stddev" )
+    public IRubyObject stddev() {
+        double stddev = 0.0;
+
+        if ( this.count > 1 ) {
+            double sq_sum = this.sum * this.sum;
+            stddev = Math.sqrt( ( this.sumsq - ( sq_sum / this.count ) ) / ( this.count - 1 ) );
+        }
+        return getRuntime().newFloat( stddev );
+    }
+
+
+    @JRubyMethod( name = "min" )
+    public IRubyObject min() {
+        return getRuntime().newFloat( this.min );
+    }
+
+    @JRubyMethod( name = "max" )
+    public IRubyObject max() {
+        return getRuntime().newFloat( this.max );
+    }
+
+    @JRubyMethod( name = "sum" )
+    public IRubyObject sum() {
+        return getRuntime().newFloat( this.sum );
+    }
+
+    @JRubyMethod( name = "sumsq" )
+    public IRubyObject sumsq() {
+        return getRuntime().newFloat( this.sumsq );
+    }
+
+    @JRubyMethod( name = "count" )
+    public IRubyObject count() {
+        return getRuntime().newFixnum( this.count );
+    }
+}
+
+

data/lib/hitimes.rb

@@ -15,16 +15,26 @@ module Hitimes
   # Base class of all errors in Hitimes
   #
   class Error < ::StandardError; end
+
+  # Hitimes.measure { } -> Float
+  #
+  # Times the execution of the block, returning the number of seconds it took
+  def self.measure(&block)
+    Hitimes::Interval.measure(&block)
+  end
 end
 require 'hitimes/paths'
 require 'hitimes/version'
 
-if RUBY_PLATFORM == "java" then
+# 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
+begin
+  # this will be for windows
+  require "hitimes/#{RUBY_VERSION.sub(/\.\d$/,'')}/hitimes"
+rescue LoadError
+  # everyone else.
   require 'hitimes/hitimes'
-else
-  # use a version subdirectory for extensions, initially to support windows, but
-  # why make a special case.  It doesn't hurt anyone to have an extra subdir.
-  require "hitimes/#{RUBY_VERSION.sub(/\.\d$/,'')}/hitimes_ext"
 end
 
 require 'hitimes/stats'

data/lib/hitimes/version.rb

@@ -4,54 +4,5 @@
 #++
 
 module Hitimes
-  #
-  # module containing all the version information about Hitimes
-  #
-  module Version
-
-    # Major version number
-    MAJOR   = 1
-
-    # Minor version number
-    MINOR   = 1
-
-    # Build number
-    BUILD   = 1
-
-    #
-    # :call-seq:
-    #   Version.to_a -> [ MAJOR, MINOR, BUILD ]
-    #
-    # Return the version as an array of Integers
-    #
-    def self.to_a
-      [MAJOR, MINOR, BUILD]
-    end
-
-    #
-    # :call-seq:
-    #   Version.to_s -> "MAJOR.MINOR.BUILD"
-    #
-    # Return the version as a String with dotted notation
-    #
-    def self.to_s
-      to_a.join(".")
-    end
-
-    #
-    # :call-seq:
-    #   Version.to_hash -> { :major => ..., :minor => ..., :build => ... }
-    #
-    # Return the version as a Hash
-    #
-    def self.to_hash
-      { :major => MAJOR, :minor => MINOR, :build => BUILD }
-    end
-
-    # The Version in MAJOR.MINOR.BUILD dotted notation
-    STRING = Version.to_s
-  end
-
-  # The Version in MAJOR.MINOR.BUILD dotted notation
-  VERSION = Version.to_s
+  VERSION = "1.2.0"
 end