parallel 1.17.0 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6b2d803fd3a136456287d19f88a5986742beed7246f587491992661235e43c2
-  data.tar.gz: f3ed40c9c16f0a80e524f55c2f50d570d5da69c2f43ddc62023c323ddb968101
+  metadata.gz: 4dd167566b23262ceacbd640fda95c5e8d0d8149cc430f51ada53765a927cb18
+  data.tar.gz: 6a21c00b1109d5c665a471aec4a7af7d213ded2fc9123132b6576ee65ceb1758
 SHA512:
-  metadata.gz: b5534907c40e98488528ed8c9bc08ae1eab61b5b8ec1ce9d1b02b40687d08a6f19f3721e962273674994654dbe7a55b8df05ff905342e0fb28ff810a6036d958
-  data.tar.gz: d0b9f65e4a85636f8b464605b9b53de89ff529139801a5f8a8c7259783bce45eb1791c43218ba9ec3950e04e00a14f40b38c6079b52375d1c50f34a8db16c109
+  metadata.gz: 1f8a810c3b7fa77e8dd2b2539238b856b9b4ea40b5df49cf2cc4af2afbd2a73d9b6f34baab614c41e7b3b8bfe1917413bfbd014f647c5b4b96e7243d5433523d
+  data.tar.gz: 0bef1c7dc19b4738e228985512ee6cce1915f67ee29161b743821f69366d561ed8c3c5cbd4d9e6829342108fe9f10329563770d1978a660a04c58c0d9e2c8461

data/lib/parallel/processor_count.rb

@@ -1,41 +1,42 @@
+# frozen_string_literal: true
 require 'etc'
 
 module Parallel
+  # TODO: inline this method into parallel.rb and kill physical_processor_count in next major release
   module ProcessorCount
-    # Number of processors seen by the OS and used for process scheduling. It's just wrapper for Etc.nprocessors
+    # Number of processors seen by the OS, used for process scheduling
     def processor_count
-      @processor_count ||= begin
-        Etc.nprocessors
-      end
+      @processor_count ||= Integer(ENV['PARALLEL_PROCESSOR_COUNT'] || Etc.nprocessors)
     end
 
     # Number of physical processor cores on the current system.
-    #
     def physical_processor_count
       @physical_processor_count ||= begin
-        ppc = case RbConfig::CONFIG["target_os"]
-        when /darwin1/
-          IO.popen("/usr/sbin/sysctl -n hw.physicalcpu").read.to_i
-        when /linux/
-          cores = {}  # unique physical ID / core ID combinations
-          phy = 0
-          IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
-            if ln.start_with?("physical")
-              phy = ln[/\d+/]
-            elsif ln.start_with?("core")
-              cid = phy + ":" + ln[/\d+/]
-              cores[cid] = true if not cores[cid]
+        ppc =
+          case RbConfig::CONFIG["target_os"]
+          when /darwin[12]/
+            IO.popen("/usr/sbin/sysctl -n hw.physicalcpu").read.to_i
+          when /linux/
+            cores = {} # unique physical ID / core ID combinations
+            phy = 0
+            IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
+              if ln.start_with?("physical")
+                phy = ln[/\d+/]
+              elsif ln.start_with?("core")
+                cid = "#{phy}:#{ln[/\d+/]}"
+                cores[cid] = true unless cores[cid]
+              end
             end
+            cores.count
+          when /mswin|mingw/
+            require 'win32ole'
+            result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
+              "select NumberOfCores from Win32_Processor"
+            )
+            result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
+          else
+            processor_count
           end
-          cores.count
-        when /mswin|mingw/
-          require 'win32ole'
-          result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
-            "select NumberOfCores from Win32_Processor")
-          result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
-        else
-          processor_count
-        end
         # fall back to logical count if physical info is invalid
         ppc > 0 ? ppc : processor_count
       end

data/lib/parallel/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Parallel
-  VERSION = Version = '1.17.0'
+  VERSION = Version = '1.21.0' # rubocop:disable Naming/ConstantName
 end

data/lib/parallel.rb

@@ -1,31 +1,40 @@
+# frozen_string_literal: true
 require 'rbconfig'
 require 'parallel/version'
 require 'parallel/processor_count'
 
 module Parallel
-  extend Parallel::ProcessorCount
+  extend ProcessorCount
+
+  Stop = Object.new.freeze
 
   class DeadWorker < StandardError
   end
 
   class Break < StandardError
+    attr_reader :value
+
+    def initialize(value = nil)
+      super()
+      @value = value
+    end
   end
 
-  class Kill < StandardError
+  class Kill < Break
   end
 
   class UndumpableException < StandardError
     attr_reader :backtrace
+
     def initialize(original)
       super "#{original.class}: #{original.message}"
       @backtrace = original.backtrace
     end
   end
 
-  Stop = Object.new.freeze
-
   class ExceptionWrapper
     attr_reader :exception
