stella 0.5.3 → 0.5.4

data/vendor/hitimes-0.4.0/ext/hitimes_interval.c

@@ -0,0 +1,340 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#include "hitimes_interval.h"
+
+/* Modules and Classes -- defined here */
+VALUE cH_Interval;         /* class  Hitimes::Interval  */
+
+/**
+ * Allocator and Deallocator for Interval classes
+ */
+
+VALUE hitimes_interval_free(hitimes_interval_t* i) 
+{
+    if ( Qnil != i->duration ) {
+        rb_gc_unregister_address( &(i->duration) );
+        i->duration = Qnil;
+    }
+    xfree( i );
+    return Qnil;
+}
+
+VALUE hitimes_interval_alloc(VALUE klass)
+{
+    VALUE obj;
+    hitimes_interval_t* i = xmalloc( sizeof( hitimes_interval_t ) );
+
+    i->start_instant = 0L;
+    i->stop_instant  = 0L;
+    i->duration      = Qnil;
+
+    obj = Data_Wrap_Struct(klass, NULL, hitimes_interval_free, i);
+    return obj;
+}
+
+/**
+ * call-seq:
+ *    Interval.now -> Interval
+ *
+ * Create an interval that has already started
+ */
+VALUE hitimes_interval_now( VALUE self )
+{
+    VALUE obj;
+    hitimes_interval_t *i = xmalloc( sizeof( hitimes_interval_t ) );
+
+    i->start_instant = hitimes_get_current_instant( );
+    i->stop_instant  = 0L;
+    i->duration      = Qnil;
+
+    obj = Data_Wrap_Struct(cH_Interval, NULL, hitimes_interval_free, i);
+
+    return obj;
+}
+
+/**
+ * call-seq:
+ *    Interval.measure {  }  -> Float
+ *
+ * Times the execution of the block returning the number of seconds it took
+ */
+VALUE hitimes_interval_measure( VALUE self )
+{
+    hitimes_instant_t before;
+    hitimes_instant_t after;
+    double            duration;
+
+    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( );
+
+    duration = ( after - before ) / HITIMES_INSTANT_CONVERSION_FACTOR;
+    return rb_float_new( duration );
+}
+
+/**
+ * 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.
+ */
+VALUE hitimes_interval_split( VALUE self )
+{
+    hitimes_interval_t *first;
+    hitimes_interval_t *second = xmalloc( sizeof( hitimes_interval_t ) );
+    VALUE              obj;
+
+    Data_Get_Struct( self, hitimes_interval_t, first );
+    first->stop_instant = hitimes_get_current_instant( );
+
+    second->start_instant = first->stop_instant;
+    second->stop_instant  = 0L;
+    second->duration      = Qnil;
+
+    obj = Data_Wrap_Struct(cH_Interval, NULL, hitimes_interval_free, second);
+
+    return obj;
+}
+
+
+/**
+ * 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+.
+ */
+VALUE hitimes_interval_start( VALUE self )
+{
+    hitimes_interval_t *i;
+    VALUE               rc = Qfalse;
+
+    Data_Get_Struct( self, hitimes_interval_t, i );
+    if ( 0L == i->start_instant ) {
+      i->start_instant = hitimes_get_current_instant( );
+      i->stop_instant  = 0L;
+      i->duration      = Qnil;
+
+      rc = Qtrue;
+    }
+
+    return rc;
+}
+
+
+/**
+ * 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+.
+ */
+VALUE hitimes_interval_stop( VALUE self )
+{
+    hitimes_interval_t *i;
+    VALUE               rc = Qfalse;
+
+    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" );
+    }
+
+    if ( 0L == i->stop_instant ) {
+      double d;
+
+      i->stop_instant = hitimes_get_current_instant( );
+      d = ( i->stop_instant - i->start_instant ) / HITIMES_INSTANT_CONVERSION_FACTOR;
+      i->duration = rb_float_new( d );
+      rb_gc_register_address( &(i->duration) );
+      rc = i->duration;
+    }
+
+    return rc;
+}
+
+/**
+ * call-seq:
+ *    interval.started? -> boolean
+ *
+ * returns whether or not the interval has been started
+ */
+VALUE hitimes_interval_started( VALUE self )
+{
+    hitimes_interval_t *i;
+
+    Data_Get_Struct( self, hitimes_interval_t, i );
+
+    return ( 0L == i->start_instant ) ? Qfalse : Qtrue;
+}
+
+
+/**
+ * call-seq:
+ *    interval.stopped? -> boolean
+ *
+ * returns whether or not the interval has been stopped
+ */
+VALUE hitimes_interval_stopped( VALUE self )
+{
+    hitimes_interval_t *i;
+
+    Data_Get_Struct( self, hitimes_interval_t, i );
+
+    return ( 0L == i->stop_instant ) ? Qfalse : Qtrue;
+}
+
+/**
+ * call-seq:
+ *    interval.running? -> boolean
+ *
+ * returns whether or not the interval is running or not.  This means that it
+ * has started, but not stopped.
+ */
+VALUE hitimes_interval_running( VALUE self )
+{
+    hitimes_interval_t *i;
+    VALUE              rc = Qfalse;
+
+    Data_Get_Struct( self, hitimes_interval_t, i );
+    if ( ( 0L != i->start_instant ) && ( 0L == i->stop_instant ) ) {
+        rc = Qtrue;
+    }
+
+    return rc;
+}
+
+
+/** 
+ * call-seq:
+ *    interval.start_instant -> Integer
+ *
+ * The integer representing the start instant of the Interval.  This value
+ * is not useful on its own.  It is a platform dependent value.
+ */
+VALUE hitimes_interval_start_instant( VALUE self )
+{
+    hitimes_interval_t *i;
+
+    Data_Get_Struct( self, hitimes_interval_t, i );
+   
+    return ULL2NUM( i->start_instant );
+}
+
+
+/** 
+ * call-seq:
+ *    interval.stop_instant -> Integer
+ *
+ * The integer representing the stop instant of the Interval.  This value
+ * is not useful on its own.  It is a platform dependent value.
+ */
+VALUE hitimes_interval_stop_instant( VALUE self )
+{
+    hitimes_interval_t *i;
+
+    Data_Get_Struct( self, hitimes_interval_t, i );
+   
+    return ULL2NUM( i->stop_instant );
+}
+
+
+
+/**
+ * call-seq:
+ *    interval.duration -> 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.
+ */
+VALUE hitimes_interval_duration ( VALUE self )
+{
+    hitimes_interval_t *i;
+    double             d;
+
+    Data_Get_Struct( self, hitimes_interval_t, i );
+
+    /** 
+     * if stop has not yet been called, then return the amount of time so far
+     */
+    if ( 0L == i->stop_instant ) {
+        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
+     */
+    if ( Qnil == i->duration ) {
+        d = ( i->stop_instant - i->start_instant ) / HITIMES_INSTANT_CONVERSION_FACTOR;
+        i->duration = rb_float_new( d );
+        rb_gc_register_address( &(i->duration) );
+    }
+
+    return i->duration;
+}
+
+
+/**
+ * Document-class: Hitimes::Interval
+ *
+ * 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.
+ *
+ */
+void Init_hitimes_interval()
+{
+    mH = rb_define_module("Hitimes"); 
+   
+    cH_Interval = rb_define_class_under( mH, "Interval", rb_cObject );
+    rb_define_alloc_func( cH_Interval, hitimes_interval_alloc );
+
+    rb_define_module_function( cH_Interval, "now", hitimes_interval_now, 0 ); /* in hitimes_interval.c */
+    rb_define_module_function( cH_Interval, "measure", hitimes_interval_measure, 0 ); /* in hitimes_interval.c */
+
+    rb_define_method( cH_Interval, "to_f",         hitimes_interval_duration, 0 ); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "to_seconds",   hitimes_interval_duration, 0 ); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "duration",     hitimes_interval_duration, 0 ); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "length",       hitimes_interval_duration, 0 ); /* in hitimes_interval.c */
+     
+    rb_define_method( cH_Interval, "started?",     hitimes_interval_started, 0 ); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "running?",     hitimes_interval_running, 0 ); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "stopped?",     hitimes_interval_stopped, 0 ); /* in hitimes_interval.c */
+
+    rb_define_method( cH_Interval, "start_instant", hitimes_interval_start_instant, 0 ); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "stop_instant",  hitimes_interval_stop_instant, 0 ); /* in hitimes_interval.c */
+
+    rb_define_method( cH_Interval, "start", hitimes_interval_start, 0); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "stop",  hitimes_interval_stop, 0); /* in hitimes_interval.c */
+    rb_define_method( cH_Interval, "split",  hitimes_interval_split, 0); /* in hitimes_interval.c */
+ 
+}

