zeevex_concurrency 0.0.1

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/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'pry'
+  gem 'pry-remote'
+  gem 'pry-doc'
+  gem 'pry-nav'
+  gem 'pry-buffers'
+  gem 'pry-syntax-hacks'
+  gem 'pry-git', :platform => :mri
+  gem 'jist'
+  gem 'ruby18_source_location', :platform => :mri_18
+end
+
+# Specify your gem's dependencies in zeevex_concurrency.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Robert Sanders
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ZeevexConcurrency
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zeevex_concurrency'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zeevex_concurrency
+
+## 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/zeevex_concurrency/delay.rb

@@ -0,0 +1,50 @@
+require 'observer'
+require 'thread'
+require 'zeevex_concurrency/delayed'
+
+class ZeevexConcurrency::Delay < ZeevexConcurrency::Delayed
+  include Observable
+  include ZeevexConcurrency::Delayed::Bindable
+
+  def initialize(computation = nil, options = {}, &block)
+    raise ArgumentError, "Must provide computation or block for a future" unless (computation || block)
+
+    @mutex       = Mutex.new
+    @exec_mutex  = Mutex.new
+    @exception   = nil
+    @done        = false
+    @result      = false
+    @executed    = false
+
+    # has to happen after exec_mutex initialized
+    bind(computation, &block)
+
+    Array(options.delete(:observer) || options.delete(:observers)).each do |observer|
+      add_observer observer
+    end
+  end
+
+  def self.create(callable = nil, options = {}, &block)
+    return callable if callable && callable.is_a?(ZeevexConcurrency::Delayed)
+    new(callable, options, &block)
+  end
+
+  def wait(timeout = nil)
+    true
+  end
+
+  def ready?
+    true
+  end
+
+  protected
+
+  def _fulfill(value, success = true)
+    @fulfilled_value = value
+  end
+
+  def _wait_for_value
+    _execute(binding)
+    @fulfilled_value
+  end
+end

data/lib/zeevex_concurrency/delayed.rb

