concurrent-ruby 1.2.2 → 1.3.5

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

@@ -3,7 +3,7 @@ require 'concurrent/atomic/event'
 require 'concurrent/collection/non_concurrent_priority_queue'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/single_thread_executor'
-
+require 'concurrent/errors'
 require 'concurrent/options'
 
 module Concurrent
@@ -162,7 +162,11 @@ module Concurrent
           # queue now must have the same pop time, or a closer one, as
           # when we peeked).
           task = synchronize { @queue.pop }
-          task.executor.post { task.process_task }
+          begin
+            task.executor.post { task.process_task }
+          rescue RejectedExecutionError
+            # ignore and continue
+          end
         else
           @condition.wait([diff, 60].min)
         end

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

@@ -15,9 +15,11 @@ module Concurrent
   # @!macro internal_implementation_note
   HashImplementation = case
                        when Concurrent.on_cruby?
-                         # Hash is thread-safe in practice because CRuby runs
-                         # threads one at a time and does not do context
-                         # switching during the execution of C functions.
+                         # Hash is not fully thread-safe on CRuby, see
+                         # https://bugs.ruby-lang.org/issues/19237
+                         # https://github.com/ruby/ruby/commit/ffd52412ab
+                         # https://github.com/ruby-concurrency/concurrent-ruby/issues/929
+                         # So we will need to add synchronization here (similar to Concurrent::Map).
                          ::Hash
 
                        when Concurrent.on_jruby?

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

@@ -20,8 +20,8 @@ module Concurrent
                             require 'concurrent/collection/map/truffleruby_map_backend'
                             TruffleRubyMapBackend
                           else
-                            require 'concurrent/collection/map/atomic_reference_map_backend'
-                            AtomicReferenceMapBackend
+                            require 'concurrent/collection/map/synchronized_map_backend'
+                            SynchronizedMapBackend
                           end
                         else
                           warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation'
@@ -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/promises.rb

@@ -5,6 +5,7 @@ require 'concurrent/collection/lock_free_stack'
 require 'concurrent/configuration'
 require 'concurrent/errors'
 require 'concurrent/re_include'
+require 'concurrent/utility/monotonic_time'
 
 module Concurrent
 
@@ -22,7 +23,7 @@ module Concurrent
     #
     # @!macro promises.param.args
     #   @param [Object] args arguments which are passed to the task when it's executed.
-    #     (It might be prepended with other arguments, see the @yeild section).
+    #     (It might be prepended with other arguments, see the @yield section).
     #
     # @!macro promises.shortcut.on
     #   Shortcut of {#$0_on} with default `:io` executor supplied.
@@ -63,8 +64,8 @@ module Concurrent
         resolvable_event_on default_executor
       end
 
-      # Created resolvable event, user is responsible for resolving the event once by
-      # {Promises::ResolvableEvent#resolve}.
+      # Creates a resolvable event, user is responsible for resolving the event once
+      # by calling {Promises::ResolvableEvent#resolve}.
       #
       # @!macro promises.param.default_executor
       # @return [ResolvableEvent]
@@ -94,7 +95,7 @@ module Concurrent
         future_on(default_executor, *args, &task)
       end
 
-      # Constructs new Future which will be resolved after block is evaluated on default executor.
+      # Constructs a new Future which will be resolved after block is evaluated on default executor.
       # Evaluation begins immediately.
       #
       # @!macro promises.param.default_executor
@@ -106,7 +107,7 @@ module Concurrent
         ImmediateEventPromise.new(default_executor).future.then(*args, &task)
       end
 
-      # Creates resolved future with will be either fulfilled with the given value or rejection with
+      # Creates a resolved future with will be either fulfilled with the given value or rejected with
       # the given reason.
       #
       # @param [true, false] fulfilled
@@ -118,7 +119,7 @@ module Concurrent
         ImmediateFuturePromise.new(default_executor, fulfilled, value, reason).future
       end
 
-      # Creates resolved future with will be fulfilled with the given value.
+      # Creates a resolved future which will be fulfilled with the given value.
       #
       # @!macro promises.param.default_executor
       # @param [Object] value
@@ -127,7 +128,7 @@ module Concurrent
         resolved_future true, value, nil, default_executor
       end
 
-      # Creates resolved future with will be rejected with the given reason.
+      # Creates a resolved future which will be rejected with the given reason.
       #
       # @!macro promises.param.default_executor
       # @param [Object] reason
@@ -190,7 +191,7 @@ module Concurrent
         delay_on default_executor, *args, &task
       end
 
-      # Creates new event or future which is resolved only after it is touched,
+      # Creates a new event or future which is resolved only after it is touched,
       # see {Concurrent::AbstractEventFuture#touch}.
       #
       # @!macro promises.param.default_executor
@@ -214,7 +215,7 @@ module Concurrent
         schedule_on default_executor, intended_time, *args, &task
       end
 
-      # Creates new event or future which is resolved in intended_time.
+      # Creates a new event or future which is resolved in intended_time.
       #
       # @!macro promises.param.default_executor
       # @!macro promises.param.intended_time
