zeevex_concurrency 0.0.1

data/lib/zeevex_concurrency/thread_pool.rb

@@ -0,0 +1,346 @@
+require 'zeevex_concurrency'
+require 'zeevex_concurrency/event_loop'
+require 'countdownlatch'
+require 'thread'
+require 'atomic'
+
+module ZeevexConcurrency::ThreadPool
+  module Stubs
+    def busy?
+      free_count == 0
+    end
+
+    def worker_count
+      -1
+    end
+
+    def busy_count
+      -1
+    end
+
+    def free_count
+      (worker_count - busy_count)
+    end
+
+    #
+    # flush any queued but un-executed tasks
+    #
+    def flush
+      true
+    end
+
+    #
+    # Returns after all currently enqueued tasks complete - does not guarantee
+    # that tasks are not enqueued while waiting
+    #
+    def join
+      latch = CountDownLatch.new(1)
+      enqueue do
+        latch.countdown!
+      end
+      latch.wait
+      true
+    end
+
+    #
+    # how many tasks are waiting
+    #
+    def backlog
+      0
+    end
+
+    protected
+
+    def _check_args(*args)
+      args = args.reject {|f| f.nil? || !f.respond_to?(:call) }
+      raise ArgumentError, "Must supply a callable or block" unless args.length == 1
+      args[0]
+    end
+  end
+  #
+  # Use a single-threaded event loop to process jobs
+  #
+  class EventLoopAdapter
+    include Stubs
+
+    def initialize(loop = nil)
+      @loop ||= ZeevexConcurrency::EventLoop.new
+      start
+    end
+
+    def start
+      @loop.start
+    end
+
+    def stop
+      @loop.stop
+    end
+
+    def enqueue(callable = nil, &block)
+      @loop.enqueue _check_args(callable, block)
+    end
+
+    def flush
+      @loop.flush
+      true
+    end
+
+    def backlog
+      @loop.backlog
+    end
+  end
+
+  #
+  # Run job semi-synchronously (on a separate thread, but block on it)
+  # We use a separate thread
+  #
+  class InlineThreadPool
+    include Stubs
+
+    def initialize(loop = nil)
+      start
+    end
+
+    def start
+      @started = true
+    end
+
+    def stop
+      @started = false
+    end
+
+    def join
+      true
+    end
+
+    def enqueue(callable = nil, &block)
+      raise "Must be started" unless @started
+      callable = _check_args(callable, block)
+      thr = Thread.new do
+        callable.call
+      end
+      thr.join
+    end
+  end
+
+  #
+  # Launch a concurrent thread for every new task enqueued
+  #
+  class ThreadPerJobPool
+    include Stubs
+
+    def initialize
+      @mutex = Mutex.new
+      @group = ThreadGroup.new
+      @busy_count = Atomic.new(0)
+
+      start
+    end
+
+    def enqueue(runnable = nil, &block)
+      raise "Must be started" unless @started
+      callable = _check_args(runnable, block)
+      thr = Thread.new do
+        @busy_count.update {|x| x + 1}
+        callable.call
+        @busy_count.update {|x| x - 1}
+      end
+      @group.add(thr)
+    end
+
+    def start
+      @started = true
+    end
+
+    def join
+      @group.list.dup.each do |thr|
+        thr.join
+      end
+      true
+    end
+
+    def stop
+      @mutex.synchronize do
+        return unless @started
+
+        @group.list.dup.each do |thr|
+          thr.kill
+        end
+
+        @started = false
+        @busy_count.set 0
+      end
+    end
+
+    def busy_count
+      @busy_count.value
+    end
+
+    def busy
+      false
+    end
+
+    def worker_count
+      @busy_count.value
+    end
+  end
+
+  #
+  # Use a fixed pool of N threads to process jobs
+  #
+  class FixedPool
+    include Stubs
+
+    def initialize(count = -1)
+      if count == -1
+        count = ZeevexConcurrency::ThreadPool.cpu_count * 2
+      end
+      @count = count
+      @queue = Queue.new
+      @mutex = Mutex.new
+      @group = ThreadGroup.new
+      @busy_count = Atomic.new(0)
+
+      start
+    end
+
+    def enqueue(runnable = nil, &block)
+      @queue << _check_args(runnable, block)
+    end
+
+    def start
+      @mutex.synchronize do
+        return if @started
+
+        @stop_requested = false
+
+        @count.times do
+          thr = Thread.new(@queue) do
+            while !@stop_requested
+              begin
+                work = @queue.pop
+
+                # notify that this thread is stopping and wait for the signal to continue
+                if work.is_a?(HaltObject)
+                  work.halt!
+                  continue
+                end
+
+                _start_work
+                work.call
+                _end_work
+              rescue Exception
+                ZeevexConcurrency.logger.error %{Exception caught in thread pool: #{$!.inspect}: #{$!.backtrace.join("\n")}}
+              end
+            end
+          end
+          @group.add(thr)
+        end
+
+        @started = true
+      end
+    end
+
+    def stop
+      @mutex.synchronize do
+        return unless @started
+
+        @stop_requested = true
+
+        @group.list.each do |thr|
+          thr.kill
+        end
+
+        @busy_count.set 0
+        @started = false
+      end
+    end
+
+    def busy?
+      free_count == 0
+    end
+
+    def worker_count
+      @count
+    end
+
+    def busy_count
+      @busy_count.value
+    end
+
+    def free_count
+      (worker_count - busy_count)
+    end
+
+    #
+    # how many tasks are waiting
+    #
+    def backlog
+      @queue.size
+    end
+
+    # flush queued jobs
+    def flush
+      @queue.clear
+    end
+
+    #
+    # this is tricky as there may be one or more workers stuck in VERY long running jobs
+    # so what we do is:
+    #
+    # Insert a job that stops processing
+    # When it runs, we can be sure that all previous jobs have popped off the queue
+    # However, previous jobs may still be running
+    # So we have to ask each thread to pause until they've all paused
+    #
+    def join
+      halter = HaltObject.new(@count)
+
+      # ensure each thread gets a copy
+      @count.times { @queue << halter }
+
+      # wait until every thread has entered
+      halter.wait
+    end
+
+    class HaltObject
+      def initialize(count)
+        @count = count
+        @latch = CountDownLatch.new(count)
+      end
+
+      def halt!
+        # notify that we're now waiting
+        @latch.countdown!
+        @latch.wait
+      end
+
+      def wait
+        @latch.wait
+      end
+    end
+
+    protected
+
+    def _start_work
+      @busy_count.update {|x| x + 1 }
+    end
+
+    def _end_work
+      @busy_count.update {|x| x - 1 }
+    end
+
+  end
+
+  #
+  # Return the number of CPUs reported by the system
+  #
+  def self.cpu_count
+    return Java::Java.lang.Runtime.getRuntime.availableProcessors if defined? Java::Java
+    return File.read('/proc/cpuinfo').scan(/^processor\s*:/).size if File.exist? '/proc/cpuinfo'
+    require 'win32ole'
+    WIN32OLE.connect("winmgmts://").ExecQuery("select * from Win32_ComputerSystem").NumberOfProcessors
+  rescue LoadError
+    Integer `sysctl -n hw.ncpu 2>/dev/null` rescue 1
+  end
+end

data/lib/zeevex_concurrency/version.rb

@@ -0,0 +1,3 @@
+module ZeevexConcurrency
+  VERSION = "0.0.1"
+end

data/lib/zeevex_concurrency.rb

@@ -0,0 +1,29 @@
+require "zeevex_concurrency/version"
+
+module ZeevexConcurrency
+  module All
+    def self.included(base)
+      base.class_eval do
+        include ZeevexConcurrency::Logging
+      end
+    end
+  end
+  
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(logger)
+    @logger = ZeevexConcurrency::Synchronized(logger)
+  end
+end
+
+require 'zeevex_concurrency/synchronized'
+
+require 'logger'
+require 'zeevex_concurrency/nil_logger'
+
+ZeevexConcurrency.logger = ZeevexConcurrency::NilLogger.new
+
+require 'zeevex_concurrency/logging'
+require 'zeevex_concurrency/event_loop'

data/script/repl

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'pry'
+require 'zeevex_concurrency'
+require 'zeevex_concurrency/delayed'
+require 'zeevex_concurrency/future'
+require 'zeevex_concurrency/promise'
+require 'zeevex_concurrency/delay'
+
+binding.pry

data/script/testall

@@ -0,0 +1,2 @@
+#!/bin/zsh
+rvm ruby-1.8.7-p371@zeevex_concurrency,1.9.3-p327@zeevex_concurrency,jruby-1.7.0@zeevex_concurrency do bundle exec rspec

data/spec/delay_spec.rb

@@ -0,0 +1,172 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'zeevex_concurrency/delay.rb'
+
+describe ZeevexConcurrency::Delay do
+  clazz = ZeevexConcurrency::Delay
+
+  before do
+    @counter = 200
+  end
+  let :proccy do
+    Proc.new { @counter += 1}
+  end
+
+  around :each do |ex|
+    Timeout::timeout(30) do
+      ex.run
+    end
+  end
+
+  context 'argument checking' do
+    it 'should not allow neither a callable nor a block' do
+      expect { clazz.new }.
+        to raise_error(ArgumentError)
+    end
+
+    it 'should not allow both a callable AND a block' do
+      expect {
+        clazz.new(Proc.new { 2 }) do
+          1
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should accept a proc' do
+      expect { clazz.new(Proc.new {}) }.
+        not_to raise_error(ArgumentError)
+    end
+
+    it 'should accept a block' do
+      expect {
+        clazz.new do
+          1
+        end
+      }.not_to raise_error(ArgumentError)
+    end
+  end
+
+  context 'at creation time' do
+    subject { clazz.new(proccy) }
+    it { should be_ready }
+  end
+
+  context 'after first deference' do
+    subject { clazz.new(proccy) }
+    before do
+      subject.value
+    end
+
+    it          { should be_ready }
+    its(:value) { should == 201 }
+    it 'should return same value for repeated calls' do
+      subject.value
+      subject.value.should == 201
+    end
+  end
+
+  context 'with exception' do
+    class FooBar < StandardError; end
+    subject do
+      clazz.new lambda {
+        raise FooBar, "test"
+      }
+    end
+
+    it { should be_ready }
+    it 'should reraise exception' do
+      expect { subject.value }.
+        to raise_error(FooBar)
+    end
+
+    it 'should optionally not reraise' do
+      expect { subject.value(false) }.
+        not_to raise_error(FooBar)
+      subject.value(false).should be_a(FooBar)
+    end
+  end
+
+  context '#wait' do
+    subject { clazz.new(proccy) }
+
+    it 'should return immediately' do
+      t_start = Time.now
+      res = subject.wait 2
+      t_end = Time.now
+      (t_end-t_start).round.should == 0
+      res.should be_true
+    end
+  end
+
+  context 'observing' do
+    subject { clazz.new(proccy) }
+    let :observer do
+      mock()
+    end
+
+    it 'should notify observer after value deref' do
+      observer.should_receive(:update).with(subject, 201, true)
+      subject.add_observer observer
+      subject.value
+    end
+
+    it 'should notify observer after value deref raises exception' do
+      edelay = clazz.new(Proc.new { raise "foo" })
+      observer.should_receive(:update).with(edelay, kind_of(Exception), false)
+      edelay.add_observer observer
+      edelay.value rescue nil
+    end
+  end
+
+  context 'access from multiple threads' do
+
+    let :pause_queue do
+      Queue.new
+    end
+
+    subject {
+      clazz.new do
+        pause_queue.pop
+        @counter += 1
+      end
+    }
+    let :queue do
+      Queue.new
+    end
+
+    before do
+      subject
+      queue
+      pause_queue
+
+      threads = []
+      5.times do
+        threads << Thread.new do
+          queue << subject.value
+        end
+      end
+      Thread.pass
+      @queue_size_before_set = queue.size
+      pause_queue << "foo"
+      threads.map &:join
+    end
+
+    it 'should block all threads before value derefed' do
+      @queue_size_before_set.should == 0
+    end
+
+    it 'should allow all threads to receive a value' do
+      queue.size.should == 5
+    end
+
+    it 'should only evaluate the computation once' do
+      @counter.should == 201
+    end
+
+    it 'should send the same value to all threads' do
+      list = []
+      5.times { list << queue.pop }
+      list.should == [201,201,201,201,201]
+    end
+  end
+end
+

data/spec/delayed_spec.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'zeevex_concurrency/delayed.rb'
+require 'zeevex_concurrency/promise.rb'
+require 'zeevex_concurrency/future.rb'
+require 'zeevex_concurrency/delay.rb'
+
+describe ZeevexConcurrency::Delayed do
+  clazz = ZeevexConcurrency
+
+  context 'creation' do
+    context '#promise' do
+      it 'should create a promise with a block' do
+        clazz.promise do
+        end.should be_a(ZeevexConcurrency::Promise)
+      end
+
+      it 'should create a promise with no arg or block' do
+        clazz.promise.should be_a(ZeevexConcurrency::Promise)
+      end
+    end
+
+    context '#future' do
+      it 'should create a future' do
+        clazz.future do
+        end.should be_a(ZeevexConcurrency::Future)
+      end
+    end
+
+    context '#delay' do
+      it 'should create a delay given a block' do
+        clazz.delay do
+        end.should be_a(ZeevexConcurrency::Delay)
+      end
+    end
+  end
+
+  context 'typing' do
+    let :efuture do
+      ZeevexConcurrency.future(Proc.new {})
+    end
+    let :epromise do
+      ZeevexConcurrency.promise(Proc.new {})
+    end
+    let :edelay do 
+      ZeevexConcurrency.delay(Proc.new {})
+    end
+    let :eproc do
+      Proc.new {}
+    end
+    context '#delayed?' do
+      it 'should be true for a promise' do
+        clazz.delayed?(epromise).should be_true
+      end
+      it 'should be true for a future' do
+        clazz.delayed?(efuture).should be_true
+      end
+      it 'should be true for a delay' do
+        clazz.delayed?(edelay).should be_true
+      end
+      it 'should not be true for a proc' do
+        clazz.delayed?(eproc).should be_false
+      end
+    end
+
+    context '#future?' do
+      it 'should be true for a future' do
+        clazz.future?(efuture).should be_true
+      end
+
+      it 'should be false for a promise' do
+        clazz.future?(epromise).should be_false
+      end
+
+      it 'should be false for a delay' do
+        clazz.future?(edelay).should be_false
+      end
+    end
+
+    context '#promise?' do
+      it 'should be true for a promise' do
+        clazz.promise?(epromise).should be_true
+      end
+      it 'should be false for a future' do
+        clazz.promise?(efuture).should be_false
+      end
+      it 'should be false for a delay' do
+        clazz.promise?(edelay).should be_false
+      end
+    end
+
+    context '#delay?' do
+      it 'should be true for a delay' do
+        clazz.delay?(edelay).should be_true
+      end
+      it 'should be false for a promise' do
+        clazz.delay?(epromise).should be_false
+      end
+      it 'should be false for a future' do
+        clazz.delay?(efuture).should be_false
+      end
+    end
+  end
+end
+