byp4a55 professor6T9

Linux premium22.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
LiteSpeed
68.65.122.106

File Name : thread_pool.rb

# frozen_string_literal: true
require "set"

require "rake/promise"

module Rake

class ThreadPool # :nodoc: all

# Creates a ThreadPool object.  The +thread_count+ parameter is the size
    # of the pool.
    def initialize(thread_count)
      @max_active_threads = [thread_count, 0].max
      @threads = Set.new
      @threads_mon = Monitor.new
      @queue = Queue.new
      @join_cond = @threads_mon.new_cond

@history_start_time = nil
      @history = []
      @history_mon = Monitor.new
      @total_threads_in_play = 0
    end

# Creates a future executed by the +ThreadPool+.
    #
    # The args are passed to the block when executing (similarly to
    # Thread#new) The return value is an object representing
    # a future which has been created and added to the queue in the
    # pool. Sending #value to the object will sleep the
    # current thread until the future is finished and will return the
    # result (or raise an exception thrown from the future)
    def future(*args, &block)
      promise = Promise.new(args, &block)
      promise.recorder = lambda { |*stats| stat(*stats) }

@queue.enq promise
      stat :queued, item_id: promise.object_id
      start_thread
      promise
    end

# Waits until the queue of futures is empty and all threads have exited.
    def join
      @threads_mon.synchronize do
        begin
          stat :joining
          @join_cond.wait unless @threads.empty?
          stat :joined
        rescue Exception => e
          stat :joined
          $stderr.puts e
          $stderr.print "Queue contains #{@queue.size} items. " +
            "Thread pool contains #{@threads.count} threads\n"
          $stderr.print "Current Thread #{Thread.current} status = " +
            "#{Thread.current.status}\n"
          $stderr.puts e.backtrace.join("\n")
          @threads.each do |t|
            $stderr.print "Thread #{t} status = #{t.status}\n"
            $stderr.puts t.backtrace.join("\n")
          end
          raise e
        end
      end
    end

# Enable the gathering of history events.
    def gather_history          #:nodoc:
      @history_start_time = Time.now if @history_start_time.nil?
    end

# Return a array of history events for the thread pool.
    #
    # History gathering must be enabled to be able to see the events
    # (see #gather_history). Best to call this when the job is
    # complete (i.e. after ThreadPool#join is called).
    def history                 # :nodoc:
      @history_mon.synchronize { @history.dup }.
        sort_by { |i| i[:time] }.
        each { |i| i[:time] -= @history_start_time }
    end

# Return a hash of always collected statistics for the thread pool.
    def statistics              #  :nodoc:
      {
        total_threads_in_play: @total_threads_in_play,
        max_active_threads: @max_active_threads,
      }
    end

private

# processes one item on the queue. Returns true if there was an
    # item to process, false if there was no item
    def process_queue_item      #:nodoc:
      return false if @queue.empty?

# Even though we just asked if the queue was empty, it
      # still could have had an item which by this statement
      # is now gone. For this reason we pass true to Queue#deq
      # because we will sleep indefinitely if it is empty.
      promise = @queue.deq(true)
      stat :dequeued, item_id: promise.object_id
      promise.work
      return true

rescue ThreadError # this means the queue is empty
      false
    end

def safe_thread_count
      @threads_mon.synchronize do
        @threads.count
      end
    end

def start_thread # :nodoc:
      @threads_mon.synchronize do
        next unless @threads.count < @max_active_threads

t = Thread.new do
          begin
            while safe_thread_count <= @max_active_threads
              break unless process_queue_item
            end
          ensure
            @threads_mon.synchronize do
              @threads.delete Thread.current
              stat :ended, thread_count: @threads.count
              @join_cond.broadcast if @threads.empty?
            end
          end
        end

@threads << t
        stat(
          :spawned,
          new_thread: t.object_id,
          thread_count: @threads.count)
        @total_threads_in_play = @threads.count if
          @threads.count > @total_threads_in_play
      end
    end

def stat(event, data=nil) # :nodoc:
      return if @history_start_time.nil?
      info = {
        event: event,
        data: data,
        time: Time.now,
        thread: Thread.current.object_id,
      }
      @history_mon.synchronize { @history << info }
    end

# for testing only

def __queue__ # :nodoc:
      @queue
    end
  end

