hitimes 1.3.0-x64-mingw32

data/ext/hitimes/c/hitimes_interval.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#ifndef __HITIMES_INTERVAL_H__
+#define __HITIMES_INTERVAL_H__
+
+#include <ruby.h>
+
+#define NANOSECONDS_PER_SECOND  1e9l
+
+#ifdef USE_INSTANT_CLOCK_GETTIME
+#    define HITIMES_U64INT unsigned long long int
+#    define HITIMES_INSTANT_CONVERSION_FACTOR 1e9l
+#elif USE_INSTANT_OSX
+#    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()
+#else
+#    error "Unable to build hitimes, no Instance backend available"
+#endif
+
+
+/* an alias for a 64bit unsigned integer.  The various sytem dependenent
+ * files must define hitimes_u64int_t 
+ */
+typedef HITIMES_U64INT hitimes_instant_t;
+
+typedef struct hitimes_interval {
+    hitimes_instant_t start_instant;
+    hitimes_instant_t stop_instant;
+    long double       duration;
+} hitimes_interval_t;
+
+/* all the backends must define these methods */
+hitimes_instant_t hitimes_get_current_instant( );
+long double hitimes_instant_conversion_factor( );
+
+/* init methods */
+void Init_hitimes_stats();
+void Init_hitimes_interval();
+
+
+/* Module and Classes -- defined at the top level */
+extern VALUE mH;           /* module Hitimes            */
+extern VALUE eH_Error;     /* class  Hitimes::Error     */
+extern VALUE cH_Interval;  /* class  Hitimes::Interval  */
+
+
+/**
+ * Methods for Interval
+ */
+
+VALUE hitimes_interval_free(hitimes_interval_t* i) ;
+VALUE hitimes_interval_alloc(VALUE klass);
+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 );
+VALUE hitimes_interval_started( VALUE self );
+VALUE hitimes_interval_stopped( VALUE self );
+VALUE hitimes_interval_running( VALUE self );
+VALUE hitimes_interval_start_instant( VALUE self );
+VALUE hitimes_interval_stop_instant( VALUE self );
+VALUE hitimes_interval_duration ( VALUE self );
+
+#endif

data/ext/hitimes/c/hitimes_stats.c

