concurrent-selectable 0.1

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/clean'
+
+GEM_VERSION = "0.1"
+
+Rake::RDocTask.new do |task|
+  task.rdoc_files.add [ 'lib/**/*.rb' ]
+end
+
+task :clobber => [ :clean ]
+
+Rake::TestTask.new do |task|
+  task.ruby_opts << '-rrubygems'
+  task.libs << 'lib'
+  task.libs << 'test'
+  task.test_files = [ "test/test_all.rb" ]
+  task.verbose = true
+end
+
+gemspec = Gem::Specification.new do |gemspec|
+  gemspec.name = "concurrent-selectable"
+  gemspec.version = GEM_VERSION
+  gemspec.author = "MenTaLguY <mental@rydia.net>"
+  gemspec.summary = "Synchronization primitives with selectable IO channels"
+  gemspec.test_file = 'test/test_all.rb'
+  gemspec.files = FileList[ 'Rakefile', 'test/*.rb', 'lib/**/*.rb' ]
+  gemspec.require_paths = [ 'lib' ]
+  gemspec.has_rdoc = true
+  gemspec.platform = Gem::Platform::RUBY
+end
+
+task :package => [ :clean, :test ]
+Rake::GemPackageTask.new( gemspec ) do |task|
+  task.gem_spec = gemspec
+  task.need_tar = true
+end
+
+task :default => [ :clean, :test ]
+

data/lib/concurrent/selectable.rb

@@ -0,0 +1,33 @@
+# concurrent/selectable - Synchronization primitives supporting IO.select
+#
+# Copyright 2008  MenTaLguY <mental@rydia.net>
+#
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * The names of the authors may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'concurrent/selectable/channel'
+require 'concurrent/selectable/latch'
+require 'concurrent/selectable/semaphore'
+

data/lib/concurrent/selectable/channel.rb

@@ -0,0 +1,86 @@
+# concurrent/selectable/channel - IO-Selectable channel
+#
+# Copyright 2008  MenTaLguY <mental@rydia.net>
+#
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * The names of the authors may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+
+require 'concurrent/selectable/common'
+
+module Concurrent
+module Selectable
+
+# A thread-safe FIFO channel of Ruby objects which can be selected on as if it
+# were an IO object.
+class Channel < Base
+  def initialize
+    super()
+    @lock = ::Mutex.new
+    @channel = ::Queue.new
+  end
+
+  # Attempts to get a value from the channel and returns it, blocking if none
+  # is available and +blocking+ is true.  If +blocking+ is false, then
+  # +default_value+ is returned if no value is currently available.
+  def get(blocking=true, default_value=nil)
+    loop do
+      @lock.synchronize do
+        size = @channel.size
+        if size.nonzero?
+          value = @channel.deq
+          internal_reset if size == 1 # i.e. if we removed the last remaining
+          return value
+        end
+      end
+      return default_value unless blocking
+      wait
+    end
+  end
+
+  # Places +value+ on the channel.
+  def put(value)
+    @lock.synchronize do
+      internal_set if @channel.empty?
+      @channel.enq value
+    end
+  end
+  alias_method :<<, :put
+
+  # Returns true if the channel is currently empty (additional external
+  # synchronization is normally required if other threads can manipulate
+  # the channel)
+  def empty?
+    @channel.empty?
+  end
+end
+
+end
+end

data/lib/concurrent/selectable/common.rb

@@ -0,0 +1,78 @@
+# concurrent/selectable/common - Common bits for IO-Selectable synchronization
+#
+# Copyright 2008  MenTaLguY <mental@rydia.net>
+#
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * The names of the authors may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+
+module Concurrent
+module Selectable
+
+# Raised if a wait exceeds a given timeout
+class TimeoutError < RuntimeError
+end
+
+# Base class for selectable primitives
+class Base
+  def initialize #:nodoc:
+    @read, @write = IO.pipe
+  end
+
+  # Waits for the primitive to become available/signaled, with the given
+  # +timeout+ (see IO.select).  If +timeout+ is given and is not +nil+, then
+  # TimeoutError will be raised if the timeout is exceeded.
+  def wait(timeout=nil)
+    ready = IO.select([@read], nil, nil, timeout)
+    raise TimeoutError, "wait timed out" unless ready
+    self
+  end
+
+  # Converts the primitive to an IO object; the object is only safe to
+  # test whether it is ready for reading; DO NOT read from the returned
+  # IO object yourself.
+  def to_io
+    @read
+  end
+
+private
+  def internal_set
+    @write.write 'x'
+    self
+  end
+
+  def internal_reset
+    @read.read 1
+    self
+  end
+end
+
+end
+end

data/lib/concurrent/selectable/latch.rb

