evilution 0.25.0 → 0.27.0

data/lib/evilution/mutator/operator/block_removal.rb

@@ -4,7 +4,7 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::BlockRemoval < Evilution::Mutator::Base
   def visit_call_node(node)
-    if node.block
+    if node.block && !node.block.is_a?(Prism::BlockArgumentNode)
       block_node = node.block
       call_end = block_node.location.start_offset
       call_start = node.location.start_offset

data/lib/evilution/mutator/operator/method_body_replacement.rb

@@ -3,11 +3,15 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::MethodBodyReplacement < Evilution::Mutator::Base
-  REPLACEMENTS = %w[nil self super].freeze
+  ALWAYS_SAFE_REPLACEMENTS = %w[nil self].freeze
+  SUPER_REPLACEMENT = "super"
 
   def visit_def_node(node)
     if node.body
-      REPLACEMENTS.each do |replacement|
+      replacements = ALWAYS_SAFE_REPLACEMENTS.dup
+      replacements << SUPER_REPLACEMENT if body_calls_super?(node.body)
+
+      replacements.each do |replacement|
         add_mutation(
           offset: node.body.location.start_offset,
           length: node.body.location.length,
@@ -19,4 +23,16 @@ class Evilution::Mutator::Operator::MethodBodyReplacement < Evilution::Mutator::
 
     super
   end
+
+  private
+
+  # The bare-super replacement raises NoMethodError at runtime when the enclosing
+  # class has no parent implementation of the method. We emit it only when the
+  # original body already calls super, using that as a heuristic that a super
+  # target is intended in this context.
+  def body_calls_super?(node)
+    return true if node.is_a?(Prism::SuperNode) || node.is_a?(Prism::ForwardingSuperNode)
+
+    node.child_nodes.any? { |child| child && body_calls_super?(child) }
+  end
 end

data/lib/evilution/parallel/work_queue/channel/frame.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../channel"
+
+module Evilution::Parallel::WorkQueue::Channel::Frame
+  module_function
+
+  def encode(object)
+    payload = Marshal.dump(object)
+    [payload.bytesize].pack("N") + payload
+  end
+
+  def decode(header, payload)
+    return nil if header.nil? || header.bytesize < 4
+
+    length = header.unpack1("N")
+    return nil if payload.nil? || payload.bytesize < length
+
+    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
+  end
+end

data/lib/evilution/parallel/work_queue/channel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../work_queue"
+
+module Evilution::Parallel::WorkQueue::Channel
+  module_function
+
+  def write(io, object)
+    io.write(Frame.encode(object))
+    io.flush
+  end
+
+  def read(io)
+    header = io.read(4)
+    return nil if header.nil? || header.bytesize < 4
+
+    length = header.unpack1("N")
+    payload = io.read(length)
+    Frame.decode(header, payload)
+  end
+end
+
+require_relative "channel/frame"

data/lib/evilution/parallel/work_queue/collection_state.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../work_queue"
+
+# CollectionState is a top-level private constant on WorkQueue (not under a
+# sub-namespace) so Dispatcher accesses it via const_get.
+class Evilution::Parallel::WorkQueue
+  CollectionState = Struct.new(:results, :in_flight, :next_index, :first_error) do
+    def initialize(item_count)
+      super(Array.new(item_count), 0, 0, nil)
+    end
+  end
+  private_constant :CollectionState
+end

data/lib/evilution/parallel/work_queue/dispatcher.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "../work_queue"
+require_relative "collection_state"
+
+class Evilution::Parallel::WorkQueue::Dispatcher
+  attr_reader :first_error
+
+  def initialize(workers:, items:, prefetch:, item_timeout:, worker_max_items:, recycle_factory:)
+    @workers = workers
+    @items = items
+    @prefetch = prefetch
+    @item_timeout = item_timeout
+    @worker_max_items = worker_max_items
+    @recycle_factory = recycle_factory
+    @state = Evilution::Parallel::WorkQueue.send(:const_get, :CollectionState).new(items.length)
+    @retired = []
+  end
+
+  def run
+    seed
+    collect
+    @first_error = @state.first_error
+    [@state.results, @retired]
+  end
+
+  private
+
+  def seed
+    @prefetch.times do
+      @workers.each do |w|
+        break unless more_to_send?
+
+        send_item(w)
+      end
+    end
+  end
+
+  def collect
+    io_to_worker = @workers.to_h { |w| [w.res_io, w] }
+    result_ios = io_to_worker.keys
+
+    while @state.in_flight.positive?
+      readable, = IO.select(result_ios, nil, nil, @item_timeout)
+
+      if readable.nil?
+        terminate_stuck
+        @state.first_error ||= Evilution::Error.new("worker timed out after #{@item_timeout}s")
+        break
+      end
+
+      readable.each do |io|
+        alive = handle(io_to_worker[io], io_to_worker, result_ios)
+        result_ios.delete(io) unless alive
+      end
+    end
+  end
+
+  def handle(worker, io_to_worker, result_ios)
+    message = worker.read_result
+    return handle_dead(worker) if message.nil?
+
+    record(message, worker)
+    return false if recycle_and_dispatch(worker, io_to_worker, result_ios)
+    return true if draining_for_recycle?(worker)
+
+    send_item(worker) if more_to_send? && @state.first_error.nil?
+    true
+  end
+
+  def record(message, worker)
+    index, status, value = message
+    @state.first_error = value if status == :error && @state.first_error.nil?
+    @state.results[index] = value if status == :ok
+    @state.in_flight -= 1
+    worker.pending -= 1
+    worker.items_completed += 1
+  end
+
+  def handle_dead(worker)
+    @state.first_error ||= Evilution::Error.new("worker process exited unexpectedly")
+    @state.in_flight -= worker.pending
+    worker.pending = 0
+    false
+  end
+
+  def draining_for_recycle?(worker)
+    @worker_max_items && worker.items_completed >= @worker_max_items && worker.pending.positive?
+  end
+
+  def should_recycle?(worker)
+    return false unless @worker_max_items
+    return false if worker.items_completed < @worker_max_items
+    return false unless worker.pending.zero?
+    return false unless more_to_send?
+
+    @state.first_error.nil?
+  end
+
+  def recycle_and_dispatch(worker, io_to_worker, result_ios)
+    return false unless should_recycle?(worker)
+
+    new_worker = recycle(worker, io_to_worker, result_ios)
+    send_item(new_worker) if more_to_send?
+    true
+  end
+
+  def recycle(old_worker, io_to_worker, result_ios)
+    io_to_worker.delete(old_worker.res_io)
+    result_ios.delete(old_worker.res_io)
+    @retired << old_worker.retire
+
+    new_worker = @recycle_factory.call(old_worker)
+    @workers[@workers.index(old_worker)] = new_worker
+    io_to_worker[new_worker.res_io] = new_worker
+    result_ios << new_worker.res_io
+    new_worker
+  end
+
+  def send_item(worker)
+    worker.send_item(@state.next_index, @items[@state.next_index])
+    @state.next_index += 1
+    @state.in_flight += 1
+  end
+
+  def more_to_send?
+    @state.next_index < @items.length
+  end
+
+  def terminate_stuck
+    @workers.each(&:kill)
+  end
+end

data/lib/evilution/parallel/work_queue/validators/optional_positive_int.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../validators"
+
+class Evilution::Parallel::WorkQueue::Validators::OptionalPositiveInt
+  def self.call!(name, value)
+    return if value.nil? || (value.is_a?(Integer) && value.positive?)
+
+    raise ArgumentError, "#{name} must be nil or a positive integer, got #{value.inspect}"
+  end
+end

data/lib/evilution/parallel/work_queue/validators/optional_positive_number.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../validators"
+
+class Evilution::Parallel::WorkQueue::Validators::OptionalPositiveNumber
+  def self.call!(name, value)
+    return if value.nil? || (value.is_a?(Numeric) && value.positive?)
+
+    raise ArgumentError, "#{name} must be nil or a positive number, got #{value.inspect}"
+  end
+end

data/lib/evilution/parallel/work_queue/validators/positive_int.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../validators"
+
+class Evilution::Parallel::WorkQueue::Validators::PositiveInt
+  def self.call!(name, value)
+    return if value.is_a?(Integer) && value >= 1
+
+    raise ArgumentError, "#{name} must be a positive integer, got #{value.inspect}"
+  end
+end

data/lib/evilution/parallel/work_queue/validators.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../work_queue"
+
+module Evilution::Parallel::WorkQueue::Validators
+end

data/lib/evilution/parallel/work_queue/worker/loop.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../worker"
+require_relative "../channel"
+require_relative "../channel/frame"
+
+module Evilution::Parallel::WorkQueue::Worker::Loop
+  module_function
+
+  def run(cmd_io, res_io, hooks: nil, &block)
+    hooks.fire(:worker_process_start) if hooks
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    busy = 0.0
+
+    loop do
+      data = Evilution::Parallel::WorkQueue::Channel.read(cmd_io)
+      break if data.nil? || data == Evilution::Parallel::WorkQueue::SHUTDOWN
+
+      busy += run_one(res_io, data, &block)
+    end
+
+    wall = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+    Evilution::Parallel::WorkQueue::Channel.write(
+      res_io, [Evilution::Parallel::WorkQueue::STATS, busy, wall]
+    )
+  ensure
+    cmd_io.close unless cmd_io.closed?
+    res_io.close unless res_io.closed?
+    exit!
+  end
+
+  def run_one(res_io, data, &block)
+    index, item = data
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    begin
+      result = block.call(item)
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+      Evilution::Parallel::WorkQueue::Channel.write(res_io, [index, :ok, result])
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+      Evilution::Parallel::WorkQueue::Channel.write(res_io, [index, :error, e])
+    end
+    elapsed
+  end
+end

data/lib/evilution/parallel/work_queue/worker.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../work_queue"
+require_relative "../../child_output"
+require_relative "channel"
+require_relative "channel/frame"
+
+class Evilution::Parallel::WorkQueue::Worker
+  attr_reader :pid, :worker_index
+  attr_accessor :items_completed, :pending, :busy_time, :wall_time
+
+  def self.spawn(worker_index:, hooks:, &block)
+    cmd_read, cmd_write = IO.pipe
+    res_read, res_write = IO.pipe
+    [cmd_read, cmd_write, res_read, res_write].each(&:binmode)
+
+    pid = Process.fork do
+      cmd_write.close
+      res_read.close
+      ENV["TEST_ENV_NUMBER"] = test_env_number_for(worker_index)
+      Evilution::ChildOutput.redirect!
+      Loop.run(cmd_read, res_write, hooks: hooks, &block)
+    end
+
+    cmd_read.close
+    res_write.close
+    new(pid: pid, cmd_write: cmd_write, res_read: res_read, worker_index: worker_index)
+  end
+
+  # EV-kdns / GH #817: translate 0-based worker slot to parallel_tests'
+  # TEST_ENV_NUMBER convention ("" for slot 0, "2" for slot 1, ...). Rails
+  # apps interpolating TEST_ENV_NUMBER into database.yml get per-worker
+  # SQLite files, avoiding lock contention under jobs > 1.
+  def self.test_env_number_for(worker_index)
+    worker_index.zero? ? "" : (worker_index + 1).to_s
+  end
+
+  def initialize(pid:, cmd_write:, res_read:, worker_index:)
+    @pid = pid
+    @cmd_write = cmd_write
+    @res_read = res_read
+    @worker_index = worker_index
+    @items_completed = 0
+    @pending = 0
+    @busy_time = 0.0
+    @wall_time = 0.0
+  end
+
+  def res_io
+    @res_read
+  end
+
+  def send_item(index, item)
+    Evilution::Parallel::WorkQueue::Channel.write(@cmd_write, [index, item])
+    @pending += 1
+  end
+
+  def read_result
+    Evilution::Parallel::WorkQueue::Channel.read(@res_read)
+  end
+
+  def shutdown
+    Evilution::Parallel::WorkQueue::Channel.write(@cmd_write, Evilution::Parallel::WorkQueue::SHUTDOWN)
+  rescue Errno::EPIPE
+    nil
+  end
+
+  def kill
+    Process.kill("KILL", @pid)
+  rescue Errno::ESRCH
+    nil
+  end
+
+  def close_pipes
+    @cmd_write.close unless @cmd_write.closed?
+    @res_read.close unless @res_read.closed?
+  end
+
+  def reap
+    Process.wait(@pid)
+  rescue Errno::ECHILD
+    nil
+  end
+
+  def retire
+    shutdown
+    busy, wall = drain_stats
+    close_pipes
+    reap
+    @busy_time = busy
+    @wall_time = wall
+    to_stat
+  end
+
+  def to_stat
+    Evilution::Parallel::WorkQueue::WorkerStat.new(
+      @pid, @items_completed, @busy_time || 0.0, @wall_time || 0.0
+    )
+  end
+
+  private
+
+  def drain_stats
+    return [0.0, 0.0] unless @res_read.wait_readable(Evilution::Parallel::WorkQueue::TIMING_GRACE_PERIOD)
+
+    message = read_result
+    return [0.0, 0.0] if message.nil?
+
+    tag, busy, wall = message
+    return [0.0, 0.0] unless tag == Evilution::Parallel::WorkQueue::STATS
+
+    [busy, wall]
+  end
+end

data/lib/evilution/parallel/work_queue/worker_stat.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../work_queue"
+
+class Evilution::Parallel::WorkQueue
+  WorkerStat = Struct.new(:pid, :items_completed, :busy_time, :wall_time) do
+    def idle_time
+      wall_time - busy_time
+    end
+
+    def utilization
+      return 0.0 if wall_time.nil? || wall_time.zero?
+
+      busy_time / wall_time
+    end
+  end
+end