parallelizer 0.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f10a7c799b97276e92c5fc8c7cf67fb96f889054
+  data.tar.gz: b04721afd9fd5dcff3adb8d323b144b1e5f209a3
+SHA512:
+  metadata.gz: 061daf70da2ca3137d942070323c8236f9bbe9128a801e8b1150b6d78615aa7933e1d5cc2f0b845c55d02f53b643090e948ba69308126c2f46b3cc9049b8dd39
+  data.tar.gz: ea9f2436eac22b671ae060f0038ac876c492765449dc701c232740ea70ed0c6f6b761a3dbf64811b89994538d5de8d4ae28162411f79dae1b8450c863142bf5c

data/lib/parallelizer.rb

@@ -0,0 +1,112 @@
+# -*- encoding : utf-8 -*-
+
+# used to call java code
+require 'java'
+
+# 'java_import' is used to import java classes
+java_import 'java.util.concurrent.Callable'
+java_import 'java.util.concurrent.FutureTask'
+java_import 'java.util.concurrent.LinkedBlockingQueue'
+java_import 'java.util.concurrent.ThreadPoolExecutor'
+java_import 'java.util.concurrent.TimeUnit'
+
+# get our DefaultDaemonThreadFactory class, so that the process will be able to end even
+# if we haven't explicitly shut down the pool (the default thread factory marks its threads as
+# non-daemon, which keeps the JVM from exiting until they are explicitly shut down)
+require "parallelizer/org.rubygems.parallelizer.jar"
+java_import 'org.rubygems.parallelizer.DefaultDaemonThreadFactory'
+
+
+class Parallelizer
+  attr_accessor :max_acceptable_delay, :delayed_too_long_proc
+
+  def initialize ops={} #:core_pool_threads, :max_pool_threads, :keep_alive_time, :max_acceptable_delay, :delayed_too_long_proc, :prestart_all_core_threads
+  core_pool_threads = ops[:core_pool_threads] || 10
+    max_pool_threads = ops[:max_pool_threads] || 10
+    raise "Parallelizer core_pool_threads greater than max_pool_threads!" if core_pool_threads > max_pool_threads
+
+    @pool = ThreadPoolExecutor.new(core_pool_threads,
+                                   max_pool_threads,
+                                   ops[:keep_alive_time] || 60,
+                                   TimeUnit::SECONDS,
+                                   LinkedBlockingQueue.new,
+                                   DefaultDaemonThreadFactory.new)
+
+    @max_acceptable_delay = ops[:max_acceptable_delay]
+    @delayed_too_long_proc = ops[:delayed_too_long_proc]
+
+    prestart_all_core_threads if ops[:prestart_all_core_threads]
+  end
+
+  def prestart_all_core_threads
+    @pool.prestartAllCoreThreads
+  end
+
+  def shutdown
+    @pool.shutdown
+  end
+
+  #works like a normal map, but in parallel, and also if an exception is raised that exception
+  #will be stored in that index instead of the result
+  def map enumerator, &proc
+    run_computation_array enumerator.map {|arg| Computation.new(self, proc, arg) }
+  end
+
+  #expects an array of procs
+  def run array
+    run_computation_array array.map {|proc| Computation.new(self, proc) }
+  end
+
+  protected
+
+  # Implement a callable class
+  class Computation
+    include Callable
+
+    attr_accessor :results_array, :result_index, :execution_requested_time
+
+    def initialize parallelizer, proc, argument=nil
+      @parallelizer = parallelizer
+      @proc = proc
+      @argument = argument
+    end
+
+    def call
+      begin
+        test_delay
+        @results_array[@result_index] = @argument ? @proc.call(@argument) : @proc.call
+      rescue
+        @results_array[@result_index] = $!
+      end
+    end
+
+    def test_delay
+      delay = nil
+      if @parallelizer.max_acceptable_delay && @parallelizer.delayed_too_long_proc && @execution_requested_time
+          (delay = Time.now.to_f - @execution_requested_time.to_f) > @parallelizer.max_acceptable_delay
+        @parallelizer.delayed_to_long_proc.call(delay)
+      end
+    end
+  end
+
+  def run_computation_array computation_array
+    results_array = Array.new(computation_array.size)
+    future_tasks = []
+    computation_array.each_with_index {|comp, i|
+      comp.results_array = results_array
+      comp.result_index = i
+      comp.execution_requested_time = Time.now
+
+      if i < computation_array.size - 1
+        task = FutureTask.new(comp)
+        @pool.execute task
+        future_tasks << task
+      else #last element, run it in this thread
+        comp.call
+      end
+    }
+
+    future_tasks.each {|task| task.get } #wait for all tasks to complete
+    results_array
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: parallelizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: java
+authors:
+- Mohamed Hafez
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-02-28 00:00:00.000000000 Z
+dependencies: []
+description: Run commands in parallel in JRuby, on a reusable thread pool
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/parallelizer.rb
+- lib/parallelizer/org.rubygems.parallelizer.jar
+homepage: https://github.com/mohamedhafez/parallelizer
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: Run commands in parallel in JRuby, on a reusable thread pool
+test_files: []