@@ -0,0 +1,80 @@
+# concurrent/selectable/latch - IO-Selectable latch
+#
+# Copyright 2008  MenTaLguY <mental@rydia.net>
+#
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * The names of the authors may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+
+require 'concurrent/selectable/common'
+
+module Concurrent
+module Selectable
+
+# A latch is a toggle which starts out unset.  Threads can wait for the
+# latch to become set by calling Latch#wait (inherited from Base).  The
+# latch can be reset to its intial state using Latch#reset.
+class Latch < Base
+  def initialize
+    super()
+    @lock = ::Mutex.new
+    @set = false
+  end
+
+  # Sets the latch, allowing any current and future waiting threads to
+  # continue
+  def set
+    @lock.synchronize do
+      internal_set unless @set
+      @set = true
+    end
+    self
+  end
+
+  # Non-blocking test whether the latch is currently set (additional
+  # external synchronization will usually be required if the latch can be
+  # set or reset by other threads)
+  def set?
+    @lock.synchronize { @set }
+  end
+
+  # Resets the latch, blocking any subsequent waiting threads until the
+  # latch is set again
+  def reset
+    @lock.synchronize do
+      internal_reset if @set
+      @set = false
+    end
+    self
+  end
+end
+
+end
+end

data/lib/concurrent/selectable/semaphore.rb

@@ -0,0 +1,91 @@
+# concurrent/selectable/semaphore - IO-Selectable semaphore
+#
+# Copyright 2008  MenTaLguY <mental@rydia.net>
+#
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * The names of the authors may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+
+require 'concurrent/selectable/common'
+
+module Concurrent
+module Selectable
+
+# A Semaphore is a counter which can be atomically incremented and decremented;
+# attempts to decrement the counter below zero will block.
+class Semaphore < Base
+  # Creates a semaphore with the given initial +count+
+  def initialize(count=0)
+    super()
+    @lock = ::Mutex.new
+    @count = count
+  end
+
+  # Decrements the semaphore, blocking if its count is already zero and
+  # +blocking+ is true.
+  def get(blocking=true)
+    loop do
+      @lock.synchronize do
+        if @count.nonzero?
+          @count -= 1
+          internal_reset if @count.zero?
+          return self
+        end
+      end
+      return nil unless blocking
+      wait
+    end
+  end
+
+  # Increments the semaphore
+  def put
+    @lock.synchronize do
+      internal_set if @count.zero?
+      @count += 1
+    end
+  end
+
+  # Returns true if the count is currently zero (additional external
+  # synchronization is usually required if other threads can modify the
+  # semaphore)
+  def zero?
+    @lock.synchronize { @count.zero? }
+  end
+
+  # Returns true if the count is currently nonzero (additional external
+  # synchronization is usually required if other threads can modify the
+  # semaphore)
+  def nonzero?
+    @lock.synchronize { @count.nonzero? }
+  end
+end
+
+end
+end

data/test/test_all.rb

@@ -0,0 +1,3 @@
+require 'test_channel.rb'
+require 'test_latch.rb'
+require 'test_semaphore.rb'

data/test/test_channel.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'concurrent/selectable/channel'
+
+SChannel = Concurrent::Selectable::Channel
+
+class TestChannel < Test::Unit::TestCase
+  def test_to_io
+    channel = SChannel.new
+    assert_instance_of IO, channel.to_io
+  end
+
+  def test_select
+    channel = SChannel.new
+    ready = IO.select([channel], nil, nil, 0.01)
+    assert !ready
+    channel.put :blah
+    ready = IO.select([channel], nil, nil, 0.01)
+    assert ready
+    channel.get
+    ready = IO.select([channel], nil, nil, 0.01)
+    assert !ready
+  end
+end

data/test/test_latch.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'concurrent/selectable/latch'
+
+Latch = Concurrent::Selectable::Latch
+
+class TestLatch < Test::Unit::TestCase
+  def test_to_io
+    latch = Latch.new
+    assert_instance_of IO, latch.to_io
+  end
+
+  def test_select
+    latch = Latch.new
+    ready = IO.select([latch], nil, nil, 0.01)
+    assert !ready
+    latch.set
+    ready = IO.select([latch], nil, nil, 0.01)
+    assert ready
+    latch.reset
+    ready = IO.select([latch], nil, nil, 0.01)
+    assert !ready
+  end
+end

data/test/test_semaphore.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'concurrent/selectable/semaphore'
+
+Semaphore = Concurrent::Selectable::Semaphore
+
+class TestSemaphore < Test::Unit::TestCase
+  def test_to_io
+    semaphore = Semaphore.new
+    assert_instance_of IO, semaphore.to_io
+  end
+
+  def test_select
+    semaphore = Semaphore.new
+    ready = IO.select([semaphore], nil, nil, 0.01)
+    assert !ready
+    semaphore.put
+    ready = IO.select([semaphore], nil, nil, 0.01)
+    assert ready
+    semaphore.get
+    ready = IO.select([semaphore], nil, nil, 0.01)
+    assert !ready
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: concurrent-selectable
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-01-27 00:00:00 -05:00
+summary: Synchronization primitives with selectable IO channels
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- MenTaLguY <mental@rydia.net>
+files: 
+- Rakefile
+- test/test_latch.rb
+- test/test_all.rb
+- test/test_semaphore.rb
+- test/test_channel.rb
+- lib/concurrent/selectable.rb
+- lib/concurrent/selectable/latch.rb
+- lib/concurrent/selectable/common.rb
+- lib/concurrent/selectable/semaphore.rb
+- lib/concurrent/selectable/channel.rb
+test_files: 
+- test/test_all.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+