evilution 0.17.0 → 0.19.0

data/lib/evilution/parallel/pool.rb

@@ -1,63 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "../parallel"
+require_relative "work_queue"
 
 class Evilution::Parallel::Pool
-  def initialize(size:, hooks: nil)
-    raise ArgumentError, "pool size must be a positive integer, got #{size.inspect}" unless size.is_a?(Integer) && size >= 1
-
-    @size = size
-    @hooks = hooks
+  def initialize(size:, hooks: nil, item_timeout: nil)
+    @queue = Evilution::Parallel::WorkQueue.new(size: size, hooks: hooks, item_timeout: item_timeout)
   end
 
-  def map(items, &block)
-    results = []
-
-    items.each_slice(@size) do |batch|
-      results.concat(run_batch(batch, &block))
-    end
-
-    results
+  def map(items, &)
+    @queue.map(items, &)
   end
 
-  private
-
-  def run_batch(items, &block)
-    entries = items.map do |item|
-      read_io, write_io = IO.pipe
-      pid = fork_worker(item, read_io, write_io, &block)
-      write_io.close
-      { pid: pid, read_io: read_io }
-    end
-
-    collect_results(entries)
-  end
-
-  def fork_worker(item, read_io, write_io, &block)
-    Process.fork do
-      read_io.close
-      @hooks.fire(:worker_process_start) if @hooks
-      result = block.call(item)
-      Marshal.dump(result, write_io)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      Marshal.dump(e, write_io)
-    ensure
-      write_io.close
-      exit!
-    end
-  end
-
-  def collect_results(entries)
-    entries.map do |entry|
-      data = entry[:read_io].read
-      entry[:read_io].close
-      Process.wait(entry[:pid])
-      raise Evilution::Error, "worker process failed with no result" if data.empty?
-
-      result = Marshal.load(data) # rubocop:disable Security/MarshalLoad
-      raise result if result.is_a?(Exception)
-
-      result
-    end
+  def worker_stats
+    @queue.worker_stats
   end
 end