@@ -240,8 +241,8 @@ module Concurrent
         zip_futures_on default_executor, *futures_and_or_events
       end
 
-      # Creates new future which is resolved after all futures_and_or_events are resolved.
-      # Its value is array of zipped future values. Its reason is array of reasons for rejection.
+      # Creates a new future which is resolved after all futures_and_or_events are resolved.
+      # Its value is an array of zipped future values. Its reason is an array of reasons for rejection.
       # If there is an error it rejects.
       # @!macro promises.event-conversion
       #   If event is supplied, which does not have value and can be only resolved, it's
@@ -262,7 +263,7 @@ module Concurrent
         zip_events_on default_executor, *futures_and_or_events
       end
 
-      # Creates new event which is resolved after all futures_and_or_events are resolved.
+      # Creates a new event which is resolved after all futures_and_or_events are resolved.
       # (Future is resolved when fulfilled or rejected.)
       #
       # @!macro promises.param.default_executor
@@ -280,8 +281,8 @@ module Concurrent
 
       alias_method :any, :any_resolved_future
 
-      # Creates new future which is resolved after first futures_and_or_events is resolved.
-      # Its result equals result of the first resolved future.
+      # Creates a new future which is resolved after the first futures_and_or_events is resolved.
+      # Its result equals the result of the first resolved future.
       # @!macro promises.any-touch
       #   If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
       #   futures un-executed if they are not required any more.
@@ -300,9 +301,9 @@ module Concurrent
         any_fulfilled_future_on default_executor, *futures_and_or_events
       end
 
-      # Creates new future which is resolved after first of futures_and_or_events is fulfilled.
-      # Its result equals result of the first resolved future or if all futures_and_or_events reject,
-      # it has reason of the last resolved future.
+      # Creates a new future which is resolved after the first futures_and_or_events is fulfilled.
+      # Its result equals the result of the first resolved future or if all futures_and_or_events reject,
+      # it has reason of the last rejected future.
       # @!macro promises.any-touch
       # @!macro promises.event-conversion
       #
@@ -319,7 +320,7 @@ module Concurrent
         any_event_on default_executor, *futures_and_or_events
       end
 
-      # Creates new event which becomes resolved after first of the futures_and_or_events resolves.
+      # Creates a new event which becomes resolved after the first futures_and_or_events resolves.
       # @!macro promises.any-touch
       #
       # @!macro promises.param.default_executor
@@ -611,7 +612,7 @@ module Concurrent
       #   @yieldparam [Object] value
       #   @yieldparam [Object] reason
       def chain_on(executor, *args, &task)
-        ChainPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        ChainPromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @return [String] Short string representation.
@@ -772,8 +773,17 @@ module Concurrent
         @Lock.synchronize do
           @Waiters.increment
           begin
-            unless resolved?
-              @Condition.wait @Lock, timeout
+            if timeout
+              start = Concurrent.monotonic_time
+              until resolved?
+                break if @Condition.wait(@Lock, timeout) == nil # nil means timeout
+                timeout -= (Concurrent.monotonic_time - start)
+                break if timeout <= 0
+              end
+            else
+              until resolved?
+                @Condition.wait(@Lock, timeout)
+              end
             end
           ensure
             # JRuby may raise ConcurrencyError
@@ -1034,7 +1044,7 @@ module Concurrent
       # @return [Future]
       # @yield [value, *args] to the task.
       def then_on(executor, *args, &task)
-        ThenPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        ThenPromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @!macro promises.shortcut.on
@@ -1052,7 +1062,7 @@ module Concurrent
       # @return [Future]
       # @yield [reason, *args] to the task.
       def rescue_on(executor, *args, &task)
-        RescuePromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        RescuePromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @!macro promises.method.zip

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/timer_task.rb

@@ -32,6 +32,17 @@ module Concurrent
   # be tested separately then passed to the `TimerTask` for scheduling and
   # running.
   #
+  # A `TimerTask` supports two different types of interval calculations.
+  # A fixed delay will always wait the same amount of time between the
+  # completion of one task and the start of the next. A fixed rate will
+  # attempt to maintain a constant rate of execution regardless of the
+  # duration of the task. For example, if a fixed rate task is scheduled
+  # to run every 60 seconds but the task itself takes 10 seconds to
+  # complete, the next task will be scheduled to run 50 seconds after
+  # the start of the previous task. If the task takes 70 seconds to
+  # complete, the next task will be start immediately after the previous
+  # task completes. Tasks will not be executed concurrently.
+  #
   # In some cases it may be necessary for a `TimerTask` to affect its own
   # execution cycle. To facilitate this, a reference to the TimerTask instance
   # is passed as an argument to the provided block every time the task is
@@ -74,6 +85,12 @@ module Concurrent
   #
   #   #=> 'Boom!'
   #
+  # @example Configuring `:interval_type` with either :fixed_delay or :fixed_rate, default is :fixed_delay
+  #   task = Concurrent::TimerTask.new(execution_interval: 5, interval_type: :fixed_rate) do
+  #          puts 'Boom!'
+  #        end
+  #   task.interval_type #=> :fixed_rate
+  #
   # @example Last `#value` and `Dereferenceable` mixin
   #   task = Concurrent::TimerTask.new(
   #     dup_on_deref: true,
