concur 0.0.4 → 0.0.6

data/README.markdown

@@ -1 +1,29 @@
-# Concur - A concurrency library for Ruby inspired by java.util.concurrency
+# Concur - A concurrency library for Ruby inspired by java.util.concurrency
+
+## General Usage
+
+    # Choose which executor you want, there are several to choose from
+    executor = Concur::Executor.new_thread_pool_executor(10)
+    start_time = Time.now
+
+    jobs = []
+    times.times do |i|
+      future = executor.execute do
+        puts "hello #{i}"
+        "result #{i}"
+      end
+      jobs << future
+    end
+    jobs.each do |j|
+      puts "uber fast result=#{j.get}"
+    end
+    pooled_duration = Time.now - start_time
+    puts "pooled_duration=" + pooled_duration.to_s
+    executor.shutdown
+
+## Futures
+
+A Future is what is returned from the execute method. Call `future.get` to get the results of the block
+or the Callable object. If it's not finished, `get` will block until it is. `get` will also raise an Exception
+if an Exception occurred during running.
+

data/lib/concur.rb

@@ -1,15 +1,15 @@
-
-require_relative 'executor'
-
-require 'logger'
-module Concur
-  @@logger = Logger.new(STDOUT)
-
-  def self.logger
-    @@logger
-  end
-  def self.logger=(logger)
-    @@logger = logger
-  end
-
+
+require_relative 'executor'
+
+require 'logger'
+module Concur
+  @@logger = Logger.new(STDOUT)
+
+  def self.logger
+    @@logger
+  end
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
 end

data/lib/executor.rb

@@ -1,73 +1,86 @@
-require_relative 'runnable'
-require_relative 'future'
-require_relative 'thread_pool'
-
-
-module Concur
-
-
-  # Decouples task submission from how each task is run. An Executor can be backed by a thread pool or some
-  # other mechanism, but how you use the Executor won't change. This allows you to change the backend implementation
-  # with minor code changes.
-  #
-  # Inspired by java.util.concurrent.Executor
-  class Executor
-
-    attr_accessor :thread_pool
-
-    def initialize(options={})
-
-    end
-
-    def self.new_single_threaded_executor(options={})
-      executor = Executor.new
-      executor.thread_pool = SingleThreaded.new
-      executor
-    end
-
-    def self.new_multi_threaded_executor(options={})
-      executor = Executor.new
-      executor.thread_pool = MultiThreaded.new
-      executor
-    end
-
-    def self.new_thread_pool_executor(max_size, options={})
-      executor = Executor.new
-      executor.thread_pool = ThreadPool.new(max_size)
-      executor
-    end
-
-    def execute(runnable=nil, &blk)
-      f = Future.new(runnable, &blk)
-      @thread_pool.process(f)
-      f
-    end
-
-    def shutdown
-      @thread_pool.shutdown
-    end
-  end
-
-  # todo: should maybe have these backends extend Executor and just override what's necessary
-  class SingleThreaded
-    def process(f)
-      f.call
-    end
-
-    def shutdown
-    end
-  end
-
-  class MultiThreaded
-    def process(f)
-      @thread = Thread.new do
-        f.thread = @thread
-        f.call
-      end
-    end
-
-    def shutdown
-
-    end
-  end
-end
+require_relative 'runnable'
+require_relative 'future'
+require_relative 'thread_pool'
+
+
+module Concur
+
+
+  # Decouples task submission from how each task is run. An Executor can be backed by a thread pool or some
+  # other mechanism, but how you use the Executor won't change. This allows you to change the backend implementation
+  # with minor code changes.
+  #
+  # Inspired by java.util.concurrent.Executor
+  class Executor
+
+    attr_accessor :thread_pool
+
+    def initialize(options={})
+
+    end
+
+    def self.new_single_threaded_executor(options={})
+      executor = Executor.new
+      executor.thread_pool = SingleThreaded.new
+      executor
+    end
+
+    def self.new_multi_threaded_executor(options={})
+      executor = Executor.new
+      executor.thread_pool = MultiThreaded.new
+      executor
+    end
+
+    def self.new_thread_pool_executor(max_size, options={})
+      executor = Executor.new
+      executor.thread_pool = ThreadPool.new(max_size)
+      executor
+    end
+
+    def self.new_eventmachine_executor()
+      require_relative 'executors/event_machine_executor'
+      executor = EventMachineExecutor.new()
+      executor
+    end
+
+    # NOT WORKING
+    def self.new_neverblock_executor(max_size)
+      require_relative 'executors/never_block_executor'
+      executor = NeverBlockExecutor.new(max_size)
+      executor
+    end
+
+    def execute(runnable=nil, &blk)
+      f = StandardFuture.new(runnable, &blk)
+      @thread_pool.process(f)
+      f
+    end
+
+    def shutdown
+      @thread_pool.shutdown
+    end
+  end
+
+  # todo: should maybe have these backends extend Executor and just override what's necessary
+  class SingleThreaded
+    def process(f)
+      f.call
+    end
+
+    def shutdown
+    end
+  end
+
+  class MultiThreaded
+    def process(f)
+      @thread = Thread.new do
+        f.thread = @thread
+        f.call
+      end
+    end
+
+    def shutdown
+
+    end
+  end
+end

