binpacker 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 991ac5d941b69573b4f6d03c211ff862465a91ee31ddd82f5ce8d8150a2d4f0d
-  data.tar.gz: 8ad2f245f73a46a4fdd64272049835c36d3b2dc4a0bb5df9cf67f851789ae59a
+  metadata.gz: 98842f3601fe059ff372b62a214ee73e5e96d0b2c01cf5b651063f04e3f00184
+  data.tar.gz: 94e73ac26474bf1da1942509f35618e8576d230b685ee69fe09579d4b9387898
 SHA512:
-  metadata.gz: 4345168c76cd0e072ab8f0775df54fe705e13f873a1f7f8ce764b897f42f91f75c5b4b0dee07329b577200230a7707a90284e73b554a339798575e084ce93f15
-  data.tar.gz: 40408cf8b88b878033226df711fbf3e57c217293b85b6eb7f94f55289eb7740d02dcc66598c5f594a3cd21821b5186eb38942c7e03747838a6487ccc37e018d1
+  metadata.gz: 6a983e121b41c7a9e62dad700ee5541813b84c2553e7fc479c3dbedf996358669a9508d2fd7f3eb8df21831c583421ee91382a453ac73a60beead9bf03da0675
+  data.tar.gz: 657ac41276da7094a5ea54d53936a9237b1b3139f53b741c954427b57f2d781dca56df91746972e33e93f49edb7a93a2155d5b92561653d672f87ca73373669a

data/exe/binpacker-worker

@@ -166,6 +166,16 @@ end.parse!
 
 wid = options[:id]
 exit_code = 0
+
+# Test code must never see the orchestrator's control pipe. A test
+# that reads stdin — an LSP server loop, anything calling gets —
+# would block forever on the pipe the orchestrator keeps open
+# between dynamic batches (or, worse, consume control messages).
+# Keep the pipe on a private handle and point process stdin, which
+# spawned test runners inherit, at /dev/null so readers see EOF.
+control = $stdin.dup
+$stdin.reopen(File::NULL)
+
 $stderr.puts "[worker-#{wid}] #{options[:runner]} worker started"
 
 loop do
@@ -174,7 +184,7 @@ loop do
 
   tests = []
   done_or_eof = false
-  $stdin.each_line do |line|
+  control.each_line do |line|
     data = JSON.parse(line.strip)
     if data["type"] == "done"
       done_or_eof = true
@@ -186,7 +196,7 @@ loop do
   end
 
   break if done_or_eof && tests.empty?
-  break if tests.empty? && ($stdin.eof? || $stdin.closed?)
+  break if tests.empty? && (control.eof? || control.closed?)
 
   files = tests.map { |t| t["file"] }.uniq
   $stderr.puts "[worker-#{wid}] batch: #{files.size} files, #{tests.size} entries"

data/lib/binpacker/orchestrator.rb

@@ -2,7 +2,27 @@
 
 module Binpacker
   class Orchestrator
-    BATCH_SIZE = 10
+    # Dynamic batches halve the queue's remaining predicted weight,
+    # floored at a per-run minimum: early batches are large to amortize
+    # the per-batch test-runner boot (each batch is a fresh rspec
+    # process), tail batches stay small so workers finish together.
+    #
+    # The floor comes in two regimes (computed by #min_batch_weight in
+    # #run and threaded into #drain_batch):
+    #   - Calibrated: weights are measured seconds, so the floor is a
+    #     fixed MIN_BATCH_WEIGHT (~30s), an order of magnitude above the
+    #     ~3s runner boot — boot overhead stays in the noise.
+    #   - Cold start: weights are filesize KB, not seconds, so a fixed
+    #     30 is meaningless. We instead derive a floor that targets
+    #     ~COLD_START_BATCHES_PER_WORKER batches per worker (below).
+    MIN_BATCH_WEIGHT = 30.0
+
+    # On a pure cold start predicted weights are filesize KB, not
+    # seconds, so the 30s MIN_BATCH_WEIGHT floor has no meaning. Instead
+    # we size the floor so the total predicted weight divides into about
+    # this many batches per worker — matching the ~5 runner boots per
+    # worker that gave the best makespan in the PR #12 simulation.
+    COLD_START_BATCHES_PER_WORKER = 5
 
     def initialize(config, passthrough: [], quiet: false, report_path: nil)
       @config = config
