hitimes 0.2.0

data/HISTORY

@@ -0,0 +1,9 @@
+= Changelog
+== Version 0.2.0
+
+* Performance improvements
+* Added Stats class
+
+== Version 0.1.0
+
+* Initial completion

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Jeremy Hinegardner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -0,0 +1,74 @@
+== hitimes
+
+* Homepage[http://copiousfreetime.rubyforge.org/hitimes] 
+* {Rubyforge project}[http://rubyforge.org/projects/copiousfreetime/]
+* email jeremy at copiousfreetime dot org
+* git clone url git://github.com/copiousfreetime/hitimes.git
+
+== INSTALL
+
+* gem install hitimes
+
+== DESCRIPTION
+
+Hitimes is a fast, high resolution timer library for recording performance
+metrics.  It uses the appropriate C method calls for each system to get the
+highest granularity time increments possible.  
+
+It currently supports any system with the POSIX call clock_gettime() and OSX.
+Windows is in the works.
+
+Using Hitimes can be faster than using a series of Time.new calls, and it will
+have a much higher granularity.   It is definitely faster than using
+Process.times. 
+
+== SYNOPSIS
+
+Use Hitimes::Interval to calculate only the duration of a block of code
+
+  duration = Hitimes::Interval.measure do
+               # some operation ...
+             end
+
+  puts duration   
+
+Use a Hitimes::Timer to calculate statistics about an iterative operation
+
+  timer = Hitimes::Timer.new
+  collection.each do |item|
+    timer.start
+    # .. do something with item
+    timer.stop
+  end
+
+  puts timer.mean
+  puts timer.median
+  puts timer.max
+  puts timer.min
+  puts timer.stddev
+
+== CREDITS
+
+* Bruce Williams for suggesting the idea
+
+== MIT LICENSE
+
+Copyright (c) 2008 Jeremy Hinegardner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,63 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+#-------------------------------------------------------------------------------
+# make sure our project's top level directory and the lib directory are added to
+# the ruby search path.
+#-------------------------------------------------------------------------------
+$: << File.expand_path(File.join(File.dirname(__FILE__),"ext"))
+$: << File.expand_path(File.join(File.dirname(__FILE__),"lib"))
+$: << File.expand_path(File.dirname(__FILE__))
+
+
+#-------------------------------------------------------------------------------
+# load the global project configuration and add in the top level clean and
+# clobber tasks so that other tasks can utilize those constants if necessary
+# This loads up the defaults for the whole project configuration
+#-------------------------------------------------------------------------------
+require 'rubygems'
+require 'tasks/config.rb'
+require 'rake/clean'
+
+#-------------------------------------------------------------------------------
+# Main configuration for the project, these overwrite the items that are in
+# tasks/config.rb
+#-------------------------------------------------------------------------------
+require 'hitimes/version'
+require 'hitimes/paths'
+
+Configuration.for("project") {
+  name      "hitimes"
+  version   Hitimes::VERSION
+  author    "Jeremy Hinegardner"
+  email     "jeremy@copiousfreetime.org"
+  homepage  "http://copiousfreetime.rubyforge.org/hitimes/"
+}
+
+#-------------------------------------------------------------------------------
+# load up all the project tasks and setup the default task to be the
+# test:default task.
+#-------------------------------------------------------------------------------
+Configuration.for("packaging").files.tasks.each do |tasklib|
+  import tasklib
+end
+task :default => 'test:default'
+
+#-------------------------------------------------------------------------------
+# Finalize the loading of all pending imports and update the top level clobber
+# task to depend on all possible sub-level tasks that have a name like
+# ':clobber'  in other namespaces.  This allows us to say:
+#
+#   rake clobber
+#
+# and it will get everything.
+#-------------------------------------------------------------------------------
+Rake.application.load_imports
+Rake.application.tasks.each do |t| 
+  if t.name =~ /:clobber/ then
+    task :clobber => [t.name] 
+  end 
+end
+

data/examples/benchmarks.rb

@@ -0,0 +1,86 @@
+require 'benchmark'
+require 'time'
+
+#
+# this is all here in case this example is run from the examples directory
+#
+begin
+  require 'hitimes'
+rescue LoadError => le
+  ext_path = File.expand_path( File.join( File.dirname( __FILE__ ), "..", "ext" ) )
+  lib_path = File.expand_path( File.join( File.dirname( __FILE__ ), "..", "lib" ) )
+  if $:.include?( ext_path ) then
+    raise le
+  end
+  $: << ext_path
+  $: << lib_path
+  retry
+end
+
+#----------------------------------------------------------------------
+# test program to look at the performance sampling time durations using
+# different methods
+#----------------------------------------------------------------------
+
+include Benchmark
+
+#
+# Normal apprach to Interval usage
+#
+def hitimes_duration_i1
+  i = Hitimes::Interval.new
+  i.start
+  i.stop
+end
+
+#
+# Use the easy access method to start stop an interval
+#
+def hitimes_duration_i2
+  Hitimes::Interval.now.stop
+end
+
+#
+# Use a new timer each time
+#
+def hitimes_duration_t1
+  Hitimes::Timer.now.stop
+end
+
+#
+# reuse the same timer over and over
+#
+HT = Hitimes::Timer.new
+def hitimes_duration_t2
+  HT.start
+  HT.stop
+end
+
+#
+# use the Struct::Tms values and return  the difference in User time between 2 
+# successive calls
+#
+def process_duration
+  t1 = Process.times.utime
+  Process.times.utime - t1
+end
+
+#
+# Take 2 times and subtract one from the other
+#
+def time_duration
+  t1 = Time.now.to_f
+  Time.now.to_f - t1
+end
+  
+
+puts "Testing time sampling 100,000 times"
+
+bm(20) do |x|
+  x.report("Process")              { 100_000.times { process_duration } }
+  x.report("Time")                 { 100_000.times { time_duration    } }
+  x.report("Hitimes::Timer 1")     { 100_000.times { hitimes_duration_t1 } }
+  x.report("Hitimes::Timer 2")     { 100_000.times { hitimes_duration_t2 } }
+  x.report("Hitimes::Interval 1")  { 100_000.times { hitimes_duration_i1 } }
+  x.report("Hitimes::Interval 2")  { 100_000.times { hitimes_duration_i2 } }
+end

data/examples/stats.rb

@@ -0,0 +1,29 @@
+#
+# this is all here in case this example is run from the examples directory
+#
+begin
+  require 'hitimes'
+rescue LoadError => le
+  %w[ ext lib ].each do |p|
+    path = File.expand_path( File.join( File.dirname( __FILE__ ), "..", p ) )
+    if $:.include?( path ) then
+      raise le
+    end
+    $: << path
+  end
+  retry
+end
+
+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 ].each do |m|
+  puts "#{m.rjust(6)} : #{s.send( m ) }"
+end
+

data/ext/hitimes_ext.c

@@ -0,0 +1,20 @@
+#include <ruby.h>
+
+/* Module and Classes */
+VALUE mH;           /* module Hitimes            */
+VALUE eH_Error;     /* class  Hitimes::Error     */
+
+/*
+ * Document-class: Hitimes::Error
+ *
+ * General error class for the Hitimes module
+ */
+void Init_hitimes_ext( )
+{
+    mH = rb_define_module("Hitimes");
+     
+    eH_Error = rb_define_class_under(mH, "Error", rb_eStandardError);
+
+    Init_hitimes_interval();
+    Init_hitimes_stats( );
+}

data/ext/hitimes_instant_clock_gettime.c

@@ -0,0 +1,20 @@
+#ifdef USE_INSTANT_CLOCK_GETTIME
+
+#include "hitimes_interval.h"
+
+#include <sys/time.h>
+
+hitimes_instant_t hitimes_get_current_instant( )
+{
+    struct timespec time;
+    int rc;
+
+    rc = clock_gettime( CLOCK_MONOTONIC, &time);
+    if ( 0 != rc )  {
+        char* e = strerror( rc );
+        rb_raise(eH_Error, "Unable to retrieve time for CLOCK_MONOTONIC :  %s", e );
+    }
+
+    return ( ( NANOSECONDS_PER_SECOND * (long)time.tv_sec ) + time.tv_nsec );
+}
+#endif

data/ext/hitimes_instant_osx.c

@@ -0,0 +1,16 @@
+#ifdef USE_INSTANT_OSX
+
+#include "hitimes_interval.h"
+#include <CoreServices/CoreServices.h>
+
+/* 
+ * returns the number of nanoseconds since the machine was booted
+ */
+hitimes_instant_t hitimes_get_current_instant( )
+{
+    Nanoseconds  nano    = AbsoluteToNanoseconds( UpTime() );
+
+    return *( hitimes_instant_t *)&nano;
+}
+
+#endif

data/ext/hitimes_instant_windows.c

@@ -0,0 +1,27 @@
+#ifdef USE_INSTANT_WINDOWS
+
+#include "hitimes_interval.h"
+
+
+/*
+ * returns the conversion factor, this value is used to convert
+ * the value from hitimes_get_current_instant() into seconds
+ */
+double hitimes_instant_conversion_factor()
+{
+    LARGE_INTEGER ticks_per_second;
+    QueryPerformanceFrequency( &ticks_per_second );
+    return (double)ticks_per_second.QuadPart;
+}
+
+/*
+ * returns the number of ticks
+ */
+hitimes_instant_t hitimes_get_current_instant()
+{
+    LARGE_INTEGER tick;
+    QueryPerformanceCounter(&tick);
+    return (hitimes_instant_t)tick.QuadPart;
+}
+
+#endif

data/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 */
+ 
+}