data/lib/executors/event_machine_executor.rb

@@ -0,0 +1,34 @@
+require 'eventmachine'
+require_relative '../futures/event_machine_future'
+
+module Concur
+  class EventMachineExecutor
+
+
+    def initialize
+      @futures = []
+      @em_thread = Thread.new do
+        EventMachine.run do
+          puts 'Starting EventMachineExecutor...'
+#          @futures.each do |f|
+#
+#          end
+        end
+        puts 'EventMachine loop done'
+      end
+    end
+
+    def execute(runnable=nil, &blk)
+      f = EventMachineFuture.new(runnable, &blk)
+#      @futures = f
+      EventMachine.schedule(f)
+      f
+    end
+
+    def shutdown
+      @em_thread.kill
+      puts 'shutdown'
+    end
+
+  end
+end

data/lib/executors/never_block_executor.rb

@@ -0,0 +1,27 @@
+
+require 'neverblock'
+
+# This doesn't work as expected. Not sure how to get it to non block on the IO calls
+
+module Concur
+  class NeverBlockExecutor
+
+    def initialize(max_size)
+      @fiber_pool = NeverBlock::Pool::FiberPool.new(max_size)
+    end
+
+    def execute(runnable=nil, &blk)
+      f = Future.new(runnable, &blk)
+      @fiber_pool.spawn do
+          puts 'running in spawn'
+        f.call
+      end
+      f
+    end
+
+    def shutdown
+
+    end
+
+  end
+end

data/lib/future.rb

@@ -1,53 +1,64 @@
-module Concur
-
-  #An Future is a class that captures the results of a threaded object so you can retreive the results later.
-  #This is what is returned from Executors.
-  class Future
-    attr_accessor :thread
-
-    def initialize(runnable=nil, &block)
-
-      @mutex = Mutex.new
-      @cv = ConditionVariable.new
-      @callable = runnable
-      if block_given?
-        @callable = block
-      end
-
-    end
-
-    def run
-      begin
-        @result = @callable.call
-      rescue Exception => ex
-        @ex = ex
-      end
-      @mutex.synchronize do # do we even need to synchronize? run should only ever be called once
-        @complete = true
-        @cv.broadcast
-      end
-    end
-
-    def call
-      run
-    end
-
-    def complete?
-      @complete
-    end
-
-    # Returns results. Will wait for thread to complete execution if not already complete.
-    def get
-#      @thread.value
-      @mutex.synchronize do
-        unless @complete
-          @cv.wait(@mutex)
-        end
-      end
-      if @ex
-        raise @ex
-      end
-      @result
-    end
-  end
-end
+#An Future is a class that captures the results of a threaded object so you can retrieve the results later.
+#This is what is returned from Executors.
+#
+# This particular Future can be used for synchronous blocks / runnables / callables that are run in a separate thread.
+
+module Concur
+
+  module Future
+    def future?
+      true
+    end
+  end
+
+  class StandardFuture
+    include Future
+
+    attr_accessor :thread, :ex
+
+    def initialize(runnable=nil, &block)
+
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+      @callable = runnable
+      if block_given?
+        @callable = block
+      end
+
+    end
+
+    def run
+      begin
+        @result = @callable.call
+      rescue Exception => ex
+        @ex = ex
+      end
+      @mutex.synchronize do # do we even need to synchronize? run should only ever be called once
+        @complete = true
+        @cv.broadcast
+      end
+    end
+
+    def call
+      run
+    end
+
+    def complete?
+      @complete
+    end
+
+    # Returns results. Will wait for thread to complete execution if not already complete.
+    def get
+#      @thread.value
+      @mutex.synchronize do
+        unless @complete
+          @cv.wait(@mutex)
+        end
+      end
+      if @ex
+        raise @ex
+      end
+      @result
+    end
+  end
+end

data/lib/futures/event_machine_future.rb