@@ -17,7 +37,7 @@ module Binpacker
       timings = timing.load_with_fallback(tests)
       @timings = timings
 
-      scheduler = Scheduler.for(@config.scheduler["algorithm"])
+      scheduler = Scheduler.for(@config.scheduler['algorithm'])
       queues = scheduler.partition(
         tests: tests,
         worker_count: @config.worker_count,
@@ -28,12 +48,12 @@ module Binpacker
       @predicted_loads = queues.map { |q| q.total_weight(timings) }
 
       runner_class = TestRunner.for(@config.test_runner)
-      workers = queues.map.with_index do |queue, idx|
+      workers = queues.map.with_index do |_queue, idx|
         Worker.new(idx, runner_class, passthrough: @passthrough, quiet: @quiet).tap(&:start)
       end
 
-      if @config.scheduler["steal_enabled"]
-        run_dynamic(workers, queues, timing, tests)
+      if @config.scheduler['steal_enabled']
+        run_dynamic(workers, queues, timing, tests, min_batch_weight(timing, timings))
       else
         run_static(workers, queues, timing, tests)
       end
@@ -43,9 +63,9 @@ module Binpacker
 
     def discover
       case @config.test_runner
-      when "rspec"
+      when 'rspec'
         RSpecDiscovery.new(@config).enumerate
-      when "minitest"
+      when 'minitest'
         MinitestDiscovery.new(@config).enumerate
       else
         raise ConfigError, "unsupported runner: #{@config.test_runner}"
@@ -58,7 +78,7 @@ module Binpacker
 
       workers.zip(queues).each do |worker, queue|
         worker.send_tests(queue.remaining)
-        progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: queue.remaining.first&.file || "")
+        progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: queue.remaining.first&.file || '')
       end
       progress.refresh
 
@@ -81,10 +101,10 @@ module Binpacker
         worker_examples[worker.id] = worker.example_count
         worker_passed[worker.id] = worker.passed_count
         worker_time[worker.id] = worker.timings.sum { |t| t[:time] }
-        progress.update(worker.id, done: queue_totals[worker.id], total: queue_totals[worker.id], file: "done")
+        progress.update(worker.id, done: queue_totals[worker.id], total: queue_totals[worker.id], file: 'done')
         progress.refresh
       rescue WorkerError => e
-        $stderr.puts "worker #{worker.id} error: #{e.message}"
+        warn "worker #{worker.id} error: #{e.message}"
         all_passed = false
       ensure
         worker.cleanup
@@ -92,7 +112,7 @@ module Binpacker
 
       progress.finish
 
