channel 1.0.1

data/README

@@ -0,0 +1,52 @@
+Simple native Channel object for Ruby MRI
+  (c) 2009 Lourens Naudé (methodmissing), James Tucker (raggi) 
+ 
+  http://github.com/methodmissing/channel
+
+This library works with Ruby 1.8 and 1.9 and is a more efficient
+implementation of the following Ruby code :
+
+  class RubyChannel
+    def initialize
+      @subscribers = []
+    end
+    def subscribe(&b)
+      @subscribers << b
+      self
+    end
+    def <<(o)
+      @subscribers.each { |s| s.call(o) }
+    end
+  end
+
+Use cases :
+
+  * In process message dispatch
+  * Parsers and protocols with a message, error and warning channel 
+  * Facilitates decoupled notification and callback patterns
+
+Caveats :
+
+  * Fixed width channel size for very thin, and fast, subscriber management
+
+Examples :
+
+  counter = 0
+  ch = Channel.new.subscribe{|obj| counter += obj }
+  ch << 3
+  ch << -2
+  counter #=> 1  
+
+Todo :
+  
+  * A deferrable mode that notifies on a background thread (pending 1.9)
+  * More flexible notification mechanism through integration with http://github.com/methodmissing/callback/tree/master 
+  * Filters
+
+To run the test suite:
+
+  rake
+
+To run the benchmarks:
+
+  rake bench

data/Rakefile