@@ -87,7 +104,7 @@ module Concurrent
   #
   # @example Controlling execution from within the block
   #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
-  #     task.execution_interval.times{ print 'Boom! ' }
+  #     task.execution_interval.to_i.times{ print 'Boom! ' }
   #     print "\n"
   #     task.execution_interval += 1
   #     if task.execution_interval > 5
@@ -96,7 +113,7 @@ module Concurrent
   #     end
   #   end
   #
-  #   timer_task.execute # blocking call - this task will stop itself
+  #   timer_task.execute
   #   #=> Boom!
   #   #=> Boom! Boom!
   #   #=> Boom! Boom! Boom!
@@ -152,18 +169,30 @@ module Concurrent
     # Default `:execution_interval` in seconds.
     EXECUTION_INTERVAL = 60
 
-    # Default `:timeout_interval` in seconds.
-    TIMEOUT_INTERVAL = 30
+    # Maintain the interval between the end of one execution and the start of the next execution.
+    FIXED_DELAY = :fixed_delay
+
+    # Maintain the interval between the start of one execution and the start of the next.
+    # If execution time exceeds the interval, the next execution will start immediately
+    # after the previous execution finishes. Executions will not run concurrently.
+    FIXED_RATE = :fixed_rate
+
+    # Default `:interval_type`
+    DEFAULT_INTERVAL_TYPE = FIXED_DELAY
 
     # Create a new TimerTask with the given task and configuration.
     #
     # @!macro timer_task_initialize
     #   @param [Hash] opts the options defining task execution.
-    #   @option opts [Integer] :execution_interval number of seconds between
+    #   @option opts [Float] :execution_interval number of seconds between
     #     task executions (default: EXECUTION_INTERVAL)
     #   @option opts [Boolean] :run_now Whether to run the task immediately
     #     upon instantiation or to wait until the first #  execution_interval
     #     has passed (default: false)
+    #   @options opts [Symbol] :interval_type method to calculate the interval
+    #     between executions, can be either :fixed_rate or :fixed_delay.
+    #     (default: :fixed_delay)
+    #   @option opts [Executor] executor, default is `global_io_executor`
     #
     #   @!macro deref_options
     #
@@ -242,6 +271,10 @@ module Concurrent
       end
     end
 
+    # @!attribute [r] interval_type
+    # @return [Symbol] method to calculate the interval between executions
+    attr_reader :interval_type
+
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
@@ -264,11 +297,17 @@ module Concurrent
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      if opts[:interval_type] && ![FIXED_DELAY, FIXED_RATE].include?(opts[:interval_type])
+        raise ArgumentError.new('interval_type must be either :fixed_delay or :fixed_rate')
+      end
       if opts[:timeout] || opts[:timeout_interval]
         warn 'TimeTask timeouts are now ignored as these were not able to be implemented correctly'
       end
+
       @run_now = opts[:now] || opts[:run_now]
-      @executor = Concurrent::SafeTaskExecutor.new(task)
+      @interval_type = opts[:interval_type] || DEFAULT_INTERVAL_TYPE
+      @task = Concurrent::SafeTaskExecutor.new(task)
+      @executor = opts[:executor] || Concurrent.global_io_executor
       @running = Concurrent::AtomicBoolean.new(false)
       @value = nil
 
@@ -289,17 +328,18 @@ module Concurrent
 
     # @!visibility private
     def schedule_next_task(interval = execution_interval)
-      ScheduledTask.execute(interval, args: [Concurrent::Event.new], &method(:execute_task))
+      ScheduledTask.execute(interval, executor: @executor, args: [Concurrent::Event.new], &method(:execute_task))
       nil
     end
 
     # @!visibility private
     def execute_task(completion)
       return nil unless @running.true?
-      _success, value, reason = @executor.execute(self)
+      start_time = Concurrent.monotonic_time
+      _success, value, reason = @task.execute(self)
       if completion.try?
         self.value = value
-        schedule_next_task
+        schedule_next_task(calculate_next_interval(start_time))
         time = Time.now
         observers.notify_observers do
           [time, self.value, reason]
@@ -307,5 +347,15 @@ module Concurrent
       end
       nil
     end
+
+    # @!visibility private
+    def calculate_next_interval(start_time)
+      if @interval_type == FIXED_RATE
+        run_time = Concurrent.monotonic_time - start_time
+        [execution_interval - run_time, 0].max
+      else # FIXED_DELAY
+        execution_interval
+      end
+    end
   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.2'
+  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.2
+  version: 1.3.5
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-24 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.
@@ -76,7 +76,6 @@ files:
 - lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb
 - lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb
 - lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb
-- lib/concurrent-ruby/concurrent/collection/map/atomic_reference_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb
@@ -147,7 +146,6 @@ files:
 - lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb
-- lib/concurrent-ruby/concurrent/thread_safe/util/cheap_lockable.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/power_of_two_tuple.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb