opee 0.0.1 → 0.0.2

data/README.md

@@ -7,16 +7,47 @@ push the flow forward, never returning values when using the ask()
 method. Other methods return immediately but they should never modify the data
 portions of the Actors. They can be used to modify the control of the Actor.
 
-# plans
+Once a reasonable API has been established a high performance C extension will
+be written to improve performance.
 
-- create an error handler that prints or logs rescued exceptions (::Opee::Log class)
+This is no where close to being ready for prime time.
+
+# Plans and Notes
+
+- Env
+ - test
+  - create and close actors and make sure each_actor changes
+  - test logger return Log instance
+  - queue_count
+  - start/stop
+  - wait_close
+
+- Log
+  - allow forward attribute to be set that forwards messages to another Actor
+  - turn output off (useful when there is a forward actor)
+  - test
+   - set formatter and stringio and test env methods
+   - test forwarding
+
+- Actor
+
+- implement a design pattern for a shared work queue
+ - queue is an actor
+ - place items on queue either as normal ask sequence or special mutex protected queue
+  - if normal then wait for a request for a job and send a job to requestor
 
 - pick a problem to test against
+ - checkers
+ - process some kind of file
+ - process random numbers to produce something
+ - life
 
 - 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:
 

data/lib/opee.rb

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

data/lib/opee/actor.rb

@@ -2,28 +2,56 @@
 module Opee
 
   class Actor
+    STOPPED = 0
+    RUNNING = 1
+    CLOSING = 2
+    STEP    = 3
 
     def initialize(options={})
       @queue = []
+      @idle = []
+      @priority = []
       @ask_mutex = Mutex.new()
+      @priority_mutex = Mutex.new()
+      @idle_mutex = Mutex.new()
+      @step_thread = nil
       @ask_timeout = 0.0
       @max_queue_count = nil
-      @running = true
+      @state = RUNNING
+      Env.add_actor(self)
       set_options(options)
       @loop = Thread.start(self) do |me|
-        begin
-          sleep(1.0) if @queue.empty?
-          unless @queue.empty?
-            a = nil
-            @ask_mutex.synchronize {
-              a = @queue.pop()
-            }
-            send(a.op, *a.args)
+        while CLOSING != @state
+          begin
+            if RUNNING == @state || STEP == @state
+              a = nil
+              if !@priority.empty?
+                @priority_mutex.synchronize {
+                  a = @priority.pop()
+                }
+              elsif !@queue.empty?
+                @ask_mutex.synchronize {
+                  a = @queue.pop()
+                }
+              elsif !@idle.empty?
+                @idle_mutex.synchronize {
+                  a = @idle.pop()
+                }
+              else
+                Env.wake_finish()
+                sleep(1.0)
+              end
+              send(a.op, *a.args) unless a.nil?
+              if STEP == @state
+                @step_thread.wakeup() unless @step_thread.nil?
+                @state = STOPPED
+              end
+            elsif STOPPED == @state
+              sleep(1.0)
+            end
+          rescue Exception => e
+            Env.log_rescue(e)
           end
-        rescue Exception => e
-          # TBD handle errors by passing them to a error handler
-          puts "*** #{e.class}: #{e.message}"
-          e.backtrace.each { |line| puts "    " + line }
         end
       end
     end
@@ -37,22 +65,59 @@ module Opee
       @ask_mutex.synchronize {
         @queue << Act.new(op, args)
       }
-      @loop.wakeup() if @running
+      @loop.wakeup() if RUNNING == @state
+    end
+
+    def on_idle(op, *args)
+      @idle_mutex.synchronize {
+        @idle << Act.new(op, args)
+      }
+      @loop.wakeup() if RUNNING == @state
+    end
+
+    def priority_ask(op, *args)
+      @priority_mutex.synchronize {
+        @priority << Act.new(op, args)
+      }
+      @loop.wakeup() if RUNNING == @state
+    end
+
+    def method_missing(m, *args, &blk)
+      ask(m, *args)
     end
 
     def queue_count()
-      @queue.length
+      @queue.length + @priority.length + @idle.length
     end
 
     def stop()
-      @running = false
+      @state = STOPPED
+    end
+
+    def step(max_wait=5)
+      @state = STEP
+      @step_thread = Thread.current
+      @loop.wakeup()
+      sleep(max_wait)
     end
 
     def start()
-      @running = true
+      @state = RUNNING
       @loop.wakeup()
     end
 
+    def close()
+      @state = CLOSING
+      begin
+        # if the loop has already exited this will raise an Exception that can be ignored
+        @loop.wakeup()
+      rescue
+        # ignore
+      end
+      Env.remove_actor(self)
+      @loop.join()
+    end
+
     private
 
     class Act

data/lib/opee/env.rb