@@ -0,0 +1,164 @@
+# This future enables a blocking get for a result from EventMachine HTTP request.
+
+module Concur
+
+  class EventMachineError < StandardError
+
+    def initialize(callbackable)
+      super("Error in #{callbackable.class.name}")
+      @callbackable = callbackable
+
+    end
+  end
+
+  class EventMachineFutureCallback
+
+    def future?
+      true
+    end
+
+    attr_accessor :errblk, :callblk
+
+    def initialize(callbackable, &block)
+      puts 'EventMachineFutureCallback.initialize: ' + callbackable.inspect
+      @callbackable = callbackable
+      if block_given?
+        @callblk = block
+      end
+    end
+
+    def run
+
+#      http = @callbackable
+#      http.errback {
+#        @ex = EventMachineError.new(http)
+#        complete
+#      }
+#      http.callback {
+#        if @callback
+#          @callback.call(@callbackable)
+#        end
+#        complete
+#      }
+
+
+    end
+    def errback &blk
+        @errblk = blk
+      end
+
+      def callback &blk
+        @callblk = blk
+      end
+
+    def errback2 &blk
+      puts 'EventMachineFutureCallback.errback'
+      proc = Proc.new do
+        puts 'errback proc'
+        blk.call(@callbackable)
+      end
+      puts 'setting errback on ' + @callbackable.inspect
+      @callbackable.errback &proc
+      puts 'errback set'
+    end
+
+    def callback2 &blk
+      puts 'EventMachineFutureCallback.callback'
+      proc = Proc.new do
+        @result = []
+        if @callblk
+          @result = @callblk.call(@callbackable)
+        end
+        blk.call(@result)        
+      end
+      @callbackable.callback &proc
+    end
+#
+#    def call_callback(response)
+#      puts 'call_callback=' + response.inspect
+#      return unless callblk
+#      callblk.call(response)
+#    end
+#
+#    def call_errback(response)
+#      return unless errblk
+#      errblk.call(response)
+#    end
+  end
+
+  class EventMachineFuture
+    include Concur::Future
+
+    attr_accessor :ex,:result
+
+    def initialize(callable, &block)
+
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+      @callable = callable
+      if block_given?
+        @callable = block
+      end
+    end
+
+
+    def run
+      puts 'EMFuture.run'
+      p @callable
+      begin
+        @callbackable = @callable.call
+        puts 'done @callable.call ' + @callbackable.inspect
+      rescue Exception => ex
+        @ex = ex
+      end
+      if @ex
+        complete
+        return
+      end
+
+      http = @callbackable
+      http.errback2 {
+        puts 'completion errback'
+        @ex = EventMachineError.new(http)
+        complete
+      }
+      @result = (http.callback2 {|result|
+        @result = result
+        complete
+      })
+      puts '@result=' + @result.inspect
+
+    end
+
+    def call
+      run
+    end
+
+    def complete
+      @complete = true
+    end
+
+
+    def complete?
+      @complete
+    end
+
+    # Returns results. Will wait for thread to complete execution if not already complete.
+    def get
+#      @thread.value
+      while not @complete
+        # todo: gotta be a better way
+        puts 'sleeping'
+        sleep 0.5
+      end
+      return get_response
+    end
+
+    def get_response
+      if @ex
+        raise @ex
+      end
+      @result
+    end
+  end
+end

data/lib/runnable.rb

@@ -1,13 +1,13 @@
-
-# A mixin for runnable classes.
-module Concur
-  module Runnable
-    def run
-      raise "No run method defined in your runable!"
-    end
-
-    def call
-      run
-    end
-  end
-end
+
+# A mixin for runnable classes.
+module Concur
+  module Runnable
+    def run
+      raise "No run method defined in your runable!"
+    end
+
+    def call
+      run
+    end
+  end
+end

data/lib/thread_pool.rb