+
     def initialize(exception)
       # Remove the bindings stack added by the better_errors gem,
       # because it cannot be marshalled
@@ -36,7 +45,7 @@ module Parallel
       @exception =
         begin
           Marshal.dump(exception) && exception
-        rescue
+        rescue StandardError
           UndumpableException.new(exception)
         end
     end
@@ -45,8 +54,11 @@ module Parallel
   class Worker
     attr_reader :pid, :read, :write
     attr_accessor :thread
+
     def initialize(read, write, pid)
-      @read, @write, @pid = read, write, pid
+      @read = read
+      @write = write
+      @pid = pid
     end
 
     def stop
@@ -73,7 +85,7 @@ module Parallel
       rescue EOFError
         raise DeadWorker
       end
-      raise result.exception if ExceptionWrapper === result
+      raise result.exception if result.is_a?(ExceptionWrapper)
       result
     end
 
@@ -102,7 +114,7 @@ module Parallel
         item, index = @mutex.synchronize do
           return if @stopped
           item = @lambda.call
-          @stopped = (item == Parallel::Stop)
+          @stopped = (item == Stop)
           return if @stopped
           [item, @index += 1]
         end
@@ -140,7 +152,7 @@ module Parallel
     end
 
     def queue_wrapper(array)
-      array.respond_to?(:num_waiting) && array.respond_to?(:pop) && lambda { array.pop(false) }
+      array.respond_to?(:num_waiting) && array.respond_to?(:pop) && -> { array.pop(false) }
     end
   end
 
@@ -156,7 +168,7 @@ module Parallel
 
         if @to_be_killed.empty?
           old_interrupt = trap_interrupt(signal) do
-            $stderr.puts 'Parallel execution interrupted, exiting ...'
+            warn 'Parallel execution interrupted, exiting ...'
             @to_be_killed.flatten.each { |pid| kill(pid) }
           end
         end
@@ -200,45 +212,44 @@ module Parallel
   end
 
   class << self
-    def in_threads(options={:count => 2})
+    def in_threads(options = { count: 2 })
+      threads = []
+      count, = extract_count_from_options(options)
+
       Thread.handle_interrupt(Exception => :never) do
-        begin
-          threads = []
-          count, _ = extract_count_from_options(options)
+        Thread.handle_interrupt(Exception => :immediate) do
           count.times do |i|
             threads << Thread.new { yield(i) }
           end
-          Thread.handle_interrupt(Exception => :immediate) do
-            threads.map(&:value)
-          end
-        ensure
-          threads.each(&:kill)
+          threads.map(&:value)
         end
+      ensure
+        threads.each(&:kill)
       end
     end
 
     def in_processes(options = {}, &block)
       count, options = extract_count_from_options(options)
       count ||= processor_count
-      map(0...count, options.merge(:in_processes => count), &block)
+      map(0...count, options.merge(in_processes: count), &block)
     end
 
-    def each(array, options={}, &block)
-      map(array, options.merge(:preserve_results => false), &block)
+    def each(array, options = {}, &block)
+      map(array, options.merge(preserve_results: false), &block)
     end
 
     def any?(*args, &block)
       raise "You must provide a block when calling #any?" if block.nil?
-      !each(*args) { |*a| raise Parallel::Kill if block.call(*a) }
+      !each(*args) { |*a| raise Kill if block.call(*a) }
     end
 
     def all?(*args, &block)
       raise "You must provide a block when calling #all?" if block.nil?
-      !!each(*args) { |*a| raise Parallel::Kill unless block.call(*a) }
+      !!each(*args) { |*a| raise Kill unless block.call(*a) }
     end
 
-    def each_with_index(array, options={}, &block)
-      each(array, options.merge(:with_index => true), &block)
+    def each_with_index(array, options = {}, &block)
+      each(array, options.merge(with_index: true), &block)
     end
 
     def map(source, options = {}, &block)
@@ -246,8 +257,8 @@ module Parallel
       options[:mutex] = Mutex.new
 
       if options[:in_processes] && options[:in_threads]
-        raise ArgumentError.new("Please specify only one of `in_processes` or `in_threads`.")
-      elsif RUBY_PLATFORM =~ /java/ and not options[:in_processes]
+        raise ArgumentError, "Please specify only one of `in_processes` or `in_threads`."
+      elsif RUBY_PLATFORM =~ (/java/) && !(options[:in_processes])
         method = :in_threads
         size = options[method] || processor_count
       elsif options[:in_threads]
@@ -269,20 +280,22 @@ module Parallel
       options[:return_results] = (options[:preserve_results] != false || !!options[:finish])
       add_progress_bar!(job_factory, options)
 
