concur 0.0.8 → 0.1.0

data/README.markdown

@@ -21,6 +21,31 @@
     puts "pooled_duration=" + pooled_duration.to_s
     executor.shutdown
 
+## EventMachine / Non-blocking I/O
+
+Perhaps more important/interesting these days is EventMachine/non-blocking io. When your program is io bound you can
+get similar performance (if not better) on a single thread as you can with multi-threads.
+
+    # Create an EventMachineExecutor
+    executor = Concur::Executor.new_eventmachine_executor()
+
+    # Now fire off a bunch of http requests
+    futures = []
+    TestConcur.urls.each do |url|
+      params_to_send = {}
+      params_to_send[:base_url] = url
+      params_to_send[:path] = "/"
+      params_to_send[:http_method] = :get
+      futures << executor.http_request(params_to_send)
+    end
+    futures.each do |f|
+      puts 'got=' + f.get.inspect
+      assert f.get.status >= 200 && f.get.status < 400
+    end
+
+
+See https://github.com/appoxy/concur/blob/master/test/test_concur.rb for more examples.
+
 ## Futures
 
 A Future is what is returned from the execute method. Call `future.get` to get the results of the block

data/lib/concur.rb

@@ -1,5 +1,6 @@
 
 require_relative 'executor'
+require_relative 'thread_pool'
 
 require 'logger'
 module Concur

data/lib/executor.rb

@@ -1,39 +1,81 @@
 require 'faraday'
 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
+  module Executor
+
+    class Base
+      def initialize(options={})
+
+      end
+
+
+      def shutdown
+
+      end
 
-    attr_accessor :thread_pool
+      def execute
+        raise "execute() not implemented, this is an invalid implemention."
+      end
+
+      def http_request(params, &blk)
+
+        f = StandardFuture.new do
+          conn = Faraday.new(:url => params[:base_url]) do |builder|
+  #          builder.use Faraday::Request::UrlEncoded # convert request params as "www-form-urlencoded"
+  #          builder.use Faraday::Request::JSON # encode request params as json
+  #          builder.use Faraday::Response::Logger # log the request to STDOUT
+            builder.use Faraday::Adapter::NetHttp # make http requests with Net::HTTP
+  #
+  #          # or, use shortcuts:
+  #          builder.request :url_encoded
+  #          builder.request :json
+  #          builder.response :logger
+  #          builder.adapter :net_http
+          end
+          if params[:http_method] == :post
+            response = conn.post params[:path]
+          else
+            response = conn.get params[:path]
+          end
+          if block_given?
+            response = blk.call(response)
+          end
+          response
+        end
+        @thread_pool.process(f)
+        f
+      end
 
-    def initialize(options={})
 
+      def queue_size
+        0
+      end
     end
 
+
     def self.new_single_threaded_executor(options={})
-      executor = Executor.new
-      executor.thread_pool = SingleThreaded.new
+      #executor = Executor.new
+      executor = SingleThreaded.new
       executor
     end
 
     def self.new_multi_threaded_executor(options={})
-      executor = Executor.new
-      executor.thread_pool = MultiThreaded.new
+      #executor = Executor.new
+      executor = MultiThreaded.new
       executor
     end
 
     def self.new_thread_pool_executor(max_size, options={})
-      executor = Executor.new
-      executor.thread_pool = ThreadPool.new(max_size)
+      #executor = Executor.new
+      executor = ThreadPool.new(max_size)
       executor
     end
 
@@ -50,60 +92,26 @@ module Concur
       executor
     end
 
