polyrun 2.2.8 → 2.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f6a7a0e969581e53f92c3e1bd4dfbb046c8321fb25601d58be12d4cc8cb6a96
-  data.tar.gz: 0c4625804e0ee0ce3f695570001658f9d907d9102c059258efa9c00fdf16d669
+  metadata.gz: dd372c59e18ffd48e6e53d42240cb4893fd165af0399ca6c50ca8a4d14a74b0e
+  data.tar.gz: 9aaf900fe002008e213c1f8b48b9c7867ad685db79946d72760f40a92c7052f6
 SHA512:
-  metadata.gz: 663f89b311212915efcb030db4cf88feb7f3f78b981746d63ee8c5548fec1abd23e13df3b307f4173601e4b3b829dab9ac56664caecfd929ed48c585deec58c2
-  data.tar.gz: be540c7af7282a2868408a6e8fa7837976ae2ffe443acbec7e65bb6e881d0bce419a344cf75573cadb2af0f562272032eabaf30564e2fab9a998f76029e37c07
+  metadata.gz: f3ba035a9df88c6722deaf3c632a213fdc11fa94554b260136fe3500e8fbe3e26825b6ef9f59732a07db3d82cf562a09553a14b677f0e8beb0ab50574775806b
+  data.tar.gz: aac4874eb9000f920691c8796c1ee35e91ed7555b4da84d9d9e1cb2fbce8783c3a6de8ef7dd82aaa02f941e55291a04c172a87fcba20ae4cf10f2a45b611a01e

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## 2.2.9 (2026-11-07)
+
+- Add `Polyrun::Benchmark::Pressure` for load benches: wall/CPU/RSS/heap/GC plus optional storage and network byte deltas, with target ceilings for iterative pressure runs.
+- Add `benchmarks/load.rb`, `benchmarks/cooker.rb`, and Make targets (`bench-load`, `bench-calibrate`, cooker propose/gate) for coverage-merge pressure matrices; JSON under `benchmarks/output/`.
+- Speed coverage merge on the hot path: faster fragment read/parse, cheaper empty-meta merges, and native merge micro-optimizations (hash capacity, Fixnum line hits, empty-operand early return).
+
 ## 2.2.8 (2026-11-04)
 
 - Honor top-level `workers:` in `polyrun.yml` when `POLYRUN_WORKERS` is unset (`polyrun config workers`, `start`, `run-shards`, `run-queue`, `doctor`).

data/ext/polyrun_coverage_merge/coverage_merge.c

@@ -16,12 +16,12 @@ static ID id_coverage;
 static ID id_relevant;
 static ID id_covered;
 static ID id_sort_branches_for_native;
+static ID id_keys;
+static ID id_plus;
+static ID id_gt;
 
-static VALUE
-ignored_string(void)
-{
-    return rb_str_new_cstr("ignored");
-}
+static VALUE str_ignored;
+static VALUE ary_empty_lines;
 
 static int
 ignored_hit_p(VALUE value)
@@ -67,7 +67,7 @@ line_hit_positive_p(VALUE value)
         return 0;
     }
 
-    VALUE comparison = rb_funcall(as_int, rb_intern(">"), 1, LONG2FIX(0));
+    VALUE comparison = rb_funcall(as_int, id_gt, 1, LONG2FIX(0));
     return RTEST(comparison);
 }
 
