concurrent-ruby 1.2.3 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c6483d36c3c75859c9b38b6ba2ba13577a0bb89b3b725a032d43f3543797099
-  data.tar.gz: e94ac3e1ba23db29a7bf025736e34a4027ba7a137ae08b493c78ce3756803792
+  metadata.gz: 14d5a264c6fdc7b6087131a0f0a2fc1ce661d18029440e426e094443eb359ca6
+  data.tar.gz: 42e7b1b8fb885aec9b7b08488c6682af2743e65ad6dcd731f8c86d34f7768981
 SHA512:
-  metadata.gz: dc0353e60638a409bf891d663626bd2c1c5f05206c08036326d63e239bfe0ea7e1e3480982c75fe44f9d416a7f76a66a2a2aeef78fc60084ed7ff94c7d3181d9
-  data.tar.gz: 24bdd3a040528c05061ec15b4057184be96fa933f69f3321755e8583ba8e6175beec48c36f1671cc3dad7e413588c9601c7f0e5b503b3de947dff63c2ba76b1e
+  metadata.gz: 31b6cf4fcc533349681610e74f6261c95e5c664583014d86101578f0380a6889288b29a89314a5da59e92cd422bcd97783c34d99c3e5c21a90db0f0d3fcc57e1
+  data.tar.gz: 4438de87d8ec3ff1cc6d7d246821002bbb76d5a9ddd8b77ebf4a15c0449f1509d694c4f57936b1e1a69e19f32736f21518fd8e82b8cdfbb99d5e2948976c230e

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 ## Current
 
