futuroscope 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3209580d247ece206a07186449942582e6611740
-  data.tar.gz: b9b20627ef16e8b590d11d0c5cb1dd636960a76c
+  metadata.gz: e165b095edd6b4a24e0d696a2de6d19fbbb32b76
+  data.tar.gz: 30b612ac0946a96b7d4016e8f66b307f45d77482
 SHA512:
-  metadata.gz: dea9d87bbe54b822f7960a2c412ea1ae3dc94e8c49f2ec8c931d70384aab9fa2ce18a0cb9d3dc2815699f150ef64250865d6b009384e293fe0256841b4d2c661
-  data.tar.gz: 209d3d2f712fbf64d4ad07faece782db1c1c998590716e1b55d5d901d5561ff20d764a5a5342fbdf0f35e290c0f790b7f3d60ee892f22e09dd7d6219b16abf43
+  metadata.gz: bb92a560f8cf1c17eb6c6251d9258bb17832c2aef483337450d08968490d8b508819a3436d108d50f4ac6875223af0a385f732d7b1c743b85fbf3de45677c2c0
+  data.tar.gz: 772f23f61ba3576af774239147047e7b0e4a5d15c2eb803ae7b71b10fe9a1b17d27c0990b5b5faa8ec56796b0e5b9b8222af59c556d926e546fd476643431e3c

data/README.md

