rubysl-thread 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c626288948b9685e901de3bcdef1eea63bb81fc3
+  data.tar.gz: 668d50eab397667930f7f05242fa5208825852b8
+SHA512:
+  metadata.gz: 2b8db86da74b9e1dbda841831a1f9725b73039f2818e5aa980df4837566d2f7a24fbb78422fdf46a39bbc947bb7d995df14c3d93157beb30e518e5db4bb57cd2
+  data.tar.gz: f07c6bf9154ca2111b5cc739e54b841014b95b342e212ca907912e5f06ac7e4c1f13ce7506acfaff091becf740d6ed7c902610fb2867b8ebee39735bee9a1026

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+env:
+  - RUBYLIB=lib
+script: bundle exec mspec
+rvm:
+  - 1.8.7
+  - rbx-nightly-18mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubysl-thread.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Brian Shirai
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the library nor the names of its contributors may 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 <COPYRIGHT HOLDER> 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.

data/README.md

@@ -0,0 +1,29 @@
+# Rubysl::Thread
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubysl-thread'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubysl-thread
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rubysl/thread.rb

@@ -0,0 +1,2 @@
+require "rubysl/thread/version"
+require "rubysl/thread/thread"

data/lib/rubysl/thread/thread.rb

@@ -0,0 +1,433 @@
+#
+#		thread.rb - thread support classes
+#			$Date: 2006-12-31 07:02:22 -0800 (Sun, 31 Dec 2006) $
+#			by Yukihiro Matsumoto <matz@netlab.co.jp>
+#
+# Copyright (C) 2001  Yukihiro Matsumoto
+# Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+# Copyright (C) 2000  Information-technology Promotion Agency, Japan
+#
+
+unless defined? Thread
+  raise "Thread not available for this ruby interpreter"
+end
+
+unless defined? ThreadError
+  class ThreadError < StandardError
+  end
+end
+
+if $DEBUG
+  Thread.abort_on_exception = true
+end
+
+class Thread
+  #
+  # Wraps a block in Thread.critical, restoring the original value upon exit
+  # from the critical section.
+  #
+  def Thread.exclusive
+    _old = Thread.critical
+    begin
+      Thread.critical = true
+      return yield
+    ensure
+      Thread.critical = _old
+    end
+  end
+end
+
+class Mutex
+  def initialize
+    @owner = nil
+  end
+
+  # Check and only allow it to be marshal'd if there are no waiters.
+  def marshal_dump
+    raise "Unable to dump locked mutex" unless @waiters.empty?
+    1
+  end
+
+  # Implemented because we must since we use marshal_load PLUS we need
+  # to create AND prime @lock. If we didn't do this, then Marshal
+  # wouldn't prime the lock anyway.
+  def marshal_load(bunk)
+    initialize
+  end
+
+  def locked?
+    Rubinius.locked?(self)
+  end
+
+  def try_lock
+    # Locking implies a memory barrier, so we don't need to use
+    # one explicitly.
+    if Rubinius.try_lock(self)
+      @owner = Thread.current
+      true
+    else
+      false
+    end
+  end
+
+  def lock
+    Rubinius.memory_barrier
+    if @owner == Thread.current
+      raise ThreadError, "Recursively locking not allowed"
+    end
+
+    Rubinius.lock self
+    @owner = Thread.current
+    Rubinius.memory_barrier
+    return self
+  end
+
+  def unlock
+    Rubinius.memory_barrier
+
+    if @owner != Thread.current
+      raise ThreadError, "#{Thread.current.inspect} not owner, #{@owner.inspect} is"
+    end
+
+    @owner = nil
+    Rubinius.unlock self
+  end
+
+  def synchronize
+    lock
+    begin
+      yield
+    ensure
+      unlock
+    end
+  end
+end
+
+#
+# ConditionVariable objects augment class Mutex. Using condition variables,
+# it is possible to suspend while in the middle of a critical section until a
+# resource becomes available.
+#
+# Example:
+#
+#   require 'thread'
+#
+#   mutex = Mutex.new
+#   resource = ConditionVariable.new
+#   
+#   a = Thread.new {
+#     mutex.synchronize {
+#       # Thread 'a' now needs the resource
+#       resource.wait(mutex)
+#       # 'a' can now have the resource
+#     }
+#   }
+#   
+#   b = Thread.new {
+#     mutex.synchronize {
+#       # Thread 'b' has finished using the resource
+#       resource.signal
+#     }
+#   }
+#
+class ConditionVariable
+  #
+  # Creates a new ConditionVariable
+  #
+  def initialize
+    @waiters = []
+  end
+
+  #
+  # Releases the lock held in +mutex+ and waits; reacquires the lock on wakeup.
+  #
+  def wait(mutex, timeout=nil)
+    Rubinius.lock(self)
+
+    begin
+      wchan = Rubinius::Channel.new
+
+      begin
+        mutex.unlock
+        @waiters.push wchan
+        Rubinius.unlock(self)
+        signaled = wchan.receive_timeout timeout
+      ensure
+        mutex.lock
+        Rubinius.lock(self)
+
+        unless signaled or @waiters.delete(wchan)
+          # we timed out, but got signaled afterwards (e.g. while waiting to
+          # acquire @lock), so pass that signal on to the next waiter
+          @waiters.shift << true unless @waiters.empty?
+        end
+      end
+
+      if timeout
+        !!signaled
+      else
+        self
+      end
+    ensure
+      Rubinius.unlock(self)
+    end
+  end
+
+  #
+  # Wakes up the first thread in line waiting for this lock.
+  #
+  def signal
+    Rubinius.lock(self)
+    begin
+      @waiters.shift << true unless @waiters.empty?
+    ensure
+      Rubinius.unlock(self)
+    end
+    self
+  end
+
+  #
+  # Wakes up all threads waiting for this lock.
+  #
+  def broadcast
+    Rubinius.lock(self)
+    begin
+      @waiters.shift << true until @waiters.empty?
+    ensure
+      Rubinius.unlock(self)
+    end
+    self
+  end
+end
+
+#
+# This class provides a way to synchronize communication between threads.
+#
+# Example:
+#
+#   require 'thread'
+#   
+#   queue = Queue.new
+#   
+#   producer = Thread.new do
+#     5.times do |i|
+#       sleep rand(i) # simulate expense
+#       queue << i
+#       puts "#{i} produced"
+#     end
+#   end
+#   
+#   consumer = Thread.new do
+#     5.times do |i|
+#       value = queue.pop
+#       sleep rand(i/2) # simulate expense
+#       puts "consumed #{value}"
+#     end
+#   end
+#   
+#   consumer.join
+#
+class Queue
+  #
+  # Creates a new queue.
+  #
+  def initialize
+    @que = []
+    @que.taint		# enable tainted comunication
+    self.taint
+    @waiting = []
+    @waiting.taint
+    @mutex = Mutex.new
+    @resource = ConditionVariable.new
+  end
+
+  #
+  # Pushes +obj+ to the queue.
+  #
+  def push(obj)
+    @mutex.synchronize do
+      @que.push obj
+      @resource.signal
+    end
+  end
+
+  #
+  # Alias of push
+  #
+  alias << push
+
+  #
+  # Alias of push
+  #
+  alias enq push
+
+  #
+  # Retrieves data from the queue.  If the queue is empty, the calling thread is
+  # suspended until data is pushed onto the queue.  If +non_block+ is true, the
+  # thread isn't suspended, and an exception is raised.
+  #
+  def pop(non_block=false)
+    while true
+      @mutex.synchronize do
+        #FIXME: some code in net or somewhere violates encapsulation
+        #and demands that a waiting queue exist for Queue, as a result
+        #we have to do a linear search here to remove the current Thread.
+        @waiting.delete(Thread.current)
+        if @que.empty?
+          raise ThreadError, "queue empty" if non_block
+          @waiting.push Thread.current
+          @resource.wait(@mutex)
+        else
+          retval = @que.shift
+          @resource.signal
+          return retval
+        end
+      end
+    end
+  end
+
+  #
+  # Alias of pop
+  #
+  alias shift pop
+
+  #
+  # Alias of pop
+  #
+  alias deq pop
+
+  #
+  # Returns +true+ if the queue is empty.
+  #
+  def empty?
+    @que.empty?
+  end
+
+  #
+  # Removes all objects from the queue.
+  #
+  def clear
+    @que.clear
+  end
+
+  #
+  # Returns the length of the queue.
+  #
+  def length
+    @que.length
+  end
+
+  #
+  # Alias of length.
+  #
+  alias size length
+
+  #
+  # Returns the number of threads waiting on the queue.
+  #
+  def num_waiting
+    @waiting.size
+  end
+end
+
+#
+# This class represents queues of specified size capacity.  The push operation
+# may be blocked if the capacity is full.
+#
+# See Queue for an example of how a SizedQueue works.
+#
+class SizedQueue < Queue
+  #
+  # Creates a fixed-length queue with a maximum size of +max+.
+  #
+  def initialize(max)
+    raise ArgumentError, "queue size must be positive" unless max > 0
+    @max = max
+    @queue_wait = []
+    @queue_wait.taint		# enable tainted comunication
+    @size_mutex = Mutex.new
+    @sem = ConditionVariable.new
+    super()
+  end
+
+  #
+  # Returns the maximum size of the queue.
+  #
+  def max
+    @max
+  end
+
+  #
+  # Sets the maximum size of the queue.
+  #
+  def max=(max)
+    @size_mutex.synchronize do
+      @max = max
+      @sem.broadcast(@size_mutex)
+    end
+    max
+  end
+
+  #
+  # Pushes +obj+ to the queue.  If there is no space left in the queue, waits
+  # until space becomes available.
+  #
+  def push(obj)
+    while true
+      @size_mutex.synchronize do
+        @queue_wait.delete(Thread.current)
+        if @que.size >= @max
+          @queue_wait.push Thread.current
+          @sem.wait(@size_mutex)
+        else
+          return super(obj)
+        end
+      end
+    end
+  end
+
+  #
+  # Alias of push
+  #
+  alias << push
+
+  #
+  # Alias of push
+  #
+  alias enq push
+
+  #
+  # Retrieves data from the queue and runs a waiting thread, if any.
+  #
+  def pop(*args)
+    retval = super
+    
+    @size_mutex.synchronize do
+      if @que.size < @max
+        @sem.broadcast
+      end      
+    end
+    
+    return retval
+  end
+
+  #
+  # Alias of pop
+  #
+  alias shift pop
+
+  #
+  # Alias of pop
+  #
+  alias deq pop
+
+  #
+  # Returns the number of threads waiting on the queue.
+  #
+  def num_waiting
+    @waiting.size + @queue_wait.size
+  end
+end
+
+# Documentation comments:
+#  - How do you make RDoc inherit documentation from superclass?