@@ -0,0 +1,88 @@
+
+module Opee
+  class Env
+
+    @@actors = []
+    @@log = nil
+    @@finish_thread = nil
+
+    def self.add_actor(actor)
+      @@actors << actor
+    end
+
+    def self.remove_actor(actor)
+      @@actors.delete(actor)
+    end
+
+    def self.each_actor(&blk)
+      @@actors.each { |a| blk.yield(a) }
+    end
+
+    def self.shutdown()
+      until @@actors.empty?
+        a = @@actors.pop()
+        a.close()
+      end
+    end
+
+    def self.log(severity, message)
+      @@log = Log.new() if @@log.nil?
+      @@log.ask(:log, severity, message)
+    end
+
+    def self.log_rescue(ex)
+      @@log = Log.new() if @@log.nil?
+      return unless Logger::Severity::ERROR >= @@log.level
+      msg = "#{ex.class}: #{ex.message}"
+      if Logger::Severity::WARN >= @@log.level
+        ex.backtrace.each { |line| msg << "    #{line}\n" }
+      end
+      @@log.ask(:log, Logger::Severity::ERROR, msg)
+    end
+
+    def self.logger()
+      @@log = Log.new() if @@log.nil?
+      @@log
+    end
+
+    def self.queue_count()
+      cnt = 0
+      @@actors.each { |a| cnt += a.queue_count() }
+      cnt
+    end
+
+    def self.stop()
+      @@actors.each { |a| a.stop() }
+    end
+
+    def self.start()
+      @@finish_thread = nil
+      @@actors.each { |a| a.start() }
+    end
+
+    def self.wait_finish()
+      @@finish_thread = Thread.current
+      while 0 < queue_count()
+        sleep(0.2) # actors should wake up when queue is empty
+      end
+    end
+
+    def self.wake_finish()
+      @@finish_thread.wakeup() unless @@finish_thread.nil?
+    end
+
+    def self.wait_close()
+      while 0 < queue_count()
+        wait_finish()
+        stop()
+        break if 0 == queue_count()
+        start()
+      end
+      until @@actors.empty?
+        a = @@actors.pop()
+        a.close()
+      end
+    end
+
+  end # Env
+end # Opee

data/lib/opee/log.rb

@@ -0,0 +1,43 @@
+
+require 'logger'
+
+module Opee
+  class Log < Actor
+
+    def initialize(options={})
+      super(options)
+    end
+
+    private
+    # use ask() to invoke private methods
+
+    def set_options(options)
+      @logger = Logger.new(STDOUT)
+      severity = options[:severity] if options.has_key?(:severity)
+
+      # TBD options for setting a file, severity, max_file_size, max_file_count, formatter
+    end
+
+    def severity=(level)
+      if level.is_a?(String)
+        severity = {
+          'FATAL' => Logger::Severity::FATAL,
+          'ERROR' => Logger::Severity::ERROR,
+          'WARN' => Logger::Severity::WARN,
+          'INFO' => Logger::Severity::INFO,
+          'DEBUG' => Logger::Severity::DEBUG
+        }[level]
+        raise "#{level} is not a severity" if severity.nil?
+        level = severity
+      elsif level < Logger::Severity::DEBUG || Logger::Severity::FATAL < level
+        raise "#{level} is not a severity"
+      end
+      @logger.level = level
+    end
+
+    def log(severity, message)
+      @logger.add(severity, message)
+    end
+
+  end # Log
+end # Opee

data/lib/opee/version.rb

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

data/test/relay.rb

@@ -0,0 +1,20 @@
+
+require 'opee'
+
+class Relay < ::Opee::Actor
+  attr_reader :last_data
+
+  def initialize(buddy)
+    super
+    @buddy = buddy
+    @last_data = nil
+  end
+  
+  private
+
+  def relay(data)
+    @last_data = data
+    @buddy.ask(:relay, data) unless @buddy.nil?
+  end
+
+end # Relay

data/test/tc_opee_actor.rb