@@ -1,62 +1,62 @@
-require 'thread'
-begin
-  require 'fastthread'
-rescue LoadError
-  $stderr.puts "Using the ruby-core thread implementation"
-end
-
-module Concur
-
-  # Another example is here: # from: http://stackoverflow.com/questions/81788/deadlock-in-threadpool
-  class ThreadPool
-    def initialize(max_size)
-      @max_size = max_size
-#      @thread_queue = SizedQueue.new(max_size)
-      @running = true
-      @mutex = Mutex.new
-      @cv = ConditionVariable.new
-      @queue = Queue.new
-      @threads = []
-
-    end
-
-    def shutdown
-      @running = false
-    end
-
-    def process(callable, &blk)
-      callable = blk if block_given?
-      @queue.push(callable)
-      start_thread
-    end
-
-    def start_thread
-      @mutex.synchronize do
-        if !@queue.empty? && @threads.size <= @max_size
-          t = UberThread.new do
-            while @running
-              f = @queue.pop
-              f.thread = t
-              f.call
-            end
-#            Concur.logger.info "Thread dying " + t.inspect
-          end
-          Concur.logger.debug "Created new thread " + t.inspect
-          @threads << t
-        end
-      end
-    end
-
-    class UberThread < Thread
-
-      def initialize
-        super
-      end
-
-    end
-
-  end
-
-
-
-end
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+  $stderr.puts "Using the ruby-core thread implementation"
+end
+
+module Concur
+
+  # Another example is here: # from: http://stackoverflow.com/questions/81788/deadlock-in-threadpool
+  class ThreadPool
+    def initialize(max_size)
+      @max_size = max_size
+#      @thread_queue = SizedQueue.new(max_size)
+      @running = true
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+      @queue = Queue.new
+      @threads = []
+
+    end
+
+    def shutdown
+      @running = false
+    end
+
+    def process(callable, &blk)
+      callable = blk if block_given?
+      @queue.push(callable)
+      start_thread
+    end
+
+    def start_thread
+      @mutex.synchronize do
+        if !@queue.empty? && @threads.size <= @max_size
+          t = UberThread.new do
+            while @running
+              f = @queue.pop
+              f.thread = t
+              f.call
+            end
+#            Concur.logger.info "Thread dying " + t.inspect
+          end
+          Concur.logger.debug "Created new thread " + t.inspect
+          @threads << t
+        end
+      end
+    end
+
+    class UberThread < Thread
+
+      def initialize
+        super
+      end
+
+    end
+
+  end
+
+
+
+end

data/test/executor_spec.rb

@@ -1,82 +1,87 @@
-require 'rspec'
-
-require_relative '../lib/concur'
-require_relative 'job'
-
-describe Concur::Executor do
-  describe "#score" do
-    it "runs faster in parallel" do
-      times = 10
-
-      job = Job.new(1)
-      puts 'runnable? ' + job.is_a?(Concur::Runnable).to_s
-      start_time = Time.now
-      times.times do |i|
-        job = Job.new(i)
-        job.run
-      end
-      non_concurrent_duration = Time.now - start_time
-      puts "duration=" + non_concurrent_duration.to_s
-
-      puts '---------------'
-
-      puts "Now for concurrent"
-      executor = Concur::Executor.new_multi_threaded_executor
-      start_time = Time.now
-
-      jobs = []
-      times.times do |i|
-        job = Job.new(i)
-        jobs << executor.execute(job)
-      end
-      jobs.each do |j|
-        puts "uber fast result=#{j.get}"
-      end
-      concurrent_duration = Time.now - start_time
-      puts "duration=" + concurrent_duration.to_s
-
-      concurrent_duration.should be < (non_concurrent_duration/2)
-
-      puts "Now for pooled"
-      executor = Concur::Executor.new_thread_pool_executor(10)
-      start_time = Time.now
-
-      jobs = []
-      times.times do |i|
-        job = Job.new(i)
-        future = executor.execute(job)
-        jobs << future
-      end
-      jobs.each do |j|
-        puts "uber fast result=#{j.get}"
-      end
-      pooled_duration = Time.now - start_time
-      puts "pooled_duration=" + pooled_duration.to_s
-
-      pooled_duration.should be < (non_concurrent_duration/2)
-#      pooled_duration.should_be > concurrent_duration
-
-      executor.shutdown
-
-    end
-  end
-end
-
-describe Concur::Future do
-
-  describe "#new" do
-
-    it "can accept blocks" do
-      future = Concur::Future.new do
-        puts "i'm in the block"
-        "result of block"
-      end
-      puts 'get=' + future.get
-      future.get.should == "result of block"
-    end
-
-  end
-
-end
-
-
+require 'rspec'
+require 'neverblock'
+
+require_relative '../lib/concur'
+require_relative 'job'
+
+@@durations = []
+
+def run_jobs(name, executor, times, options={})
+  puts "Running #{name}..."
+  start_time = Time.now
+
+  jobs = []
+  times.times do |i|
+    job = Job.new(i, options)
+    jobs << executor.execute(job)
+  end
+  jobs.each do |j|
+    puts "result=#{j.get}"
+  end
+  concurrent_duration = Time.now - start_time
+o = "#{name} duration=" + concurrent_duration.to_s
+  puts o
+  @@durations << o
+  concurrent_duration
+end
+
+describe Concur::Executor do
+  describe "#score" do
+    it "runs faster in parallel" do
+      times = 10
+
+      job = Job.new(1)
+      puts 'runnable? ' + job.is_a?(Concur::Runnable).to_s
+      non_concurrent_duration = 0
+#
+      executor = Concur::Executor.new_single_threaded_executor
+      non_concurrent_duration =run_jobs("non concurrent", executor, times)
+      executor.shutdown
+
+      executor = Concur::Executor.new_multi_threaded_executor
+      concurrent_duration = run_jobs("multi thread", executor, times)
+      concurrent_duration.should be < (non_concurrent_duration/2)
+      executor.shutdown
+
+      executor = Concur::Executor.new_thread_pool_executor(10)
+      pooled_duration = run_jobs("thread pool", executor, times)
+      pooled_duration.should be < (non_concurrent_duration/2)
+      executor.shutdown
+
+      # Don't think I know how to use NeverBlock properly
+#      executor = Concur::Executor.new_neverblock_executor(10)
+#      neverblock_duration = run_jobs("never blocked", executor, times)
+#      neverblock_duration.should be < (non_concurrent_duration/2)
+#      executor.shutdown
+
+      executor = Concur::Executor.new_eventmachine_executor()
+      em_duration = run_jobs("eventmachine", executor, times, :em=>true)
+      em_duration.should be < (non_concurrent_duration/2)
+      executor.shutdown
+
+      @@durations.each do |s|
+        puts s
+      end
+
+    end
+  end
+end
+
+describe Concur::Future do
+
+  describe "#new" do
+
+    it "can accept blocks" do
+      future = Concur::Future.new do
+        puts "i'm in the block"
+        "result of block"
+      end
+      puts 'get=' + future.get
+      future.get.should == "result of block"
+    end
+
+  end
+
+end
+
+

