parallizer 0.2.4 → 0.3.0

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    parallizer (0.2.3)
-      work_queue (~> 2.5.2)
+    parallizer (0.3.0)
+      work_queue
 
 GEM
   remote: http://rubygems.org/

data/lib/parallizer/proxy.rb

@@ -9,31 +9,18 @@ class Parallizer
     end
 
     def method_missing(name, *args, &block)
-      value = nil
-      
       if call_info = @call_infos[[name, *args]]
-        call_info[:mutex].synchronize do
-          if !call_info[:complete?]
-            # not done, so lets wait for signal of completion
-            call_info[:condition_variable].wait(call_info[:mutex])
-          end
-          # we now have our result from the worker thread
-          
-          if call_info[:exception]
-            # add the current call stack to the exception backtrace
-            exception = call_info[:exception].clone
-            exception.set_backtrace((call_info[:exception].backtrace || []) + caller)
-            raise exception
-          end
-          
-          value = call_info[:result]
+        if call_info[:exception]
+          # add the current call stack to the exception backtrace
+          exception = call_info[:exception].clone
+          exception.set_backtrace((call_info[:exception].backtrace || []) + caller)
+          raise exception
+        else
+          call_info[:result]
         end
       else
-        # pass through to client since not added
-        value = @client.send(*[name, *args], &block)
+        @client.send(*[name, *args], &block)
       end
-      
-      value
     end
   
     def respond_to?(name, include_private = false, &block)

data/lib/parallizer/version.rb

@@ -1,3 +1,3 @@
 class Parallizer
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
 end

data/lib/parallizer.rb

@@ -1,10 +1,10 @@
+require 'work_queue'
 require 'parallizer/version'
 require 'parallizer/proxy'
 require 'parallizer/method_call_notifier'
-require 'parallizer/thread_pool'
 
 class Parallizer
-  WORK_QUEUE_SIZE = Parallizer::ThreadPool::THEAD_POOL_SIZE
+  WORK_QUEUE_SIZE = 10
   
   attr_reader :calls, :call_infos, :client, :proxy, :options
   
@@ -34,42 +34,43 @@ class Parallizer
       :complete? => false,
       :result => nil,
       :exception => nil,
-      :condition_variable => ConditionVariable.new,
-      :mutex => Mutex.new,
       :retries => options[:retries]
     }
     call_infos[method_name_and_args] = call_info
-    
-    enqueue_call_info(call_info, method_name_and_args)
   end
   
   def create_proxy
     raise ArgumentError, "Cannot create another proxy" if @proxy
     
+    execute
+    
     Parallizer::Proxy.new(client, call_infos)
   end
   
   private
   
-  def enqueue_call_info(call_info, method_name_and_args)
-    Parallizer::ThreadPool.get do
-      call_info[:mutex].synchronize do
-        begin
-          (call_info[:retries] + 1).times do
-            begin
-              call_info[:exception] = nil # reset exception before each send attempt
-              call_info[:result] = client.send(*method_name_and_args)
-              break # success
-            rescue Exception => e
-              call_info[:exception] = e
-            end
+  def self.work_queue
+    # TODO: share the work queue among calling threads
+    Thread.current[:parallizer_work_queue] ||= WorkQueue.new(WORK_QUEUE_SIZE)
+  end
+  
+  def execute
+    call_infos.each do |method_name_and_args, call_info|
+      Parallizer.work_queue.enqueue_b do
+        (call_info[:retries] + 1).times do
+          begin
+            call_info[:exception] = nil # reset exception before each send attempt
+            call_info[:result] = client.send(*method_name_and_args)
+            break # success
+          rescue Exception => e
+            call_info[:exception] = e
           end
-        ensure
-          call_info[:complete?] = true
-          call_info[:condition_variable].broadcast
-          Parallizer::ThreadPool.put(Thread.current)
         end
       end
     end
+    
+    Parallizer.work_queue.join
+
+    Parallizer::Proxy.new(client, call_infos)
   end
 end

data/parallizer.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]
 
+  s.add_dependency 'work_queue'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '~> 2.9.0'
   s.add_development_dependency 'always_execute', '~> 0.1.1'

data/spec/parallizer/proxy_spec.rb

@@ -29,57 +29,39 @@ describe Parallizer::Proxy do
           @call_key += [:a_method, "some value"]
         end
         
-        context "with not complete?" do
+        context "with an exception" do
           before do