data/lib/rubysl/thread/version.rb

@@ -0,0 +1,5 @@
+module RubySL
+  module Thread
+    VERSION = "1.0.0"
+  end
+end

data/lib/thread.rb

@@ -0,0 +1 @@
+require "rubysl/thread"

data/rubysl-thread.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+require './lib/rubysl/thread/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubysl-thread"
+  spec.version       = RubySL::Thread::VERSION
+  spec.authors       = ["Brian Shirai"]
+  spec.email         = ["brixen@gmail.com"]
+  spec.description   = %q{Support classes for working with threads.}
+  spec.summary       = %q{Support classes for working with threads.}
+  spec.homepage      = "https://github.com/rubysl/rubysl-thread"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mspec", "~> 1.5"
+end

data/spec/exclusive_spec.rb

@@ -0,0 +1,28 @@
+ruby_version_is "".."1.9" do
+  require 'thread'
+
+  describe "Thread.exclusive" do
+    before :each do
+      ScratchPad.clear
+    end
+
+    it "sets Thread.critical to true and yields" do
+      Thread.exclusive { ScratchPad.record Thread.critical }
+      ScratchPad.recorded.should == true
+    end
+
+    it "returns the result of yielding" do
+      Thread.exclusive { :result }.should == :result
+    end
+
+    it "resets Thread.critical after yielding" do
+      Thread.exclusive {}
+      Thread.critical.should be_false
+    end
+
+    it "resets Thread.critical if the block raises" do
+      lambda { Thread.exclusive { raise Exception } }.should raise_error(Exception)
+      Thread.critical.should be_false
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: rubysl-thread
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Shirai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: mspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Support classes for working with threads.
+email:
+- brixen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/rubysl/thread.rb
+- lib/rubysl/thread/thread.rb
+- lib/rubysl/thread/version.rb
+- lib/thread.rb
+- rubysl-thread.gemspec
+- spec/exclusive_spec.rb
+homepage: https://github.com/rubysl/rubysl-thread
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Support classes for working with threads.
+test_files:
+- spec/exclusive_spec.rb