data/vendor/hitimes-0.4.0/ext/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  1e9
+
+#ifdef USE_INSTANT_CLOCK_GETTIME
+#    define HITIMES_U64INT unsigned long long int
+#    define HITIMES_INSTANT_CONVERSION_FACTOR 1e9
+#elif USE_INSTANT_OSX
+#    define HITIMES_U64INT unsigned long long int
+#    define HITIMES_INSTANT_CONVERSION_FACTOR 1e9
+#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;
+    VALUE             duration;
+} hitimes_interval_t;
+
+/* all the backends must define this method */
+hitimes_instant_t hitimes_get_current_instant( );
+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 self );
+VALUE hitimes_interval_measure( VALUE self );
+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/vendor/hitimes-0.4.0/ext/hitimes_stats.c

@@ -0,0 +1,242 @@
+/**
+ * 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 ) -> nil
+ * 
+ * Update the running stats with the new value.
+ */
+VALUE hitimes_stats_update( VALUE self, VALUE v )
+{
+    double           new_v = NUM2DBL( v );
+    hitimes_stats_t *stats;
+
+    Data_Get_Struct( self, hitimes_stats_t, stats );
+
+    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 Qnil;
+}
+
+/**
+ * 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;
+    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 per seconds ( rate ) rate stat.  If no values have passed
+ * through the stats object then 0.0 is returned.
+ */
+VALUE hitimes_stats_rate( VALUE self )
+{
+    hitimes_stats_t *stats;
+    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.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;
+    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_ and _sum_ and when
+ * you want you may also retrieve the _mean_ and _stddev_.
+ *
+ * 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, "stddev", hitimes_stats_stddev, 0 ); /* in hitimes_stats.c */
+}
+ 

data/vendor/hitimes-0.4.0/ext/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 {
+    double min;
+    double max;
+    double sum;
+    double sumsq;
+    long   count;
+} hitimes_stats_t;
+
+#endif
+
+