-      worker_stats = workers.map.with_index do |w, i|
+      worker_stats = workers.map.with_index do |_w, i|
         {
           files: queue_totals[i],
           total_time: worker_time[i],
@@ -106,11 +126,9 @@ module Binpacker
       finalize(timing, all_timings, all_passed, total_examples, passed_examples, tests)
     end
 
-    def run_dynamic(workers, queues, timing, tests)
+    def run_dynamic(workers, queues, timing, tests, floor)
       all_timings = []
       all_passed = true
-      total_examples = 0
-      passed_examples = 0
       active = []
 
       queue_totals = queues.map(&:size)
@@ -123,25 +141,23 @@ module Binpacker
       progress = ProgressDisplay.new(workers.size)
 
       workers.zip(queues).each do |worker, queue|
-        batch = drain_batch(queue)
+        batch = drain_batch(queue, floor)
         if batch.empty?
           worker.signal_done
           worker.collect_results
           all_timings.concat(worker.timings)
           all_passed &&= worker.success?
-          total_examples += worker.example_count
-          passed_examples += worker.passed_count
           worker_examples[worker.id] = worker.example_count
           worker_passed[worker.id] = worker.passed_count
           worker.cleanup
           worker_done[worker.id] = queue_totals[worker.id]
-          progress.update(worker.id, done: worker_done[worker.id], total: queue_totals[worker.id], file: "done")
+          progress.update(worker.id, done: worker_done[worker.id], total: queue_totals[worker.id], file: 'done')
         else
           worker.send_tests(batch)
           worker.batch_done
           active << worker
           batch_sizes[worker.id] = batch.size
-          current_file = batch.first&.file || ""
+          current_file = batch.first&.file || ''
           progress.update(worker.id, done: 0, total: queue_totals[worker.id], file: current_file)
         end
       end
@@ -149,33 +165,38 @@ module Binpacker
       until active.empty?
         ready = active.find { |w| w.wait_for_batch }
         unless ready
-          active.reject! { |w| w.status == :crashed || w.status == :error }
+          active.reject! { |w| %i[crashed error].include?(w.status) }
           sleep 0.1
           next
         end
 
         begin
           all_passed &&= ready.success?
-          total_examples += ready.example_count
-          passed_examples += ready.passed_count
 
           worker_done[ready.id] += batch_sizes[ready.id]
+          # Worker#example_count accumulates across batches, so these
+          # are running totals per worker; the grand totals are summed
+          # once after the loop, never added per batch.
           worker_examples[ready.id] = ready.example_count
           worker_passed[ready.id] = ready.passed_count
 
           own_queue = queues[ready.id]
-          next_batch = drain_batch(own_queue)
+          next_batch = drain_batch(own_queue, floor)
 
           if next_batch.empty?
-            donor = queues.reject(&:empty?).max_by(&:size)
-            next_batch = drain_batch(donor) if donor
+            donor = queues.reject(&:empty?).max_by { |q| q.total_weight(@timings) }
+            if donor
+              next_batch = drain_batch(donor, floor)
+              queue_totals[ready.id] += next_batch.size
+              queue_totals[donor.worker_id] -= next_batch.size
+            end
           end
 
           if next_batch.any?
             ready.send_tests(next_batch)
             ready.batch_done
             batch_sizes[ready.id] = next_batch.size
-            current_file = next_batch.first&.file || ""
+            current_file = next_batch.first&.file || ''
             progress.update(ready.id, done: worker_done[ready.id], total: queue_totals[ready.id], file: current_file)
             progress.refresh
           else
@@ -183,11 +204,11 @@ module Binpacker
             all_timings.concat(ready.timings)
             active.delete(ready)
             worker_done[ready.id] = queue_totals[ready.id]
-            progress.update(ready.id, done: queue_totals[ready.id], total: queue_totals[ready.id], file: "done")
+            progress.update(ready.id, done: queue_totals[ready.id], total: queue_totals[ready.id], file: 'done')
             progress.refresh
           end
         rescue WorkerError => e
-          $stderr.puts "worker #{ready.id} error: #{e.message}"
+          warn "worker #{ready.id} error: #{e.message}"
           all_passed = false
           active.delete(ready)
         end
@@ -195,6 +216,9 @@ module Binpacker
 
       progress.finish
 
+      total_examples = worker_examples.sum
+      passed_examples = worker_passed.sum
+
       worker_stats = workers.map.with_index do |w, i|
         tw = w.timings.sum { |t| t[:time] }
         {
@@ -216,7 +240,7 @@ module Binpacker
 
       Report.new(
         profile: @config.profile,
-        algorithm: @config.scheduler["algorithm"],
+        algorithm: @config.scheduler['algorithm'],
         predicted_loads: @predicted_loads,
         worker_stats: worker_stats,
         all_timings: all_timings,
@@ -224,19 +248,43 @@ module Binpacker
       ).write(@report_path)
     end
 
-    def drain_batch(queue)
+    # Per-run batch-weight floor. Calibrated runs use the fixed
+    # seconds-scale MIN_BATCH_WEIGHT. On a cold start weights are KB, so
+    # that floor is meaningless; derive one that splits the total
+    # predicted weight into ~COLD_START_BATCHES_PER_WORKER batches per
+    # worker, falling back to MIN_BATCH_WEIGHT when there is nothing to
+    # divide (zero total weight or zero workers).
+    def min_batch_weight(timing, timings)
+      return MIN_BATCH_WEIGHT if timing.calibrated?
+
+      total = timings.values.sum(0.0)
+      workers = @config.worker_count
+      return MIN_BATCH_WEIGHT if total.zero? || workers.zero?
+
+      total / (workers * COLD_START_BATCHES_PER_WORKER)
+    end
+
+    # Drains the next batch off +queue+: enough tests to halve its
+    # remaining predicted weight, but never less than +floor+ (see
+    # #min_batch_weight) and never fewer than one test.
+    def drain_batch(queue, floor)
       return [] if queue.nil? || queue.empty?
+
+      target = [queue.total_weight(@timings) / 2.0, floor].max
       batch = []
-      BATCH_SIZE.times do
-        test = queue.pop
-        break unless test
+      weight = 0.0
+      while (batch.empty? || weight < target) && (test = queue.pop)
         batch << test
+        weight += @timings.fetch(test.key, Timing::DEFAULT_WEIGHT)
       end
       batch
     end
 
     def finalize(timing, all_timings, all_passed, total_examples, passed_examples, tests)
-      timing.append_all(all_timings) unless all_timings.empty?
+      unless all_timings.empty?
+        timing.append_all(all_timings)
+        timing.compact!
+      end
       empty_filter = minitest_empty_filter?(tests, total_examples)
       all_passed = false if empty_filter
 
@@ -250,7 +298,7 @@ module Binpacker
     end
 
     def minitest_empty_filter?(tests, total_examples)
-      return false unless @config.test_runner == "minitest"
+      return false unless @config.test_runner == 'minitest'
       return false unless tests.any?
       return false unless total_examples.zero?
 
@@ -260,8 +308,8 @@ module Binpacker
     def minitest_include_filter?
       @passthrough.any? do |arg|
         %w[--name --include -n -i].include?(arg) ||
-          arg.start_with?("--name=", "--include=") ||
-          (arg.start_with?("-n", "-i") && arg.length > 2)
+          arg.start_with?('--name=', '--include=') ||
+          (arg.start_with?('-n', '-i') && arg.length > 2)
       end
     end
   end

data/lib/binpacker/progress.rb

@@ -7,7 +7,7 @@ module Binpacker
     def initialize(worker_count, tty: $stdout.tty?)
       @worker_count = worker_count
       @tty = tty
-      @workers = Array.new(worker_count) { { done: 0, total: 0, file: "", elapsed: 0.0 } }
+      @workers = Array.new(worker_count) { { done: 0, total: 0, file: '', elapsed: 0.0 } }
       @start = Time.now
       @last_ci_output = Time.at(Time.now.to_f - CI_INTERVAL)
       @lines_written = 0
@@ -32,8 +32,9 @@ module Binpacker
       end
     end
 
-    def finish(worker_stats = [])
+    def finish(_worker_stats = [])
       return unless @tty
+
       redraw
       $stdout.puts
     end
@@ -42,9 +43,10 @@ module Binpacker
       active = worker_stats.reject { |s| s[:files] == 0 && s[:examples] == 0 }
       return if active.empty?
 
-      active.each_with_index do |s, i|
+      worker_stats.each_with_index do |s, wid|
+        next if s[:files] == 0 && s[:examples] == 0
+
         t = format_time(s[:total_time])
-        wid = worker_stats.index(s)
         $stdout.puts "  Worker #{wid}: #{s[:files]} tests, #{t} | #{s[:examples]} examples, #{s[:passed]} passed"
       end
       total_tests = active.sum { |s| s[:files] }
@@ -55,7 +57,7 @@ module Binpacker
       max_dev = times.map { |t| (t - mean).abs }.max
       dev_pct = mean > 0 ? (max_dev / mean * 100).round(1) : 0
 
-      $stdout.puts "  ──"
+      $stdout.puts '  ──'
       $stdout.puts "  Total: #{total_tests} tests, #{format_time(total_time)} | #{total_examples} examples"
       $stdout.puts "  Balance: max deviation #{format_time(max_dev)} (#{dev_pct}%)"
     end
@@ -67,7 +69,7 @@ module Binpacker
         clear_lines
         @workers.each_with_index do |w, i|
           bar = build_bar(w[:done], w[:total])
-          status = w[:total] > 0 && w[:done] >= w[:total] ? "done" : w[:file][-50..] || ""
+          status = w[:total] > 0 && w[:done] >= w[:total] ? 'done' : w[:file][-50..] || ''
           $stdout.puts format_line(i, bar, w[:done], w[:total], status, w[:elapsed])
         end
         @lines_written = @worker_count
@@ -76,13 +78,15 @@ module Binpacker
 
     def clear_lines
       return if @lines_written == 0
+
       @lines_written.times do
         $stdout.print "\033[A\033[K"
       end
     end
 
     def build_bar(done, total)
-      return "[----------]" if total == 0
+      return '[----------]' if total == 0
+
       width = 10
       filled = (done.to_f / total * width).round
       "[#{'█' * filled}#{'░' * (width - filled)}]"
@@ -96,10 +100,11 @@ module Binpacker
     def periodic_output
       now = Time.now
       return if now - @last_ci_output < CI_INTERVAL
+
       @last_ci_output = now
 
       parts = @workers.map.with_index do |w, i|
-        ratio = w[:total] > 0 ? "#{w[:done]}/#{w[:total]}" : "0/?"
+        ratio = w[:total] > 0 ? "#{w[:done]}/#{w[:total]}" : '0/?'
         "W#{i}: #{ratio}"
       end
       elapsed = (now - @start).round(1)
@@ -108,7 +113,8 @@ module Binpacker
     end
 
     def format_time(seconds)
-      return "  0.0s" if seconds < 0.001
+      return '  0.0s' if seconds < 0.001
+
       m = (seconds / 60).floor
       s = (seconds % 60).round(1)
       m > 0 ? "#{m}m#{s.to_s.rjust(4, '0')}s" : "#{s.to_s.rjust(5)}s"

data/lib/binpacker/timing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+require 'json'
 
 module Binpacker
   class Timing
@@ -8,40 +8,69 @@ module Binpacker
 
     DEFAULT_WEIGHT = 1.0
 
+    # Samples retained per test by #compact! and consulted by the
+    # median in #load_per_file. Three samples make a single anomalous
+    # run (GC pause, noisy CI neighbour) unable to move the weight.
+    MAX_SAMPLES_PER_TEST = 3
+
     def initialize(path)
       @path = Pathname(path)
     end
 
+    # True once any timing samples exist, i.e. the project has been
+    # calibrated at least once. Callers use this to tell a measured
+    # run (weights in seconds) from a pure cold start (fallbacks only).
+    def calibrated?
+      !samples_by_test.empty?
+    end
+
     def load_with_fallback(tests)
       per_file = load_per_file
+      coefficient = seconds_per_kb(per_file)
       tests.each_with_object({}) do |test, hash|
         key = normalize_path(test.file)
-        hash[test.key] = per_file.fetch(key) { filesize_weight(test.file) }
+        hash[test.key] = per_file.fetch(key) { fallback_weight(test.file, coefficient) }
       end
     end
 
     def load_raw
-      return {} unless @path.exist?
-
-      @path.each_line(encoding: "UTF-8")
-        .map { |line| parse_line(line) }
-        .compact
-        .group_by { |e| [normalize_path(e.file), e.name] }
-        .transform_values { |entries| entries.last.time }
+      @load_raw ||= samples_by_test.transform_values(&:last)
     end
 
+    # Predicted weight per file: the median of each test's recent
+    # samples, summed per file. The append-only history must NOT be
+    # summed wholesale — a file present in N historical runs would
+    # weigh ~N times its true cost, so long-lived files dominate and
+    # newly added ones are starved, skewing the partition.
     def load_per_file
-      return {} unless @path.exist?
+      samples_by_test.each_with_object({}) do |((file, _name), times), per_file|
+        weight = median(times.last(MAX_SAMPLES_PER_TEST))
+        per_file[file] = per_file.fetch(file, 0.0) + weight
+      end
+    end
 
-      @path.each_line(encoding: "UTF-8")
-        .map { |line| parse_line(line) }
-        .compact
-        .group_by { |e| normalize_path(e.file) }
-        .transform_values { |entries| entries.sum(&:time) }
+    # Rewrites the timing file keeping only the most recent
+    # MAX_SAMPLES_PER_TEST samples per test, so the append-only
+    # history (and any CI cache built from it) stays bounded instead
+    # of growing by one run per invocation.
+    def compact!
+      samples = samples_by_test
+      return if samples.empty?
+
+      tmp = Pathname("#{@path}.tmp")
+      tmp.open('w', encoding: 'UTF-8') do |io|
+        samples.each do |(file, name), times|
+          times.last(MAX_SAMPLES_PER_TEST).each do |time|
+            io.puts JSON.generate({ file: file, name: name, time: time })
+          end
+        end
+      end
+      File.rename(tmp.to_s, @path.to_s)
+      invalidate
     end
 
     def normalize_path(path)
-      Pathname(path).cleanpath.to_s.sub(/\A\.\//, "")
+      Pathname(path).cleanpath.to_s.sub(%r{\A\./}, '')
     end
 
     # True when a measured Weight already exists for this Test.
@@ -49,34 +78,103 @@ module Binpacker
       load_raw.key?([normalize_path(file), name])
     end
 
-    def weight_for(file:, name:)
-      measured = load_raw
-      measured.fetch([file, name]) { filesize_weight(file) }
-    end
-
     def append(file:, name:, time:)
       @path.dirname.mkpath unless @path.dirname.directory?
-      @path.open("a", encoding: "UTF-8") { |io| io.puts JSON.generate({ file: file, name: name, time: time }) }
+      @path.open('a', encoding: 'UTF-8') { |io| io.puts JSON.generate({ file: file, name: name, time: time }) }
+      invalidate
     end
 
     def append_all(entries)
       return if entries.empty?
+
       @path.dirname.mkpath unless @path.dirname.directory?
-      @path.open("a", encoding: "UTF-8") do |io|
+      @path.open('a', encoding: 'UTF-8') do |io|
         entries.each { |e| io.puts JSON.generate({ file: e[:file], name: e[:name], time: e[:time] }) }
       end
+      invalidate
     end
 
     private
 
+    # [normalized file, name] => [sample, ...] in append (= run) order.
+    def samples_by_test
+      @samples_by_test ||= begin
+        samples = Hash.new { |h, k| h[k] = [] }
+        if @path.exist?
+          @path.each_line(encoding: 'UTF-8') do |line|
+            entry = parse_line(line)
+            samples[[normalize_path(entry.file), entry.name]] << entry.time if entry
+          end
+        end
+        samples.default_proc = nil
+        samples
+      end
+    end
+
+    def invalidate
+      @samples_by_test = nil
+      @load_raw = nil
+    end
+
+    def median(values)
+      sorted = values.sort
+      mid = sorted.size / 2
+      sorted.size.odd? ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2.0
+    end
+
     def filesize_weight(file)
       path = Pathname(file)
       path.exist? ? [path.size / 1024.0, DEFAULT_WEIGHT].max : DEFAULT_WEIGHT
     end
 
+    # Seconds-per-KB coefficient used to scale filesize fallbacks onto
+    # the same axis as measured Weights. Measured Weights are seconds;
+    # the raw filesize fallback is KB, so mixing them (batch floors,
+    # donor selection) compares apples to oranges — 30s of predicted
+    # work reads as "30 KB of files". We estimate a conversion from
+    # the files we DO have timings for: for each measured file that
+    # still exists on disk with size > 0, take measured_seconds /
+    # size_kb, and use the median of those ratios (robust to a few
+    # outlier files that are unusually fast or slow for their size).
+    # nil when nothing can be estimated (no measurements, or none of
+    # the measured files exist on disk) — callers then keep raw KB.
+    def seconds_per_kb(per_file)
+      ratios = per_file.filter_map do |file, seconds|
+        kb = size_kb(file)
+        next if kb.nil? || kb <= 0
+
+        seconds / kb
+      end
+      ratios.empty? ? nil : median(ratios)
+    end
+
+    # Predicted Weight for an unmeasured Test. Without a coefficient we
+    # keep the legacy raw-KB behavior (floored at 1.0). With one we
+    # scale filesize into seconds: an existing file becomes
+    # size_kb * coefficient (floored at 0.01 to avoid degenerate zero
+    # weights, but NOT at 1.0 — sub-second predictions are meaningful
+    # now that the unit is seconds); a missing/unreadable file falls
+    # back to DEFAULT_WEIGHT as a plausible seconds-scale default.
+    def fallback_weight(file, coefficient)
+      return filesize_weight(file) if coefficient.nil?
+
+      kb = size_kb(file)
+      return DEFAULT_WEIGHT if kb.nil?
+
+      [kb * coefficient, 0.01].max
+    end
+
+    # File size in KB, or nil when the file does not exist / is unreadable.
+    def size_kb(file)
+      path = Pathname(file)
+      path.exist? ? path.size / 1024.0 : nil
+    rescue SystemCallError
+      nil
+    end
+
     def parse_line(line)
       data = JSON.parse(line.strip)
-      Entry.new(file: data["file"], name: data["name"], time: data["time"])
+      Entry.new(file: data['file'], name: data['name'], time: data['time'])
     rescue JSON::ParserError
       nil
     end

data/lib/binpacker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Binpacker
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/binpacker/worker_queue.rb

@@ -37,7 +37,7 @@ module Binpacker
     end
 
     def total_weight(timings)
-      remaining.sum { |t| timings.fetch(t.key, Timing::DEFAULT_WEIGHT) }
+      remaining.sum(0.0) { |t| timings.fetch(t.key, Timing::DEFAULT_WEIGHT) }
     end
 
     def push(test)

data/sig/binpacker/orchestrator.rbs

@@ -1,6 +1,28 @@
 module Binpacker
   class Orchestrator
+    MIN_BATCH_WEIGHT: Float
+    COLD_START_BATCHES_PER_WORKER: Integer
+
+    @config: untyped
+    @passthrough: untyped
+    @quiet: untyped
+    @report_path: untyped
+    @timings: Hash[untyped, Float]
+    @predicted_loads: Array[Float]
+
     def initialize: (untyped, ?passthrough: untyped, ?quiet: untyped, ?report_path: untyped) -> void
     def run: () -> { passed: untyped, total: untyped, passed_count: untyped, timings: Array[untyped], empty_filter: untyped }
+
+    private
+
+    def discover: () -> untyped
+    def run_static: (untyped, untyped, Binpacker::Timing, untyped) -> untyped
+    def run_dynamic: (untyped, untyped, Binpacker::Timing, untyped, Float) -> untyped
+    def write_report: (untyped, Array[untyped]) -> void
+    def min_batch_weight: (Binpacker::Timing, Hash[untyped, Float]) -> Float
+    def drain_batch: (Binpacker::WorkerQueue?, Float) -> Array[untyped]
+    def finalize: (Binpacker::Timing, Array[untyped], untyped, untyped, untyped, untyped) -> { passed: untyped, total: untyped, passed_count: untyped, timings: Array[untyped], empty_filter: untyped }
+    def minitest_empty_filter?: (untyped, untyped) -> bool
+    def minitest_include_filter?: () -> bool
   end
 end

data/sig/binpacker/timing.rbs

@@ -1,10 +1,16 @@
 module Binpacker
   class Timing
     def initialize: (untyped) -> void
+    DEFAULT_WEIGHT: Float
+    MAX_SAMPLES_PER_TEST: Integer
+    def calibrated?: () -> bool
+    def load_with_fallback: (untyped) -> Hash[untyped, Float]
     def load_raw: () -> (Hash[[String, untyped], untyped] | {})
     def load_per_file: () -> (Hash[String, untyped] | {})
     def normalize_path: (untyped) -> String
     def measured?: (file: untyped, name: untyped) -> bool
+    def compact!: () -> nil
+    def append_all: (untyped) -> nil
     class Entry
     end
   end

data/sig/binpacker/worker_queue.rbs

@@ -2,5 +2,7 @@ module Binpacker
   class WorkerQueue
     def initialize: (untyped, ?untyped) -> void
     def empty?: () -> (false | true)
+    def pop: () -> untyped
+    def total_weight: (Hash[untyped, Float]) -> Float
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: binpacker
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - megurine