@@ -75,7 +75,7 @@ static VALUE
 coerce_line_array(VALUE value)
 {
     if (NIL_P(value)) {
-        return rb_ary_new();
+        return ary_empty_lines;
     }
     if (!RB_TYPE_P(value, T_ARRAY)) {
         rb_raise(rb_eTypeError, "lines must be an Array");
@@ -88,7 +88,7 @@ static VALUE
 line_array_for_count(VALUE value)
 {
     if (NIL_P(value) || !RB_TYPE_P(value, T_ARRAY)) {
-        return rb_ary_new();
+        return ary_empty_lines;
     }
 
     return value;
@@ -104,14 +104,17 @@ merge_line_hits(VALUE left, VALUE right)
         return left;
     }
     if (ignored_hit_p(left) || ignored_hit_p(right)) {
-        return ignored_string();
+        return str_ignored;
     }
 
     VALUE left_i = line_hit_to_i(left);
     VALUE right_i = line_hit_to_i(right);
 
     if (!NIL_P(left_i) && !NIL_P(right_i)) {
-        return rb_funcall(left_i, rb_intern("+"), 1, right_i);
+        if (RB_FIXNUM_P(left_i) && RB_FIXNUM_P(right_i)) {
+            return LONG2FIX(FIX2LONG(left_i) + FIX2LONG(right_i));
+        }
+        return rb_funcall(left_i, id_plus, 1, right_i);
     }
     if (NIL_P(left_i) && !NIL_P(right_i)) {
         return right_i;
@@ -134,9 +137,12 @@ merge_line_arrays(VALUE left, VALUE right)
     long max_len = left_len > right_len ? left_len : right_len;
     VALUE out = rb_ary_new2(max_len);
 
+    const VALUE *left_ptr = RARRAY_CONST_PTR(left);
+    const VALUE *right_ptr = RARRAY_CONST_PTR(right);
+
     for (long index = 0; index < max_len; index++) {
-        VALUE left_hit = index < left_len ? rb_ary_entry(left, index) : Qnil;
-        VALUE right_hit = index < right_len ? rb_ary_entry(right, index) : Qnil;
+        VALUE left_hit = index < left_len ? left_ptr[index] : Qnil;
+        VALUE right_hit = index < right_len ? right_ptr[index] : Qnil;
         rb_ary_store(out, index, merge_line_hits(left_hit, right_hit));
     }
 
@@ -185,7 +191,7 @@ static VALUE
 merge_branch_entries(VALUE left, VALUE right)
 {
     VALUE out = rb_hash_dup(left);
-    VALUE sum = rb_funcall(coverage_count(left), rb_intern("+"), 1, coverage_count(right));
+    VALUE sum = rb_funcall(coverage_count(left), id_plus, 1, coverage_count(right));
     rb_hash_aset(out, str_coverage, sum);
 
     return out;
@@ -202,7 +208,7 @@ merge_module_value(void)
 static VALUE
 hash_keys(VALUE hash)
 {
-    return rb_funcall(hash, rb_intern("keys"), 0);
+    return rb_funcall(hash, id_keys, 0);
 }
 
 static VALUE
@@ -395,7 +401,12 @@ merge_two(VALUE module, VALUE left, VALUE right)
         secondary = left;
     }
 
-    VALUE out = rb_hash_new();
+    if (RHASH_SIZE(secondary) == 0) {
+        return rb_hash_dup(primary);
+    }
+
+    long capa = (long)RHASH_SIZE(primary);
+    VALUE out = rb_hash_new_capa(capa > 0 ? capa : 0);
     VALUE primary_keys = hash_keys(primary);
     long primary_length = RARRAY_LEN(primary_keys);
 
@@ -472,18 +483,26 @@ Init_polyrun_coverage_merge(void)
     id_relevant = rb_intern("relevant");
     id_covered = rb_intern("covered");
     id_sort_branches_for_native = rb_intern("sort_branches_for_native");
+    id_keys = rb_intern("keys");
+    id_plus = rb_intern("+");
+    id_gt = rb_intern(">");
     str_lines = rb_obj_freeze(rb_str_new_cstr("lines"));
     str_branches = rb_obj_freeze(rb_str_new_cstr("branches"));
     str_type = rb_obj_freeze(rb_str_new_cstr("type"));
     str_start_line = rb_obj_freeze(rb_str_new_cstr("start_line"));
     str_end_line = rb_obj_freeze(rb_str_new_cstr("end_line"));
     str_coverage = rb_obj_freeze(rb_str_new_cstr("coverage"));
+    str_ignored = rb_obj_freeze(rb_str_new_cstr("ignored"));
+    ary_empty_lines = rb_ary_new();
+    rb_obj_freeze(ary_empty_lines);
     rb_global_variable(&str_lines);
     rb_global_variable(&str_branches);
     rb_global_variable(&str_type);
     rb_global_variable(&str_start_line);
     rb_global_variable(&str_end_line);
     rb_global_variable(&str_coverage);
+    rb_global_variable(&str_ignored);
+    rb_global_variable(&ary_empty_lines);
 
     VALUE module = rb_define_module("PolyrunCoverageMerge");
     rb_define_singleton_method(module, "merge_line_arrays", merge_line_arrays_method, 2);

data/lib/polyrun/benchmark/pressure/cooker.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+module Polyrun
+  module Benchmark
+    module Pressure
+      # Episode helpers for amkisko/pressure-benchmarking prayer: multi-sample measure,
+      # propose ceilings, calibrate stage separation, and cooker iteration logs.
+      module Cooker
+        DEFAULT_SAMPLES = 3
+        DEFAULT_HEADROOM = 1.15
+        DEFAULT_COOKER_N = 10
+        SERIES_KEYS = %w[
+          wall_s cpu_s rss_delta_bytes heap_delta_bytes storage_delta_bytes
+          network_in_bytes network_out_bytes allocated_objects
+        ].freeze
+
+        module_function
+
+        def measure_samples(n:, label:, ops: nil, gc_start: true, extras: {}, &block)
+          raise ArgumentError, "samples-per-load must be >= 1" if n < 1
+
+          samples = Array.new(n) do |i|
+            Pressure.measure(
+              label: "#{label}_s#{i + 1}",
+              ops: ops,
+              gc_start: gc_start,
+              extras: extras,
+              &block
+            )
+          end
+          aggregate(samples, label: label, basis: extras.fetch("basis", "median"))
+        end
+
+        def aggregate(samples, label:, basis: "median")
+          metrics_list = samples.map { |s| flatten_metrics(s["metrics"]) }
+          keys = SERIES_KEYS
+          summary = {}
+          keys.each do |key|
+            values = metrics_list.filter_map { |m| m[key] }
+            next if values.empty?
+
+            summary[key] = {
+              "samples" => values,
+              "median" => percentile(values, 0.5),
+              "max" => values.max,
+              "min" => values.min,
+              "basis_value" => (basis.to_s == "max") ? values.max : percentile(values, 0.5)
+            }
+          end
+          wall = summary.dig("wall_s", "basis_value")
+          ops = samples.first && samples.first["ops"]
+          {
+            "label" => label.to_s,
+            "ops" => ops,
+            "ops_per_s" => (ops && wall&.positive?) ? ops / wall : nil,
+            "basis" => basis.to_s,
+            "n" => samples.length,
+            "samples" => samples,
+            "series" => summary,
+            "metrics" => summary.transform_values { |h| h["basis_value"] },
+            "gateable" => samples.length >= DEFAULT_SAMPLES
+          }
+        end
+
+        def flatten_metrics(metrics)
+          flat = metrics.dup
+          flat["allocated_objects"] = metrics.dig("gc", "allocated_objects")
+          flat
+        end
+
+        def propose_ceilings(series_summary, headroom: DEFAULT_HEADROOM, keys: nil)
+          keys ||= SERIES_KEYS
+          keys.each_with_object({}) do |key, out|
+            entry = series_summary[key] || series_summary.dig("series", key)
+            next unless entry
+
+            value = entry.is_a?(Hash) ? entry["basis_value"] : entry
+            next if value.nil?
+
+            out[key] = value.to_f * headroom
+          end
+        end
+
+        def gate(series_or_metrics, ceilings)
+          metrics = series_or_metrics["metrics"] || series_or_metrics
+          failures = []
+          ceilings.each do |key, limit|
+            next if limit.nil?
+            next unless metrics.key?(key)
+
+            failures << key if metrics[key].to_f > limit.to_f
+          end
+          {"pass" => failures.empty?, "failures" => failures, "metrics" => metrics, "ceilings" => ceilings}
+        end
+
+        def calibrate!(stages)
+          # stages: ordered Array of [name, known_rank, callable]
+          # known_rank must be strictly increasing with expected wall cost.
+          measured = stages.map do |name, known_rank, callable|
+            result = Pressure.measure(label: "calibrate_#{name}", ops: 1, gc_start: true) { callable.call }
+            {
+              "stage" => name.to_s,
+              "known_rank" => known_rank,
+              "wall_s" => result["metrics"]["wall_s"],
+              "cpu_s" => result["metrics"]["cpu_s"]
+            }
+          end
+          by_wall = measured.sort_by { |row| row["wall_s"] }
+          by_known = measured.sort_by { |row| row["known_rank"] }
+          order_ok = by_wall.map { |r| r["stage"] } == by_known.map { |r| r["stage"] }
+          distinct = measured.map { |r| r["wall_s"] }.uniq.length == measured.length
+          {
+            "pass" => order_ok && distinct,
+            "order_ok" => order_ok,
+            "distinct_wall" => distinct,
+            "stages" => measured,
+            "report" => format_calibrate(measured, order_ok, distinct)
+          }
+        end
+
+        def format_calibrate(measured, order_ok, distinct)
+          lines = measured.map { |r| format("%s rank=%s wall=%.6fs cpu=%.6fs", r["stage"], r["known_rank"], r["wall_s"], r["cpu_s"]) }
+          status = (order_ok && distinct) ? "PASS" : "FAIL"
+          ([status, "order_ok=#{order_ok}", "distinct_wall=#{distinct}"] + lines).join(" | ")
+        end
+
+        def load_ceilings(path)
+          return {} unless File.file?(path)
+
+          JSON.parse(File.read(path))
+        end
+
+        def write_ceilings!(path, ceilings, meta: {})
+          FileUtils.mkdir_p(File.dirname(path))
+          payload = {
+            "meta" => meta.merge("recorded_at" => Time.now.utc.iso8601),
+            "ceilings" => ceilings
+          }
+          File.write(path, JSON.pretty_generate(payload))
+          path
+        end
+
+        def new_episode(repository_root:, binding:)
+          {
+            "started_at" => Time.now.utc.iso8601,
+            "finished_at" => nil,
+            "repository_root" => repository_root,
+            "binding" => binding,
+            "calibrate" => nil,
+            "load_steps" => [],
+            "ceilings_before" => nil,
+            "ceilings_after" => nil,
+            "iterations" => [],
+            "accepted" => false,
+            "stop_reason" => nil
+          }
+        end
+
+        def append_iteration!(episode, iteration:, primary:, hypothesis:, change:, prove:)
+          episode["iterations"] << {
+            "n" => iteration,
+            "primary_series" => primary,
+            "hypothesis" => hypothesis,
+            "change" => change,
+            "prove" => prove
+          }
+          episode
+        end
+
+        def write_episode!(episode, path:)
+          episode["finished_at"] = Time.now.utc.iso8601
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, JSON.pretty_generate(episode))
+          path
+        end
+
+        def percentile(values, fraction)
+          sorted = values.map(&:to_f).sort
+          return sorted.first if sorted.length == 1
+
+          idx = ((sorted.length - 1) * fraction).round
+          sorted[idx]
+        end
+      end
+    end
+  end
+end

data/lib/polyrun/benchmark/pressure/process_sample.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "objspace"
+require "open3"
+
+module Polyrun
+  module Benchmark
+    module Pressure
+      # Wall/CPU/RSS/heap/GC sampling and diffs for {Pressure.measure}.
+      module ProcessSample
+        module_function
+
+        def sample
+          times = Process.times
+          {
+            "wall_s" => monotonic_s,
+            "cpu_user_s" => times.utime,
+            "cpu_system_s" => times.stime,
+            "rss_bytes" => rss_bytes,
+            "heap_bytes" => heap_bytes,
+            "gc" => gc_sample,
+            "storage_bytes" => 0,
+            "network_in_bytes" => 0,
+            "network_out_bytes" => 0
+          }
+        end
+
+        def diff(before, after_sample, extras: {})
+          wall_s = after_sample["wall_s"] - before["wall_s"]
+          cpu = cpu_diff(before, after_sample)
+          memory = memory_diff(before, after_sample)
+          io = io_diff(before, after_sample, extras)
+          {
+            "wall_s" => wall_s,
+            "cpu_user_s" => cpu[:user],
+            "cpu_system_s" => cpu[:system],
+            "cpu_s" => cpu[:total],
+            "cpu_pct" => wall_s.positive? ? (cpu[:total] / wall_s) * 100.0 : 0.0,
+            "rss_bytes" => memory[:rss],
+            "rss_delta_bytes" => memory[:rss_delta],
+            "heap_bytes" => memory[:heap],
+            "heap_delta_bytes" => memory[:heap_delta],
+            "gc" => gc_diff(before["gc"], after_sample["gc"]),
+            "storage_delta_bytes" => io[:storage],
+            "network_in_bytes" => io[:network_in],
+            "network_out_bytes" => io[:network_out]
+          }
+        end
+
+        def monotonic_s
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        def rss_bytes
+          if File.readable?("/proc/self/status")
+            status = File.read("/proc/self/status")
+            if (match = status.match(/^VmRSS:\s+(\d+)\s+kB/))
+              return match[1].to_i * 1024
+            end
+          end
+
+          stdout, status = Open3.capture2("ps", "-o", "rss=", "-p", Process.pid.to_s)
+          return 0 unless status.success?
+
+          stdout.strip.to_i * 1024
+        rescue
+          0
+        end
+
+        def heap_bytes
+          ObjectSpace.memsize_of_all
+        rescue
+          0
+        end
+
+        def gc_sample
+          stat = GC.stat
+          {
+            "count" => stat[:count],
+            "allocated_objects" => stat[:total_allocated_objects],
+            "heap_live_slots" => stat[:heap_live_slots],
+            "heap_free_slots" => stat[:heap_free_slots],
+            "major_gc_count" => stat[:major_gc_count],
+            "minor_gc_count" => stat[:minor_gc_count]
+          }
+        end
+
+        def gc_diff(before, after_sample)
+          {
+            "count" => after_sample["count"] - before["count"],
+            "allocated_objects" => after_sample["allocated_objects"] - before["allocated_objects"],
+            "heap_live_slots" => after_sample["heap_live_slots"],
+            "heap_live_delta" => after_sample["heap_live_slots"] - before["heap_live_slots"],
+            "major_gc_count" => after_sample["major_gc_count"] - before["major_gc_count"],
+            "minor_gc_count" => after_sample["minor_gc_count"] - before["minor_gc_count"]
+          }
+        end
+
+        def cpu_diff(before, after_sample)
+          user = after_sample["cpu_user_s"] - before["cpu_user_s"]
+          system = after_sample["cpu_system_s"] - before["cpu_system_s"]
+          {user: user, system: system, total: user + system}
+        end
+
+        def memory_diff(before, after_sample)
+          {
+            rss: after_sample["rss_bytes"],
+            rss_delta: after_sample["rss_bytes"] - before["rss_bytes"],
+            heap: after_sample["heap_bytes"],
+            heap_delta: after_sample["heap_bytes"] - before["heap_bytes"]
+          }
+        end
+
+        def io_diff(before, after_sample, extras)
+          {
+            storage: (after_sample["storage_bytes"] - before["storage_bytes"]) +
+              extras.fetch("storage_delta_bytes", 0),
+            network_in: (after_sample["network_in_bytes"] - before["network_in_bytes"]) +
+              extras.fetch("network_in_bytes", 0),
+            network_out: (after_sample["network_out_bytes"] - before["network_out_bytes"]) +
+              extras.fetch("network_out_bytes", 0)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/polyrun/benchmark/pressure.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "socket"
+require_relative "pressure/process_sample"
+
+module Polyrun
+  module Benchmark
+    # Process resource sampler for pressure / load benches.
+    #
+    # Measures wall time, CPU (user+system), RSS, GC / heap, optional storage and
+    # network byte counters. Callers raise load (N, threads, payload size) and lower
+    # resource targets after each successful round.
+    #
+    # Usage:
+    #   result = Polyrun::Benchmark::Pressure.measure(label: "merge_disk", ops: 8) do
+    #     merge_files(...)
+    #   end
+    #   Polyrun::Benchmark::Pressure.write_results!([result], repository_root: Dir.pwd)
+    module Pressure
+      module_function
+
+      DEFAULT_TARGET_FACTOR = 0.85
+
+      def sample
+        ProcessSample.sample
+      end
+
+      def diff(before, after_sample, extras: {})
+        ProcessSample.diff(before, after_sample, extras: extras)
+      end
+
+      def measure(label:, ops: nil, gc_start: true, extras: {})
+        GC.start if gc_start
+        before = sample
+        started = ProcessSample.monotonic_s
+        yield
+        wall_s = ProcessSample.monotonic_s - started
+        after_sample = sample
+        metrics = diff(before, after_sample, extras: extras)
+        metrics["wall_s"] = wall_s
+        metrics["cpu_pct"] = wall_s.positive? ? (metrics["cpu_s"] / wall_s) * 100.0 : 0.0
+        result = {
+          "label" => label.to_s,
+          "ops" => ops,
+          "ops_per_s" => (ops && wall_s.positive?) ? ops / wall_s : nil,
+          "metrics" => metrics,
+          "targets" => extras["targets"],
+          "pass" => targets_met?(metrics, extras["targets"])
+        }
+        result["report"] = format_report(result)
+        result
+      end
+
+      def targets_from(metrics, factor: DEFAULT_TARGET_FACTOR)
+        {
+          "wall_s" => metrics["wall_s"] * factor,
+          "cpu_s" => metrics["cpu_s"] * factor,
+          "rss_delta_bytes" => [metrics["rss_delta_bytes"] * factor, 0].max,
+          "heap_delta_bytes" => [metrics["heap_delta_bytes"] * factor, 0].max,
+          "storage_delta_bytes" => [metrics["storage_delta_bytes"] * factor, 0].max,
+          "network_in_bytes" => metrics["network_in_bytes"] * factor,
+          "network_out_bytes" => metrics["network_out_bytes"] * factor
+        }
+      end
+
+      def targets_met?(metrics, targets)
+        return nil if targets.nil? || targets.empty?
+
+        targets.all? do |key, limit|
+          next true if limit.nil?
+          next true unless metrics.key?(key)
+
+          metrics[key].to_f <= limit.to_f
+        end
+      end
+
+      def format_report(result)
+        m = result["metrics"]
+        parts = format_report_core(result, m)
+        append_format_report_extras!(parts, result, m)
+        parts.join(" | ")
+      end
+
+      def write_results!(results, repository_root: Dir.pwd, name: "load")
+        dir = File.join(repository_root, "benchmarks", "output")
+        FileUtils.mkdir_p(dir)
+        stamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        path = File.join(dir, "#{stamp}_#{name}.json")
+        payload = {
+          "meta" => {
+            "recorded_at" => Time.now.utc.iso8601,
+            "ruby" => RUBY_VERSION,
+            "engine" => RUBY_ENGINE,
+            "platform" => RUBY_PLATFORM,
+            "polyrun_version" => defined?(Polyrun::VERSION) ? Polyrun::VERSION : nil,
+            "hostname" => Socket.gethostname
+          },
+          "results" => results
+        }
+        File.write(path, JSON.pretty_generate(payload))
+        path
+      end
+
+      def human_bytes(value)
+        n = value.to_f
+        units = %w[B KiB MiB GiB]
+        i = 0
+        while n.abs >= 1024.0 && i < units.length - 1
+          n /= 1024.0
+          i += 1
+        end
+        format("%.1f%s", n, units[i])
+      end
+
+      def format_report_core(result, metrics)
+        [
+          result["label"],
+          format("wall=%.4fs", metrics["wall_s"]),
+          format("cpu=%.4fs (%.0f%%)", metrics["cpu_s"], metrics["cpu_pct"]),
+          format("rss=%s (Δ%s)", human_bytes(metrics["rss_bytes"]), human_bytes(metrics["rss_delta_bytes"])),
+          format("heap_Δ=%s", human_bytes(metrics["heap_delta_bytes"])),
+          format("alloc=%d", metrics.dig("gc", "allocated_objects") || 0)
+        ]
+      end
+
+      def append_format_report_extras!(parts, result, metrics)
+        parts << format("ops/s=%.1f", result["ops_per_s"]) if result["ops_per_s"]
+        if metrics["storage_delta_bytes"].to_i != 0
+          parts << format("storage_Δ=%s", human_bytes(metrics["storage_delta_bytes"]))
+        end
+        net = metrics["network_in_bytes"].to_i + metrics["network_out_bytes"].to_i
+        parts << format("net=%s", human_bytes(net)) if net != 0
+        return if result["pass"].nil?
+
+        parts << (result["pass"] ? "PASS" : "FAIL targets")
+      end
+      private_class_method :format_report_core, :append_format_report_extras!
+    end
+  end
+end
+
+require_relative "pressure/cooker"

data/lib/polyrun/coverage/merge.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 module Polyrun
@@ -26,15 +28,15 @@ module Polyrun
       def merge_fragments(paths)
         return {blob: {}, meta: {}, groups: nil} if paths.empty?
 
-        # Parse one fragment at a time: keep only meta + blob so peak RSS drops after each fold step.
+        # Fold one fragment at a time so peak RSS does not retain every blob concurrently.
         metas = []
-        blobs = []
+        merged_blob = nil
         paths.each do |path|
-          doc = JSON.parse(File.read(path))
+          doc = JSON.parse(File.binread(path))
           metas << extract_doc_meta(doc)
-          blobs << extract_coverage_blob(doc)
+          blob = coverage_blob_from_doc(doc)
+          merged_blob = merged_blob.nil? ? blob : merge_two(merged_blob, blob)
         end
-        merged_blob = merge_blob_tree(blobs)
         merged_meta = merge_fragment_metas_from_metas(metas)
         merged_blob = apply_track_files_once_after_merge(merged_blob, merged_meta)
         groups_payload = recompute_groups_from_meta(merged_blob, merged_meta)
@@ -96,13 +98,33 @@ module Polyrun
       end
 
       def parse_file(path)
-        text = File.read(path)
+        text = File.binread(path)
         data = JSON.parse(text)
         extract_coverage_blob(data)
       end
 
       # Picks top-level export `coverage`, merges all suite entries (e.g. RSpec + Minitest),
       # and combines both when present.
+      # Hot path: cooker and worker fragments are { "coverage" => Hash, "meta" => ... } without
+      # nested per-tool suites under extra top-level keys.
+      def coverage_blob_from_doc(doc)
+        return extract_coverage_blob(doc) unless doc.is_a?(Hash)
+
+        top = doc["coverage"]
+        return extract_coverage_blob(doc) unless top.is_a?(Hash)
+
+        doc.each_key do |k|
+          next if k == "coverage"
+
+          v = doc[k]
+          if v.is_a?(Hash) && v["coverage"].is_a?(Hash)
+            return extract_coverage_blob(doc)
+          end
+        end
+
+        top
+      end
+
       def extract_coverage_blob(data)
         return {} unless data.is_a?(Hash)
 
@@ -121,6 +143,11 @@ module Polyrun
           return {}
         end
 
+        if nested.size == 1
+          only = nested.first
+          return top.is_a?(Hash) ? merge_two(top, only) : only
+        end
+
         merged = nested.reduce { |acc, el| merge_two(acc, el) }
         top.is_a?(Hash) ? merge_two(top, merged) : merged
       end

data/lib/polyrun/coverage/merge_fragment_meta.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Polyrun
   module Coverage
     module Merge
@@ -9,6 +11,7 @@ module Polyrun
 
       def merge_fragment_metas_from_metas(metas)
         return {} if metas.empty?
+        return {} if metas.all? { |m| m.nil? || m.empty? }
 
         base = metas.first.dup
         roots = metas.map { |m| m["polyrun_coverage_root"] }.compact
@@ -43,7 +46,10 @@ module Polyrun
       end
 
       def merge_fragment_meta_warn_track_files!(tfs)
-        return if tfs.map { |tf| JSON.generate(normalize_track_files_meta(tf)) }.uniq.size <= 1
+        return if tfs.empty?
+
+        normalized = tfs.map { |tf| normalize_track_files_meta(tf) }
+        return if normalized.uniq.size <= 1
 
         Polyrun::Log.warn "Polyrun merge-coverage: polyrun_track_files differs across fragments; using first."
       end

data/lib/polyrun/coverage/merge_merge_two.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Polyrun
   module Coverage
     module Merge

data/lib/polyrun/coverage/merge_native.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Polyrun
   module Coverage
     module MergeNative

data/lib/polyrun/version.rb

@@ -1,3 +1,3 @@
 module Polyrun
-  VERSION = "2.2.8"
+  VERSION = "2.2.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polyrun
 version: !ruby/object:Gem::Version
-  version: 2.2.8
+  version: 2.2.9
 platform: ruby
 authors:
 - Andrei Makarov
@@ -210,6 +210,9 @@ files:
 - ext/polyrun_coverage_merge/coverage_merge.c
 - ext/polyrun_coverage_merge/extconf.rb
 - lib/polyrun.rb
+- lib/polyrun/benchmark/pressure.rb
+- lib/polyrun/benchmark/pressure/cooker.rb
+- lib/polyrun/benchmark/pressure/process_sample.rb
 - lib/polyrun/benchmark/profile.rb
 - lib/polyrun/benchmark/report.rb
 - lib/polyrun/cli.rb