@@ -128,26 +128,27 @@ If you're looking for other ways to improve your code performance via
 concurrency, you should probably deal directly with [Ruby's
 threads](http://ruby-doc.org/core-2.0/Thread.html).
 
-## Thread pool
+## Worker Pool
 
-Futures are scheduled in a thread pool that helps managing concurrency in a way
+Futures are scheduled in a worker pool that helps managing concurrency in a way
 that doesn't get out of hands. Also comes with great benefits since their
 threads are spawned at load time (and not in runtime).
 
-The default thread pool comes with a concurrency of 8 threads, which seems
-reasonable for the most use cases.
+The default thread pool comes with a concurrency of 8 Workers, which seems
+reasonable for the most use cases. It will elastically expand to the default of
+16 threads and will kill them when they're not needed.
 
-The default thread pool can be replaced by a new pool with different 
-concurrency like this:
+The default thread pool can be configured like this:
 
 ```Ruby
-Futuroscope.default_pool = Futuroscope::Pool.new(24)
+Futuroscope.default_pool.min_workers = 2
+Futuroscope.default_pool.max_workers = 16
 ```
 
 Also, each future can be scheduled to a different pool like this:
 
 ```Ruby
-pool = Futuroscope::Pool.new(32)
+pool = Futuroscope::Pool.new(16, 32)
 
 future = Future.new(pool){ :edballs }
 

data/lib/futuroscope/pool.rb

@@ -1,44 +1,86 @@
 require 'thread'
+require 'futuroscope/worker'
 
 module Futuroscope
   # Futuroscope's pool is design to control concurency and keep it between some
   # certain benefits. Moreover, we warm up the threads beforehand so we don't
   # have to spin them up each time a future is created.
   class Pool
-    attr_reader :threads
+    attr_reader :workers
+    attr_accessor :min_workers, :max_workers
 
-    # Initializes a new Pool.
+    # Public: Initializes a new Pool.
     #
-    # thread_count - The number of threads that this pool is gonna have
-    def initialize(thread_count = 8)
-      @thread_count = thread_count
-      @mutex = Mutex.new
+    # thread_count - The number of workers that this pool is gonna have
+    def initialize(min_workers = 8, max_workers = 16)
+      @min_workers = min_workers
+      @max_workers = max_workers
       @queue = Queue.new
-      @threads = Array.new
-      spin_threads
+      @workers = Set.new
+      @mutex = Mutex.new
+      warm_up_workers
     end
 
-    # Enqueues a new Future into the pool.
+    # Public: Enqueues a new Future into the pool.
     #
     # future - The Future to enqueue.
     def queue(future)
-      @queue.push future
+      @mutex.synchronize do
+        spin_worker if can_spin_extra_workers?
+        @queue.push future
+      end
+    end
+
+    # Public: Pops a new job from the pool. It will return nil if there's 
+    # enough workers in the pool to take care of it.
+    #
+    # Returns a Future
+    def pop
+      return nil if @queue.empty? && more_workers_than_needed?
+      return @queue.pop
+    end
+
+    # Private: Notifies that a worker just died so it can be removed from the
+    # pool.
+    #
+    # worker - A Worker
+    def worker_died(worker)
+      @mutex.synchronize do
+        @workers.delete(worker)
+      end
+    end
+
+    def min_workers=(count)
+      @min_workers = count
+      warm_up_workers
     end
 
     private
 
-    def spin_threads
-      @thread_count.times do |i|
-        @threads << Thread.new do
-          loop do
-            @queue.pop.run_future
-          end
+    def warm_up_workers
+      @mutex.synchronize do
+        while(@workers.length < @min_workers) do
+          spin_worker
         end
       end
     end
 
+    def can_spin_extra_workers?
+      @workers.length < @max_workers
+    end
+
+    def more_workers_than_needed?
+      @workers.length > @min_workers
+    end
+
+    def spin_worker
+      worker = Worker.new(self)
+      @workers << worker
+      worker.run
+    end
+
     def finalize
-      @threads.each(&:kill)
+      @workers.each(&:stop)
     end
   end
 end

data/lib/futuroscope/version.rb

@@ -1,3 +1,3 @@
 module Futuroscope
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/futuroscope/worker.rb

@@ -0,0 +1,32 @@
+module Futuroscope
+  # A futuroscope worker takes care of resolving a future's value. It works
+  # together with a Pool.
+  class Worker
+    # Public: Initializes a new Worker.
+    #
+    # pool - The worker Pool it belongs to.
+    def initialize(pool)
+      @pool = pool
+    end
+
+    # Runs the worker. It keeps asking the Pool for a new job. If the pool
+    # decides there's no job use it now or in the future, it will die and the
+    # Pool will be notified. Otherwise, it will be given a new job or blocked
+    # until there's a new future available to process.
+    #
+    def run
+      @thread = Thread.new do
+        while(future = @pool.pop) do
+          future.run_future
+        end
+        stop
+      end
+    end
+
+    private
+
+    def stop
+      @pool.worker_died(self)
+    end
+  end
+end

data/spec/futuroscope/pool_spec.rb

@@ -3,12 +3,12 @@ require 'futuroscope/pool'
 
 module Futuroscope
   describe Pool do
-    it "spins up a number of threads" do
+    it "spins up a number of workers" do
       pool = Pool.new(2)
-      expect(pool.threads).to have(2).threads
+      expect(pool.workers).to have(2).workers
 
       pool = Pool.new(3)
-      expect(pool.threads).to have(3).threads
+      expect(pool.workers).to have(3).workers
     end
 
     describe "queue" do
@@ -21,5 +21,38 @@ module Futuroscope
         sleep(0.1)
       end
     end
+
+    describe "worker control" do
+      it "adds more workers when needed and returns to the default amount" do
+        pool = Pool.new(2, 8)
+        10.times do |future|
+          Future.new(pool){ sleep(1) }
+        end
+
+        sleep(0.5)
+        expect(pool.workers).to have(8).workers
+
+        sleep(1.5)
+        expect(pool.workers).to have(2).workers
+      end
+
+      it "allows overriding min workers real time" do
+        pool = Pool.new(2, 8)
+        pool.min_workers = 3
+        expect(pool.workers).to have(3).workers
+      end
+
+      it "allows overriding max workers real time" do
+        pool = Pool.new(2, 8)
+        pool.max_workers = 4
+
+        10.times do |future|
+          Future.new(pool){ sleep(1) }
+        end
+
+        sleep(0.5)
+        expect(pool.workers).to have(4).workers
+      end
+    end
   end
 end

data/spec/futuroscope/worker_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'futuroscope/worker'
+require 'futuroscope/pool'
+
+module Futuroscope
+  describe Worker do
+    it "asks the pool for a new job and runs the future" do
+      future = double(:future)
+      pool = [future]
+      future.should_receive :run_future
+
+      Worker.new(pool).run
+      sleep(1)
+    end
+
+    it "notifies the pool when the worker died because there's no job" do
+      pool = []
+      worker = Worker.new(pool)
+
+      pool.should_receive(:worker_died).with(worker)
+      worker.run
+      sleep(1)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: futuroscope
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Josep Jaume Rey Peroy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-04 00:00:00.000000000 Z
+date: 2013-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,10 +91,12 @@ files:
 - lib/futuroscope/map.rb
 - lib/futuroscope/pool.rb
 - lib/futuroscope/version.rb
+- lib/futuroscope/worker.rb
 - spec/futuroscope/convenience_spec.rb
 - spec/futuroscope/future_spec.rb
 - spec/futuroscope/map_spec.rb
 - spec/futuroscope/pool_spec.rb
+- spec/futuroscope/worker_spec.rb
 - spec/futuroscope_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -127,5 +129,6 @@ test_files:
 - spec/futuroscope/future_spec.rb
 - spec/futuroscope/map_spec.rb
 - spec/futuroscope/pool_spec.rb
+- spec/futuroscope/worker_spec.rb
 - spec/futuroscope_spec.rb
 - spec/spec_helper.rb