@@ -0,0 +1,233 @@
+require 'thread'
+require 'countdownlatch'
+
+#
+# base class for Promise, Future, etc.
+#
+class ZeevexConcurrency::Delayed
+
+  module ConvenienceMethods
+    def future(*args, &block)
+      ZeevexConcurrency::Future.__send__(:create, *args, &block)
+    end
+
+    def promise(*args, &block)
+      ZeevexConcurrency::Promise.__send__(:create, *args, &block)
+    end
+
+    def delay(*args, &block)
+      ZeevexConcurrency::Delay.__send__(:create, *args, &block)
+    end
+
+    def delayed?(obj)
+      obj.is_a?(ZeevexConcurrency::Delayed)
+    end
+
+    def delay?(obj)
+      obj.is_a?(ZeevexConcurrency::Delay)
+    end
+
+    def promise?(obj)
+      obj.is_a?(ZeevexConcurrency::Promise)
+    end
+
+    def future?(obj)
+      obj.is_a?(ZeevexConcurrency::Future)
+    end
+  end
+
+  def exception
+    @exception
+  end
+
+  def exception?
+    !! @exception
+  end
+
+  def executed?
+    @executed
+  end
+
+  def value(reraise = true)
+    @mutex.synchronize do
+      unless @done
+        @result = _wait_for_value
+        @done   = true
+      end
+    end
+    if @exception && reraise
+      raise @exception
+    else
+      @result
+    end
+  end
+
+  def wait(timeout = nil)
+    Timeout::timeout(timeout) do
+      value(false)
+      true
+    end
+  rescue Timeout::Error
+    false
+  end
+
+  def set_result(&block)
+    @exec_mutex.synchronize do
+      raise ArgumentError, "Must supply block" unless block_given?
+      raise ArgumentError, "Already supplied block" if bound?
+      raise ArgumentError, "Promise already executed" if executed?
+
+      _execute(block)
+    end
+  end
+
+  protected
+
+  #
+  # not MT-safe; only to be called from executor thread
+  #
+  def _execute(computation)
+    raise "Already executed" if executed?
+    raise ArgumentError, "Cannot execute without computation" unless computation
+    success = false
+    begin
+      result = computation.call
+      success = true
+    rescue Exception
+      _smash($!)
+    end
+    @executed = true
+    # run this separately so we can report exceptions in _fulfill rather than capture them
+    _fulfill_and_notify(result) if (success)
+  rescue Exception
+    puts "*** exception in _fulfill: #{$!.inspect} ***"
+  ensure
+    @executed = true
+  end
+
+  def _fulfill_and_notify(value, success = true)
+    _fulfill(value, success)
+    if respond_to?(:notify_observers)
+      changed
+      begin
+        notify_observers(self, value, success)
+      rescue Exception
+        puts "Exception in notifying observers: #{$!.inspect}"
+      end
+    end
+  end
+  #
+  # not MT-safe; only to be called from executor thread
+  #
+  def _smash(ex)
+    @exception = ex
+    _fulfill_and_notify ex, false
+  end
+
+  ###
+
+  module LatchBased
+    def wait(timeout = nil)
+      @_latch.wait(timeout)
+    end
+
+    def ready?
+      @_latch.count == 0
+    end
+
+    protected
+
+    def _initialize_latch
+      @_latch = CountDownLatch.new(1)
+    end
+
+    def _fulfill(value, success = true)
+      @result = value
+      @_latch.countdown!
+    end
+
+    def _wait_for_value
+      @_latch.wait
+      @result
+    end
+  end
+
+  module QueueBased
+    def ready?
+      @exec_mutex.synchronize do
+        @queue.size > 0 || @executed
+      end
+    end
+
+    protected
+
+    def _initialize_queue
+      @queue = Queue.new
+    end
+
+    def _fulfill(value, success = true)
+      @queue << value
+    end
+
+    def _wait_for_value
+      @queue.pop
+    end
+  end
+
+  module Bindable
+    def bound?
+      !! @binding
+    end
+
+    def binding
+      @binding
+    end
+
+    def bind(proccy = nil, &block)
+      raise "Already bound" if bound?
+      if proccy && block
+        raise ArgumentError, "must supply a callable OR a block or neither, but not both"
+      end
+      raise ArgumentError, "Must provide computation as proc or block" unless (proccy || block)
+      @binding = proccy || block
+    end
+
+    def execute
+      @exec_mutex.synchronize do
+        return if executed?
+        return if respond_to?(:cancelled?) && cancelled?
+        _execute(binding)
+      end
+    end
+
+    def call
+      execute
+    end
+  end
+
+  module Cancellable
+    def cancelled?
+      @cancelled
+    end
+
+    def cancel
+      @exec_mutex.synchronize do
+        return false if executed?
+        return true  if cancelled?
+        @cancelled = true
+        _smash CancelledException.new
+        true
+      end
+    end
+
+    def ready?
+      cancelled? || super
+    end
+  end
+
+  class CancelledException < StandardError; end
+end
+
+module ZeevexConcurrency
+  extend(ZeevexConcurrency::Delayed::ConvenienceMethods)
+end

data/lib/zeevex_concurrency/event_loop.rb