data/test/job.rb

@@ -1,16 +1,51 @@
-require_relative '../lib/runnable'
-
-class Job
-  include Concur::Runnable
-
-  def initialize(i)
-    @i = i
-  end
-
-  def run
-    sleep 3
-    puts "Finished #{@i}"
-    "response #{@i}"
-  end
-
+require_relative '../lib/runnable'
+require 'rest-client'
+require 'eventmachine'
+
+class Job
+  include Concur::Runnable
+
+  def initialize(i, options={})
+    @i = i
+    if options[:em]
+      @em = true
+    end
+  end
+
+  def em_request(url)
+    puts 'emrequest for ' + url
+    http = EventMachine::Protocols::HttpClient.request(
+        :host => url,
+        :port => 80,
+        :request => "/"
+    )
+    http.callback { |response|
+      puts response[:status]
+      puts response[:headers]
+      puts response[:content]
+    }
+  end
+
+  def run
+    puts "Starting #{@i}... em? #{@em}"
+#    sleep 1
+    urls = ["www.yahoo.com", "www.microsoft.com"] # , "www.github.com"
+    if @em
+      urls.each do |u|
+        em_request(u)
+      end
+    else
+      urls.each do |u|
+        get(u)
+      end
+    end
+    puts "Finished #{@i}"
+    "response #{@i}"
+  end
+
+  def get(url)
+    puts 'getting ' + url
+    RestClient.get "http://#{url}"
+  end
+
 end

metadata

@@ -1,69 +1,65 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: concur
-version: !ruby/object:Gem::Version
-  version: 0.0.4
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.6
 platform: ruby
-authors:
+authors: 
 - Travis Reeder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-03-10 00:00:00.000000000 -08:00
-default_executable: 
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: &25999668 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *25999668
-description: A concurrency library for Ruby inspired by java.util.concurrency. By
-  http://www.appoxy.com
+
+date: 2011-05-02 00:00:00 Z
+dependencies: []
+
+description: A concurrency library for Ruby inspired by java.util.concurrency. By http://www.appoxy.com
 email: travis@appoxy.com
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - README.markdown
-files:
+files: 
 - lib/concur.rb
 - lib/executor.rb
+- lib/executors/event_machine_executor.rb
+- lib/executors/never_block_executor.rb
 - lib/future.rb
+- lib/futures/event_machine_future.rb
 - lib/runnable.rb
 - lib/thread_pool.rb
 - README.markdown
 - test/executor_spec.rb
 - test/job.rb
-has_rdoc: true
 homepage: http://github.com/appoxy/concur/
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A concurrency library for Ruby inspired by java.util.concurrency. By http://www.appoxy.com
-test_files:
+test_files: 
 - test/executor_spec.rb
 - test/job.rb