+## Release v1.3.5, edge v0.7.2 (15 January 2025)
+
+concurrent-ruby:
+
+* (#1062) Remove dependency on logger.
+
+concurrent-ruby-edge:
+
+* (#1062) Remove dependency on logger.
+
+## Release v1.3.4 (10 August 2024)
+
+* (#1060) Fix bug with return value of `Concurrent.available_processor_count` when `cpu.cfs_quota_us` is -1.
+* (#1058) Add `Concurrent.cpu_shares` that is cgroups aware.
+
+## Release v1.3.3 (9 June 2024)
+
+* (#1053) Improve the speed of `Concurrent.physical_processor_count` on Windows.
+
+## Release v1.3.2, edge v0.7.1 (7 June 2024)
+
+concurrent-ruby:
+
+* (#1051) Remove dependency on `win32ole`.
+
+concurrent-ruby-edge:
+
+* (#1052) Fix dependency on `concurrent-ruby` to allow the latest release.
+
+## Release v1.3.1 (29 May 2024)
+
+* Release 1.3.0 was broken when pushed to RubyGems. 1.3.1 is a packaging fix.
+
+## Release v1.3.0 (28 May 2024)
+
+* (#1042) Align Java Executor Service behavior for `shuttingdown?`, `shutdown?`
+* (#1038) Add `Concurrent.available_processor_count` that is cgroups aware.
+
 ## Release v1.2.3 (16 Jan 2024)
 
 * See [the GitHub release](https://github.com/ruby-concurrency/concurrent-ruby/releases/tag/v1.2.3) for details.
@@ -268,7 +306,7 @@ concurrent-ruby-edge:
 * Simplification of `RubySingleThreadExecutor`
 * `Async` improvements
   - Each object uses its own `SingleThreadExecutor` instead of the global thread pool.
-  - No longers supports executor injection
+  - No longer supports executor injection
   - Much better documentation
 * `Atom` updates
   - No longer `Dereferenceable`
@@ -443,7 +481,7 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * Fixed bug with return value of `Concurrent::Actor::Utils::Pool#ask`
 * Fixed timing bug in `TimerTask`
 * Fixed bug when creating a `JavaThreadPoolExecutor` with minimum pool size of zero
-* Removed confusing warning when not using native extenstions
+* Removed confusing warning when not using native extensions
 * Improved documentation
 
 ## Release v0.7.0 (13 August 2014)

data/Gemfile

@@ -1,14 +1,14 @@
 source 'https://rubygems.org'
 
-require File.join(File.dirname(__FILE__), 'lib/concurrent-ruby/concurrent/version')
-require File.join(File.dirname(__FILE__ ), 'lib/concurrent-ruby-edge/concurrent/edge/version')
+version = File.read("#{__dir__}/lib/concurrent-ruby/concurrent/version.rb")[/'(.+)'/, 1] or raise
+edge_version = File.read("#{__dir__}/lib/concurrent-ruby-edge/concurrent/edge/version.rb")[/'(.+)'/, 1] or raise
 
 no_path = ENV['NO_PATH']
 options = no_path ? {} : { path: '.' }
 
-gem 'concurrent-ruby', Concurrent::VERSION, options
-gem 'concurrent-ruby-edge', Concurrent::EDGE_VERSION, options
-gem 'concurrent-ruby-ext', Concurrent::VERSION, options.merge(platform: :mri)
+gem 'concurrent-ruby', version, options
+gem 'concurrent-ruby-edge', edge_version, options
+gem 'concurrent-ruby-ext', version, options.merge(platform: :mri)
 
 group :development do
   gem 'rake', '~> 13.0'

data/README.md

@@ -284,7 +284,7 @@ To use the tools in the Edge gem it must be required separately:
 require 'concurrent-edge'
 ```
 
-If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could 
+If the library does not behave as expected, `Concurrent.use_simple_logger(:DEBUG)` could
 help to reveal the problem.
 
 ## Installation

data/Rakefile

@@ -1,6 +1,5 @@
-require_relative 'lib/concurrent-ruby/concurrent/version'
-require_relative 'lib/concurrent-ruby-edge/concurrent/edge/version'
-require_relative 'lib/concurrent-ruby/concurrent/utility/engine'
+version = File.read("#{__dir__}/lib/concurrent-ruby/concurrent/version.rb")[/'(.+)'/, 1] or raise
+edge_version = File.read("#{__dir__}/lib/concurrent-ruby-edge/concurrent/edge/version.rb")[/'(.+)'/, 1] or raise
 
 core_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby.gemspec')
 ext_gemspec  = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-ext.gemspec')
@@ -8,14 +7,16 @@ edge_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-edge.
 
 require 'rake/javaextensiontask'
 
-ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME'] && !Concurrent.on_jruby?
+ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME'] && RUBY_ENGINE != 'jruby'
 
 Rake::JavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
   ext.ext_dir = 'ext/concurrent-ruby'
   ext.lib_dir = 'lib/concurrent-ruby/concurrent'
+  ext.source_version = '8'
+  ext.target_version = '8'
 end
 
-unless Concurrent.on_jruby? || Concurrent.on_truffleruby?
+if RUBY_ENGINE == 'ruby'
   require 'rake/extensiontask'
 
   Rake::ExtensionTask.new('concurrent_ruby_ext', ext_gemspec) do |ext|
@@ -28,6 +29,10 @@ unless Concurrent.on_jruby? || Concurrent.on_truffleruby?
   end
 end
 
+def which?(executable)
+  !`which #{executable} 2>/dev/null`.empty?
+end
+
 require 'rake_compiler_dock'
 namespace :repackage do
   desc '* with Windows fat distributions'
@@ -42,12 +47,19 @@ namespace :repackage do
       Rake::Task['lib/concurrent-ruby/concurrent/concurrent_ruby.jar'].invoke
 
       # build all gem files
+      rack_compiler_dock_kwargs = {}
+      if which?('podman') and (!which?('docker') || `docker --version`.include?('podman'))
+        # podman and only podman available, so RakeCompilerDock will use podman, otherwise it uses docker
+        rack_compiler_dock_kwargs = {
+          options: ['--privileged'], # otherwise the directory in the image is empty
+          runas: false
+        }
+      end
       %w[x86-mingw32 x64-mingw32].each do |plat|
         RakeCompilerDock.sh(
           "bundle install --local && bundle exec rake native:#{plat} gem --trace",
           platform: plat,
-          options: ['--privileged'], # otherwise the directory in the image is empty
-          runas: false)
+          **rack_compiler_dock_kwargs)
       end
     end
   end
@@ -57,7 +69,7 @@ require 'rubygems'
 require 'rubygems/package_task'
 
 Gem::PackageTask.new(core_gemspec) {} if core_gemspec
-Gem::PackageTask.new(ext_gemspec) {} if ext_gemspec && !Concurrent.on_jruby?
+Gem::PackageTask.new(ext_gemspec) {} if ext_gemspec && RUBY_ENGINE != 'jruby'
 Gem::PackageTask.new(edge_gemspec) {} if edge_gemspec
 
 CLEAN.include(
@@ -85,9 +97,9 @@ begin
     task :installed do
       Bundler.with_original_env do
         Dir.chdir(__dir__) do
-          sh "gem install pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
-          sh "gem install pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if Concurrent.on_cruby?
-          sh "gem install pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem"
+          sh "gem install pkg/concurrent-ruby-#{version}.gem"
+          sh "gem install pkg/concurrent-ruby-ext-#{version}.gem" if RUBY_ENGINE == 'ruby'
+          sh "gem install pkg/concurrent-ruby-edge-#{edge_version}.gem"
           ENV['NO_PATH'] = 'true'
           sh 'bundle update'
           sh 'bundle exec rake spec:ci'
@@ -117,7 +129,7 @@ rescue LoadError => e
   puts 'RSpec is not installed, skipping test task definitions: ' + e.message
 end
 
-current_yard_version_name = Concurrent::VERSION
+current_yard_version_name = version
 
 begin
   require 'yard'
@@ -221,6 +233,8 @@ namespace :release do
   # Depends on environment of @pitr-ch
 
   task :checks do
+    raise '$CONCURRENT_JRUBY_HOME must be set' unless ENV['CONCURRENT_JRUBY_HOME']
+
     Dir.chdir(__dir__) do
       sh 'test -z "$(git status --porcelain)"' do |ok, res|
         unless ok
@@ -251,15 +265,19 @@ namespace :release do
 
   desc '* test actual installed gems instead of cloned repository on MRI and JRuby'
   task :test do
+    raise '$CONCURRENT_JRUBY_HOME must be set' unless ENV['CONCURRENT_JRUBY_HOME']
+
     Dir.chdir(__dir__) do
       puts "Testing with the installed gem"
 
       Bundler.with_original_env do
         sh 'ruby -v'
+        sh 'bundle install'
         sh 'bundle exec rake spec:installed'
 
-        env = { "PATH" => "#{ENV['CONCURRENT_JRUBY_HOME']}/bin:#{ENV['PATH']}" }
+        env = { "PATH" => "#{ENV.fetch('CONCURRENT_JRUBY_HOME')}/bin:#{ENV['PATH']}" }
         sh env, 'ruby -v'
+        sh env, 'bundle install'
         sh env, 'bundle exec rake spec:installed'
       end
 
@@ -271,8 +289,8 @@ namespace :release do
   task :publish => ['publish:ask', 'publish:tag', 'publish:rubygems', 'publish:post_steps']
 
   namespace :publish do
-    publish_base = true
-    publish_edge = false
+    publish_base = nil
+    publish_edge = nil
 
     task :ask do
       begin
@@ -280,8 +298,15 @@ namespace :release do
         input = STDIN.gets.strip.downcase
       end until %w(y n).include?(input)
       exit 1 if input == 'n'
+
+      begin
+        STDOUT.puts 'Do you want to publish `concurrent-ruby`? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      publish_base = input == 'y'
+
       begin
-        STDOUT.puts 'It will publish `concurrent-ruby`. Do you want to publish `concurrent-ruby-edge`? (y/n)'
+        STDOUT.puts 'Do you want to publish `concurrent-ruby-edge`? (y/n)'
         input = STDIN.gets.strip.downcase
       end until %w(y n).include?(input)
       publish_edge = input == 'y'
@@ -290,21 +315,21 @@ namespace :release do
     desc '** tag HEAD with current version and push to github'
     task :tag => :ask do
       Dir.chdir(__dir__) do
-        sh "git tag v#{Concurrent::VERSION}" if publish_base
-        sh "git push origin v#{Concurrent::VERSION}" if publish_base
-        sh "git tag edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
-        sh "git push origin edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
+        sh "git tag v#{version}" if publish_base
+        sh "git push origin v#{version}" if publish_base
+        sh "git tag edge-v#{edge_version}" if publish_edge
+        sh "git push origin edge-v#{edge_version}" if publish_edge
       end
     end
 
     desc '** push all *.gem files to rubygems'
     task :rubygems => :ask do
       Dir.chdir(__dir__) do
-        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem" if publish_base
-        sh "gem push pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem" if publish_edge
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if publish_base
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem" if publish_base
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-#{version}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-edge-#{edge_version}.gem" if publish_edge
+        sh "gem push pkg/concurrent-ruby-ext-#{version}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{version}-x64-mingw32.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{version}-x86-mingw32.gem" if publish_base
       end
     end
 

data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/ConcurrentHashMapV8.java

@@ -481,7 +481,7 @@ public class ConcurrentHashMapV8<K, V>
      *
      * Maintaining API and serialization compatibility with previous
      * versions of this class introduces several oddities. Mainly: We
-     * leave untouched but unused constructor arguments refering to
+     * leave untouched but unused constructor arguments referring to
      * concurrencyLevel. We accept a loadFactor constructor argument,
      * but apply it only to initial table capacity (which is the only
      * time that we can guarantee to honor it.) We also declare an

data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/ConcurrentHashMapV8.java

@@ -484,7 +484,7 @@ public class ConcurrentHashMapV8<K, V>
      *
      * Maintaining API and serialization compatibility with previous
      * versions of this class introduces several oddities. Mainly: We
-     * leave untouched but unused constructor arguments refering to
+     * leave untouched but unused constructor arguments referring to
      * concurrencyLevel. We accept a loadFactor constructor argument,
      * but apply it only to initial table capacity (which is the only
      * time that we can guarantee to honor it.) We also declare an

data/lib/concurrent-ruby/concurrent/agent.rb

@@ -371,7 +371,7 @@ module Concurrent
     # @param [Float] timeout the maximum number of seconds to wait
     # @return [Boolean] true if all actions complete before timeout
     #
-    # @raise [Concurrent::TimeoutError] when timout is reached
+    # @raise [Concurrent::TimeoutError] when timeout is reached
     #
     # @!macro agent_await_warning
     def await_for!(timeout)
@@ -477,7 +477,7 @@ module Concurrent
       # @param [Array<Concurrent::Agent>] agents the Agents on which to wait
       # @return [Boolean] true if all actions complete before timeout
       #
-      # @raise [Concurrent::TimeoutError] when timout is reached
+      # @raise [Concurrent::TimeoutError] when timeout is reached
       # @!macro agent_await_warning
       def await_for!(timeout, *agents)
         raise Concurrent::TimeoutError unless await_for(timeout, *agents)

data/lib/concurrent-ruby/concurrent/async.rb

@@ -218,7 +218,7 @@ module Concurrent
 
     # @!method self.new(*args, &block)
     #
-    #   Instanciate a new object and ensure proper initialization of the
+    #   Instantiate a new object and ensure proper initialization of the
     #   synchronization mechanisms.
     #
     #   @param [Array<Object>] args Zero or more arguments to be passed to the

data/lib/concurrent-ruby/concurrent/atom.rb

@@ -113,7 +113,7 @@ module Concurrent
     # @option opts [Proc] :validator (nil) Optional proc used to validate new
     #   values. It must accept one and only one argument which will be the
     #   intended new value. The validator will return true if the new value
-    #   is acceptable else return false (preferrably) or raise an exception.
+    #   is acceptable else return false (preferably) or raise an exception.
     #
     # @!macro deref_options
     #

data/lib/concurrent-ruby/concurrent/concern/logging.rb

@@ -1,4 +1,3 @@
-require 'logger'
 require 'concurrent/atomic/atomic_reference'
 
 module Concurrent
@@ -8,10 +7,12 @@ module Concurrent
     #
     # @!visibility private
     module Logging
-      include Logger::Severity
+      # The same as Logger::Severity but we copy it here to avoid a dependency on the logger gem just for these 7 constants
+      DEBUG, INFO, WARN, ERROR, FATAL, UNKNOWN = 0, 1, 2, 3, 4, 5
+      SEV_LABEL = %w[DEBUG INFO WARN ERROR FATAL ANY].freeze
 
       # Logs through {Concurrent.global_logger}, it can be overridden by setting @logger
-      # @param [Integer] level one of Logger::Severity constants
+      # @param [Integer] level one of Concurrent::Concern::Logging constants
       # @param [String] progname e.g. a path of an Actor
       # @param [String, nil] message when nil block is used to generate the message
       # @yieldreturn [String] a message
@@ -23,7 +24,7 @@ module Concurrent
                  end
         logger.call level, progname, message, &block
       rescue => error
-        $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
+        $stderr.puts "`Concurrent.global_logger` failed to log #{[level, progname, message, block]}\n" +
           "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
       end
     end
@@ -33,8 +34,10 @@ end
 module Concurrent
   extend Concern::Logging
 
-  # @return [Logger] Logger with provided level and output.
-  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
+  # Create a simple logger with provided level and output.
+  def self.create_simple_logger(level = :FATAL, output = $stderr)
+    level = Concern::Logging.const_get(level) unless level.is_a?(Integer)
+
     # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
     lambda do |severity, progname, message = nil, &block|
       return false if severity < level
@@ -52,7 +55,7 @@ module Concurrent
 
       output.print format "[%s] %5s -- %s: %s\n",
                           Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
-                          Logger::SEV_LABEL[severity],
+                          Concern::Logging::SEV_LABEL[severity],
                           progname,
                           formatted_message
       true
@@ -60,13 +63,15 @@ module Concurrent
   end
 
   # Use logger created by #create_simple_logger to log concurrent-ruby messages.
-  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
+  def self.use_simple_logger(level = :FATAL, output = $stderr)
     Concurrent.global_logger = create_simple_logger level, output
   end
 
-  # @return [Logger] Logger with provided level and output.
+  # Create a stdlib logger with provided level and output.
+  # If you use this deprecated method you might need to add logger to your Gemfile to avoid warnings from Ruby 3.3.5+.
   # @deprecated
-  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
+  def self.create_stdlib_logger(level = :FATAL, output = $stderr)
+    require 'logger'
     logger           = Logger.new(output)
     logger.level     = level
     logger.formatter = lambda do |severity, datetime, progname, msg|
@@ -93,7 +98,7 @@ module Concurrent
 
   # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
   # @deprecated
-  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
+  def self.use_stdlib_logger(level = :FATAL, output = $stderr)
     Concurrent.global_logger = create_stdlib_logger level, output
   end
 
@@ -103,7 +108,7 @@ module Concurrent
   NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
 
   # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
+  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(:WARN))
   private_constant :GLOBAL_LOGGER
 
   def self.global_logger

data/lib/concurrent-ruby/concurrent/delay.rb

@@ -19,7 +19,7 @@ module Concurrent
   #
   # When a `Delay` is created its state is set to `pending`. The value and
   # reason are both `nil`. The first time the `#value` method is called the
-  # enclosed opration will be run and the calling thread will block. Other
+  # enclosed operation will be run and the calling thread will block. Other
   # threads attempting to call `#value` will block as well. Once the operation
   # is complete the *value* will be set to the result of the operation or the
   # *reason* will be set to the raised exception, as appropriate. All threads

data/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb

@@ -83,7 +83,7 @@ module Concurrent
   #
   #   This is a no-op on some pool implementation (e.g. the Java one).  The Ruby
   #   pool will auto-prune each time a new job is posted. You will need to call
-  #   this method explicitely in case your application post jobs in bursts (a
+  #   this method explicitly in case your application post jobs in bursts (a
   #   lot of jobs and then nothing for long periods)
 
   # @!macro thread_pool_executor_public_api

data/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb

@@ -57,15 +57,11 @@ if Concurrent.on_jruby?
       end
 
       def ns_shuttingdown?
-        if @executor.respond_to? :isTerminating
-          @executor.isTerminating
-        else
-          false
-        end
+        @executor.isShutdown && !@executor.isTerminated
       end
 
       def ns_shutdown?
-        @executor.isShutdown || @executor.isTerminated
+        @executor.isTerminated
       end
 
       class Job

data/lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb

@@ -27,7 +27,7 @@ module Concurrent
   #   is received. This pattern has several issues. The thread itself is highly
   #   susceptible to errors during processing. Also, the thread itself must be
   #   constantly monitored and restarted should it die. `SingleThreadExecutor`
-  #   encapsulates all these bahaviors. The task processor is highly resilient
+  #   encapsulates all these behaviors. The task processor is highly resilient
   #   to errors from within tasks. Also, should the thread die it will
   #   automatically be restarted.
   #

data/lib/concurrent-ruby/concurrent/map.rb

@@ -148,7 +148,7 @@ module Concurrent
         if value = super # non-falsy value is an existing mapping, return it right away
           value
           # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
+          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrect +nil+ value
           # would be returned)
           # note: nil == value check is not technically necessary
         elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))

data/lib/concurrent-ruby/concurrent/promise.rb

@@ -103,7 +103,7 @@ module Concurrent
   # - if parent is *rejected* the child will be *pending* (but will ultimately be *rejected*)
   #
   # Promises are executed asynchronously from the main thread. By the time a
-  # child Promise finishes intialization it may be in a different state than its
+  # child Promise finishes initialization it may be in a different state than its
   # parent (by the time a child is created its parent may have completed
   # execution and changed state). Despite being asynchronous, however, the order
   # of execution of Promise objects in a chain (or tree) is strictly defined.

data/lib/concurrent-ruby/concurrent/scheduled_task.rb

@@ -193,7 +193,7 @@ module Concurrent
       end
     end
 
-    # The `delay` value given at instanciation.
+    # The `delay` value given at instantiation.
     #
     # @return [Float] the initial delay.
     def initial_delay

data/lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb

@@ -157,7 +157,7 @@ module Concurrent
           end
         end
         members.each_with_index do |member, index|
-          clazz.send :remove_method, member if clazz.instance_methods.include? member
+          clazz.send :remove_method, member if clazz.instance_methods(false).include? member
           clazz.send(:define_method, member) do
             @values[index]
           end

data/lib/concurrent-ruby/concurrent/synchronization/object.rb

@@ -58,7 +58,7 @@ module Concurrent
 
       # Creates methods for reading and writing to a instance variable with
       # volatile (Java) semantic as {.attr_volatile} does.
-      # The instance variable should be accessed oly through generated methods.
+      # The instance variable should be accessed only through generated methods.
       # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
       # `swap_value(new_value) #=> old_value`,
       # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.

data/lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb

@@ -9,7 +9,7 @@ module Concurrent
     # @!visibility private
     module Util
 
-      # A Ruby port of the Doug Lea's jsr166e.LondAdder class version 1.8
+      # A Ruby port of the Doug Lea's jsr166e.LongAdder class version 1.8
       # available in public domain.
       #
       # Original source code available here:

data/lib/concurrent-ruby/concurrent/thread_safe/util/xor_shift_random.rb

@@ -15,7 +15,7 @@ module Concurrent
       # Usage:
       #   x = XorShiftRandom.get # uses Kernel.rand to generate an initial seed
       #   while true
-      #     if (x = XorShiftRandom.xorshift).odd? # thread-localy generate a next random number
+      #     if (x = XorShiftRandom.xorshift).odd? # thread-locally generate a next random number
       #       do_something_at_random
       #     end
       #   end

data/lib/concurrent-ruby/concurrent/utility/processor_counter.rb

@@ -11,6 +11,8 @@ module Concurrent
       def initialize
         @processor_count          = Delay.new { compute_processor_count }
         @physical_processor_count = Delay.new { compute_physical_processor_count }
+        @cpu_quota                = Delay.new { compute_cpu_quota }
+        @cpu_shares               = Delay.new { compute_cpu_shares }
       end
 
       def processor_count
@@ -21,6 +23,29 @@ module Concurrent
         @physical_processor_count.value
       end
 
+      def available_processor_count
+        cpu_count = processor_count.to_f
+        quota = cpu_quota
+
+        return cpu_count if quota.nil?
+
+        # cgroup cpus quotas have no limits, so they can be set to higher than the
+        # real count of cores.
+        if quota > cpu_count
+          cpu_count
+        else
+          quota
+        end
+      end
+
+      def cpu_quota
+        @cpu_quota.value
+      end
+
+      def cpu_shares
+        @cpu_shares.value
+      end
+
       private
 
       def compute_processor_count
@@ -48,10 +73,20 @@ module Concurrent
                 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(:+)
+                # Get-CimInstance introduced in PowerShell 3 or earlier: https://learn.microsoft.com/en-us/previous-versions/powershell/module/cimcmdlets/get-ciminstance?view=powershell-3.0
+                result = run('powershell -command "Get-CimInstance -ClassName Win32_Processor -Property NumberOfCores | Select-Object -Property NumberOfCores"')
+                if !result || $?.exitstatus != 0
+                  # fallback to deprecated wmic for older systems
+                  result = run("wmic cpu get NumberOfCores")
+                end
+                if !result || $?.exitstatus != 0
+                  # Bail out if both commands returned something unexpected
+                  processor_count
+                else
+                  # powershell: "\nNumberOfCores\n-------------\n            4\n\n\n"
+                  # wmic:       "NumberOfCores  \n\n4              \n\n\n\n"
+                  result.scan(/\d+/).map(&:to_i).reduce(:+)
+                end
               else
                 processor_count
               end
@@ -60,6 +95,45 @@ module Concurrent
       rescue
         return 1
       end
+
+      def run(command)
+        IO.popen(command, &:read)
+      rescue Errno::ENOENT
+      end
+
+      def compute_cpu_quota
+        if RbConfig::CONFIG["target_os"].include?("linux")
+          if File.exist?("/sys/fs/cgroup/cpu.max")
+            # cgroups v2: https://docs.kernel.org/admin-guide/cgroup-v2.html#cpu-interface-files
+            cpu_max = File.read("/sys/fs/cgroup/cpu.max")
+            return nil if cpu_max.start_with?("max ") # no limit
+            max, period = cpu_max.split.map(&:to_f)
+            max / period
+          elsif File.exist?("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_quota_us")
+            # cgroups v1: https://kernel.googlesource.com/pub/scm/linux/kernel/git/glommer/memcg/+/cpu_stat/Documentation/cgroups/cpu.txt
+            max = File.read("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_quota_us").to_i
+            # If the cpu.cfs_quota_us is -1, cgroup does not adhere to any CPU time restrictions
+            # https://docs.kernel.org/scheduler/sched-bwc.html#management
+            return nil if max <= 0
+            period = File.read("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_period_us").to_f
+            max / period
+          end
+        end
+      end
+
+      def compute_cpu_shares
+        if RbConfig::CONFIG["target_os"].include?("linux")
+          if File.exist?("/sys/fs/cgroup/cpu.weight")
+            # cgroups v2: https://docs.kernel.org/admin-guide/cgroup-v2.html#cpu-interface-files
+            # Ref: https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/2254-cgroup-v2#phase-1-convert-from-cgroups-v1-settings-to-v2
+            weight = File.read("/sys/fs/cgroup/cpu.weight").to_f
+            ((((weight - 1) * 262142) / 9999) + 2) / 1024
+          elsif File.exist?("/sys/fs/cgroup/cpu/cpu.shares")
+            # cgroups v1: https://kernel.googlesource.com/pub/scm/linux/kernel/git/glommer/memcg/+/cpu_stat/Documentation/cgroups/cpu.txt
+            File.read("/sys/fs/cgroup/cpu/cpu.shares").to_f / 1024
+          end
+        end
+      end
     end
   end
 
@@ -75,8 +149,8 @@ module Concurrent
   # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
   # to the Java documentation this "value may change during a particular
   # invocation of the virtual machine... [applications] should therefore
-  # occasionally poll this property." Subsequently the result will NOT be
-  # memoized under JRuby.
+  # occasionally poll this property." We still memoize this value once under
+  # JRuby.
   #
   # Otherwise Ruby's Etc.nprocessors will be used.
   #
@@ -107,4 +181,40 @@ module Concurrent
   def self.physical_processor_count
     processor_counter.physical_processor_count
   end
+
+  # Number of processors cores available for process scheduling.
+  # This method takes in account the CPU quota if the process is inside a cgroup with a
+  # dedicated CPU quota (typically Docker).
+  # Otherwise it returns the same value as #processor_count but as a Float.
+  #
+  # For performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # @return [Float] number of available processors
+  def self.available_processor_count
+    processor_counter.available_processor_count
+  end
+
+  # The maximum number of processors cores available for process scheduling.
+  # Returns `nil` if there is no enforced limit, or a `Float` if the
+  # process is inside a cgroup with a dedicated CPU quota (typically Docker).
+  #
+  # Note that nothing prevents setting a CPU quota higher than the actual number of
+  # cores on the system.
+  #
+  # For performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # @return [nil, Float] Maximum number of available processors as set by a cgroup CPU quota, or nil if none set
+  def self.cpu_quota
+    processor_counter.cpu_quota
+  end
+
+  # The CPU shares requested by the process. For performance reasons the calculated
+  # value will be memoized on the first call.
+  #
+  # @return [Float, nil] CPU shares requested by the process, or nil if not set
+  def self.cpu_shares
+    processor_counter.cpu_shares
+  end
 end

data/lib/concurrent-ruby/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '1.2.3'
+  VERSION = '1.3.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.5
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-16 00:00:00.000000000 Z
+date: 2025-01-15 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.