end

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2024-03-03 10:50:44
..	dir	-	root/root	0755	2024-03-03 10:50:44
ext	dir	-	root/root	0755	2024-03-03 10:50:44
loaders	dir	-	root/root	0755	2024-03-03 10:50:44
application.rb	text/x-ruby	24.53 KB	root/linksafe	0644	2021-04-05 11:46:37
backtrace.rb	text/x-ruby	896 B	root/linksafe	0644	2021-04-05 11:46:37
clean.rb	text/x-ruby	2.03 KB	root/linksafe	0644	2021-04-05 11:46:37
cloneable.rb	text/x-ruby	448 B	root/linksafe	0644	2021-04-05 11:46:37
cpu_counter.rb	text/x-ruby	2.33 KB	root/linksafe	0644	2021-04-05 11:46:37
default_loader.rb	text/x-ruby	265 B	root/linksafe	0644	2021-04-05 11:46:37
dsl_definition.rb	text/x-ruby	5.48 KB	root/linksafe	0644	2021-04-05 11:46:37
early_time.rb	text/x-ruby	370 B	root/linksafe	0644	2021-04-05 11:46:37
file_creation_task.rb	text/x-ruby	699 B	root/linksafe	0644	2021-04-05 11:46:37
file_list.rb	text/x-ruby	12.45 KB	root/linksafe	0644	2021-04-05 11:46:37
file_task.rb	text/x-ruby	1.5 KB	root/linksafe	0644	2021-04-05 11:46:37
file_utils.rb	text/x-ruby	3.8 KB	root/linksafe	0644	2021-04-05 11:46:37
file_utils_ext.rb	text/x-ruby	4.08 KB	root/linksafe	0644	2021-04-05 11:46:37
invocation_chain.rb	text/x-ruby	1.19 KB	root/linksafe	0644	2021-04-05 11:46:37
invocation_exception_mixin.rb	text/x-ruby	461 B	root/linksafe	0644	2021-04-05 11:46:37
late_time.rb	text/x-ruby	295 B	root/linksafe	0644	2021-04-05 11:46:37
linked_list.rb	text/x-ruby	2.77 KB	root/linksafe	0644	2021-04-05 11:46:37
multi_task.rb	text/x-ruby	345 B	root/linksafe	0644	2021-04-05 11:46:37
name_space.rb	text/x-ruby	702 B	root/linksafe	0644	2021-04-05 11:46:37
packagetask.rb	text/x-ruby	5.52 KB	root/linksafe	0644	2021-04-05 11:46:37
phony.rb	text/x-ruby	381 B	root/linksafe	0644	2021-04-05 11:46:37
private_reader.rb	text/x-ruby	394 B	root/linksafe	0644	2021-04-05 11:46:37
promise.rb	text/x-ruby	2.28 KB	root/linksafe	0644	2021-04-05 11:46:37
pseudo_status.rb	text/x-ruby	405 B	root/linksafe	0644	2021-04-05 11:46:37
rake_module.rb	text/x-ruby	1.49 KB	root/linksafe	0644	2021-04-05 11:46:37
rake_test_loader.rb	text/plain	505 B	root/linksafe	0644	2021-04-05 11:46:37
rule_recursion_overflow_error.rb	text/x-ruby	382 B	root/linksafe	0644	2021-04-05 11:46:37
scope.rb	text/x-ruby	898 B	root/linksafe	0644	2021-04-05 11:46:37
task.rb	text/x-ruby	12.08 KB	root/linksafe	0644	2021-04-05 11:46:37
task_argument_error.rb	text/x-ruby	149 B	root/linksafe	0644	2021-04-05 11:46:37
task_arguments.rb	text/x-ruby	2.41 KB	root/linksafe	0644	2021-04-05 11:46:37
task_manager.rb	text/x-ruby	9.66 KB	root/linksafe	0644	2021-04-05 11:46:37
tasklib.rb	text/x-ruby	165 B	root/linksafe	0644	2021-04-05 11:46:37
testtask.rb	text/x-ruby	6 KB	root/linksafe	0644	2021-04-05 11:46:37
thread_history_display.rb	text/x-ruby	1.13 KB	root/linksafe	0644	2021-04-05 11:46:37
thread_pool.rb	text/x-ruby	4.67 KB	root/linksafe	0644	2021-04-05 11:46:37
trace_output.rb	text/x-ruby	575 B	root/linksafe	0644	2021-04-05 11:46:37
version.rb	text/x-ruby	208 B	root/linksafe	0644	2021-04-05 11:46:37
win32.rb	text/x-ruby	1.52 KB	root/linksafe	0644	2021-04-05 11:46:37

Team Anon Force

https://t.me/Professor6T9x