@@ -0,0 +1,78 @@
+#!/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 'opee'
+require 'relay'
+
+class OpeeTest < ::Test::Unit::TestCase
+
+  def test_opee_actor_queue
+    a = ::Relay.new(nil)
+    assert_equal(0, a.queue_count())
+    a.stop()
+    a.ask(:relay, 5)
+    assert_equal(1, a.queue_count())
+    a.ask(:relay, 7)
+    assert_equal(2, a.queue_count())
+    a.close()
+  end
+
+  def test_opee_actor_ask
+    a = ::Relay.new(nil)
+    a.ask(:relay, 7)
+    sleep(0.5) # minimize dependencies for simplest possible test
+    assert_equal(7, a.last_data)
+    a.close()
+  end
+
+  def test_opee_actor_method_missing
+    a = ::Relay.new(nil)
+    a.relay(7)
+    ::Opee::Env.wait_close()
+    assert_equal(7, a.last_data)
+    a.close()
+  end
+
+  def test_opee_actor_raise_after_close
+    a = ::Relay.new(nil)
+    a.close()
+    assert_raise(ThreadError) { a.start() }
+  end
+
+  def test_opee_actor_priority
+    a = ::Relay.new(nil)
+    a.priority_ask(:relay, 7)
+    ::Opee::Env.wait_close()
+    assert_equal(7, a.last_data)
+    a.close()
+  end
+
+  def test_opee_actor_idle
+    a = ::Relay.new(nil)
+    a.on_idle(:relay, 7)
+    ::Opee::Env.wait_close()
+    assert_equal(7, a.last_data)
+    a.close()
+  end
+
+  def test_opee_actor_order
+    a = ::Relay.new(nil)
+    a.stop()
+    a.on_idle(:relay, 17)
+    a.priority_ask(:relay, 3)
+    a.ask(:relay, 7)
+    a.step()
+    assert_equal(3, a.last_data)
+    a.step()
+    assert_equal(7, a.last_data)
+    a.step()
+    assert_equal(17, a.last_data)
+    a.close()
+  end
+
+end # OpeeTest

data/test/tc_opee_env.rb

@@ -0,0 +1,22 @@
+#!/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 'opee'
+require 'relay'
+
+class OpeeTest < ::Test::Unit::TestCase
+
+  def test_wait_close
+    a = ::Relay.new(nil)
+    a.ask(:relay, 7)
+    ::Opee::Env.wait_close()
+    assert_equal(7, a.last_data)
+    a.close()
+  end
+
+end # OpeeTest

data/test/tc_opee_log.rb

@@ -0,0 +1,21 @@
+#!/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 'opee'
+
+class OpeeTest < ::Test::Unit::TestCase
+
+  def test_opee_log_log
+    #::Opee::Env.logger.ask(:severity=, Logger::INFO)
+    ::Opee::Env.logger.severity= Logger::INFO
+    ::Opee::Env.log(Logger::INFO, "hello")
+    ::Opee::Env.each_actor { |a| puts a.to_s }
+    sleep(0.2)
+  end
+
+end # OpeeTest

data/test/tests.rb

@@ -5,24 +5,7 @@ $: << File.join(File.dirname(__FILE__), "../lib")
 
 require 'test/unit'
 require 'opee'
-
-class Relay < ::Opee::Actor
-  attr_reader :last_data
-
-  def initialize(buddy)
-    super
-    @buddy = buddy
-    @last_data = nil
-  end
-  
-  private
-
-  def relay(data)
-    @last_data = data
-    @buddy.ask(:relay, data) unless @buddy.nil?
-  end
-
-end # Relay
+require 'relay'
 
 class Opeet < ::Test::Unit::TestCase
 
@@ -33,8 +16,25 @@ class Opeet < ::Test::Unit::TestCase
     a.ask(:relay, 7)
     assert_equal(1, a.queue_count())
     a.start()
+    sleep(0.5)
+    assert_equal(7, a.last_data)
+    a.close()
+  end
+
+  def test_log
+    #::Opee::Env.logger.ask(:severity=, Logger::INFO)
+    ::Opee::Env.logger.severity= Logger::INFO
+    ::Opee::Env.log(Logger::INFO, "hello")
+    ::Opee::Env.each_actor { |a| puts a.to_s }
     sleep(0.2)
+  end
+
+  def test_wait_close
+    a = ::Relay.new(nil)
+    a.ask(:relay, 7)
+    ::Opee::Env.wait_close()
     assert_equal(7, a.last_data)
+    a.close()
   end
 
 end # Opeet

data/test/ts_opee.rb

@@ -0,0 +1,16 @@
+#!/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 'opee'
+
+class OpeeTest < ::Test::Unit::TestCase
+end # OpeeTest
+
+require 'tc_opee_actor'
+require 'tc_opee_log'
+require 'tc_opee_env'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opee
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-17 00:00:00.000000000 Z
+date: 2012-04-29 00:00:00.000000000 Z
 dependencies: []
 description: ! 'An experimental Object-base Parallel Evaluation Environment. '
 email: peter@ohler.com
@@ -19,9 +19,16 @@ extra_rdoc_files:
 - README.md
 files:
 - lib/opee/actor.rb
+- lib/opee/env.rb
+- lib/opee/log.rb
 - lib/opee/version.rb
 - lib/opee.rb
+- test/relay.rb
+- test/tc_opee_actor.rb
+- test/tc_opee_env.rb
+- test/tc_opee_log.rb
 - test/tests.rb
+- test/ts_opee.rb
 - LICENSE
 - README.md
 homepage: http://www.ohler.com/opee
@@ -46,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: opee
-rubygems_version: 1.8.21
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: An experimental Object-base Parallel Evaluation Environment.