quack_concurrency 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc94fc7f4e6591c7475601d36f579e27f92d3489
+  data.tar.gz: c799eea3980d05c7615bb188f20691fde758839f
+SHA512:
+  metadata.gz: 5acd18b4ddcce70586e1029deab493435c73d077934f3ce0df32de5616ba5ea466526bb9f3c8c58a7c538a024ed75d2c33aa776e1624a0f6453547f2c2133d25
+  data.tar.gz: b4586e26fdf8fc425ebb70dca328bc90e9eb88a229fd44982433710554b36cf61c6773ef7f43745d1e23a0d40a64680f6e351921db6a5457711b723eff8f5fe5

data/lib/quack_concurrency/condition_variable.rb

@@ -0,0 +1,34 @@
+# Author: Rob Fors
+# Revision Date: 20180102
+
+module QuackConcurrency
+  class ConditionVariable
+  
+    def initialize(duck_types: {})
+      mutex_class = duck_types[:mutex] || Mutex
+      queue_class = duck_types[:queue] || Queue
+      @mutex = mutex_class.new
+      @queue = queue_class.new
+    end
+    
+    def signal
+      @mutex.synchronize do
+        @queue.push(nil) unless @queue.num_waiting == 0
+      end
+    end
+    
+    def broadcast
+      @mutex.synchronize do
+        @queue.push(nil) until @queue.num_waiting == 0
+      end
+    end
+    
+    def wait(mutex)
+      mutex.unlock
+      @queue.pop
+      mutex.lock
+      nil
+    end
+    
+  end
+end

data/lib/quack_concurrency/future.rb

@@ -0,0 +1,51 @@
+# Author: Rob Fors
+# Revision Date: 20180102
+
+module QuackConcurrency
+  class Future
+    
+    class Canceled < StandardError
+    end
+    
+    def initialize(duck_types: {})
+      mutex_class = duck_types[:mutex] || Mutex
+      condition_variable_class = duck_types[:condition_variable] || ::ConditionVariable
+      @mutex = mutex_class.new
+      @condition_variable = condition_variable_class.new
+      @value = nil
+      @value_set = false
+      @complete = false
+    end
+    
+    def set(new_value = nil)
+      @mutex.synchronize do
+        raise if @complete
+        @value_set = true
+        @complete = true
+        @value = new_value
+        @condition_variable.broadcast
+      end
+    end
+    
+    def get
+      @mutex.synchronize do
+        @condition_variable.wait(@mutex) unless complete?
+        raise 'should not get here' unless complete?
+        raise Canceled unless @value_set
+        @value
+      end
+    end
+    
+    def cancel
+      @mutex.synchronize do
+        raise if @complete
+        @complete = true
+      end
+    end
+    
+    def complete?
+      @complete
+    end
+    
+  end
+end

data/lib/quack_concurrency/reentrant_mutex.rb

@@ -0,0 +1,85 @@
+# Author: Rob Fors
+# Revision Date: 20180102
+
+# based off https://en.wikipedia.org/wiki/Reentrant_mutex
+
+module QuackConcurrency
+  class ReentrantMutex
+  
+    def initialize(duck_types: {})
+      mutex_class = duck_types[:mutex] || Mutex
+      condition_variable_class = duck_types[:condition_variable] || ::ConditionVariable
+      @mutex = mutex_class.new
+      @condition_variable = condition_variable_class.new
+      @owner = nil
+      @lock_depth = 0
+    end
+    
+    def lock
+      @mutex.synchronize do
+        @condition_variable.wait(@mutex) if @owner && @owner != caller
+        @owner = caller
+        @lock_depth += 1
+      end
+      nil
+    end
+    
+    def locked?
+      !!@owner
+    end
+    
+    def locked_out?
+      @mutex.synchronize { locked? && @owner != caller }
+    end
+    
+    def owned?
+      @owner == caller
+    end
+    
+    def synchronize
+      lock
+      start_depth = @lock_depth
+      start_owner = @owner
+      result = yield
+      result
+    ensure
+      unless @lock_depth == start_depth && @owner == start_owner
+        raise 'Could not unlock mutex as its state has been modified.'
+      end
+      unlock
+    end
+    
+    def try_lock
+      @mutex.synchronize do
+        if @owner && @owner != caller
+          return false
+        else
+          @owner = caller
+          @lock_depth += 1
+        end
+      end
+      true
+    end
+    
+    def unlock
+      @mutex.synchronize do
+        raise "Not locked." if @lock_depth == 0
+        raise "Not the owner." unless @owner == Thread.current
+        @lock_depth -= 1
+        if @lock_depth == 0
+          @owner = nil
+          @condition_variable.signal
+        end
+      end
+      nil
+    end
+    
+    private
+    
+    def caller
+      Thread.current
+    end
+    
+  end
+end
+  

