strand 0.1.0 → 0.2.0.rc0

data/lib/strand/monitor.rb

@@ -0,0 +1,193 @@
+
+module Strand
+
+    # See MRI Ruby's MonitorMixin
+    # This file (strand/monitor.rb) is derived from MRI Ruby 1.9.3 monitor.rb
+    #
+    # Copyright (C) 2001  Shugo Maeda <shugo@ruby-lang.org>
+    #
+    module MonitorMixin
+        
+        class ConditionVariable
+            
+            #
+            # Releases the lock held in the associated monitor and waits; reacquires the lock on wakeup.
+            #
+            # If +timeout+ is given, this method returns after +timeout+ seconds passed,
+            # even if no other thread doesn't signal.
+            #
+            def wait(timeout = nil)
+                @monitor.__send__(:mon_check_owner)
+                count = @monitor.__send__(:mon_exit_for_cond)
+                begin
+                    @cond.wait(@monitor.instance_variable_get("@mon_mutex"), timeout)
+                    return true
+                ensure
+                    @monitor.__send__(:mon_enter_for_cond, count)
+                end
+            end
+
+            #
+            # Calls wait repeatedly while the given block yields a truthy value.
+            #
+            def wait_while
+                while yield
+                    wait
+                end
+            end
+
+            #
+            # Calls wait repeatedly until the given block yields a truthy value.
+            #
+            def wait_until
+                until yield
+                    wait
+                end
+            end
+
+            #
+            # Wakes up the first thread in line waiting for this lock.
+            #
+            def signal
+                @monitor.__send__(:mon_check_owner)
+                @cond.signal
+            end
+
+            #
+            # Wakes up all threads waiting for this lock.
+            #
+            def broadcast
+                @monitor.__send__(:mon_check_owner)
+                @cond.broadcast
+            end
+
+            private
+
+            def initialize(monitor)
+                @monitor = monitor
+                @cond = ConditionVariable.new
+            end
+        end
+
+        def self.extend_object(obj)
+            super(obj)
+            obj.__send__(:mon_initialize)
+        end
+
+        #
+        # Attempts to enter exclusive section.  Returns +false+ if lock fails.
+        #
+        def mon_try_enter
+            if @mon_owner != Strand.current
+                unless @mon_mutex.try_lock
+                    return false
+                end
+                @mon_owner = Strand.current
+            end
+            @mon_count += 1
+            return true
+        end
+        # For backward compatibility
+        alias try_mon_enter mon_try_enter
+
+        #
+        # Enters exclusive section.
+        #
+        def mon_enter
+            if @mon_owner != Strand.current
+                @mon_mutex.lock
+                @mon_owner = Strand.current
+            end
+            @mon_count += 1
+        end
+
+        #
+        # Leaves exclusive section.
+        #
+        def mon_exit
+            mon_check_owner
+            @mon_count -=1
+            if @mon_count == 0
+                @mon_owner = nil
+                @mon_mutex.unlock
+            end
+        end
+
+        #
+        # Enters exclusive section and executes the block.  Leaves the exclusive
+        # section automatically when the block exits.  See example under
+        # +MonitorMixin+.
+        #
+        def mon_synchronize
+            mon_enter
+            begin
+                yield
+            ensure
+                mon_exit
+            end
+        end
+        alias synchronize mon_synchronize
+
+        #
+        # Creates a new MonitorMixin::ConditionVariable associated with the
+        # receiver.
+        #
+        def new_cond
+            return ConditionVariable.new(self)
+        end
+
+        private
+
+        # Use <tt>extend MonitorMixin</tt> or <tt>include MonitorMixin</tt> instead
+        # of this constructor.  Have look at the examples above to understand how to
+        # use this module.
+        def initialize(*args)
+            super
+            mon_initialize
+        end
+
+        # Initializes the MonitorMixin after being included in a class or when an
+        # object has been extended with the MonitorMixin
+        def mon_initialize
+            @mon_owner = nil
+            @mon_count = 0
+            @mon_mutex = Mutex.new
+        end
+
+        def mon_check_owner
+            if @mon_owner != Strand.current
+                raise Strand.delegate_class(ThreadError,FiberError), "current thread not owner"
+            end
+        end
+
+        def mon_enter_for_cond(count)
+            @mon_owner = Strand.current
+            @mon_count = count
+        end
+
+        def mon_exit_for_cond
+            count = @mon_count
+            @mon_owner = nil
+            @mon_count = 0
+            return count
+        end
+    end
+
+    # Use the Monitor class when you want to have a lock object for blocks with
+    # mutual exclusion.
+    #
+    #   require 'monitor'
+    #
+    #   lock = Monitor.new
+    #   lock.synchronize do
+    #     # exclusive access
+    #   end
+    #
+    class Monitor
+        include MonitorMixin
+        alias try_enter try_mon_enter
+        alias enter mon_enter
+        alias exit mon_exit
+    end
+
+end

