jobQueue 1.0.1 → 1.0.2

data/bin/prun.rb

@@ -14,6 +14,6 @@ end
 noTh = ARGV[0].to_i
 # read file line per line
 lines = File.open(ARGV[1]).readlines.map(&:chomp)
-q = JobQueue.new(noTh)
+q = SystemJobs.new(noTh)
 q.push(*lines)
 q.run

data/gemspec

@@ -2,17 +2,19 @@ require 'rubygems'
 
 spec = Gem::Specification.new do |s|
   s.name              = "jobQueue"
-  s.version           = '1.0.1'
+  s.version           = '1.0.2'
   s.platform          = Gem::Platform::RUBY
   s.bindir            = 'bin'
   s.files             = ["lib/jobqueue.rb","bin/prun.rb"] + ["gemspec","LICENSE","README.rdoc"]
   s.executables       << 'prun.rb'
   s.description       = "Run Shell commands or Ruby methods in parallel"
-  s.summary           = s.description
+  s.summary           = "Run Shell commands or Ruby methods in parallel"
   s.author            = "Ralf Mueller"
   s.email             = "stark.dreamdetective@gmail.com"
-#  s.homepage          = "http://
+  s.homepage          = "https://github.com/Try2Code/jobQueue"
   s.extra_rdoc_files          = ["README.rdoc","LICENSE"]
+  s.license           = "BSD"
+  s.test_files        = "test/test_jobqueue.rb"
   s.required_ruby_version = ">= 1.9"
 end
 

data/lib/jobqueue.rb

@@ -18,12 +18,10 @@ class JobQueue
   end
 
   # Put jobs into the queue. Use
-  #   strings for system commands
   #   proc,args for single methods
-  #   [object,[:methods,args]] for sende messages to objects
-  #
-  def push(*items)
-    items.each {|it| @queue << it}
+  #   object,:method,args for sende messages to objects
+  def push(*item)
+    @queue << item
   end
 
   # Start workers to run through the queue