@@ -0,0 +1,269 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#include "hitimes_stats.h"
+
+/* classes defined here */
+VALUE cH_Stats;         /* Hitimes::Stats */
+
+/**
+ * Allocator and Deallocator for Stats classes
+ */
+
+VALUE hitimes_stats_free(hitimes_stats_t* s) 
+{
+    xfree( s );
+    return Qnil;
+}
+
+VALUE hitimes_stats_alloc(VALUE klass)
+{
+    VALUE obj;
+    hitimes_stats_t* s = xmalloc( sizeof( hitimes_stats_t ) );
+
+    s->min = 0.0;
+    s->max = 0.0;
+    s->count = 0;
+    s->sum = 0.0;
+    s->sumsq = 0.0;
+
+    obj = Data_Wrap_Struct(klass, NULL, hitimes_stats_free, s);
+
+    return obj;
+}
+
+
+/**
+ * call-seq:
+ *    stat.update( val ) -> val
+ * 
+ * Update the running stats with the new value.
+ * Return the input value.
+ */
+VALUE hitimes_stats_update( VALUE self, VALUE v )
+{
+    long double      new_v;
+    hitimes_stats_t *stats;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+    new_v = NUM2DBL( v );
+
+    if ( 0 == stats->count ) {
+      stats->min = new_v;
+      stats->max = new_v;
+    } else {
+      stats->min = ( new_v < stats->min) ? ( new_v ) : ( stats->min );
+      stats->max = ( new_v > stats->max) ? ( new_v ) : ( stats->max );
+    }
+
+    stats->count += 1;
+    stats->sum   += new_v;
+    stats->sumsq += ( new_v * new_v );
+
+    return v;
+}
+
+/**
+ * call-seq:
+ *    stat.mean -> Float
+ * 
+ * Return the arithmetic mean of the values put into the Stats object.  If no
+ * values have passed through the stats object then 0.0 is returned;
+ */
+VALUE hitimes_stats_mean( VALUE self )
+{
+    hitimes_stats_t *stats;
+    long double      mean = 0.0;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    if ( stats->count > 0 ) {
+      mean = stats->sum / stats->count ;
+    }
+
+    return rb_float_new( mean );
+}
+
+
+/**
+ * call-seq:
+ *    stat.rate -> Float
+ * 
+ * Return the +count+ divided by +sum+.
+ *
+ * In many cases when Stats#update( _value_ ) is called, the _value_ is a unit
+ * of time, typically seconds or microseconds.  #rate is a convenience for those
+ * times.  In this case, where _value_ is a unit if time, then count divided by
+ * sum is a useful value, i.e. +something per unit of time+.
+ *
+ * In the case where _value_ is a non-time related value, then the value
+ * returned by _rate_ is not really useful.
+ *
+ */
+VALUE hitimes_stats_rate( VALUE self )
+{
+    hitimes_stats_t *stats;
+    long double      rate = 0.0;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    if ( stats->sum > 0.0 ) {
+      rate = stats->count / stats->sum;
+    }
+
+    return rb_float_new( rate );
+}
+
+
+/**
+ * call-seq:
+ *    stat.max -> Float
+ * 
+ * Return the maximum value that has passed through the Stats object
+ */
+VALUE hitimes_stats_max( VALUE self )
+{
+    hitimes_stats_t *stats;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    return rb_float_new( stats->max );
+}
+
+
+
+/**
+ * call-seq:
+ *    stat.min  -> Float
+ * 
+ * Return the minimum value that has passed through the Stats object
+ */
+VALUE hitimes_stats_min( VALUE self )
+{
+    hitimes_stats_t *stats;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    return rb_float_new( stats->min );
+}
+
+
+/**
+ * call-seq:
+ *    stat.count -> Integer
+ * 
+ * Return the number of values that have passed through the Stats object.
+ */
+VALUE hitimes_stats_count( VALUE self )
+{
+    hitimes_stats_t *stats;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    return LONG2NUM( stats->count );
+}
+
+
+/**
+ * call-seq:
+ *    stat.sum -> Float
+ * 
+ * Return the sum of all the values that have passed through the Stats object.
+ */
+VALUE hitimes_stats_sum( VALUE self )
+{
+    hitimes_stats_t *stats;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    return rb_float_new( stats->sum );
+}
+
+/**
+ * call-seq:
+ *   stat.sumsq -> Float
+ *
+ * Return the sum of the squars of all the values that passed through the Stats
+ * object.
+ */
+VALUE hitimes_stats_sumsq( VALUE self )
+{
+    hitimes_stats_t *stats;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    return rb_float_new( stats->sumsq );
+}
+
+
+/**
+ * call-seq:
+ *    stat.stddev -> Float
+ * 
+ * Return the standard deviation of all the values that have passed through the
+ * Stats object.  The standard deviation has no meaning unless the count is > 1,
+ * therefore if the current _stat.count_ is < 1 then 0.0 will be returned;
+ */
+VALUE hitimes_stats_stddev ( VALUE self )
+{
+    hitimes_stats_t *stats;
+    long double     stddev = 0.0;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+    if ( stats->count > 1 ) {
+      stddev = sqrt( ( stats->sumsq - ( stats->sum * stats->sum  / stats->count ) ) / ( stats->count - 1 ) );
+    }
+
+    return rb_float_new( stddev );
+}
+
+
+/**
+ * Document-class: Hitimes::Stats
+ *
+ * The Stats class encapulsates capturing and reporting statistics.  It is
+ * modeled after the RFuzz::Sampler class, but implemented in C.  For general use
+ * you allocate a new Stats object, and then update it with new values.  The
+ * Stats object will keep track of the _min_, _max_, _count_, _sum_ and _sumsq_ 
+ * and when you want you may also retrieve the _mean_, _stddev_ and _rate_.
+ *
+ * this contrived example shows getting a list of all the files in a directory
+ * and running stats on file sizes.
+ *
+ *     s = Hitimes::Stats.new
+ *     dir = ARGV.shift || Dir.pwd
+ *     Dir.entries( dir ).each do |entry|
+ *       fs = File.stat( entry )
+ *       if fs.file? then
+ *         s.update( fs.size )
+ *        end
+ *     end
+ *
+ *     %w[ count min max mean sum stddev rate ].each do |m|
+ *       puts "#{m.rjust(6)} : #{s.send( m ) }"
+ *     end
+ */
+void Init_hitimes_stats()
+{
+
+    mH = rb_define_module("Hitimes"); 
+
+    cH_Stats = rb_define_class_under( mH, "Stats", rb_cObject ); /* in hitimes_stats.c */
+    rb_define_alloc_func( cH_Stats, hitimes_stats_alloc );
+
+    rb_define_method( cH_Stats, "update", hitimes_stats_update, 1 ); /* in hitimes_stats.c */
+    
+    rb_define_method( cH_Stats, "count", hitimes_stats_count, 0 ); /* in hitimes_stats.c */
+    rb_define_method( cH_Stats, "max", hitimes_stats_max, 0 ); /* in hitimes_stats.c */
+    rb_define_method( cH_Stats, "mean", hitimes_stats_mean, 0 ); /* in hitimes_stats.c */
+    rb_define_method( cH_Stats, "min", hitimes_stats_min, 0 ); /* in hitimes_stats.c */
+    rb_define_method( cH_Stats, "rate", hitimes_stats_rate, 0 ); /* in hitimes_stats.c */
+    rb_define_method( cH_Stats, "sum", hitimes_stats_sum, 0 ); /* in hitimes_stats.c */
+    rb_define_method( cH_Stats, "sumsq", hitimes_stats_sumsq, 0 ); /* in hitimes_stats.c */
+    rb_define_method( cH_Stats, "stddev", hitimes_stats_stddev, 0 ); /* in hitimes_stats.c */
+}
+ 

