mame-threadfiber 1.0.0

data/History.txt

@@ -0,0 +1,3 @@
+=== 1.0.0 / 2008-08-24
+
+* first release.

data/Manifest.txt

@@ -0,0 +1,6 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/threadfiber.rb
+test/test_threadfiber.rb

data/README.txt

@@ -0,0 +1,36 @@
+= threadfiber
+
+* http://github.com/mame/threadfiber/tree/master
+
+== DESCRIPTION:
+
+ThreadFiber is an implementation of fiber using threads.
+
+== FEATURES/PROBLEMS:
+
+
+== SYNOPSIS:
+
+require "threadfiber"
+
+f = ThreadFiber.new do
+  p :foo
+  Fiber.yield
+  p :bar
+end
+
+f.resume  #=> :foo
+f.resume  #=> :bar
+
+== REQUIREMENTS:
+
+None
+
+== INSTALL:
+
+* gem install mame-threadfiber
+
+== LICENSE:
+
+Copyright:: Yusuke Endoh <mame@tsg.ne.jp>
+License:: Ruby's

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/threadfiber.rb'
+
+Hoe.new('threadfiber', ThreadFiber::VERSION) do |p|
+  p.rubyforge_name = 'threadfiberx' # if different than lowercase project name
+  p.developer('Yusuke Endoh', 'mame@tsg.ne.jp')
+end
+
+# vim: syntax=Ruby

data/lib/threadfiber.rb

@@ -0,0 +1,94 @@
+require "thread"
+
+class ThreadFiber
+  VERSION = "1.0.0"
+
+  @@fibers = {}
+
+  def initialize(&block)
+    unless block_given?
+      raise(ArgumentError, "tried to create Fiber without a block")
+    end
+
+    @resume_mutex = Mutex.new
+    @switch_mutex = Mutex.new
+    @switch_cond = ConditionVariable.new
+    @arg, @exception, @dead = nil, nil, false
+    @switch_mutex.synchronize do
+      th = Thread.new do
+        arg, exc = call_block(switch, &block)
+        @switch_mutex.synchronize do
+          @arg, @exception, @dead = arg, exc, true
+          @switch_cond.signal
+        end
+        @@fibers.delete(Thread.current)
+      end
+      @@fibers[th] = self
+      @switch_cond.wait(@switch_mutex)
+    end
+  end
+
+  def call_block(arg, &block)
+    [yield(arg), nil]
+  rescue ThreadError
+    case $!.message
+    when "return can't jump across threads"
+      [nil, LocalJumpError.new("unexpected return")]
+    when /\Auncaught throw/
+      [nil, ArgumentError.new($!.message)]
+    else
+      [nil, $!]
+    end
+  rescue Exception
+    [nil, $!]
+  end
+
+  def switch(*args)
+    @switch_mutex.synchronize do
+      raise(FiberError, "dead fiber called") if @dead
+      @arg = args.size <= 1 ? args.first : args
+      @switch_cond.signal
+      @switch_cond.wait(@switch_mutex)
+      raise @exception if @exception
+      @arg
+    end
+  end
+
+  def resume(*args)
+    if @resume_mutex.try_lock
+      begin
+        switch(*args)
+      ensure
+        @resume_mutex.unlock
+      end
+    else
+      raise(FiberError, "double resume")
+    end
+  end
+
+  def resume_wait(*args)
+    @resume_mutex.synchronize { switch(*args) }
+  end
+
+  def self.yield(*args)
+    fib = current
+    raise(FiberError, "can't yield from root fiber") unless fib
+    fib.switch(*args)
+  end
+
+  def self.current
+    @@fibers[Thread.current]
+  end
+
+  def self.deploy
+    Object.instance_eval do
+      remove_const(:Fiber) if const_defined?(:Fiber)
+      const_set(:Fiber, ThreadFiber)
+    end
+  end
+end
+
+unless defined?(FiberError)
+  class FiberError < StandardError
+  end
+end

data/test/test_threadfiber.rb

