concur 0.0.1 → 0.0.2

data/lib/concur.rb

@@ -1,3 +1,15 @@
 
 require_relative 'executor'
-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,10 +1,49 @@
 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
-    def queue(runnable)
-      Future.new(runnable)
+
+    attr_accessor :thread_pool
+
+    def initialize(options={})
+
+    end
+
+    def self.new_thread_pool_executor(options={})
+      executor = Executor.new
+      executor.thread_pool = ThreadPool.new(options[:max_size])
+      p executor.thread_pool
+      executor
+    end
+
+    def execute(runnable, &blk)
+      puts 'executing ' + runnable.inspect
+      f = Future.new(runnable, &blk)
+      if @thread_pool
+        @thread_pool.process(f)
+      else
+        @thread = Thread.new do
+          f.thread = @thread
+          f.call
+        end
+      end
+      f
+    end
+
+    def shutdown
+       if @thread_pool
+         @thread_pool.shutdown
+       end
     end
   end
 end

data/lib/future.rb

@@ -1,27 +1,49 @@
-=begin
-An Future is a class that captures the results of a threaded object so you can retreive these results later.
+module Concur
 
-Example usage:
+  #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, :pool
 
-    searcher = Searcher.new
-    # todo: not sure if this will be usage in the end.... but
-    future = Future.new(searcher)
-    do_some_other_stuff_in_the_meantime()
-    search_results = future.get
+    def initialize(runnable=nil, &block)
 
-`get` retrieves the results.
-=end
-module Concur
-  class Future
-    def initialize(runnable)
-      @thread = Thread.new do
-        @result = runnable.run
+#      if block
+#        @thread = Thread.new do
+#          @result = yield
+#        end
+#      else
+#        @thread = Thread.new do
+#          @result = runnable.run
+#        end
+#      end
+
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+      @callable = runnable
+      if block_given?
+        @callable = block
       end
+
+    end
+
+    def run
+      @result = @callable.call
+      @complete = true
+      @cv.signal
+    end
+
+    def call
+      run
     end
 
     # Returns results. Will wait for thread to complete execution if not already complete.
     def get
-      @thread.join
+#      @thread.value
+      @mutex.synchronize do
+        unless @complete
+          @cv.wait(@mutex)
+        end
+      end
       @result
     end
   end

data/lib/runnable.rb

@@ -1,10 +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

data/lib/thread_pool.rb

@@ -0,0 +1,63 @@
+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.pool = self
+              f.call
+            end
+            Concur.logger.info "Thread dying " + t.inspect
+          end
+          Concur.logger.info "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,11 +1,14 @@
 require 'rspec'
 
-require_relative '../lib/executor'
+require_relative '../lib/concur'
 require_relative 'job'
 
 describe Concur::Executor do
-   describe "#score" do
+  describe "#score" do
     it "runs faster in parallel" do
+
+      job = Job.new(1)
+      puts 'runnable? ' + job.is_a?(Concur::Runnable).to_s
       start_time = Time.now
       20.times do |i|
         job = Job.new(i)
@@ -14,24 +17,66 @@ describe Concur::Executor do
       non_concurrent_duration = Time.now - start_time
       puts "duration=" + non_concurrent_duration.to_s
 
-      puts
+      puts '---------------'
 
       puts "Now for concurrent"
-      executor = Concur::Executor.new
+      executor = Concur::Executor.new # unbounded
       start_time = Time.now
+
       jobs = []
       20.times do |i|
         job = Job.new(i)
-        future = executor.queue(job)
+        future = executor.execute(job)
         jobs << future
       end
       jobs.each do |j|
         puts "uber fast result=#{j.get}"
       end
       concurrent_duration = Time.now - start_time
-      puts "duration=" + concurrent_duration .to_s
+      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(:max_size=>10)
+      start_time = Time.now
+
+      jobs = []
+      20.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
 
-      concurrent_duration.should be < (non_concurrent_duration-2)
     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

@@ -9,7 +9,7 @@ class Job
 
   def run
     sleep 0.25
-    puts "#{@i} finished"
+    puts "Finished #{@i}"
     "response #{@i}"
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concur
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-02-23 00:00:00.000000000 -08:00
+date: 2011-03-10 00:00:00.000000000 -08:00
 default_executable: 
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &22290888 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *22290888
 description: A concurrency library for Ruby like java.util.concurrency By http://www.appoxy.com
 email: travis@appoxy.com
 executables: []
@@ -23,6 +34,7 @@ files:
 - lib/executor.rb
 - lib/future.rb
 - lib/runnable.rb
+- lib/thread_pool.rb
 - README.markdown
 - test/executor_spec.rb
 - test/job.rb
@@ -47,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.6.0
 signing_key: 
 specification_version: 3
 summary: A concurrency library for Ruby like java.util.concurrency. By http://www.appoxy.com