Concurrent

# File lib/concurrent/tvar.rb, line 150
def abort_transaction
  raise Transaction::AbortError.new
end

# File lib/concurrent/tvar.rb, line 93
def atomically
  raise ArgumentError.new('no block given') unless block_given?

  # Get the current transaction

  transaction = Transaction::current

  # Are we not already in a transaction (not nested)?

  if transaction.nil?
    # New transaction

    begin
      # Retry loop

      loop do

        # Create a new transaction

        transaction = Transaction.new
        Transaction::current = transaction

        # Run the block, aborting on exceptions

        begin
          result = yield
        rescue Transaction::AbortError => e
          transaction.abort
          result = Transaction::ABORTED
        rescue Transaction::LeaveError => e
          transaction.abort
          break result
        rescue => e
          transaction.abort
          raise e
        end
        # If we can commit, break out of the loop

        if result != Transaction::ABORTED
          if transaction.commit
            break result
          end
        end
      end
    ensure
      # Clear the current transaction

      Transaction::current = nil
    end
  else
    # Nested transaction - flatten it and just run the block

    yield
  end
end

# File lib/concurrent/dataflow.rb, line 55
def call_dataflow(method, executor, *inputs, &block)
  raise ArgumentError.new('an executor must be provided') if executor.nil?
  raise ArgumentError.new('no block given') unless block_given?
  raise ArgumentError.new('not all dependencies are IVars') unless inputs.all? { |input| input.is_a? IVar }

  result = Future.new(executor: executor) do
    values = inputs.map { |input| input.send(method) }
    block.call(*values)
  end

  if inputs.empty?
    result.execute
  else
    counter = DependencyCounter.new(inputs.size) { result.execute }

    inputs.each do |input|
      input.add_observer counter
    end
  end

  result
end

# File lib/concurrent/configuration.rb, line 18
def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
  logger           = Logger.new(output)
  logger.level     = level
  logger.formatter = lambda do |severity, datetime, progname, msg|
    formatted_message = case msg
                        when String
                          msg
                        when Exception
                          format "%s (%s)\n%s",
                            msg.message, msg.class, (msg.backtrace || []).join("\n")
                        else
                          msg.inspect
                        end
    format "[%s] %5s -- %s: %s\n",
      datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
      severity,
      progname,
      formatted_message
  end

  lambda do |loglevel, progname, message = nil, &block|
  logger.add loglevel, message, progname, &block
  end
end

# File lib/concurrent/dataflow.rb, line 33
def dataflow(*inputs, &block)
  dataflow_with(Concurrent.global_io_executor, *inputs, &block)
end

# File lib/concurrent/dataflow.rb, line 43
def dataflow!(*inputs, &block)
  dataflow_with!(Concurrent.global_io_executor, *inputs, &block)
end

# File lib/concurrent/dataflow.rb, line 38
def dataflow_with(executor, *inputs, &block)
  call_dataflow(:value, executor, *inputs, &block)
end

# File lib/concurrent/dataflow.rb, line 48
def dataflow_with!(executor, *inputs, &block)
  call_dataflow(:value!, executor, *inputs, &block)
end

# File lib/concurrent/configuration.rb, line 93
def self.disable_at_exit_handlers!
  AtExit.enabled = false
end

# File lib/concurrent/configuration.rb, line 128
def self.executor(executor_identifier)
  Options.executor(executor_identifier)
end

# File lib/concurrent/configuration.rb, line 100
def self.global_fast_executor
  GLOBAL_FAST_EXECUTOR.value
end

# File lib/concurrent/configuration.rb, line 111
def self.global_immediate_executor
  GLOBAL_IMMEDIATE_EXECUTOR
end

# File lib/concurrent/configuration.rb, line 107
def self.global_io_executor
  GLOBAL_IO_EXECUTOR.value
end

# File lib/concurrent/configuration.rb, line 55
def self.global_logger
  GLOBAL_LOGGER.value
end

# File lib/concurrent/configuration.rb, line 59
def self.global_logger=(value)
  GLOBAL_LOGGER.value = value
end

# File lib/concurrent/configuration.rb, line 118
def self.global_timer_set
  GLOBAL_TIMER_SET.value
end

# File lib/concurrent/tvar.rb, line 155
def leave_transaction
  raise Transaction::LeaveError.new
end

# File lib/concurrent/utility/monotonic_time.rb, line 53
def monotonic_time
  GLOBAL_MONOTONIC_CLOCK.get_time
end

# File lib/concurrent/utility/monotonic_time.rb, line 6
def initialize
  @last_time = Time.now.to_f
  super()
end

# File lib/concurrent/configuration.rb, line 132
def self.new_fast_executor(opts = {})
  FixedThreadPool.new(
    [2, Concurrent.processor_count].max,
    auto_terminate:  opts.fetch(:auto_terminate, true),
    idletime:        60, # 1 minute
    max_queue:       0, # unlimited
    fallback_policy: :abort # shouldn't matter -- 0 max queue
  )
end

# File lib/concurrent/configuration.rb, line 142
def self.new_io_executor(opts = {})
  ThreadPoolExecutor.new(
    min_threads:     [2, Concurrent.processor_count].max,
    max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
    # max_threads:     1000,
    auto_terminate:  opts.fetch(:auto_terminate, true),
    idletime:        60, # 1 minute
    max_queue:       0, # unlimited
    fallback_policy: :abort # shouldn't matter -- 0 max queue
  )
end

# File lib/concurrent/utility/processor_counter.rb, line 153
def self.physical_processor_count
  processor_counter.physical_processor_count
end

# File lib/concurrent/utility/processor_counter.rb, line 149
def self.processor_count
  processor_counter.processor_count
end

# File lib/concurrent/configuration.rb, line 44
def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
  Concurrent.global_logger = create_stdlib_logger level, output
end

# File lib/concurrent/utility/monotonic_time.rb, line 13
def get_time
  Process.clock_gettime(Process::CLOCK_MONOTONIC)
end