hitimes 1.1.1-x86-mingw32 → 1.2.2-x86-mingw32

data/ext/hitimes/c/extconf.rb

@@ -0,0 +1,24 @@
+require 'rbconfig'
+require 'mkmf'
+
+if RbConfig::CONFIG['host_os'] =~ /darwin/ then
+  $CFLAGS += " -DUSE_INSTANT_OSX=1 -Wall"
+  $LDFLAGS += " -framework CoreServices"
+elsif RbConfig::CONFIG['host_os'] =~ /win32/ or RbConfig::CONFIG['host_os'] =~ /mingw/ then
+  $CFLAGS += " -DUSE_INSTANT_WINDOWS=1"
+else
+  if have_library("rt", "clock_gettime") then
+    $CFLAGS += " -DUSE_INSTANT_CLOCK_GETTIME=1"
+  elsif have_library("c", "clock_gettime") then
+    $CFLAGS += " -DUSE_INSTANT_CLOCK_GETTIME=1"
+  else
+    raise NotImplementedError, <<-_
+Unable to find the function 'clock_gettime' in either libc or librt.
+Please file an issue at https://github.com/copiousfreetime/hitimes.
+_
+  end
+end
+
+# put in a different location if on windows so we can have fat binaries
+subdir = RUBY_VERSION.gsub(/\.\d$/,'')
+create_makefile("hitimes/#{subdir}/hitimes")

data/ext/hitimes/{hitimes_ext.c → c/hitimes.c}

@@ -10,7 +10,7 @@ VALUE eH_Error;     /* class  Hitimes::Error     */
  *
  * General error class for the Hitimes module
  */
-void Init_hitimes_ext( )
+void Init_hitimes( )
 {
     mH = rb_define_module("Hitimes");
      

data/ext/hitimes/c/hitimes_instant_osx.c

@@ -0,0 +1,45 @@
+#ifdef USE_INSTANT_OSX
+
+#include "hitimes_interval.h"
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+
+/* All this OSX code is adapted from http://developer.apple.com/library/mac/#qa/qa1398/_index.html */
+
+/*
+ * returns the conversion factor, this value is used to convert
+ * the value from hitimes_get_current_instant() into seconds
+ */
+long double hitimes_instant_conversion_factor()
+{
+    static mach_timebase_info_data_t  s_timebase_info;
+    static long double                conversion_factor;
+    static uint64_t                   nano_conversion;
+
+    /**
+     * If this is the first time we've run, get the timebase.
+     * We can use denom == 0 to indicate that s_timebase_info is
+     * uninitialised because it makes no sense to have a zero
+     * denominator is a fraction.
+     */
+
+    if ( s_timebase_info.denom == 0 ) {
+        mach_timebase_info(&s_timebase_info);
+        nano_conversion   = s_timebase_info.numer / s_timebase_info.denom;
+        conversion_factor = (long double) (nano_conversion) * (1e9l);
+    }
+
+    return conversion_factor;
+}
+
+/*
+ * returns the mach absolute time, which has no meaning outside of a conversion
+ * factor.
+ */
+hitimes_instant_t hitimes_get_current_instant()
+{
+    return mach_absolute_time();
+}
+
+
+#endif

data/ext/hitimes/{hitimes_interval.c → c/hitimes_interval.c}

@@ -39,7 +39,7 @@ VALUE hitimes_interval_alloc(VALUE klass)
  *
  * Create an interval that has already started
  */
-VALUE hitimes_interval_now( VALUE self )
+VALUE hitimes_interval_now( )
 {
     VALUE obj;
     hitimes_interval_t *i = xmalloc( sizeof( hitimes_interval_t ) );
@@ -59,7 +59,7 @@ VALUE hitimes_interval_now( VALUE self )
  *
  * Times the execution of the block returning the number of seconds it took
  */
-VALUE hitimes_interval_measure( VALUE self )
+VALUE hitimes_interval_measure( )
 {
     hitimes_instant_t before;
     hitimes_instant_t after;
@@ -68,7 +68,7 @@ VALUE hitimes_interval_measure( VALUE self )
     if ( !rb_block_given_p() ) {
         rb_raise(eH_Error, "No block given to Interval.measure" );
     }
-    
+
     before = hitimes_get_current_instant( );
     rb_yield( Qnil );
     after  = hitimes_get_current_instant( );
@@ -105,7 +105,7 @@ VALUE hitimes_interval_split( VALUE self )
 
 /**
  * call-seq:
- *    interval.start -> boolean 
+ *    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
@@ -144,7 +144,7 @@ VALUE hitimes_interval_stop( VALUE self )
 
     Data_Get_Struct( self, hitimes_interval_t, i );
     if ( 0L == i->start_instant )  {
-        rb_raise(eH_Error, "Attempt to stop an interval that has not started.\n" );
+        rb_raise(eH_Error, "Attempt to stop an interval that has not started" );
     }
 
     if ( 0L == i->stop_instant ) {
@@ -281,6 +281,8 @@ VALUE hitimes_interval_stop_instant( VALUE self )
  * 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.
  */
 VALUE hitimes_interval_duration ( VALUE self )
 {
@@ -288,7 +290,13 @@ VALUE hitimes_interval_duration ( VALUE self )
 
     Data_Get_Struct( self, hitimes_interval_t, i );
 
-    /** 
+    /* raise an error if the internval is not started */
+    if ( 0L == i->start_instant )  {
+        rb_raise(eH_Error, "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 ( 0L == i->stop_instant ) {
@@ -296,7 +304,7 @@ VALUE hitimes_interval_duration ( VALUE self )
         hitimes_instant_t now = hitimes_get_current_instant( );
         d = ( now - i->start_instant ) / HITIMES_INSTANT_CONVERSION_FACTOR;
         return rb_float_new( d );
-    } 
+    }
 
     /*
      * stop has been called, calculate the duration and save the result

data/ext/hitimes/{hitimes_interval.h → c/hitimes_interval.h}

@@ -16,8 +16,8 @@
 #    define HITIMES_U64INT unsigned long long int
 #    define HITIMES_INSTANT_CONVERSION_FACTOR 1e9l
 #elif USE_INSTANT_OSX
-#    define HITIMES_U64INT unsigned long long int
-#    define HITIMES_INSTANT_CONVERSION_FACTOR 1e9l
+#    define HITIMES_U64INT uint64_t
+#    define HITIMES_INSTANT_CONVERSION_FACTOR hitimes_instant_conversion_factor()
 #elif USE_INSTANT_WINDOWS
 #    define HITIMES_U64INT unsigned __int64
 #    define HITIMES_INSTANT_CONVERSION_FACTOR hitimes_instant_conversion_factor()
@@ -37,7 +37,7 @@ typedef struct hitimes_interval {
     long double       duration;
 } hitimes_interval_t;
 
-/* all the backends must define this method */
+/* all the backends must define these methods */
 hitimes_instant_t hitimes_get_current_instant( );
 long double hitimes_instant_conversion_factor( );
 
@@ -58,8 +58,8 @@ extern VALUE cH_Interval;  /* class  Hitimes::Interval  */
 
 VALUE hitimes_interval_free(hitimes_interval_t* i) ;
 VALUE hitimes_interval_alloc(VALUE klass);
-VALUE hitimes_interval_now( VALUE self );
-VALUE hitimes_interval_measure( VALUE self );
+VALUE hitimes_interval_now( );
+VALUE hitimes_interval_measure( );
 VALUE hitimes_interval_split( VALUE self );
 VALUE hitimes_interval_start( VALUE self );
 VALUE hitimes_interval_stop( VALUE self );

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;
+    }
+}
+
+