@@ -0,0 +1,154 @@
+require 'thread'
+require 'zeevex_concurrency/promise'
+
+module ZeevexConcurrency
+  class EventLoop
+    def initialize(options = {})
+      @options = options
+      @mutex   = options.delete(:mutex) || Mutex.new
+      @queue   = options.delete(:queue) || Queue.new
+      @state   = :stopped
+    end
+
+    def running?
+      @state == :started
+    end
+
+    def start
+      return unless @state == :stopped
+      @stop_requested = false
+      @thread = Thread.new do
+        process
+      end
+
+      @state = :started
+    end
+
+    def stop
+      return unless @state == :started
+      enqueue { @stop_requested = true }
+      unless @thread.join(1)
+        @thread.kill
+        @thread.join(0)
+      end
+
+      @thread = nil
+      @state = :stopped
+    end
+
+    #
+    # Enqueue any callable object (including a Promise or Future or other Delayed class) to the event loop
+    # and return a Delayed object which can be used to fetch the return value.
+    #
+    # Strictly obeys ordering.
+    #
+    def enqueue(callable = nil, &block)
+      to_run = callable || block
+      raise ArgumentError, "Must provide proc or block arg" unless to_run
+
+      to_run = ZeevexConcurrency::Promise.new(to_run) unless to_run.is_a?(ZeevexConcurrency::Delayed)
+      @queue << to_run
+      to_run
+    end
+
+    def <<(callable)
+      enqueue(callable)
+    end
+
+    def flush
+      @queue.clear
+    end
+
+    def backlog
+      @queue.size
+    end
+
+    def reset
+      stop
+      flush
+      start
+    end
+
+    #
+    # Returns true if the method was called from code executing on the event loop's thread
+    #
+    def in_event_loop?
+      Thread.current.object_id == @thread.object_id
+    end
+
+    #
+    # Runs a computation on the event loop. Does not deadlock if currently on the event loop, but
+    # will not preserve ordering either - it runs the computation immediately despite other events
+    # in the queue
+    #
+    def on_event_loop(runnable = nil, &block)
+      return unless runnable || block_given?
+      promise = (runnable && runnable.is_a?(ZeevexConcurrency::Delayed)) ?
+                 runnable :
+                 ZeevexConcurrency::Promise.create(runnable, &block)
+      if in_event_loop?
+        promise.call
+        promise
+      else
+        enqueue promise, &block
+      end
+    end
+
+    #
+    # Returns the value from the computation rather than a Promise.  Has similar semantics to
+    # `on_event_loop` - if this is called from the event loop, it just executes the
+    # computation synchronously ahead of any other queued computations
+    #
+    def run_and_wait(runnable = nil, &block)
+      promise = on_event_loop(runnable, &block)
+      promise.value
+    end
+
+    protected
+
+    def process
+      while !@stop_requested
+        begin
+          process_one
+        rescue
+          ZeevexConcurrency.logger.error %{Exception caught in event loop: #{$!.inspect}: #{$!.backtrace.join("\n")}}
+        end
+      end
+    end
+
+    def process_one
+      @queue.pop.call
+    end
+
+    public
+
+    # event loop which throws away all events without running, returning nil from all promises
+    class Null
+      def initialize(options = {}); end
+      def start; end
+      def stop; end
+      def enqueue(callable = nil, &block)
+        to_run = ZeevexConcurrency::Promise.new unless to_run.is_a?(ZeevexConcurrency::Delayed)
+        to_run.set_result { nil }
+        to_run
+      end
+      def in_event_loop?; false; end
+      def on_event_loop(runnable = nil, &block)
+        enqueue(runnable, &block)
+      end
+    end
+
+    # event loop which runs all events synchronously when enqueued
+    class Inline < ZeevexConcurrency::EventLoop
+      def start; end
+      def stop; end
+      def enqueue(callable = nil, &block)
+        res = super
+        process_one
+        res
+      end
+      def in_event_loop?; true; end
+    end
+
+  end
+end

data/lib/zeevex_concurrency/future.rb

@@ -0,0 +1,60 @@
+require 'observer'
+require 'timeout'
+require 'zeevex_concurrency/delayed'
+require 'zeevex_concurrency/event_loop'
+require 'zeevex_concurrency/thread_pool'
+
+class ZeevexConcurrency::Future < ZeevexConcurrency::Delayed
+  include Observable
+  include ZeevexConcurrency::Delayed::Bindable
+  include ZeevexConcurrency::Delayed::LatchBased
+  include ZeevexConcurrency::Delayed::Cancellable
+
+  # @@worker_pool = ZeevexConcurrency::EventLoop.new
+  @@worker_pool = ZeevexConcurrency::ThreadPool::FixedPool.new
+  @@worker_pool.start
+
+  def initialize(computation = nil, options = {}, &block)
+    raise ArgumentError, "Must provide computation or block for a future" unless (computation || block)
+
+    @mutex       = Mutex.new
+    @exec_mutex  = Mutex.new
+    @exception   = nil
+    @done        = false
+    @result      = false
+    @executed    = false
+
+    _initialize_latch
+
+    # has to happen after exec_mutex initialized
+    bind(computation, &block) if (computation || block)
+
+    Array(options.delete(:observer) || options.delete(:observers)).each do |observer|
+      add_observer observer
+    end
+  end
+
+  def self.shutdown
+    self.worker_pool.stop
+  end
+
+  def self.create(callable=nil, options = {}, &block)
+    nfuture = ZeevexConcurrency::Future.new(callable, options, &block)
+    (options.delete(:event_loop) || worker_pool).enqueue nfuture
+
+    nfuture
+  end
+
+  def self.worker_pool
+    @@worker_pool
+  end
+
+  def self.worker_pool=(pool)
+    @@worker_pool = pool
+  end
+
+  class << self
+    alias_method :future, :create
+  end
+end
+

data/lib/zeevex_concurrency/logging.rb

@@ -0,0 +1,7 @@
+module ZeevexConcurrency
+  module Logging
+    def logger
+      @logger || ZeevexConcurrency.logger
+    end
+  end
+end

data/lib/zeevex_concurrency/nil_logger.rb

@@ -0,0 +1,7 @@
+module ZeevexConcurrency
+  class NilLogger
+    def method_missing(symbol, *args)
+      nil
+    end
+  end
+end

data/lib/zeevex_concurrency/promise.rb

@@ -0,0 +1,32 @@
+require 'observer'
+require 'timeout'
+require 'zeevex_concurrency/delayed'
+
+class ZeevexConcurrency::Promise < ZeevexConcurrency::Delayed
+  include Observable
+  include ZeevexConcurrency::Delayed::Bindable
+  include ZeevexConcurrency::Delayed::LatchBased
+
+  def initialize(computation = nil, options = {}, &block)
+    @mutex       = Mutex.new
+    @exec_mutex  = Mutex.new
+    @exception   = nil
+    @done        = false
+    @result      = false
+    @executed    = false
+
+    _initialize_latch
+
+    # has to happen after exec_mutex initialized
+    bind(computation, &block) if (computation || block)
+
+    Array(options.delete(:observer) || options.delete(:observers)).each do |observer|
+      self.add_observer observer
+    end
+  end
+
+  def self.create(callable = nil, options = {}, &block)
+    return callable if callable && callable.is_a?(ZeevexConcurrency::Delayed)
+    new(callable, options, &block)
+  end
+end

data/lib/zeevex_concurrency/synchronized.rb

@@ -0,0 +1,46 @@
+# Alex's Ruby threading utilities - taken from https://github.com/alexdowad/showcase
+
+require 'thread'
+require 'zeevex_proxy'
+
+# Wraps an object, synchronizes all method calls
+# The wrapped object can also be set and read out
+#   which means this can also be used as a thread-safe reference
+#   (like a 'volatile' variable in Java)
+class ZeevexConcurrency::Synchronized < ZeevexProxy::Base
+  def initialize(obj)
+    super
+    @mutex = ::Mutex.new
+  end
+
+  def _set_synchronized_object(val)
+    @mutex.synchronize { @obj = val }
+  end
+  def _get_synchronized_object
+    @mutex.synchronize { @obj }
+  end
+
+  def respond_to?(method)
+    if [:_set_synchronized_object, :_get_synchronized_object].include?(method.to_sym)
+      true
+    else
+      @obj.respond_to?(method)
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    result = @mutex.synchronize { @obj.__send__(method, *args, &block) }
+    # result.__id__ == @obj.__id__ ? self : result
+  end
+end
+
+#
+# make object synchronized unless already synchronized
+#
+def ZeevexConcurrency.Synchronized(obj)
+  if obj.respond_to?(:_get_synchronized_object)
+    obj
+  else
+    ZeevexConcurrency::Synchronized.new(obj)
+  end
+end