data/lib/strand/version.rb

@@ -0,0 +1,3 @@
+module Strand
+  VERSION = "0.2.0.rc0"
+end

data/spec/spec_helper.rb

@@ -1,11 +1,11 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'eventmachine'
 require 'strand'
+require 'bundler'
 Bundler.require(:development)
 
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+require 'support/scratch'
+require 'support/fixtures'
+
 
 RSpec.configure do |config|
   config.mock_with :rr
@@ -15,3 +15,7 @@ require "strand/atc"
 Atc = Strand::Atc
 
 require "em-spec/rspec"
+
+def quarantine!(&specs)
+    #Nothing
+end

data/spec/strand/alive.rb

@@ -0,0 +1,62 @@
+
+shared_examples_for "Strand#alive?" do
+
+    context "alive?" do
+        it "can check it's own status" do
+            StrandSpecs.status_of_current_strand.alive?.should == true
+        end
+
+        it "describes a sleeping strand" do
+            StrandSpecs.status_of_sleeping_strand.alive?.should == true
+        end
+
+        it "describes a blocked strand" do
+            StrandSpecs.status_of_blocked_strand.alive?.should == true
+        end
+
+        it "describes a completed strand" do
+            StrandSpecs.status_of_completed_strand.alive?.should == false
+        end
+
+        it "describes a killed strand" do
+            StrandSpecs.status_of_killed_strand.alive?.should == false
+        end
+
+        it "describes a strand with an uncaught exception" do
+            StrandSpecs.status_of_strand_with_uncaught_exception.alive?.should == false
+        end
+
+        it "describes a dying running strand" do
+            StrandSpecs.status_of_dying_running_strand.alive?.should == true
+        end
+
+        it "describes a dying sleeping strand" do
+            StrandSpecs.status_of_dying_sleeping_strand.alive?.should == true
+        end
+
+        # No such thing as a "running" strand
+        quarantine!() do  
+            it "describes a running strand" do
+                StrandSpecs.status_of_running_strand.alive?.should == true
+            end
+
+            it "return true for a killed but still running strand" do
+                exit = false
+                t = Strand.new do
+                    begin
+                        sleep
+                    ensure
+                        true while !exit # spin until told to exit
+                    end
+                end
+
+                StrandSpecs.spin_until_sleeping(t)
+
+                t.kill
+                t.alive?.should == true
+                exit = true
+                t.join
+            end
+        end
+    end
+end

data/spec/strand/condition_variable.rb

@@ -0,0 +1,10 @@
+require 'strand/condition_variable/broadcast'
+require 'strand/condition_variable/signal'
+require 'strand/condition_variable/wait'
+
+shared_examples_for "a condition variable" do
+    include_examples "ConditionVariable#signal"
+    include_examples "ConditionVariable#wait"
+    include_examples "ConditionVariable#broadcast"
+end
+

data/spec/strand/condition_variable/broadcast.rb