data/lib/evilution/parallel/work_queue.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require_relative "../parallel"
+
+class Evilution::Parallel::WorkQueue
+  SHUTDOWN = :__shutdown__
+
+  STATS = :__stats__
+
+  TIMING_GRACE_PERIOD = 5
+
+  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
+
+  def initialize(size:, hooks: nil, prefetch: 1, item_timeout: nil)
+    raise ArgumentError, "pool size must be a positive integer, got #{size.inspect}" unless size.is_a?(Integer) && size >= 1
+    raise ArgumentError, "prefetch must be a positive integer, got #{prefetch.inspect}" unless prefetch.is_a?(Integer) && prefetch >= 1
+    unless item_timeout.nil? || (item_timeout.is_a?(Numeric) && item_timeout.positive?)
+      raise ArgumentError, "item_timeout must be nil or a positive number, got #{item_timeout.inspect}"
+    end
+
+    @size = size
+    @hooks = hooks
+    @prefetch = prefetch
+    @item_timeout = item_timeout
+    @worker_stats = []
+  end
+
+  def map(items, &)
+    return [] if items.empty?
+
+    worker_count = [@size, items.length].min
+    workers = spawn_workers(worker_count, &)
+
+    begin
+      distribute_and_collect(items, workers)
+    ensure
+      shutdown_workers(workers)
+      @worker_stats = build_worker_stats(workers)
+    end
+  end
+
+  def worker_stats
+    @worker_stats.map { |stat| stat.dup.freeze }
+  end
+
+  private
+
+  def spawn_workers(count, &)
+    count.times.map do
+      cmd_read, cmd_write = IO.pipe
+      res_read, res_write = IO.pipe
+
+      pid = Process.fork do
+        cmd_write.close
+        res_read.close
+        worker_loop(cmd_read, res_write, &)
+      end
+
+      cmd_read.close
+      res_write.close
+
+      { pid: pid, cmd_write: cmd_write, res_read: res_read, items_completed: 0, pending: 0 }
+    end
+  end
+
+  def worker_loop(cmd_read, res_write, &block)
+    @hooks.fire(:worker_process_start) if @hooks
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    busy_time = 0.0
+
+    loop do
+      data = read_command(cmd_read)
+      break if data == SHUTDOWN
+
+      index, item = data
+      begin
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = block.call(item)
+        busy_time += Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+        write_message(res_write, [index, :ok, result])
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        busy_time += Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
+        write_message(res_write, [index, :error, e])
+      end
+    end
+
+    wall_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    write_message(res_write, [STATS, busy_time, wall_time])
+  ensure
+    cmd_read.close
+    res_write.close
+    exit!
+  end
+
+  def distribute_and_collect(items, workers)
+    state = CollectionState.new(items.length)
+    seed_workers(items, workers, state)
+    collect_results(items, workers, state)
+    raise state.first_error if state.first_error
+
+    state.results
+  end
+
+  def seed_workers(items, workers, state)
+    @prefetch.times do
+      workers.each do |worker|
+        break unless state.next_index < items.length
+
+        send_item(worker, items, state)
+      end
+    end
+  end
+
+  def collect_results(items, workers, state)
+    io_to_worker = workers.to_h { |w| [w[:res_read], 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_workers(workers)
+        state.first_error = Evilution::Error.new("worker timed out after #{@item_timeout}s") if state.first_error.nil?
+        break
+      end
+
+      readable.each do |io|
+        alive = handle_result(io, io_to_worker[io], items, state)
+        result_ios.delete(io) unless alive
+      end
+    end
+  end
+
+  def handle_result(io, worker, items, state)
+    message = read_result(io)
+
+    if message.nil?
+      state.first_error = Evilution::Error.new("worker process exited unexpectedly") if state.first_error.nil?
+      state.in_flight -= worker[:pending]
+      worker[:pending] = 0
+      return false
+    end
+
+    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
+
+    send_item(worker, items, state) if state.next_index < items.length && state.first_error.nil?
+    true
+  end
+
+  def send_item(worker, items, state)
+    write_message(worker[:cmd_write], [state.next_index, items[state.next_index]])
+    state.next_index += 1
+    state.in_flight += 1
+    worker[:pending] += 1
+  end
+
+  def build_worker_stats(workers)
+    workers.map do |worker|
+      WorkerStat.new(worker[:pid], worker[:items_completed], worker[:busy_time] || 0.0, worker[:wall_time] || 0.0)
+    end
+  end
+
+  def terminate_stuck_workers(workers)
+    workers.each do |worker|
+      Process.kill("KILL", worker[:pid])
+    rescue Errno::ESRCH
+      nil # Already exited
+    end
+  end
+
+  def shutdown_workers(workers)
+    workers.each do |worker|
+      write_message(worker[:cmd_write], SHUTDOWN)
+    rescue Errno::EPIPE
+      # Worker already exited
+    end
+
+    collect_worker_timing(workers)
+
+    workers.each do |worker|
+      worker[:cmd_write].close unless worker[:cmd_write].closed?
+      worker[:res_read].close unless worker[:res_read].closed?
+      Process.wait(worker[:pid])
+    rescue Errno::ECHILD
+      # Already reaped
+    end
+  end
+
+  def collect_worker_timing(workers)
+    io_to_worker = workers.reject { |w| w[:res_read].closed? }.to_h { |w| [w[:res_read], w] }
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + TIMING_GRACE_PERIOD
+
+    until io_to_worker.empty?
+      remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      break if remaining <= 0
+
+      readable, = IO.select(io_to_worker.keys, nil, nil, remaining)
+      break unless readable
+
+      readable.each { |io| apply_worker_timing(io_to_worker.delete(io), io) }
+    end
+  end
+
+  def apply_worker_timing(worker, io)
+    message = read_result(io)
+    return if message.nil?
+
+    tag, busy_time, wall_time = message
+    return unless tag == STATS
+
+    worker[:busy_time] = busy_time
+    worker[:wall_time] = wall_time
+  end
+
+  def write_message(io, data)
+    payload = Marshal.dump(data)
+    io.write([payload.bytesize].pack("N"))
+    io.write(payload)
+    io.flush
+  end
+
+  def read_command(io)
+    header = io.read(4)
+    return SHUTDOWN if header.nil? || header.bytesize < 4
+
+    length = header.unpack1("N")
+    payload = io.read(length)
+    return SHUTDOWN if payload.nil? || payload.bytesize < length
+
+    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
+  end
+
+  def read_result(io)
+    header = io.read(4)
+    return nil if header.nil? || header.bytesize < 4
+
+    length = header.unpack1("N")
+    payload = io.read(length)
+    return nil if payload.nil? || payload.bytesize < length
+
+    Marshal.load(payload) # rubocop:disable Security/MarshalLoad
+  end
+
+  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/reporter/cli.rb

@@ -13,11 +13,13 @@ class Evilution::Reporter::CLI
     lines << mutations_line(summary)
     lines << score_line(summary)
     lines << duration_line(summary)
+    lines << efficiency_line(summary) if summary.duration.positive?
     peak = summary.peak_memory_mb
     lines << peak_memory_line(peak) if peak
     append_survived(lines, summary)
     append_neutral(lines, summary)
     append_equivalent(lines, summary)
+    append_disabled(lines, summary)
     lines << ""
     lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
     lines << result_line(summary)
@@ -51,6 +53,14 @@ class Evilution::Reporter::CLI
     summary.equivalent_results.each { |result| lines << format_neutral(result) }
   end
 
+  def append_disabled(lines, summary)
+    return unless summary.disabled_mutations.any?
+
+    lines << ""
+    lines << "Disabled mutations (skipped by # evilution:disable):"
+    summary.disabled_mutations.each { |mutation| lines << format_disabled(mutation) }
+  end
+
   def header
     "Evilution v#{Evilution::VERSION} — Mutation Testing Results"
   end
@@ -74,11 +84,17 @@ class Evilution::Reporter::CLI
     "Duration: #{format("%.2f", summary.duration)}s"
   end
 
+  def efficiency_line(summary)
+    pct = format("%.2f%%", summary.efficiency * 100)
+    rate = format("%.2f", summary.mutations_per_second)
+    "Efficiency: #{pct} killtime, #{rate} mutations/s"
+  end
+
   def format_survived(result)
     mutation = result.mutation
     location = "#{mutation.file_path}:#{mutation.line}"
     diff_lines = mutation.diff.split("\n").map { |l| "    #{l}" }.join("\n")
-    "  #{mutation.operator_name}: #{location}\n#{diff_lines}"
+    "  #{mutation.operator_name}: #{location} (#{mutation.subject.name})\n#{diff_lines}"
   end
 
   def format_neutral(result)
@@ -86,6 +102,10 @@ class Evilution::Reporter::CLI
     "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
   end
 
+  def format_disabled(mutation)
+    "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
+  end
+
   def result_line(summary)
     min_score = 0.8
     pass_fail = summary.success?(min_score: min_score) ? "PASS" : "FAIL"

data/lib/evilution/reporter/html.rb

@@ -6,8 +6,10 @@ require_relative "suggestion"
 require_relative "../reporter"
 
 class Evilution::Reporter::HTML
-  def initialize
+  def initialize(baseline: nil)
     @suggestion = Evilution::Reporter::Suggestion.new
+    @baseline = baseline
+    @baseline_keys = build_baseline_keys(baseline)
   end
 
   def call(summary)
@@ -40,6 +42,7 @@ class Evilution::Reporter::HTML
       <body>
         #{build_header(summary)}
         #{build_summary_cards(summary)}
+        #{build_baseline_comparison(summary)}
         #{build_truncation_notice(summary)}
         #{build_file_sections(files)}
         #{build_footer}
@@ -79,11 +82,21 @@ class Evilution::Reporter::HTML
         <div class="card"><span class="card-value">#{summary.equivalent}</span><span class="card-label">Equivalent</span></div>
         #{build_skipped_card(summary)}
         <div class="card"><span class="card-value">#{format("%.2f", summary.duration)}s</span><span class="card-label">Duration</span></div>
+        #{build_efficiency_cards(summary)}
         #{peak_html}
       </section>
     HTML
   end
 
+  def build_efficiency_cards(summary)
+    return "" unless summary.duration.positive?
+
+    pct = format("%.1f%%", summary.efficiency * 100)
+    rate = format("%.2f", summary.mutations_per_second)
+    %(<div class="card"><span class="card-value">#{pct}</span><span class="card-label">Efficiency</span></div>) +
+      %(<div class="card"><span class="card-value">#{rate}/s</span><span class="card-label">Rate</span></div>)
+  end
+
   def build_skipped_card(summary)
     return "" unless summary.skipped.positive?
 
@@ -156,10 +169,13 @@ class Evilution::Reporter::HTML
     mutation = result.mutation
     suggestion_text = @suggestion.suggestion_for(mutation)
     diff_html = format_diff(mutation.diff)
+    regression = regression?(mutation)
+    entry_class = regression ? "survived-entry regression" : "survived-entry"
+    regression_badge = regression ? ' <span class="regression-badge">NEW REGRESSION</span>' : ""
     <<~HTML
-      <div class="survived-entry">
+      <div class="#{entry_class}">
         <div class="survived-header">
-          <span class="operator">#{h(mutation.operator_name)}</span>
+          <span class="operator">#{h(mutation.operator_name)}#{regression_badge}</span>
           <span class="location">#{h(mutation.file_path)}:#{mutation.line}</span>
         </div>
         <pre class="diff">#{diff_html}</pre>
@@ -196,6 +212,48 @@ class Evilution::Reporter::HTML
     end
   end
 
+  def build_baseline_comparison(summary)
+    return "" unless @baseline
+
+    base_summary = @baseline["summary"] || {}
+    base_score = base_summary["score"] || 0.0
+    head_score = summary.score
+    delta = head_score - base_score
+    delta_str = format("%+.2f%%", delta * 100)
+    delta_class = if delta.positive?
+                    "delta-positive"
+                  elsif delta.negative?
+                    "delta-negative"
+                  else
+                    "delta-neutral"
+                  end
+
+    <<~HTML
+      <section class="baseline-comparison">
+        <h2>Baseline Comparison</h2>
+        <div class="comparison-scores">
+          <span>Baseline: #{format("%.2f%%", base_score * 100)}</span>
+          <span>Current: #{format("%.2f%%", head_score * 100)}</span>
+          <span class="#{delta_class}">Delta: #{delta_str}</span>
+        </div>
+      </section>
+    HTML
+  end
+
+  def regression?(mutation)
+    return false if @baseline_keys.nil?
+
+    key = [mutation.operator_name, mutation.file_path, mutation.line, mutation.subject.name]
+    !@baseline_keys.include?(key)
+  end
+
+  def build_baseline_keys(baseline)
+    return nil unless baseline
+
+    survived = baseline["survived"] || []
+    survived.to_set { |m| [m["operator"], m["file"], m["line"], m["subject"]] }
+  end
+
   def h(text)
     CGI.escapeHTML(text.to_s)
   end
@@ -250,6 +308,14 @@ class Evilution::Reporter::HTML
         .diff-added { color: #3fb950; display: block; }
         .suggestion { color: #d29922; font-size: 0.8rem; margin-top: 0.5rem; font-style: italic; }
         .empty { color: #8b949e; text-align: center; padding: 2rem; }
+        .baseline-comparison { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 1rem; margin-bottom: 2rem; }
+        .baseline-comparison h2 { font-size: 1rem; color: #f0f6fc; margin-bottom: 0.75rem; }
+        .comparison-scores { display: flex; gap: 2rem; font-size: 0.9rem; }
+        .delta-positive { color: #3fb950; font-weight: bold; }
+        .delta-negative { color: #f85149; font-weight: bold; }
+        .delta-neutral { color: #8b949e; font-weight: bold; }
+        .survived-entry.regression { border-color: #f85149; background: #2a1010; }
+        .regression-badge { background: #da3633; color: #fff; font-size: 0.65rem; padding: 0.1rem 0.4rem; border-radius: 4px; margin-left: 0.5rem; text-transform: uppercase; font-weight: bold; }
         footer { text-align: center; color: #484f58; font-size: 0.75rem; margin-top: 2rem; padding-top: 1rem; border-top: 1px solid #21262d; }
       </style>
     HTML

data/lib/evilution/reporter/json.rb

@@ -19,7 +19,7 @@ class Evilution::Reporter::JSON
 
   # rubocop:disable Metrics/PerceivedComplexity
   def build_report(summary)
-    {
+    report = {
       version: Evilution::VERSION,
       timestamp: Time.now.iso8601,
       summary: build_summary(summary),
@@ -30,9 +30,17 @@ class Evilution::Reporter::JSON
       errors: summary.results.select(&:error?).map { |r| build_mutation_detail(r) },
       equivalent: summary.equivalent_results.map { |r| build_mutation_detail(r) }
     }
+    append_disabled_to_report(report, summary)
+    report
   end
   # rubocop:enable Metrics/PerceivedComplexity
 
+  def append_disabled_to_report(report, summary)
+    return unless summary.disabled_mutations.any?
+
+    report[:disabled] = summary.disabled_mutations.map { |m| build_disabled_detail(m) }
+  end
+
   def build_summary(summary)
     data = {
       total: summary.total,
@@ -43,7 +51,10 @@ class Evilution::Reporter::JSON
       neutral: summary.neutral,
       equivalent: summary.equivalent,
       score: summary.score.round(4),
-      duration: summary.duration.round(4)
+      duration: summary.duration.round(4),
+      killtime: summary.killtime.round(4),
+      efficiency: summary.efficiency.round(4),
+      mutations_per_second: summary.mutations_per_second.round(2)
     }
     data[:truncated] = true if summary.truncated?
     data[:skipped] = summary.skipped if summary.skipped.positive?
@@ -64,8 +75,18 @@ class Evilution::Reporter::JSON
     }
     detail[:suggestion] = @suggestion.suggestion_for(mutation) if result.status == :survived
     detail[:test_command] = result.test_command if result.test_command
+    detail[:parent_rss_kb] = result.parent_rss_kb if result.parent_rss_kb
     detail[:child_rss_kb] = result.child_rss_kb if result.child_rss_kb
     detail[:memory_delta_kb] = result.memory_delta_kb if result.memory_delta_kb
     detail
   end
+
+  def build_disabled_detail(mutation)
+    {
+      operator: mutation.operator_name,
+      file: mutation.file_path,
+      line: mutation.line,
+      diff: mutation.diff
+    }
+  end
 end

data/lib/evilution/reporter/suggestion.rb

@@ -48,7 +48,9 @@ class Evilution::Reporter::Suggestion
     "index_assignment_removal" => "Add a test that verifies the []= assignment side effect is observable (the collection is modified)",
     "pattern_matching_guard" => "Add a test with input that matches the pattern but fails the guard to verify filtering",
     "pattern_matching_alternative" => "Add a test with input that matches only one specific alternative to verify each branch is reachable",
-    "pattern_matching_array" => "Add a test that verifies each element position in the array pattern matches the expected type or value"
+    "pattern_matching_array" => "Add a test that verifies each element position in the array pattern matches the expected type or value",
+    "collection_return" => "Add a test that verifies the method returns a non-empty collection, not just any array or hash",
+    "scalar_return" => "Add a test that verifies the method returns a non-zero/non-empty scalar value, not just any type"
   }.freeze
 
   CONCRETE_TEMPLATES = {
@@ -614,6 +616,32 @@ class Evilution::Reporter::Suggestion
         end
       RSPEC
     },
+    "collection_return" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'returns a non-empty collection from ##{method_name}' do
+          # Assert the collection has the expected elements, not just non-empty
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "scalar_return" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'returns a non-zero/non-empty value from ##{method_name}' do
+          # Assert the exact scalar value, not just presence or type
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
     "pattern_matching_array" => lambda { |mutation|
       method_name = parse_method_name(mutation.subject.name)
       original_line, mutated_line = extract_diff_lines(mutation.diff)

data/lib/evilution/result/mutation_result.rb

@@ -6,9 +6,11 @@ class Evilution::Result::MutationResult
   STATUSES = %i[killed survived timeout error neutral equivalent].freeze
 
   attr_reader :mutation, :status, :duration, :killing_test, :test_command,
-              :child_rss_kb, :memory_delta_kb
+              :child_rss_kb, :memory_delta_kb, :parent_rss_kb
 
-  def initialize(mutation:, status:, duration: 0.0, killing_test: nil, test_command: nil, child_rss_kb: nil, memory_delta_kb: nil)
+  def initialize(mutation:, status:, duration: 0.0, killing_test: nil,
+                 test_command: nil, child_rss_kb: nil, memory_delta_kb: nil,
+                 parent_rss_kb: nil)
     raise ArgumentError, "invalid status: #{status}" unless STATUSES.include?(status)
 
     @mutation = mutation
@@ -18,6 +20,7 @@ class Evilution::Result::MutationResult
     @test_command = test_command
     @child_rss_kb = child_rss_kb
     @memory_delta_kb = memory_delta_kb
+    @parent_rss_kb = parent_rss_kb
     freeze
   end
 

data/lib/evilution/result/summary.rb

@@ -3,13 +3,14 @@
 require_relative "../result"
 
 class Evilution::Result::Summary
-  attr_reader :results, :duration, :skipped
+  attr_reader :results, :duration, :skipped, :disabled_mutations
 
-  def initialize(results:, duration: 0.0, truncated: false, skipped: 0)
+  def initialize(results:, duration: 0.0, truncated: false, skipped: 0, disabled_mutations: [])
     @results = results
     @duration = duration
     @truncated = truncated
     @skipped = skipped
+    @disabled_mutations = disabled_mutations
     freeze
   end
 
@@ -72,6 +73,22 @@ class Evilution::Result::Summary
     results.select(&:equivalent?)
   end
 
+  def killtime
+    results.sum(0.0, &:duration)
+  end
+
+  def efficiency
+    return 0.0 if duration.zero?
+
+    killtime / duration
+  end
+
+  def mutations_per_second
+    return 0.0 if duration.zero?
+
+    total.to_f / duration
+  end
+
   def peak_memory_mb
     max_rss = nil
     results.each do |result|