@@ -0,0 +1,69 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+
+CH_ROOT = 'ext/channel'
+
+desc 'Default: test'
+task :default => :test
+
+desc 'Run channel tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs = [CH_ROOT]
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+end
+task :test => :build
+
+namespace :build do
+  file "#{CH_ROOT}/channel.c"
+  file "#{CH_ROOT}/extconf.rb"
+  file "#{CH_ROOT}/Makefile" => %W(#{CH_ROOT}/channel.c #{CH_ROOT}/extconf.rb) do
+    Dir.chdir(CH_ROOT) do
+      ruby 'extconf.rb'
+    end
+  end
+
+  desc "generate makefile"
+  task :makefile => %W(#{CH_ROOT}/Makefile #{CH_ROOT}/channel.c)
+
+  dlext = Config::CONFIG['DLEXT']
+  file "#{CH_ROOT}/channel.#{dlext}" => %W(#{CH_ROOT}/Makefile #{CH_ROOT}/channel.c) do
+    Dir.chdir(CH_ROOT) do
+      sh 'make' # TODO - is there a config for which make somewhere?
+    end
+  end
+
+  desc "compile channel extension"
+  task :compile => "#{CH_ROOT}/channel.#{dlext}"
+
+  task :clean do
+    Dir.chdir(CH_ROOT) do
+      sh 'make clean'
+    end if File.exists?("#{CH_ROOT}/Makefile")
+  end
+
+  CLEAN.include("#{CH_ROOT}/Makefile")
+  CLEAN.include("#{CH_ROOT}/channel.#{dlext}")
+end
+
+task :clean => %w(build:clean)
+
+desc "compile"
+task :build => %w(build:compile)
+
+task :install do |t|
+  Dir.chdir(CH_ROOT) do
+    sh 'sudo make install'
+  end
+end
+
+desc "clean build install"
+task :setup => %w(clean build install)
+
+desc "run benchmarks"
+task :bench do |t|
+  ruby "bench/bench.rb"
+  ruby "bench/bench_deferred.rb"    
+end
+task :bench => :build

data/bench/bench.rb

@@ -0,0 +1,15 @@
+require "benchmark"
+$:.unshift "."
+require File.dirname(__FILE__) + "/../ext/channel/channel"
+require File.dirname(__FILE__) + "/ruby_channel"
+
+channel = Channel.new(16)
+16.times{ channel.subscribe{|o| o } }
+rb_channel = RubyChannel.new(16)
+16.times{ rb_channel.subscribe{|o| o } }
+
+TESTS = 10_000
+Benchmark.bmbm do |results|
+  results.report("Channel#<<") { TESTS.times { channel << :obj } }  
+  results.report("RubyChannel#<<") { TESTS.times { rb_channel << :obj  } }
+end

data/bench/ruby_channel.rb

@@ -0,0 +1,19 @@
+class RubyChannel
+  def initialize(size = 1,defer = false)
+    @size = size
+    @subscribers = []
+    @defer = defer
+  end
+  def subscribe(&b)
+    raise ArgumentError.new("Maximum number of subscribers exceeded!") unless @subscribers.size < @size
+    @subscribers << b
+    self
+  end
+  def <<(o)
+    unless @defer
+      @subscribers.each { |s| s.call(o) }
+    else
+      Thread.new{ @subscribers.each { |s| s.call(o) } }
+    end
+  end
+end

data/channel.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name     = "channel"
+  s.version  = "1.0.1"
+  s.date     = "2009-08-28"
+  s.summary  = "Native MRI channel"
+  s.email    = "lourens@methodmissing.com"
+  s.homepage = "http://github.com/methodmissing/channel"
+  s.description = "Simple native Channel object for Ruby MRI (1.8.{6,7} and 1.9.2)"
+  s.has_rdoc = true
+  s.authors  = ["Lourens Naudé (methodmissing)","James Tucker (raggi)"]
+  s.platform = Gem::Platform::RUBY
+  s.files    = %w[
+    README
+    Rakefile
+    bench/bench.rb
+    bench/ruby_channel.rb
+    ext/channel/extconf.rb
+    ext/channel/channel.c
+    channel.gemspec
+  ] + Dir.glob('test/*')
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+  s.extensions << "ext/channel/extconf.rb"
+end

data/ext/channel/channel.c

@@ -0,0 +1,157 @@
+#include "ruby.h"
+
+typedef struct {
+    int size;
+    int defer;
+    int sbs;
+    VALUE *subscribers;
+} RChannel;
+
+typedef struct{
+  RChannel *chs;
+  VALUE *obj;
+} deferred_push_args;
+
+#define MAX_CHANNEL_SIZE 32
+#define GetChannelStruct(obj)	(Check_Type(obj, T_DATA), (RChannel*)DATA_PTR(obj))
+
+VALUE rb_cChannel;
+static ID id_call;
+
+static void mark_channel(RChannel* ch)
+{
+    int i;
+    for (i=0; i < ch->sbs; i++) {
+      rb_gc_mark(ch->subscribers[i]);
+    }
+}
+
+static void free_channel(RChannel* ch)
+{
+    xfree(ch);
+}
+
+static VALUE channel_alloc _((VALUE));
+static VALUE
+channel_alloc( VALUE klass )
+{
+    VALUE ch;
+    RChannel* chs;
+    ch = Data_Make_Struct(klass, RChannel, mark_channel, free_channel, chs);
+    chs->size = 0;
+    chs->defer = 0;
+    chs->sbs = 0;
+    chs->subscribers = 0;
+   
+    return ch;
+}
+
+static VALUE
+rb_channel_new(VALUE ch, int size, int defer)
+{
+    RChannel* chs = GetChannelStruct(ch);
+    if (size < 0 || size > MAX_CHANNEL_SIZE){ 
+      rb_raise(rb_eArgError, "Invalid channel size!");
+    }
+    if (size == 0) size++;
+    chs->size = size;
+    chs->defer = defer;
+    chs->subscribers = ALLOC_N(VALUE, size);
+    return ch;  
+}
+
+static VALUE 
+rb_channel_initialize( int argc, VALUE *argv, VALUE ch )
+{
+    VALUE size, defer;
+    int channel_size, def;  
+    rb_scan_args(argc, argv, "02", &size, &defer);
+    channel_size = NIL_P(size) ? 0 : FIX2INT(size);
+    def = (defer == Qtrue) ? 1 : 0;  
+    return rb_channel_new(ch, channel_size, def); 
+}
+
+static VALUE 
+rb_channel_size( VALUE ch )
+{
+    RChannel* chs = GetChannelStruct(ch);    
+    return INT2FIX(chs->size); 
+}
+
+static VALUE 
+rb_channel_subscribers( VALUE ch )
+{
+    RChannel* chs = GetChannelStruct(ch);    
+    return INT2FIX(chs->sbs); 
+}
+
+static VALUE 
+rb_channel_deferrable_p( VALUE ch )
+{
+    RChannel* chs = GetChannelStruct(ch);    
+    return (chs->defer == 1) ? Qtrue : Qfalse; 
+}
+
+static VALUE 
+rb_channel_subscribe( int argc, VALUE *argv, VALUE ch )
+{
+    VALUE cb;
+    RChannel* chs = GetChannelStruct(ch);    
+    if (!rb_block_given_p()) rb_raise(rb_eArgError, "Block callback required!");
+    if (chs->sbs == chs->size) rb_raise(rb_eArgError, "Maximum number of subscribers exceeded!");
+    cb = rb_block_proc();
+    chs->subscribers[chs->sbs] = cb;
+    chs->sbs++;
+    return ch;
+}
+
+static void 
+rb_channel_push0( RChannel* chs, VALUE *obj )
+{
+    int i;    
+    for (i=0; i < chs->sbs; i++) {
+      rb_funcall(chs->subscribers[i],id_call,1,*obj);
+    }  
+}
+
+static void 
+rb_channel_push1( deferred_push_args *args )
+{
+    RChannel* chs = args->chs;
+    VALUE obj = *(args->obj);
+    int i;    
+    for (i=0; i < chs->sbs; i++) {
+      rb_funcall(chs->subscribers[i],id_call,1,obj);
+    }
+}
+
+static VALUE 
+rb_channel_push( VALUE ch, VALUE obj )
+{
+    deferred_push_args args;
+    RChannel* chs = GetChannelStruct(ch);
+    if (chs->defer == 1){
+      args.chs = chs;
+      args.obj = &obj;
+      rb_thread_create(rb_channel_push1,&args);
+    }else{
+      rb_channel_push0(chs,&obj);
+    }
+    return ch;
+}
+
+void
+Init_channel()
+{ 
+    id_call = rb_intern("call");
+
+    rb_cChannel  = rb_define_class("Channel", rb_cObject);
+    rb_define_alloc_func(rb_cChannel, channel_alloc);
+    
+    rb_define_method(rb_cChannel,"initialize", rb_channel_initialize, -1);
+    rb_define_method(rb_cChannel,"size", rb_channel_size, 0);
+    rb_define_method(rb_cChannel,"subscribers", rb_channel_subscribers, 0);
+    rb_define_method(rb_cChannel,"deferrable?", rb_channel_deferrable_p, 0);
+    rb_define_method(rb_cChannel,"subscribe", rb_channel_subscribe, -1);
+    rb_define_method(rb_cChannel,"<<", rb_channel_push, 1);
+}

data/ext/channel/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+def add_define(name)
+  $defs.push("-D#{name}")
+end
+
+dir_config('channel')
+
+add_define 'RUBY19' if have_func('rb_thread_blocking_region') and have_macro('RUBY_UBF_IO', 'ruby.h')
+add_define 'RUBY18' if have_var('rb_trap_immediate', ['ruby.h', 'rubysig.h'])
+
+create_makefile('channel')

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'channel'

data/test/test_channel.rb

@@ -0,0 +1,65 @@
+$:.unshift "."
+require File.dirname(__FILE__) + '/helper'
+require 'timeout'
+
+class TestChannel < Test::Unit::TestCase
+  
+  def test_initialize
+    assert_instance_of Channel, Channel.new
+    assert_raises(ArgumentError){ Channel.new(-1)  }
+    assert_raises(ArgumentError){ Channel.new(33)  }    
+  end
+  
+  def test_initialize_deferrable
+    assert !Channel.new(10).deferrable?
+    assert Channel.new(10,true).deferrable?    
+  end
+  
+  def test_size
+    assert_equal 10, Channel.new(10).size
+  end
+  
+  def test_subscribers
+    assert_equal 0, Channel.new(10).subscribers
+  end
+  
+  def test_subscribe
+    assert_equal 1, Channel.new.subscribe{|obj| obj }.subscribers
+    assert_raises(ArgumentError){ Channel.new.subscribe }
+    assert_raises(ArgumentError){ Channel.new.subscribe(:arg) }    
+  end 
+  
+  def test_subscriber_threshold
+    ch = Channel.new(3)
+    assert_raises ArgumentError do
+      4.times{ ch.subscribe{|o| o } }
+    end
+  end
+  
+  def test_push
+    @counter = 0
+    ch = Channel.new.subscribe{|obj| @counter += obj }
+    ch << 3
+    ch << -2
+    assert_equal 1, @counter
+  end
+  
+  def test_push_deferred
+    ch = Channel.new(3).subscribe{|obj| sleep(obj) }    
+    assert_raises Timeout::Error do
+      Timeout.timeout(0.8) do
+        ch << 1
+      end
+    end  
+    ch = Channel.new(3,true).subscribe{|obj| sleep(obj) }    
+    assert_nothing_raised do
+      Timeout.timeout(0.8) do
+        ch << 1
+        ch << 2
+        ch << 3
+      end
+    end
+    ch << 0.5
+    sleep 0.7
+  end  
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: channel
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- "Lourens Naud\xC3\xA9 (methodmissing)"
+- James Tucker (raggi)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-28 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Simple native Channel object for Ruby MRI (1.8.{6,7} and 1.9.2)
+email: lourens@methodmissing.com
+executables: []
+
+extensions: 
+- ext/channel/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- bench/bench.rb
+- bench/ruby_channel.rb
+- ext/channel/extconf.rb
+- ext/channel/channel.c
+- channel.gemspec
+- test/helper.rb
+- test/test_channel.rb
+has_rdoc: true
+homepage: http://github.com/methodmissing/channel
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Native MRI channel
+test_files: []
+