@@ -0,0 +1,61 @@
+
+shared_examples_for "ConditionVariable#broadcast" do
+
+    context "#broadcast" do
+        it "returns self if nothing to broadcast to" do
+            cv = Strand::ConditionVariable.new
+            cv.broadcast.should == cv
+        end
+
+        it "returns self if something is waiting for a broadcast" do
+            m = Strand::Mutex.new
+            cv = Strand::ConditionVariable.new
+            th = Strand.new do
+                m.synchronize do
+                    cv.wait(m)
+                end
+            end
+
+            Strand.pass while th.status and th.status != 'sleep'
+
+            m.synchronize { cv.broadcast }.should == cv
+
+            th.join
+        end
+
+        it "releases all strands waiting in line for this resource" do
+            m = Strand::Mutex.new
+            cv = Strand::ConditionVariable.new
+            strands = []
+            r1 = []
+            r2 = []
+
+            # large number to attempt to cause race conditions
+            10.times do |i|
+                strands << Strand.new(i) do |tid|
+                    m.synchronize do
+                        r1 << tid
+                        cv.wait(m)
+                        r2 << tid
+                    end
+                end
+            end
+
+            # wait for all strands to acquire the mutex the first time
+            Strand.pass until m.synchronize { r1.size == strands.size }
+            # wait until all strands are sleeping (ie waiting)
+            Strand.pass until strands.all? {|th| th.status == "sleep" }
+            r2.should be_empty
+            m.synchronize do
+                cv.broadcast
+            end
+
+            strands.each {|t| t.join }
+
+            # ensure that all strands that enter cv.wait are released
+            r2.sort.should == r1.sort
+            # note that order is not specified as broadcast results in a race
+            # condition on regaining the lock m
+        end
+    end
+end

data/spec/strand/condition_variable/signal.rb

@@ -0,0 +1,62 @@
+shared_examples_for "ConditionVariable#signal" do
+    context :signal do
+        it "returns self if nothing to signal" do
+            cv = Strand::ConditionVariable.new
+            cv.signal.should == cv
+        end
+
+        it "returns self if something is waiting for a signal" do
+            m = Strand::Mutex.new
+            cv = Strand::ConditionVariable.new
+            th = Strand.new do
+                m.synchronize do
+                    cv.wait(m)
+                end
+            end
+
+            # ensures that th grabs m before current strand
+            Strand.pass while th.status and th.status != "sleep"
+
+            m.synchronize { cv.signal }.should == cv
+
+            th.join
+        end
+
+        it "releases the first strand waiting in line for this resource" do
+            m = Strand::Mutex.new
+            cv = Strand::ConditionVariable.new
+            strands = []
+            r1 = []
+            r2 = []
+
+            # large number to attempt to cause race conditions
+            10.times do |i|
+                strands << Strand.new(i) do |tid|
+                    m.synchronize do
+                        r1 << tid
+                        cv.wait(m)
+                        r2 << tid
+                    end
+                end
+            end
+
+            # wait for all strands to acquire the mutex the first time
+            Strand.pass until m.synchronize { r1.size == strands.size }
+            # wait until all strands are sleeping (ie waiting)
+            Strand.pass until strands.all? {|th| th.status == "sleep" || !thread.status } 
+            r2.should be_empty
+            10.times do |i|
+                m.synchronize do
+                    cv.signal
+                end
+                Strand.pass until r2.size == i+1
+            end
+
+            strands.each {|t| t.join }
+
+            # ensure that all the strands that went into the cv.wait are
+            # released in the same order
+            r2.should == r1
+        end
+    end
+end

data/spec/strand/condition_variable/wait.rb

@@ -0,0 +1,20 @@
+shared_examples_for "ConditionVariable#wait" do
+    context :wait do
+        it "returns self" do
+            m = Strand::Mutex.new
+            cv = Strand::ConditionVariable.new
+
+            th = Strand.new do
+                m.synchronize do
+                    cv.wait(m).should == cv
+                end
+            end
+
+            # ensures that th grabs m before current thread
+            Strand.pass while th.status and th.status != "sleep"
+
+            m.synchronize { cv.signal }
+            th.join
+        end
+    end
+end

data/spec/strand/current.rb

@@ -0,0 +1,15 @@
+
+shared_examples_for "Strand#current" do
+    context "current" do  
+        it "returns a strand" do
+            current = Strand.current
+            current.should be_kind_of(strand_type)
+        end
+
+        it "returns the current strand" do
+            t = Strand.new { Strand.current }
+            t.value.should equal(t)
+            Strand.current.should_not equal(t.value)
+        end
+    end
+end