Method compute_physical_processor_count has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def compute_physical_processor_count
        ppc = case RbConfig::CONFIG["target_os"]
              when /darwin\d\d/
                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
              when /linux/

Method atomically has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def atomically
    raise ArgumentError.new('no block given') unless block_given?

    # Get the current transaction

Method attr_volatile has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def attr_volatile(*attr_names)
          return if attr_names.empty?
          include(Module.new do
            atomic_ref_setup = attr_names.map {|attr_name| "@__#{attr_name} = Concurrent::AtomicReference.new"}
            initialize_copy_setup = attr_names.zip(atomic_ref_setup).map do |attr_name, ref_setup|

Method ns_pop_op has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def ns_pop_op(matcher, probe, include_channel)
        message = ns_shift_message matcher

        # got message from buffer
        if message != NOTHING

Method acquire_read_lock has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def acquire_read_lock
      if (held = @HeldCount.value) > 0
        # If we already have a lock, there's no need to wait
        if held & READ_LOCK_MASK == 0
          # But we do need to update the counter, if we were holding a write

Method ns_initialize has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def ns_initialize(opts)
        min_length       = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
        max_length       = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
        idletime         = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
        @max_queue       = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i

Method acquire has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def acquire(timeout = nil, &block)
      event = acquire_or_event
      if event
        within_timeout = event.wait(timeout)
        # release immediately when acquired later after the timeout since it is unused

Method splitTreeBin has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    private static void splitTreeBin(Node[] nextTab, int i, TreeBin t) {
        int bit = nextTab.length >>> 1;
        TreeBin lt = new TreeBin();
        TreeBin ht = new TreeBin();
        int lc = 0, hc = 0;

• Read up
  Read up

Method splitTreeBin has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    private static void splitTreeBin(AtomicReferenceArray<Node> nextTab, int i, TreeBin t) {
        int bit = nextTab.length() >>> 1;
        TreeBin lt = new TreeBin();
        TreeBin ht = new TreeBin();
        int lc = 0, hc = 0;

• Read up
  Read up

Method para_setup has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def para_setup(num_threads, count, &block)
  if num_threads % 2 > 0
    raise ArgumentError, 'num_threads must be a multiple of two'
  end
  raise ArgumentError, 'need block' unless block_given?

• Read up
  Read up

Method post has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def post(*args, &task)
        raise ArgumentError.new('no block given') unless block_given?
        return fallback_action(*args, &task).call unless running?
        @executor.submit Job.new(args, task)
        true

• Read up
  Read up

Method release has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def release
      while true
        current_capacity = capacity
        if compare_and_set_capacity current_capacity, current_capacity + 1
          if current_capacity < 0

• Read up
  Read up

Method compute_cpu_quota has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      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")

• Read up
  Read up

Method create_simple_logger has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

  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|

• Read up
  Read up

Method pop_matching has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def pop_matching(matcher, timeout = nil, timeout_value = nil)
        # TODO (pitr-ch 27-Jan-2019): should it try to match pending pushes if it fails to match in the buffer? Maybe only if the size is zero. It could be surprising if it's used as a throttle it might be expected that it will not pop if buffer is full of messages which di not match, it might it expected it will block until the message is added to the buffer
        # that it returns even if the buffer is full. User might expect that it has to be in the buffer first.
        probe = @Mutex.synchronize do
          message = ns_shift_message matcher

• Read up
  Read up

Method execute_next_job has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def execute_next_job
      job       = synchronize { @queue.first }
      old_value = @current.value

      @caller.value = job.caller # for nested actions

• Read up
  Read up

Method process_tasks has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def process_tasks
      loop do
        task = synchronize { @condition.reset; @queue.peek }
        break unless task

• Read up
  Read up

Method atomic_resolution has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

      def self.atomic_resolution(resolvable_map)
        # atomic_resolution event => [], future => [true, :v, nil]
        sorted = resolvable_map.to_a.sort_by { |resolvable, _| locking_order_by resolvable }

        reserved = 0

• Read up
  Read up

Method toArray has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        @SuppressWarnings("unchecked") public final <T> T[] toArray(T[] a) {
            long sz = map.mappingCount();
            if (sz > (long)(MAX_ARRAY_SIZE))
                throw new OutOfMemoryError(oomeMsg);
            int m = (int)sz;

Method toArray has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        @SuppressWarnings("unchecked") public final <T> T[] toArray(T[] a) {
            long sz = map.mappingCount();
            if (sz > (long)(MAX_ARRAY_SIZE))
                throw new OutOfMemoryError(oomeMsg);
            int m = (int)sz;