opee 0.0.4 → 0.0.5

data/README.md

@@ -16,16 +16,14 @@ Any comments, thoughts, or suggestions are welcome.
 
 ## <a name="release">Release Notes</a>
 
-### Release 0.0.4
+### Release 0.0.5
 
- - Filling in the Log class and unit tests for it.
+ - Added tests for WorkQueue.
 
- - Added WorkQueue but have not tested it yet.
+ - Added busy method to Actor.
 
 # Plans and Notes
 
-- WorkQueue test tc_opee_workqueue
-
 - pick a problem to test against
  - file density distribution
   - find all files under a directory
@@ -36,18 +34,8 @@ Any comments, thoughts, or suggestions are welcome.
   - wait_finish
   - ask to print or write report
 
-- implement Actor max_queue_count limiter
- - test with actor that reports queue size and pauses for 0.1 seconds
- - try to send too many requests at it so it has to report busy
-
-
 - describe patterns for use
 
-- Is the notion of a job needed to follow processing of an initial input?
- - avoid using job for storing data though unless rules can be set up to isolate portions of the data to a specific processing path
- - need something for sharing large chunks of data
-  - maybe just another actor
-
 ### License:
 
     Copyright (c) 2012, Peter Ohler

data/lib/opee.rb

@@ -2,6 +2,7 @@
 module Opee
 end # Opee
 
+require 'opee/errors'
 require 'opee/env'
 require 'opee/actor'
 require 'opee/log'

data/lib/opee/actor.rb

@@ -17,7 +17,9 @@ module Opee
       @step_thread = nil
       @ask_timeout = 0.0
       @max_queue_count = nil
+      @ask_thread = nil
       @state = RUNNING
+      @busy = false
       Env.add_actor(self)
       set_options(options)
       @loop = Thread.start(self) do |me|
@@ -33,6 +35,7 @@ module Opee
                 @ask_mutex.synchronize {
                   a = @queue.pop()
                 }
+                @ask_thread.wakeup() unless @ask_thread.nil?
               elsif !@idle.empty?
                 @idle_mutex.synchronize {
                   a = @idle.pop()
@@ -41,7 +44,9 @@ module Opee
                 Env.wake_finish()
                 sleep(1.0)
               end
+              @busy = true
               send(a.op, *a.args) unless a.nil?
+              @busy = false
               if STEP == @state
                 @step_thread.wakeup() unless @step_thread.nil?
                 @state = STOPPED
@@ -57,17 +62,28 @@ module Opee
     end
 
     def set_options(options)
-      # 
+      @max_queue_count = options.fetch(:max_queue_count, @max_queue_count)
+      @ask_timeout = options.fetch(:ask_timeout, @ask_timeout)
     end
 
     # deep copy and freeze args if not already frozen or primitive types
-    def ask(op, *args)
+    def timeout_ask(timeout, op, *args)
+      unless @max_queue_count.nil? || 0 == @max_queue_count || @queue.size() < @max_queue_count
+        @ask_thread = Thread.current
+        sleep(timeout) unless timeout.nil?
+        @ask_thread = nil
+        raise BusyError.new() unless @queue.size() < @max_queue_count
+      end
       @ask_mutex.synchronize {
         @queue.insert(0, Act.new(op, args))
       }
       @loop.wakeup() if RUNNING == @state
     end
 
+    def ask(op, *args)
+      timeout_ask(@ask_timeout, op, *args)
+    end
+
     def on_idle(op, *args)
       @idle_mutex.synchronize {
         @idle.insert(0, Act.new(op, args))
@@ -91,6 +107,18 @@ module Opee
       @queue.length + @priority.length + @idle.length
     end
 
+    def busy?
+      @busy || !@queue.empty? || !@priority.empty? || !@idle.empty?
+    end
+
+    def ask_timeout()
+      @ask_timeout
+    end
+
+    def max_queue_count
+      @max_queue_count
+    end
+
     def stop()
       @state = STOPPED
     end
@@ -125,6 +153,14 @@ module Opee
 
     private
 
+    def ask_timeout=(timeout)
+      @ask_timeout = timeout
+    end
+
+    def max_queue_count=(max)
+      @max_queue_count = max
+    end
+
     class Act
       attr_accessor :op
       attr_accessor :args

data/lib/opee/env.rb

@@ -82,6 +82,11 @@ module Opee
       cnt
     end
 
+    def self.busy?
+      @@actors.each { |a| return true if a.busy? }
+      false
+    end
+
     def self.stop()
       @@actors.each { |a| a.stop() }
     end
@@ -94,7 +99,7 @@ module Opee
     def self.wait_finish()
       @@finish_thread = Thread.current
       @@actors.each { |a| a.wakeup() }
-      while 0 < queue_count()
+      while busy?
         sleep(0.2) # actors should wake up when queue is empty
       end
     end

data/lib/opee/errors.rb

@@ -0,0 +1,15 @@
+
+module Opee
+  class MissingOptionError < Exception
+    def initialize(option, msg)
+      super("option #{option} for #{msg} missing")
+    end
+  end # MissingOptionError
+
+  class BusyError < Exception
+    def initialize()
+      super("Busy, try again later")
+    end
+  end # BusyError
+
+end # Opee

data/lib/opee/log.rb

@@ -27,6 +27,7 @@ module Opee
     # picked up by the Actor method_missing() method.
 
     def set_options(options)
+      super(options)
       if !(filename = options[:filename]).nil?
         max_file_size = options.fetch(:max_file_size, options.fetch(:shift_size, 1048576))
         max_file_count = options.fetch(:max_file_count, options.fetch(:shift_age, 7))

data/lib/opee/version.rb

@@ -1,5 +1,5 @@
 
 module Opee
   # Current version of the module. 
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/opee/workqueue.rb

@@ -6,6 +6,9 @@ module Opee
       @workers = []
       @work_queue = []
       @method = nil
+      @max_job_count = 0
+      @job_timeout = 3.0
+      @add_thread = nil
       super(options)
     end
 
@@ -13,10 +16,36 @@ module Opee
       @work_queue.size
     end
 
+    def worker_count()
+      @workers.size
+    end
+
+    def busy?
+      !@work_queue.empty? || super
+    end
+
+    def ask(op, *args)
+      if :add == op && 0 < @max_job_count && (@work_queue.size() + @queue.size()) >= @max_job_count
+        unless 0.0 >= @job_timeout
+          @add_thread = Thread.current
+          give_up_at = Time.now + @job_timeout
+          until Time.now > give_up_at || (@work_queue.size() + @queue.size()) < @max_job_count
+            sleep(@job_timeout)
+          end
+          @add_thread = nil
+        end
+        raise BusyError.new() unless @work_queue.size() < @max_job_count
+      end
+      super
+    end
+
     private
 
     def set_options(options)
-      raise "A method for for processing jobs must be specified" if (@method = options[:method]).nil?
+      super(options)
+      raise MissingOptionError.new(:method, "for processing jobs") if (@method = options[:method]).nil?
+      @max_job_count = options.fetch(:max_job_count, @max_job_count)
+      @job_timeout = options.fetch(:job_timeout, @job_timeout)
     end
 
     def add(job)
@@ -33,6 +62,7 @@ module Opee
         @workers.insert(0, worker) unless @workers.include?(worker)
       else
         job = @work_queue.pop()
+        @add_thread.wakeup() unless @add_thread.nil?
         worker.ask(@method, job)
       end
     end

data/test/relay.rb

@@ -12,6 +12,7 @@ class Relay < ::Opee::Actor
   end
   
   def set_options(options)
+    super(options)
     @buddy = options[:buddy]
   end
 
@@ -22,4 +23,10 @@ class Relay < ::Opee::Actor
     @buddy.ask(:relay, data) unless @buddy.nil?
   end
 
+  def slow(delay)
+    @last_data = [] unless @last_data.is_a?(Array)
+    @last_data << queue_count()
+    sleep(delay)
+  end
+
 end # Relay

data/test/tc_opee_actor.rb

@@ -81,4 +81,11 @@ class OpeeTest < ::Test::Unit::TestCase
     a.close()
   end
 
+  def test_opee_actor_max_queue_count
+    a = ::Relay.new(:max_queue_count => 4, :ask_timeout => 1.0)
+    10.times { |i| a.ask(:slow, 0.1) }
+    ::Opee::Env.wait_close()
+    assert(4 > a.last_data.max)
+  end
+
 end # OpeeTest

data/test/tc_opee_workqueue.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby -wW2
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'stringio'
+require 'opee'
+
+class Worker < ::Opee::Actor
+
+  def initialize(options={})
+    @collector = nil
+    @work_queue = nil
+    super(options)
+    @work_queue.ask(:ready, self)
+  end
+  
+  def set_options(options)
+    super(options)
+    @collector = options[:collector]
+    @work_queue = options[:work_queue]
+  end
+
+  private
+
+  def do_it(num)
+    @collector.ask(:accept, num * 2)
+    @work_queue.ask(:ready, self)
+  end
+  
+  def how_busy(num)
+    @collector.ask(:accept, @work_queue.work_queue_size())
+    sleep(0.1)
+    @work_queue.ask(:ready, self)
+  end
+  
+end # Worker
+
+class Collector < ::Opee::Actor
+  attr_reader :results
+
+  def initialize(options={})
+    @results = []
+    super(options)
+  end
+
+  private
+
+  def accept(num)
+    @results << num
+  end
+  
+end # Collector
+
+class OpeeTest < ::Test::Unit::TestCase
+
+  def test_opee_workqueue_basic
+    col = Collector.new()
+    wq = ::Opee::WorkQueue.new(:method => :do_it,
+                               :max_job_count => 10,
+                               :job_timeout => 1.0)
+    4.times { |i| Worker.new(:collector => col, :work_queue => wq) }
+    10.times { |i| wq.ask(:add, i) }
+    ::Opee::Env.wait_close()
+    assert_equal([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], col.results.sort())
+  end
+
+  def test_opee_workqueue_busy
+    col = Collector.new()
+    wq = ::Opee::WorkQueue.new(:method => :how_busy,
+                               :max_job_count => 4,
+                               :job_timeout => 1.0)
+    2.times { |i| Worker.new(:collector => col, :work_queue => wq) }
+    20.times { |i| wq.ask(:add, i) }
+    ::Opee::Env.wait_close()
+    assert(4 >= col.results.max)
+  end
+
+end # OpeeTest

data/test/ts_opee.rb

@@ -14,3 +14,4 @@ end # OpeeTest
 require 'tc_opee_actor'
 require 'tc_opee_log'
 require 'tc_opee_env'
+require 'tc_opee_workqueue'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opee
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-01 00:00:00.000000000 Z
+date: 2012-05-03 00:00:00.000000000 Z
 dependencies: []
 description: ! 'An experimental Object-base Parallel Evaluation Environment. '
 email: peter@ohler.com
@@ -20,6 +20,7 @@ extra_rdoc_files:
 files:
 - lib/opee/actor.rb
 - lib/opee/env.rb
+- lib/opee/errors.rb
 - lib/opee/log.rb
 - lib/opee/version.rb
 - lib/opee/workqueue.rb
@@ -28,6 +29,7 @@ files:
 - test/tc_opee_actor.rb
 - test/tc_opee_env.rb
 - test/tc_opee_log.rb
+- test/tc_opee_workqueue.rb
 - test/tests.rb
 - test/ts_opee.rb
 - LICENSE
@@ -54,9 +56,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: opee
-rubygems_version: 1.8.21
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: An experimental Object-base Parallel Evaluation Environment.
 test_files: []
-has_rdoc: true