itimer 3

data/README.md

@@ -0,0 +1,80 @@
+# Itimer [![Build Status](https://secure.travis-ci.org/nearbuy/ruby-itimer.png?branch=master)]
+
+Drop-in replacement for stdlib Timeout that uses POSIX interval timers instead of threads.  Not as portable but much lighter weight.  Also includes low-level wrappers for setitimer and getitimer.
+
+## Examples
+
+``` ruby
+require 'itimer'
+
+begin
+  Itimer.timeout(1) { sleep 5 }
+rescue Itimer::Timeout
+  puts 'Time expired'
+end
+```
+
+``` ruby
+require 'itimer/compat'
+
+begin
+  Timeout::timeout(1) { sleep 5 }
+rescue Timeout::Error
+  puts 'Time expired'
+end
+```
+
+``` ruby
+require 'itimer'
+
+Signal.trap('VTALRM') { raise Itimer::Timeout }
+
+begin
+  # set :real, :virtual and :prof
+  Itimer.set(:virtual, 1)
+  do\_expensive\_computation()
+rescue Itimer::Timeout
+  puts 'Execution time expired'
+end
+
+Signal.trap('ALRM') { print '.' }
+
+Itimer.set\_interval(:real, 0.5)
+do\_expensive\_computation()
+puts 'Done'
+```
+
+## Support
+
+Please report issues at https://github.com/nearbuy/ruby-itimer/issues
+
+## See Also
+
+getitimer(2), setitimer(2)
+
+## Authors
+
+* Nate Mueller ([natemueller](https://github.com/natemueller))
+
+## License
+
+Copyright (c) 2011 Nearbuy Systems
+
+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,12 @@
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('itimer_native') do |ext|
+  ext.ext_dir = 'ext'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*.rb']
+end
+
+task :test => :compile

data/ext/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+$CFLAGS = "-g -O2 -Wall -Werror"
+
+if have_header('sys/time.h')
+  create_makefile 'itimer_native'
+end

data/ext/itimer_native.c

@@ -0,0 +1,81 @@
+#include <math.h>
+#include <ruby.h>
+#include <sys/time.h>
+
+VALUE itimer_real;
+VALUE itimer_virtual;
+VALUE itimer_prof;
+
+int which_from_val(VALUE which_val) {
+  return which_val == itimer_real
+    ? ITIMER_REAL
+    : which_val == itimer_virtual
+      ? ITIMER_VIRTUAL
+      : ITIMER_PROF;
+}
+
+VALUE rb_itimer_get(VALUE self, VALUE which_val) {
+  struct itimerval value;
+  getitimer(which_from_val(which_val), &value);
+
+  return DBL2NUM(value.it_value.tv_sec + (double)value.it_value.tv_usec/1000000);
+}
+
+VALUE rb_itimer_get_interval(VALUE self, VALUE which_val) {
+  struct itimerval value;
+  getitimer(which_from_val(which_val), &value);
+
+  return DBL2NUM(value.it_interval.tv_sec + (double)value.it_interval.tv_usec/1000000);
+}
+
+VALUE rb_itimer_set(VALUE self, VALUE which_val, VALUE new_value) {
+  struct itimerval value;
+  getitimer(which_from_val(which_val), &value);
+
+  double dbl_value = NUM2DBL(new_value);
+
+  value.it_value.tv_sec = (int)floor(dbl_value);
+  value.it_value.tv_usec = (dbl_value - floor(dbl_value)) * 1000000;
+
+  int ret = setitimer(which_from_val(which_val), &value, NULL);
+  if (ret != 0) {
+    rb_sys_fail(0);
+  } else {
+    return Qtrue;
+  }
+}
+
+VALUE rb_itimer_set_interval(VALUE self, VALUE which_val, VALUE new_value) {
+  struct itimerval value;
+  getitimer(which_from_val(which_val), &value);
+
+  double dbl_value = NUM2DBL(new_value);
+
+  value.it_interval.tv_sec = (int)floor(dbl_value);
+  value.it_interval.tv_usec = (dbl_value - floor(dbl_value)) * 1000000;
+
+  if (value.it_value.tv_sec == 0 && value.it_value.tv_usec == 0) {
+    value.it_value.tv_sec = (int)floor(dbl_value);
+    value.it_value.tv_usec = (dbl_value - floor(dbl_value)) * 1000000;
+  }
+
+  int ret = setitimer(which_from_val(which_val), &value, NULL);
+  if (ret != 0) {
+    rb_sys_fail(0);
+  } else {
+    return Qtrue;
+  }
+}
+
+void Init_itimer_native(void) {
+  VALUE itimer_module = rb_const_get(rb_cObject, rb_intern("Itimer"));
+
+  rb_define_singleton_method(itimer_module, "get", rb_itimer_get, 1);
+  rb_define_singleton_method(itimer_module, "get_interval", rb_itimer_get_interval, 1);
+  rb_define_singleton_method(itimer_module, "set", rb_itimer_set, 2);
+  rb_define_singleton_method(itimer_module, "set_interval", rb_itimer_set_interval, 2);
+
+  itimer_real = ID2SYM(rb_intern("real"));
+  itimer_virtual = ID2SYM(rb_intern("virtual"));
+  itimer_prof = ID2SYM(rb_intern("prof"));
+}

data/lib/itimer.rb

@@ -0,0 +1,18 @@
+module Itimer
+  require 'itimer_native'
+
+  class Timeout < RuntimeError
+  end
+
+  def self.timeout(seconds, klass=Timeout)
+    Signal.trap 'ALRM' do
+      raise klass
+    end
+
+    set(:real, seconds)
+    ret = yield
+    set(:real, 0)
+
+    return ret
+  end
+end

data/lib/itimer/compat.rb

@@ -0,0 +1,12 @@
+require 'itimer'
+
+module Timeout
+  class Error < RuntimeError
+  end
+
+  def timeout(sec, klass=Error, &block)
+    return Itimer.timeout(sec, klass, &block)
+  end
+
+  module_function :timeout
+end

data/test/itimer.rb

@@ -0,0 +1,93 @@
+require 'itimer'
+require 'test/unit'
+require 'itimer/compat'
+
+class ItimerTest < Test::Unit::TestCase
+  def test_itimer
+    Signal.trap 'ALRM' do
+      raise Exception.new('ALRM')
+    end
+
+    Signal.trap 'VTALRM' do
+      raise Exception.new('VTALRM')
+    end
+
+    Signal.trap 'PROF' do
+      raise Exception.new('PROF')
+    end
+
+    assert_equal( 0, Itimer.get(:real) )
+    assert_equal( 0, Itimer.get(:virtual) )
+    assert_equal( 0, Itimer.get(:prof) )
+
+    assert_equal( 0, Itimer.get_interval(:real) )
+    assert_equal( 0, Itimer.get_interval(:virtual) )
+    assert_equal( 0, Itimer.get_interval(:prof) )
+
+    Itimer.set(:real, 5)
+    Itimer.set(:virtual, 4)
+    Itimer.set(:prof, 0.5)
+
+    sleep 0.5
+    assert_in_delta( 4.5, Itimer.get(:real), 0.1 )
+    assert_in_delta( 4, Itimer.get(:virtual), 0.1 )
+    assert_in_delta( 0.5, Itimer.get(:prof), 0.1 )
+
+    assert_raises( Errno::EINVAL) { Itimer.set(:real, 2**32) }
+
+    Itimer.set(:real, 0)
+    Itimer.set(:virtual, 0)
+    Itimer.set(:prof, 0)
+
+    wait_for_sig = lambda do
+      signal = nil
+      begin
+        sleep 2
+      rescue Exception
+        signal = $!.message
+      end
+
+      signal
+    end
+
+    start = Time.now
+    Itimer.set(:real, 1)
+    assert_equal( 'ALRM', wait_for_sig.call )
+    assert_in_delta( Time.now-start, 1, 0.1 )
+
+    start = Time.now
+    Itimer.set_interval(:real, 1.2)
+    Itimer.set(:real, 0.5)
+    assert_in_delta( 1.2, Itimer.get_interval(:real), 0.1 )
+    assert_equal( 'ALRM', wait_for_sig.call )
+    assert_in_delta( Time.now-start, 0.5, 0.1 )
+    assert_in_delta( Itimer.get(:real), 1.2, 0.1 )
+
+    start = Time.now
+    assert_equal( 'ALRM', wait_for_sig.call )
+    assert_in_delta( Time.now-start, 1.2, 0.1 )
+    Itimer.set_interval(:real, 0)
+  end
+
+  def test_timeout
+    start = Time.now
+    assert_raises( Itimer::Timeout ) do
+      Itimer.timeout(1) { sleep 5 }
+    end
+    assert_in_delta( Time.now-start, 1, 0.1 )
+
+    start = Time.now
+    assert_raises( RuntimeError ) do
+      Itimer.timeout(0.25, RuntimeError) { sleep 5 }
+    end
+    assert_in_delta( Time.now-start, 0.25, 0.1 )
+  end
+
+  def test_compat
+    start = Time.now
+    assert_raises( Timeout::Error ) do
+      Timeout::timeout(0.25) { sleep 5 }
+    end
+    assert_in_delta( Time.now-start, 0.25, 0.1 )
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: itimer
+version: !ruby/object:Gem::Version
+  version: '3'
+  prerelease: 
+platform: ruby
+authors:
+- Nate Mueller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-10 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &70188994886360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70188994886360
+description: Drop-in replacement for stdlib Timeout that uses POSIX interval timers
+  instead of threads.  Not as portable but much lighter weight.  Also includes low-level
+  wrappers for setitimer and getitimer.
+email: hackers@nearbuysystems.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/itimer.rb
+- lib/itimer/compat.rb
+- test/itimer.rb
+- ext/extconf.rb
+- ext/itimer_native.c
+homepage: http://github.com/nearbuy/ruby-itimer
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Timeout replacement using POSIX interval timers
+test_files: []