data/ext/hitimes/c/hitimes_stats.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#ifndef __HITIMES_STATS_H__
+#define __HITIMES_STATS_H__
+
+#include <ruby.h>
+#include <math.h>
+
+/* classes and modules defined elswhere */
+extern VALUE mH;        /* Hitimes */
+extern VALUE eH_Error;  /* Hitimes::Error */
+extern VALUE cH_Stats;  /* Hitimes::Stats */
+
+
+typedef struct hitimes_stats {
+    long double min;
+    long double max;
+    long double sum;
+    long double sumsq;
+    long long   count;
+} hitimes_stats_t;
+
+#endif
+
+

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

@@ -0,0 +1,66 @@
+package hitimes;
+
+import java.lang.Math;
+import java.lang.System;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.anno.JRubyConstant;
+import org.jruby.runtime.Visibility;
+
+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;
+
+import org.jruby.runtime.builtin.IRubyObject;
+
+
+/**
+ * @author <a href="mailto:jeremy@hinegardner.org">Jeremy Hinegardner</a>
+ */
+@JRubyModule( name = "Hitimes" )
+public class Hitimes {
+
+    public static final double INSTANT_CONVERSION_FACTOR = 1000000000d;
+
+    private static final Ruby __ruby__ = Ruby.getGlobalRuntime();
+
+    public static RubyClass hitimesIntervalClass;
+    /**
+     * Create the Hitimes module and add it to the Ruby runtime.
+     */
+    public static RubyModule createHitimesModule( Ruby runtime ) {
+        RubyModule mHitimes = runtime.defineModule("Hitimes");
+        mHitimes.defineConstant("INSTANT_CONVERSION_FACTOR", __ruby__.newFloat(INSTANT_CONVERSION_FACTOR));
+        mHitimes.defineAnnotatedMethods( Hitimes.class );
+
+        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 );
+    }
+
+
+    @JRubyMethod( name = "raw_instant", module = true )
+    public static IRubyObject rawInstant(IRubyObject self) {
+      return __ruby__.newFixnum( System.nanoTime() );
+    }
+
+}

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

@@ -0,0 +1,176 @@
+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 {
+
+    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 ) / Hitimes.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) / Hitimes.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 ) / Hitimes.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) / Hitimes.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" );
+        }
+    }
+}