@@ -31,23 +29,17 @@ class JobQueue
     @threads = (1..@size).map {|i|
       Thread.new(@queue) {|q|
         until ( q == ( task = q.deq ) )
-          if task.kind_of? String
-            system(task)
-          elsif task.kind_of? Proc
-            task.call
-          elsif task.kind_of? Array
-            if task.size > 1
-              if not task[1].kind_of? Array 
-                # Expects proc/lambda with arguments, e.g. [mysqrt,2.789]
-                task[0].call(*task[1..-1])
-              else
-                # expect an object in task[0] and one of its methods with arguments in task[1] as a symbol
-                # e.g. [a,[:attribute=,1]
-                task[0].send(task[1][0],*task[1][1..-1])
-              end
+          if task.size > 1
+            if task[0].kind_of? Proc
+              # Expects proc/lambda with arguments, e.g. [mysqrt,2.789]
+              task[0].call(*task[1..-1])
             else
-              warn 'provide 2d arrays'
+              # expect an object in task[0] and one of its methods with arguments in task[1] as a symbol
+              # e.g. [a,[:attribute=,1]
+              task[0].send(task[1],*task[2..-1])
             end
+          else
+            task[0].call
           end
         end
       }
@@ -81,3 +73,17 @@ class JobQueue
   end
 end
 
+# Special class for runing operating system commands with Ruby's system call
+class SystemJobs < JobQueue
+  def run
+    @threads = (1..@size).map {|i|
+      Thread.new(@queue) {|q|
+        until ( q == ( task = q.deq ) )
+          IO.popen(task).read
+        end
+      }
+    }
+    @threads.size.times { @queue.enq @queue}
+    @threads.each {|t| t.join}
+  end
+end

data/test/test_jobqueue.rb

@@ -0,0 +1,151 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+require 'test/unit'
+require 'jobqueue'
+
+
+NTHREDs = ENV['NTHREDs'].nil? ? 4 : ENV['NTHREDs']
+
+class A
+  attr_accessor :i,:j,:k,:h
+  @@lock = Mutex.new
+
+  def initialize
+    @i, @j, @k = nil,nil,nil
+    @h    = {}
+  end
+  def seti(i)
+    @i = i
+  end
+  def seth(v)
+    @@lock.synchronize{ @h[v] = 2*v}
+  end
+end
+class B
+  @@val = 0
+  def B.set(val)
+    @@val = val
+  end
+  def B.get
+    @@val
+  end
+end
+module C
+  def C.sqrt(v)
+    Math.sqrt(v)
+  end
+end
+
+class TestJobQueue < Test::Unit::TestCase
+
+  def setup
+    @jq    = JobQueue.new(NTHREDs)
+    @jqSer = JobQueue.new(1)
+    @sysjq = SystemJobs.new(NTHREDs)
+  end
+
+  def test_system_cmds
+    cmds = %w[date ls echo true]
+    7.times { @sysjq.push(cmds[(4*rand).floor])}
+    20.times { @sysjq.push('ls')}
+    @sysjq.run
+  end
+
+  def test_proc_simple
+    halo = lambda { puts "halo"}
+    11.times { @jq.push(halo) }
+    @jq.run
+  end
+  def test_proc
+    sqrt = lambda {|v| puts Math.sqrt(v)}
+    norm = lambda {|x,y| puts Math.sqrt(x*x + y*y)}
+    10.times { @jq.push(sqrt,rand)}
+    10.times { @jq.push(norm,rand,rand)}
+    @jq.run
+  end
+  def test_method
+    a = A.new
+    assert_equal(nil,a.i)
+    assert_equal(nil,a.j)
+    assert_equal(nil,a.k)
+    i = 10
+    @jq.push(a,:seti,i)
+    @jq.run
+    assert_equal(i,a.i)
+    i = 11
+    @jq.push(a,:seti,i)
+    @jq.run
+    assert_equal(i,a.i)
+    (0..77).each {|i| @jq.push(a,:seth,i) }
+    @jq.run
+    (0..77).each {|i| assert_equal(2*i,a.h[i]) }
+    a.h.clear;assert_equal({},a.h)
+  end
+  def test_accessor
+    a = A.new
+    assert_equal(nil,a.i)
+    assert_equal(nil,a.j)
+    assert_equal(nil,a.k)
+    # try ruby style accessors
+    @jqSer.push(a,:i=,1)
+    @jqSer.push(a,:j=,2)
+    @jqSer.push(a,:k=,3)
+    @jqSer.run
+    assert_equal(1,a.i)
+    assert_equal(2,a.j)
+    assert_equal(3,a.k)
+    @jq.push(a,:i=,10)
+    @jq.push(a,:j=,20)
+    @jq.push(a,:k=,30)
+    @jq.run
+    assert_equal(10,a.i)
+    assert_equal(20,a.j)
+    assert_equal(30,a.k)
+  end
+
+  def test_class_methods
+    @jq.push(B,:set,1)
+    @jq.run
+    assert_equal(1,B.get)
+  end
+  def test_module
+    @jq.push(C,:sqrt,10)
+    @jq.push(C,:sqrt,100)
+    @jq.push(C,:sqrt,1000)
+    @jq.run
+  end
+  def test_lock
+    lockfill = lambda {|myhash,value,lock|
+      lock.synchronize { myhash[value] = value}
+    }
+    fill = lambda {|myhash,value| myhash[value] = value}
+    a = A.new
+    a.seth(1)
+    assert_equal(2,a.h[1])
+
+    (0..1000).each {|i| @jq.push(fill,a.h,i) }
+    @jq.run
+    assert_not_equal(a.h.keys, a.h.keys.sort)
+    (0..20).each {|i| assert_equal(i,a.h[i])}
+    a.h.clear;assert_equal({},a.h)
+ 
+    lock = Mutex.new
+    (0..20).each {|i| @jq.push(lockfill,a.h,i,lock) }
+    @jq.run
+  end
+
+  def test_max
+    assert_equal(8,@jq.number_of_processors) if `hostname`.chomp == 'thingol'
+  end
+
+  def test_push
+    a = A.new
+    @jq.push(a,:seth,1)
+    @jq.push(a,:i=,77)
+    @jq.push($stdout,:puts,"halo")
+    @jq.push(Math,:sqrt,22)
+    @jq.push(lambda { puts "halo"})
+    @jq.run
+    assert_equal(2,a.h[1])
+    assert_equal(77,a.i)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jobQueue
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-12 00:00:00.000000000 Z
+date: 2011-12-14 00:00:00.000000000 Z
 dependencies: []
 description: Run Shell commands or Ruby methods in parallel
 email: stark.dreamdetective@gmail.com
@@ -25,8 +25,10 @@ files:
 - gemspec
 - LICENSE
 - README.rdoc
-homepage: 
-licenses: []
+- test/test_jobqueue.rb
+homepage: https://github.com/Try2Code/jobQueue
+licenses:
+- BSD
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -49,4 +51,5 @@ rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Run Shell commands or Ruby methods in parallel
-test_files: []
+test_files:
+- test/test_jobqueue.rb