-    def execute(runnable=nil, &blk)
-      f = StandardFuture.new(runnable, &blk)
-      @thread_pool.process(f)
-      f
-    end
-
-    def shutdown
-      @thread_pool.shutdown
-    end
-
-    def http_request(params, &blk)
-
-      f = StandardFuture.new do
-        conn = Faraday.new(:url => params[:base_url]) do |builder|
-#          builder.use Faraday::Request::UrlEncoded # convert request params as "www-form-urlencoded"
-#          builder.use Faraday::Request::JSON # encode request params as json
-#          builder.use Faraday::Response::Logger # log the request to STDOUT
-          builder.use Faraday::Adapter::NetHttp # make http requests with Net::HTTP
-#
-#          # or, use shortcuts:
-#          builder.request :url_encoded
-#          builder.request :json
-#          builder.response :logger
-#          builder.adapter :net_http
-        end
-        if params[:http_method] == :post
-          response = conn.post params[:path]
-        else
-          response = conn.get params[:path]
-        end
-        if block_given?
-          response = blk.call(response)
-        end
-        response
-      end
-      @thread_pool.process(f)
-      f
-    end
-
 
   end
 
 
   # todo: should maybe have these backends extend Executor and just override what's necessary
-  class SingleThreaded
+  class SingleThreaded < Executor::Base
     def process(f)
       f.call
     end
 
+    def execute(f)
+      process(f)
+    end
+
     def shutdown
     end
   end
 
-  class MultiThreaded
+  # Spins off a new thread per job
+  class MultiThreaded < Executor::Base
     def process(f)
       @thread = Thread.new do
         f.thread = @thread
@@ -111,6 +119,10 @@ module Concur
       end
     end
 
+    def execute(f)
+      process(f)
+    end
+
     def shutdown
 
     end

data/lib/executors/event_machine_executor.rb

@@ -2,7 +2,7 @@ require 'eventmachine'
 require_relative '../futures/event_machine_future'
 
 module Concur
-  class EventMachineExecutor
+  class EventMachineExecutor < Executor::Base
 
     def initialize
       unless EventMachine.reactor_running? # also check EventMachine.reactor_thread? ??

data/lib/future.rb

@@ -28,12 +28,12 @@ module Concur
     end
 
     def run
-      puts 'running StandardFuture'
+      #Concur.logger.debug 'running StandardFuture'
       begin
         @result = @callable.call
-        puts 'callable called: ' + @result.inspect
+        Concur.logger.debug 'callable result: ' + @result.inspect
       rescue Exception => ex
-        puts 'error occurred'
+        Concur.logger.debug "Error occurred! #{ex.class.name}: #{ex.message}"
         @ex = ex
       end
       @mutex.synchronize do # do we even need to synchronize? run should only ever be called once

data/lib/thread_pool.rb

@@ -2,13 +2,16 @@ require 'thread'
 begin
   require 'fastthread'
 rescue LoadError
-  $stderr.puts "Using the ruby-core thread implementation"
+  # $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
+  class ThreadPool < Executor::Base
+
+    attr_reader :queue
+
     def initialize(max_size)
       @max_size = max_size
 #      @thread_queue = SizedQueue.new(max_size)
@@ -24,12 +27,20 @@ module Concur
       @running = false
     end
 
+
     def process(callable, &blk)
       callable = blk if block_given?
       @queue.push(callable)
       start_thread
     end
 
+    def execute(runnable=nil, &blk)
+      f = StandardFuture.new(runnable, &blk)
+      process(f)
+      f
+    end
+
+
     def start_thread
       @mutex.synchronize do
         if !@queue.empty? && @threads.size <= @max_size
@@ -47,6 +58,12 @@ module Concur
       end
     end
 
+
+    def queue_size
+      @queue.size
+    end
+
+
     class UberThread < Thread
 
       def initialize
@@ -58,5 +75,4 @@ module Concur
   end
 
 
-
 end

metadata

@@ -2,7 +2,7 @@
 name: concur
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors: 
 - Travis Reeder
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-23 00:00:00 Z
+date: 2011-11-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
@@ -45,6 +45,39 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: faraday
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
 description: A concurrency library for Ruby inspired by java.util.concurrency. By http://www.appoxy.com
 email: travis@appoxy.com
 executables: []
@@ -89,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: A concurrency library for Ruby inspired by java.util.concurrency. By http://www.appoxy.com