data/lib/quack_concurrency/semaphore.rb

@@ -0,0 +1,90 @@
+# Author: Rob Fors
+# Revision Date: 20180102
+
+module QuackConcurrency
+  class Semaphore
+  
+    attr_reader :permit_count
+    
+    def initialize(permit_count = 1, duck_types: {})
+      raise 'Error: permit_count invalid' if permit_count < 1
+      @permit_count = permit_count
+      @permits_used = 0
+      @mutex = ReentrantMutex.new(duck_types: duck_types)
+      @condition_variable = ConditionVariable.new
+    end
+    
+    def acquire
+      @mutex.synchronize do
+        @condition_variable.wait(@mutex) unless permit_available?
+        @permits_used += 1
+      end
+      nil
+    end
+    
+    def set_permit_count(new_permit_count)
+      @mutex.synchronize do
+        remove_permits = @permit_count - new_permit_count
+        if remove_permits.positive? && remove_permits > permits_available
+          raise 'Error: can not remove enough permits right not'
+        end
+        set_permit_count!(new_permit_count)
+      end
+      nil
+    end
+    
+    def set_permit_count!(new_permit_count)
+      raise 'Error: permit_count invalid' if new_permit_count < 1
+      @mutex.synchronize do
+        new_permits = new_permit_count - @permit_count
+        if new_permits.positive?
+          new_permits.times { add_permit }
+        else
+          remove_permits = -new_permits
+          remove_permits.times { remove_permit! }
+        end
+      end
+      nil
+    end
+    
+    def release
+      @mutex.synchronize do
+        raise 'No pemit to release.' if @permits_used == 0
+        @permits_used -= 1
+        @condition_variable.signal if permit_available?
+      end
+      nil
+    end
+    
+    # how to handle if yield raises an error but has temporarily released its permit?
+    #def synchronize
+    #  acquire
+    #  begin
+    #    yield
+    #  ensure
+    #    release
+    #  end
+    #end
+    
+    def permits_available
+      @mutex.synchronize { @permit_count - @permits_used }
+    end
+    
+    def permit_available?
+      @mutex.synchronize { permits_available >= 1 }
+    end
+    
+    private
+    
+    def add_permit
+      @permit_count += 1
+      @condition_variable.signal
+    end
+    
+    def remove_permit!
+      @permit_count -= 1
+    end
+    
+  end
+end
+  

data/lib/quack_concurrency/waiter.rb

@@ -0,0 +1,21 @@
+# Author: Rob Fors
+# Revision Date: 20180102
+
+module QuackConcurrency
+  class Waiter
+  
+    def initialize(duck_types: {})
+      queue_class = duck_types[:queue] || Queue
+      @queue = queue_class.new
+    end
+    
+    def resume(value = nil)
+      @queue << value
+    end
+    
+    def wait
+      @queue.pop
+    end
+    
+  end
+end

data/lib/quack_concurrency.rb

@@ -0,0 +1,10 @@
+require 'thread'
+
+require_relative "quack_concurrency/condition_variable.rb"
+require_relative "quack_concurrency/future.rb"
+require_relative "quack_concurrency/reentrant_mutex.rb"
+require_relative "quack_concurrency/semaphore.rb"
+require_relative "quack_concurrency/waiter.rb"
+
+module QuackConcurrency
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: quack_concurrency
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Rob Fors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-25 00:00:00.000000000 Z
+dependencies: []
+description: Offers concurrency tools that accept duck types to allow core classes
+  to behave as desired.
+email: mail@robfors.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/quack_concurrency.rb
+- lib/quack_concurrency/condition_variable.rb
+- lib/quack_concurrency/future.rb
+- lib/quack_concurrency/reentrant_mutex.rb
+- lib/quack_concurrency/semaphore.rb
+- lib/quack_concurrency/waiter.rb
+homepage: https://github.com/robfors/quack_concurrency
+licenses:
+- MIT
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Concurrency tools that accept duck types.
+test_files: []