stella 0.5.4 → 0.5.5

data/vendor/hitimes-0.4.0/examples/benchmarks.rb

@@ -1,86 +0,0 @@
-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/vendor/hitimes-0.4.0/examples/stats.rb

@@ -1,29 +0,0 @@
-#
-# 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/vendor/hitimes-0.4.0/ext/extconf.rb

@@ -1,15 +0,0 @@
-require 'rbconfig'
-require 'mkmf'
-
-if Config::CONFIG['host_os'] =~ /darwin/ then
-  $CFLAGS += " -DUSE_INSTANT_OSX=1 -Wall"
-  $LDFLAGS += " -framework CoreServices"
-elsif Config::CONFIG['host_os'] =~ /win32/ or Config::CONFIG['host_os'] =~ /mingw/ then
-  $CFLAGS += " -DUSE_INSTANT_WINDOWS=1"
-else
-  if have_library("rt", "clock_gettime") then
-    $CFLAGS += " -DUSE_INSTANT_CLOCK_GETTIME=1"
-  end
-end
-
-create_makefile('hitimes_ext')

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

@@ -1,21 +0,0 @@
-#include <ruby.h>
-#include "hitimes_interval.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/vendor/hitimes-0.4.0/ext/hitimes_instant_clock_gettime.c

@@ -1,20 +0,0 @@
-#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/vendor/hitimes-0.4.0/ext/hitimes_instant_osx.c

@@ -1,16 +0,0 @@
-#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/vendor/hitimes-0.4.0/ext/hitimes_instant_windows.c

@@ -1,27 +0,0 @@
-#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/vendor/hitimes-0.4.0/ext/hitimes_interval.c

@@ -1,340 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-/**
- * 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