-            @call_info[:complete?] = false
-            @call_info[:condition_variable].should_receive(:wait).with(@call_info[:mutex])
-            @call_info[:result] = 'this is a value'
+            @call_info[:exception] = StandardError.new('An Exception')
+            @call_info[:exception].set_backtrace(["/tmp/foo.rb:123:in `in a_worker_thread_method'"])
           end
           
-          it "should return the call_info result" do
-            @execute_result.should == @call_info[:result]
+          execute do
+            def a_calling_thread_method
+              call_infos = { @call_key => @call_info }
+              proxy = Parallizer::Proxy.new(@client, call_infos)
+              proxy.send(*@call_key) rescue $!
+            end
+            a_calling_thread_method
+          end
+
+          it "should raise exception" do
+            @execute_result.class.should == @call_info[:exception].class
+            @execute_result.message.should == @call_info[:exception].message
+          end
+          
+          it "should append backtrace of current call" do
+            @execute_result.backtrace.join.should match /a_worker_thread_method/
+            @execute_result.backtrace.join.should match /a_calling_thread_method/
           end
         end
         
-        context "with complete? call info" do
+        context "with a result" do
           before do
-            @call_info[:complete?] = true
-          end
-          
-          context "with an exception" do
-            before do
-              @call_info[:exception] = StandardError.new('An Exception')
-              @call_info[:exception].set_backtrace(["/tmp/foo.rb:123:in `in a_worker_thread_method'"])
-            end
-            
-            execute do
-              def a_calling_thread_method
-                call_infos = { @call_key => @call_info }
-                proxy = Parallizer::Proxy.new(@client, call_infos)
-                proxy.send(*@call_key) rescue $!
-              end
-              a_calling_thread_method
-            end
-
-            it "should raise exception" do
-              @execute_result.class.should == @call_info[:exception].class
-              @execute_result.message.should == @call_info[:exception].message
-            end
-            
-            it "should append backtrace of current call" do
-              @execute_result.backtrace.join.should match /a_worker_thread_method/
-              @execute_result.backtrace.join.should match /a_calling_thread_method/
-            end
+            @call_info[:result] = "a result"
           end
           
-          context "with a result" do
-            before do
-              @call_info[:result] = "a result"
-            end
-            
-            it "should return result" do
-              @execute_result.should == @call_info[:result]
-            end
+          it "should return result" do
+            @execute_result.should == @call_info[:result]
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parallizer
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-22 00:00:00.000000000 Z
+date: 2012-10-30 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: work_queue
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -75,7 +91,6 @@ files:
 - lib/parallizer.rb
 - lib/parallizer/method_call_notifier.rb
 - lib/parallizer/proxy.rb
-- lib/parallizer/thread_pool.rb
 - lib/parallizer/version.rb
 - parallizer.gemspec
 - spec/parallizer/method_call_notifier_spec.rb
@@ -94,12 +109,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 4537061514701133663
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 4537061514701133663
 requirements: []
 rubyforge_project: parallizer
 rubygems_version: 1.8.24

data/lib/parallizer/thread_pool.rb

@@ -1,63 +0,0 @@
-require 'thread'
-
-class Parallizer
-  # Initially taken from Celluloid. -mgp
-  module ThreadPool
-    THEAD_POOL_SIZE = 16
-    
-    @pool = []
-    @mutex = Mutex.new
-
-    @max_idle = THEAD_POOL_SIZE
-
-    class << self
-      attr_accessor :max_idle
-
-      # Get a thread from the pool, running the given block
-      def get(&block)
-        @mutex.synchronize do
-          begin
-            if @pool.empty?
-              thread = create
-            else
-              thread = @pool.shift
-            end
-          end until thread.status # handle crashed threads
-
-          thread[:queue] << block
-          thread
-        end
-      end
-
-      # Return a thread to the pool
-      def put(thread)
-        @mutex.synchronize do
-          if @pool.size >= @max_idle
-            thread[:queue] << nil
-          else
-            @pool << thread
-          end
-        end
-      end
-
-      # Create a new thread with an associated queue of procs to run
-      def create
-        queue = Queue.new
-        thread = Thread.new do
-          while proc = queue.pop
-            begin
-              proc.call
-            rescue => ex
-              # Let this thread die on exceptions other than standard errors
-            end
-            put thread
-          end
-        end
-
-        thread[:queue] = queue
-        thread
-      end
-    end
-  end
-end
-