-      results = if size == 0
-        work_direct(job_factory, options, &block)
-      elsif method == :in_threads
-        work_in_threads(job_factory, options.merge(:count => size), &block)
-      else
-        work_in_processes(job_factory, options.merge(:count => size), &block)
-      end
-      if results
-        options[:return_results] ? results : source
-      end
+      result =
+        if size == 0
+          work_direct(job_factory, options, &block)
+        elsif method == :in_threads
+          work_in_threads(job_factory, options.merge(count: size), &block)
+        else
+          work_in_processes(job_factory, options.merge(count: size), &block)
+        end
+
+      return result.value if result.is_a?(Break)
+      raise result if result.is_a?(Exception)
+      options[:return_results] ? result : source
     end
 
-    def map_with_index(array, options={}, &block)
-      map(array, options.merge(:with_index => true), &block)
+    def map_with_index(array, options = {}, &block)
+      map(array, options.merge(with_index: true), &block)
     end
 
     def flat_map(*args, &block)
@@ -336,10 +349,10 @@ module Parallel
             call_with_index(item, index, options, &block)
           end
         end
-      rescue
+      rescue StandardError
         exception = $!
       end
-      handle_exception(exception, results)
+      exception || results
     ensure
       self.worker_number = nil
     end
@@ -360,13 +373,13 @@ module Parallel
               call_with_index(item, index, options, &block)
             end
             results_mutex.synchronize { results[index] = result }
-          rescue
+          rescue StandardError
             exception = $!
           end
         end
       end
 
-      handle_exception(exception, results)
+      exception || results
     end
 
     def work_in_processes(job_factory, options, &blk)
@@ -400,9 +413,9 @@ module Parallel
                 results_mutex.synchronize { results[index] = result } # arrays are not threads safe on jRuby
               rescue StandardError => e
                 exception = e
-                if Parallel::Kill === exception
+                if exception.is_a?(Kill)
                   (workers - [worker]).each do |w|
-                    w.thread.kill if w.thread
+                    w.thread&.kill
                     UserInterruptHandler.kill(w.pid)
                   end
                 end
@@ -413,19 +426,18 @@ module Parallel
           end
         end
       end
-
-      handle_exception(exception, results)
+      exception || results
     end
 
-    def replace_worker(job_factory, workers, i, options, blk)
+    def replace_worker(job_factory, workers, index, options, blk)
       options[:mutex].synchronize do
         # old worker is no longer used ... stop it
-        worker = workers[i]
+        worker = workers[index]
         worker.stop
 
         # create a new replacement worker
         running = workers - [worker]
-        workers[i] = worker(job_factory, options.merge(started_workers: running, worker_number: i), &blk)
+        workers[index] = worker(job_factory, options.merge(started_workers: running, worker_number: index), &blk)
       end
     end
 
@@ -467,11 +479,17 @@ module Parallel
       until read.eof?
         data = Marshal.load(read)
         item, index = job_factory.unpack(data)
-        result = begin
-          call_with_index(item, index, options, &block)
-        rescue
-          ExceptionWrapper.new($!)
-        end
+
+        result =
+          begin
+            call_with_index(item, index, options, &block)
+          # https://github.com/rspec/rspec-support/blob/673133cdd13b17077b3d88ece8d7380821f8d7dc/lib/rspec/support.rb#L132-L140
+          rescue NoMemoryError, SignalException, Interrupt, SystemExit # rubocop:disable Lint/ShadowedException
+            raise $!
+          rescue Exception # # rubocop:disable Lint/RescueException
+            ExceptionWrapper.new($!)
+          end
+
         begin
           Marshal.dump(result, write)
         rescue Errno::EPIPE
@@ -480,12 +498,6 @@ module Parallel
       end
     end
 
-    def handle_exception(exception, results)
-      return nil if [Parallel::Break, Parallel::Kill].include? exception.class
-      raise exception if exception
-      results
-    end
-
     # options is either a Integer or a Hash with :count
     def extract_count_from_options(options)
       if options.is_a?(Hash)
@@ -500,10 +512,10 @@ module Parallel
     def call_with_index(item, index, options, &block)
       args = [item]
       args << index if options[:with_index]
+      results = block.call(*args)
       if options[:return_results]
-        block.call(*args)
+        results
       else
-        block.call(*args)
         nil # avoid GC overhead of passing large results around
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel
 version: !ruby/object:Gem::Version
-  version: 1.17.0
+  version: 1.21.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-01 00:00:00.000000000 Z
+date: 2021-09-13 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: michael@grosser.it
@@ -23,7 +23,11 @@ files:
 homepage: https://github.com/grosser/parallel
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/grosser/parallel/issues
+  documentation_uri: https://github.com/grosser/parallel/blob/v1.21.0/Readme.md
+  source_code_uri: https://github.com/grosser/parallel/tree/v1.21.0
+  wiki_uri: https://github.com/grosser/parallel/wiki
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -32,15 +36,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.2.16
 signing_key: 
 specification_version: 4
 summary: Run any kind of code in parallel processes