@@ -0,0 +1,168 @@
+require 'test/unit'
+require 'threadfiber'
+begin
+  require 'continuation'
+rescue LoadError
+end
+ThreadFiber.deploy
+
+class TestFiber < Test::Unit::TestCase
+  def test_normal
+    f = Fiber.current
+    assert_equal(:ok2,
+      Fiber.new{|e|
+        assert_equal(:ok1, e)
+        Fiber.yield :ok2
+      }.resume(:ok1)
+    )
+    assert_equal([:a, :b], Fiber.new{|a, b| [a, b]}.resume(:a, :b))
+  end
+
+  def test_term
+    assert_equal(:ok, Fiber.new{:ok}.resume)
+    assert_equal([:a, :b, :c, :d, :e],
+      Fiber.new{
+        Fiber.new{
+          Fiber.new{
+            Fiber.new{
+              [:a]
+            }.resume + [:b]
+          }.resume + [:c]
+        }.resume + [:d]
+      }.resume + [:e])
+  end
+
+  def test_many_fibers
+    max = 100
+    assert_equal(max, max.times{
+      Fiber.new{}
+    })
+    assert_equal(max,
+      max.times{|i|
+        Fiber.new{
+        }.resume
+      }
+    )
+  end
+
+  def test_many_fibers_with_threads
+    max = 10
+    @cnt = 0
+    (1..10).map{|ti|
+      Thread.new{
+        max.times{|i|
+          Fiber.new{
+            @cnt += 1
+          }.resume
+        }
+      }
+    }.each{|t|
+      t.join
+    }
+    assert_equal(:ok, :ok)
+  end
+
+  def test_error
+    assert_raise(ArgumentError){
+      Fiber.new # Fiber without block
+    }
+#    assert_raise(FiberError){
+#      f = Fiber.new{}
+#      Thread.new{f.resume}.join # Fiber yielding across thread
+#    }
+    assert_raise(FiberError){
+      f = Fiber.new{}
+      f.resume
+      f.resume
+    }
+    assert_raise(RuntimeError){
+      f = Fiber.new{
+        @c = callcc{|c| @c = c}
+      }.resume
+      @c.call # cross fiber callcc
+    }
+    assert_raise(RuntimeError){
+      Fiber.new{
+        raise
+      }.resume
+    }
+    assert_raise(FiberError){
+      Fiber.yield
+    }
+    assert_raise(FiberError){
+      fib = Fiber.new{
+        fib.resume
+      }
+      fib.resume
+    }
+    assert_raise(FiberError){
+      fib = Fiber.new{
+        Fiber.new{
+          fib.resume
+        }.resume
+      }
+      fib.resume
+    }
+  end
+
+  def test_return
+    assert_raise(LocalJumpError){
+      Fiber.new do
+        return
+      end.resume
+    }
+  end
+
+  def test_throw
+    assert_raise(ArgumentError){
+      Fiber.new do
+        throw :a
+      end.resume
+    }
+  end
+
+#  def test_transfer
+#    ary = []
+#    f2 = nil
+#    f1 = Fiber.new{
+#      ary << f2.transfer(:foo)
+#      :ok
+#    }
+#    f2 = Fiber.new{
+#      ary << f1.transfer(:baz)
+#      :ng
+#    }
+#    assert_equal(:ok, f1.transfer)
+#    assert_equal([:baz], ary)
+#  end
+
+  def test_tls
+    # 
+    def tvar(var, val)
+      old = Thread.current[var]
+      begin
+        Thread.current[var] = val
+        yield
+      ensure
+        Thread.current[var] = old
+      end
+    end
+
+    fb = Fiber.new {
+      assert_equal(nil, Thread.current[:v]); tvar(:v, :x) {
+      assert_equal(:x,  Thread.current[:v]);   Fiber.yield
+      assert_equal(:x,  Thread.current[:v]); }
+      assert_equal(nil, Thread.current[:v]); Fiber.yield
+      raise # unreachable
+    }
+
+    assert_equal(nil, Thread.current[:v]); tvar(:v,1) {
+    assert_equal(1,   Thread.current[:v]);   tvar(:v,3) {
+    assert_equal(3,   Thread.current[:v]);     fb.resume
+    assert_equal(3,   Thread.current[:v]);   }
+    assert_equal(1,   Thread.current[:v]); }
+    assert_equal(nil, Thread.current[:v]); fb.resume
+    assert_equal(nil, Thread.current[:v]);
+  end
+end
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: mame-threadfiber
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Yusuke Endoh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: ThreadFiber is an implementation of fiber using threads.
+email: 
+- mame@tsg.ne.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/threadfiber.rb
+- test/test_threadfiber.rb
+has_rdoc: true
+homepage: http://github.com/mame/threadfiber/tree/master
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: threadfiberx
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ThreadFiber is an implementation of fiber using threads.
+test_files: 
+- test/test_threadfiber.rb