padded_cell 0.1.0

data/lib/padded_cell/pool.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module PaddedCell
+  # Forked workers fed one test at a time over a socket pair. A worker writes
+  # back each Minitest::Result as a length-prefixed Marshal frame.
+  #
+  # Work comes in batches, one per class: a worker takes a whole class, so
+  # per-class setup (fixtures) happens once. When no class is left in the
+  # queue, an idle worker takes the second half of the largest remainder of
+  # another worker's class, so one big class still spreads over all workers.
+  #
+  # With isolation :test a worker forks a Cell per test; with :worker it runs
+  # tests itself, faster but sharing process state. A worker that dies
+  # mid-test, or runs past the timeout, gets its test reported as an error and
+  # is replaced; its replacement continues the class.
+  class Pool
+    Slot = Struct.new(:worker, :pid, :socket, :test, :started, :batch)
+
+    # tests: [[klass, method_name], ...], dispatched by index.
+    def initialize(tests, jobs:, isolation:, seed:, timeout: nil)
+      @tests = tests
+      @jobs = jobs
+      @isolation = isolation
+      @seed = seed
+      @timeout = timeout
+    end
+
+    # Runs batches of test indices in order (consuming them), yielding
+    # (index, result) as results arrive.
+    def run(batches, &on_result)
+      @queue = batches
+      @on_result = on_result
+      @sockets = []
+      Hooks.run_before_fork
+      @slots = Array.new([@jobs, batches.sum(&:size)].min) { spawn(Slot.new(it, nil, nil, nil, nil, [])) }
+      @slots.each { feed(it) }
+      loop do
+        busy = @slots.select(&:test)
+        break if busy.empty?
+
+        ready, = IO.select(busy.map(&:socket), nil, nil, wait_time(busy))
+        ready ? ready.each { |io| receive(busy.find { it.socket == io }) } : expire(busy)
+      end
+    ensure
+      shutdown(force: !$!.nil?)
+    end
+
+    # Dispatch nothing more; tests already running still report.
+    def stop!
+      @queue.clear
+      @slots.each { it.batch.clear }
+    end
+
+    private
+
+    def spawn(slot)
+      parent, child = UNIXSocket.pair
+      $stdout.flush
+      $stderr.flush
+      slot.pid = Process.fork do
+        # A worker holding another worker's socket would keep it from ever
+        # seeing EOF: keep only its own end.
+        [parent, *@sockets].each(&:close)
+        work(slot.worker, child)
+      end
+      child.close
+      @sockets << parent
+      slot.socket = parent
+      slot
+    end
+
+    # The worker process.
+    def work(worker, socket)
+      status = 1
+      begin
+        srand(@seed)
+        setup_error = after_fork(worker)
+        while (line = socket.gets)
+          payload = Results.dump(perform(Integer(line), socket, setup_error))
+          socket.write([payload.bytesize].pack('N'), payload)
+        end
+        Hooks.run_cleanup(worker) unless setup_error
+        status = 0
+      rescue Exception => e # anything: report it, then exit!
+        warn "padded_cell: worker #{worker} failed: #{e.class}: #{e.message}"
+      ensure
+        exit!(status)
+      end
+    end
+
+    # A failing after_fork hook fails every test of the worker, the way Rails
+    # parallel testing reports a broken parallelize_setup.
+    def after_fork(worker)
+      Hooks.run_after_fork(worker)
+      nil
+    rescue StandardError => e
+      e
+    end
+
+    def perform(index, socket, setup_error)
+      klass, name = @tests.fetch(index)
+      if setup_error
+        Results.crashed(klass, name, "after_fork hook failed: #{setup_error.class}: #{setup_error.message}")
+      elsif @isolation == :test
+        Cell.run(klass, name, seed: @seed, timeout: @timeout, close: [socket])
+      else
+        Cell.execute(klass, name)
+      end
+    end
+
+    def feed(slot)
+      slot.batch = @queue.shift || steal if slot.batch.empty?
+      slot.test = slot.batch.shift
+      return unless slot.test
+
+      slot.started = Minitest.clock_time
+      begin
+        slot.socket.puts(slot.test)
+      rescue Errno::EPIPE, Errno::ECONNRESET
+        # The worker died between tests: its replacement gets this one.
+        reap(slot)
+        spawn(slot).socket.puts(slot.test)
+      end
+    end
+
+    # The second half of the largest remainder of another class.
+    def steal
+      victim = @slots.max_by { it.batch.size }
+      victim.batch.pop(victim.batch.size - (victim.batch.size / 2))
+    end
+
+    def receive(slot)
+      header = slot.socket.read(4)
+      return died(slot) unless header&.bytesize == 4
+
+      size = header.unpack1('N')
+      payload = slot.socket.read(size)
+      return died(slot) unless payload&.bytesize == size
+
+      report(slot, Results.load(payload, *@tests.fetch(slot.test)))
+      feed(slot)
+    end
+
+    def report(slot, result)
+      index = slot.test
+      slot.test = nil
+      @on_result.call(index, result)
+    end
+
+    def died(slot)
+      status = reap(slot)
+      replace(slot, Results.describe(status, 'worker'), Minitest.clock_time - slot.started)
+    end
+
+    # Cells time out inside their worker; with :worker isolation the runner
+    # kills the worker itself.
+    def wait_time(busy)
+      return unless @timeout && @isolation == :worker
+
+      deadline = busy.map { it.started + @timeout }.min
+      [deadline - Minitest.clock_time, 0].max
+    end
+
+    def expire(busy)
+      busy.each do |slot|
+        next if Minitest.clock_time - slot.started < @timeout
+
+        Process.kill(:KILL, slot.pid)
+        reap(slot)
+        replace(slot, "timed out after #{@timeout}s", @timeout)
+      end
+    end
+
+    # Reports the running test of a dead worker and starts a new one.
+    def replace(slot, message, time)
+      klass, name = @tests.fetch(slot.test)
+      report(slot, Results.crashed(klass, name, message, time:))
+      return if @queue.empty? && @slots.all? { it.batch.empty? }
+
+      spawn(slot)
+      feed(slot)
+    end
+
+    def reap(slot)
+      @sockets.delete(slot.socket)
+      slot.socket.close
+      _, status = Process.wait2(slot.pid)
+      slot.pid = nil
+      status
+    end
+
+    # Closing a socket tells its worker to finish. On an error in the runner
+    # (Interrupt included) workers are killed instead of awaited.
+    def shutdown(force:)
+      live = Array(@slots).select(&:pid)
+      live.each { Process.kill(:KILL, it.pid) } if force
+      live.each { reap(it) }
+    end
+  end
+end

data/lib/padded_cell/railtie.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PaddedCell
+  # `bin/rails padded_cell` / `rake padded_cell`, with arguments in ARGS:
+  #
+  #   bin/rails padded_cell ARGS="-j 8 test/models"
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      desc 'Run the test suite with padded_cell (arguments in ARGS)'
+      task :padded_cell do
+        require 'padded_cell/cli'
+        require 'shellwords'
+        status = PaddedCell::CLI.start(Shellwords.split(ENV.fetch('ARGS', '')))
+        exit status unless status.zero?
+      end
+    end
+  end
+end

data/lib/padded_cell/reporters.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module PaddedCell
+  # File reporters for CI, next to Minitest's own console output.
+  module Reporters
+    # Collects results, writes them all at the end.
+    class FileReporter < Minitest::AbstractReporter
+      def initialize(path)
+        super()
+        @path = path
+        @results = []
+      end
+
+      def record(result) = @results << result
+
+      def report
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.write(@path, render(@results))
+      end
+
+      private
+
+      def status(result)
+        return :skipped if result.skipped?
+        return :error if result.error?
+
+        result.passed? ? :passed : :failed
+      end
+
+      def file_and_line(result)
+        file, line = result.source_location
+        [relative(file.to_s), line]
+      end
+
+      def relative(file) = file.delete_prefix("#{Dir.pwd}/")
+    end
+
+    # JUnit XML, as read by GitHub, GitLab, Jenkins and friends.
+    class JUnit < FileReporter
+      ESCAPES = { '&' => '&amp;', '<' => '&lt;', '>' => '&gt;', '"' => '&quot;', "'" => '&apos;' }.freeze
+      # XML 1.0 has no place for most control characters.
+      INVALID = /[^\t\n\r -\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}]/
+
+      private
+
+      def render(results)
+        suites = results.group_by(&:klass).map { |klass, cases| suite(klass, cases) }
+        %(<?xml version="1.0" encoding="UTF-8"?>\n<testsuites name="padded_cell" #{counts(results)}>\n) +
+          suites.join + "</testsuites>\n"
+      end
+
+      def suite(klass, results)
+        %(  <testsuite name="#{escape(klass)}" #{counts(results)}>\n) +
+          results.map { testcase(it) }.join + "  </testsuite>\n"
+      end
+
+      def counts(results)
+        statuses = results.map { status(it) }
+        %(tests="#{results.size}" failures="#{statuses.count(:failed)}" errors="#{statuses.count(:error)}" ) +
+          %(skipped="#{statuses.count(:skipped)}" time="#{format('%.6f', results.sum(&:time))}")
+      end
+
+      def testcase(result)
+        file, line = file_and_line(result)
+        attributes = %(classname="#{escape(result.klass)}" name="#{escape(result.name)}" file="#{escape(file)}" ) +
+                     %(line="#{line}" time="#{format('%.6f', result.time)}" assertions="#{result.assertions}")
+        body = outcome(result)
+        body.empty? ? %(    <testcase #{attributes}/>\n) : %(    <testcase #{attributes}>\n#{body}    </testcase>\n)
+      end
+
+      def outcome(result)
+        failure = result.failure
+        case status(result)
+        when :skipped then %(      <skipped message="#{escape(failure.message)}"/>\n)
+        when :error, :failed
+          tag = status(result) == :error ? 'error' : 'failure'
+          type = failure.is_a?(Minitest::UnexpectedError) ? failure.error.class : failure.class
+          %(      <#{tag} type="#{escape(type.to_s)}" message="#{escape(failure.message.lines.first.to_s.strip)}">) +
+            %(#{escape(failure.message)}</#{tag}>\n)
+        else ''
+        end
+      end
+
+      def escape(text) = text.to_s.scrub.gsub(INVALID, '').gsub(/[&<>"']/, ESCAPES)
+    end
+
+    # One JSON object per test, one per line.
+    class JSONLines < FileReporter
+      private
+
+      def render(results) = results.map { "#{JSON.generate(entry(it))}\n" }.join
+
+      def entry(result)
+        file, line = file_and_line(result)
+        {
+          id: "#{result.klass}##{result.name}", class: result.klass, name: result.name, file:, line:,
+          status: status(result), time: result.time, assertions: result.assertions,
+          failures: result.failures.map { { type: it.result_label, message: it.message.scrub } }
+        }
+      end
+    end
+  end
+end

data/lib/padded_cell/results.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module PaddedCell
+  # Raised (in a result, never for real) for a test that did not report:
+  # its process crashed, exited or timed out.
+  class CellCrashed < StandardError; end
+
+  # Minitest::Result helpers.
+  module Results
+    module_function
+
+    # An error result for a test that never reported.
+    def crashed(klass, name, message, time: 0.0)
+      result = Minitest::Result.new(name)
+      result.klass = klass.name
+      result.time = time
+      result.source_location = source_location(klass, name)
+      error = CellCrashed.new(message)
+      error.set_backtrace(["#{result.source_location.join(':')}:in '#{klass}##{name}'"])
+      result.failures = [Minitest::UnexpectedError.new(error)]
+      result
+    end
+
+    # Why a process ended without reporting.
+    def describe(status, process)
+      return "#{process} killed by SIG#{Signal.signame(status.termsig)}" if status.signaled?
+
+      "#{process} exited with status #{status.exitstatus} before reporting"
+    end
+
+    MISSING_CONSTANT = %r{\Aundefined class/module (\S+)\z}
+    # Nesting deeper than this is not a result anyone wrote.
+    PLACEHOLDER_LIMIT = 32
+
+    # A result from a worker or cell, or an error result for klass#name when
+    # it cannot be loaded. Never raises: one bad result must not end the run.
+    #
+    # The sender may have loaded classes after it was forked (an error class
+    # Rails autoloads during a test, a class a test defines): placeholders
+    # named like them stand in during the load, then are removed again, so
+    # the failure keeps its class name, message and backtrace.
+    def load(payload, klass, name)
+      placeholders = []
+      begin
+        Marshal.load(payload) # written by our own worker or cell
+      rescue ArgumentError => e
+        missing = MISSING_CONSTANT.match(e.message)&.[](1)
+        raise unless missing && placeholders.size < PLACEHOLDER_LIMIT && placeholder(missing, placeholders)
+
+        retry
+      end
+    rescue StandardError => e
+      crashed(klass, name, "its result could not be loaded: #{e.class}: #{e.message}")
+    ensure
+      placeholders.reverse_each { |owner, constant| owner.send(:remove_const, constant) }
+    end
+
+    # Defines the first missing constant of path (a module on the way, an
+    # error class at the end). False when path cannot be made to exist.
+    def placeholder(path, placeholders)
+      owner = Object
+      *namespaces, last = path.split('::')
+      namespaces.each do |segment|
+        unless owner.const_defined?(segment, false)
+          owner.const_set(segment, Module.new)
+          return placeholders << [owner, segment]
+        end
+        owner = owner.const_get(segment, false)
+        return false unless owner.is_a?(Module)
+      end
+      return false if owner.const_defined?(last, false)
+
+      owner.const_set(last, Class.new(StandardError))
+      placeholders << [owner, last]
+    end
+
+    # Marshal.dump, after replacing failures that cannot cross a pipe (an
+    # exception holding a Proc, an IO...) with plain copies.
+    def dump(result)
+      Marshal.dump(result)
+    rescue TypeError, ArgumentError
+      result.failures = result.failures.map { portable(it) }
+      result.metadata = {} if result.metadata?
+      Marshal.dump(result)
+    end
+
+    def portable(failure)
+      Marshal.dump(failure)
+      failure
+    rescue TypeError, ArgumentError
+      error = failure.is_a?(Minitest::UnexpectedError) ? failure.error : failure
+      message = "#{error.class}: #{error.message}"
+      copy = case failure
+             when Minitest::UnexpectedError then Minitest::UnexpectedError.new(RuntimeError.new(message))
+             when Minitest::Skip then Minitest::Skip.new(error.message)
+             else Minitest::Assertion.new(message)
+             end
+      (copy.is_a?(Minitest::UnexpectedError) ? copy.error : copy).set_backtrace(error.backtrace || [])
+      copy
+    end
+
+    def source_location(klass, name)
+      klass.instance_method(name).source_location || ['unknown', -1]
+    rescue NameError
+      ['unknown', -1]
+    end
+  end
+end

data/lib/padded_cell/runner.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'etc'
+require 'minitest'
+require_relative '../padded_cell'
+require_relative 'results'
+require_relative 'cell'
+require_relative 'pool'
+require_relative 'loader'
+require_relative 'timings'
+require_relative 'reporters'
+
+module PaddedCell
+  # Running tests needs fork: Windows (and the JVM Rubies) are not supported.
+  class Unsupported < StandardError; end
+
+  # Runs a Minitest suite: select, discover, load once, order, fork, report.
+  class Runner
+    DEFAULTS = {
+      paths: [], jobs: Etc.nprocessors, seed: nil, include: nil, exclude: nil, shard: [0, 1],
+      isolation: nil, timeout: nil, fail_fast: false, verbose: false, show_skips: false,
+      list: false, junit: nil, json: nil, timings: 'tmp/padded_cell/timings.tsv', io: $stdout
+    }.freeze
+
+    attr_reader :options
+
+    def initialize(**options)
+      @options = DEFAULTS.merge(options)
+      @options[:seed] ||= (ENV['SEED'] || Random.new_seed).to_i % 0xFFFF
+    end
+
+    # Exit status: 0 when everything passed, 1 otherwise, 130 on Ctrl-C.
+    def run
+      selection = Selection.parse(options[:paths])
+      refs = Discovery.call(selection.files)
+      return list(selection, refs) if options[:list]
+      raise Unsupported, 'padded_cell needs fork, which this Ruby does not have' unless Process.respond_to?(:fork)
+
+      Loader.call(selection.files, seed: options[:seed])
+      if defined?(ActiveSupport::TestCase)
+        require_relative 'active_support_hooks'
+        ActiveSupportHooks.install
+      end
+      options[:isolation] ||= default_isolation
+      filter = Filter.new(selection, refs, include: options[:include], exclude: options[:exclude])
+      execute(Loader.tests.select { filter.call(*it) })
+    end
+
+    private
+
+    # A fork per test discards Active Record's connection pool, and with it
+    # the fixtures loaded through it: every test would reload them. With
+    # fixtures around, tests share their worker instead.
+    def default_isolation = defined?(ActiveRecord::FixtureSet) ? :worker : :test
+
+    # Tests as they would run (static discovery, no loading), in file order.
+    def list(selection, refs)
+      refs = refs.select { selection.covers?(it.file, it.lines) }
+      kept = Scheduler.batches(refs.map(&:class_name), seed: options[:seed], shard: options[:shard]).flatten.sort
+      kept.each do |index|
+        ref = refs[index]
+        options[:io].puts "#{ref.file.delete_prefix("#{Dir.pwd}/")}:#{ref.start_line} #{ref.id}"
+      end
+      0
+    end
+
+    def execute(tests)
+      ids = tests.map { |klass, name| "#{klass}##{name}" }
+      timings = Timings.load(options[:timings])
+      batches = Scheduler.batches(tests.map { |klass, _| klass.to_s }, durations: ids.map { timings[it] },
+                                                                      seed: options[:seed], shard: options[:shard])
+      reporter = build_reporter
+      reporter.start
+      interrupted = dispatch(tests, batches, reporter) { |index, result| timings[ids[index]] = result.time }
+      reporter.report
+      Timings.save(options[:timings], timings)
+      after_run
+      finish(reporter, interrupted, batches.empty?)
+    end
+
+    # Yields each result after reporting it. True when interrupted.
+    def dispatch(tests, batches, reporter)
+      pool = nil
+      on_result = lambda do |index, result|
+        reporter.prerecord(*tests[index])
+        reporter.record(result)
+        yield index, result
+        pool&.stop! if options[:fail_fast] && !result.passed? && !result.skipped?
+      end
+      pool = Pool.new(tests, jobs: options[:jobs], isolation: options[:isolation], seed: options[:seed],
+                             timeout: options[:timeout])
+      pool.run(batches, &on_result)
+      false
+    rescue Interrupt
+      warn 'Interrupted. Exiting...'
+      true
+    end
+
+    def build_reporter
+      reporter = Minitest::CompositeReporter.new
+      minitest_options = {
+        io: options[:io], seed: options[:seed], args: "--seed #{options[:seed]} --isolation #{options[:isolation]}",
+        verbose: options[:verbose], show_skips: options[:show_skips]
+      }
+      reporter << Minitest::SummaryReporter.new(options[:io], minitest_options)
+      reporter << Minitest::ProgressReporter.new(options[:io], minitest_options)
+      # Plugins (minitest-reporters, Rails...) may add or swap reporters.
+      Minitest.reporter = reporter
+      Minitest.init_plugins(minitest_options)
+      Minitest.reporter = nil
+      reporter << Reporters::JUnit.new(options[:junit]) if options[:junit]
+      reporter << Reporters::JSONLines.new(options[:json]) if options[:json]
+      reporter
+    end
+
+    # Minitest.after_run blocks, which autorun would have called.
+    def after_run
+      Minitest.class_variable_get(:@@after_run).reverse_each(&:call)
+    end
+
+    def finish(reporter, interrupted, nothing_ran)
+      return 130 if interrupted
+      if nothing_ran && options[:include]
+        warn "Nothing ran for filter: #{options[:include]}"
+        return 1
+      end
+
+      reporter.passed? ? 0 : 1
+    end
+  end
+end

data/lib/padded_cell/scheduler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PaddedCell
+  # Deterministic run order: tests grouped by class, shards of whole classes,
+  # seeded shuffle, slowest classes (and tests) first.
+  module Scheduler
+    UNKNOWN = -1.0
+
+    module_function
+
+    # Batches of test indices, one per class, in run order, for one shard.
+    #
+    #   classes:   class name of each test
+    #   durations: seconds per test (nil when unknown)
+    #   shard:     [index, count], 0-based
+    def batches(classes, durations: Array.new(classes.size), seed: 0, shard: [0, 1])
+      index, count = shard
+      PaddedCellNative.plan(classes, durations.map { it || UNKNOWN }, seed, index, count)
+    end
+  end
+end

data/lib/padded_cell/selection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module PaddedCell
+  # What to run, from command line arguments, the way `rails test` reads them:
+  #
+  #   (none)                  test/**/*_test.rb, minus test/{system,dummy,fixtures}
+  #   test/models             every *_test.rb below it
+  #   test/models/a_test.rb   that file
+  #   a_test.rb:12            the test whose definition spans line 12
+  #   a_test.rb:12-20:31      tests overlapping 12..20, or spanning 31
+  #   'test/**/*_x_test.rb'   a glob
+  class Selection
+    DEFAULT_GLOB = 'test/**/*_test.rb'
+    DEFAULT_EXCLUDE = 'test/{system,dummy,fixtures}/**/*_test.rb'
+    LINES = /(?::\d+(?:-\d+)?)+\z/
+
+    # Absolute paths, sorted.
+    attr_reader :files
+
+    def self.parse(args, root: Dir.pwd) = new(args, root)
+
+    def initialize(args, root)
+      @root = root
+      @lines = Hash.new { |hash, file| hash[file] = [] }
+      @files = (args.empty? ? defaults : args.flat_map { expand(it) }).uniq.sort
+    end
+
+    # Line ranges asked for each file; empty when the whole file runs.
+    def lines_for(file) = @lines.fetch(file, [])
+
+    def line_filtered? = @lines.any?
+
+    # Whether a test defined in file over lines is selected by line.
+    def covers?(file, lines)
+      ranges = lines_for(file)
+      ranges.empty? || ranges.any? { it.begin <= lines.end && lines.begin <= it.end }
+    end
+
+    private
+
+    def defaults
+      Dir.glob(DEFAULT_GLOB, base: @root).map { absolute(it) } -
+        Dir.glob(DEFAULT_EXCLUDE, base: @root).map { absolute(it) }
+    end
+
+    def expand(arg)
+      if (match = LINES.match(arg))
+        file = existing_file(match.pre_match, arg)
+        @lines[file].concat(ranges(match[0]))
+        [file]
+      elsif glob?(arg)
+        Dir.glob(arg, base: @root).map { absolute(it) }
+      elsif File.directory?(absolute(arg))
+        Dir.glob('**/*_test.rb', base: absolute(arg)).map { File.join(absolute(arg), it) }
+      else
+        [existing_file(arg, arg)]
+      end
+    end
+
+    def ranges(spec)
+      spec.delete_prefix(':').split(':').map do |part|
+        first, last = part.split('-').map { Integer(it, 10) }
+        first..(last || first)
+      end
+    end
+
+    def existing_file(path, arg)
+      file = absolute(path)
+      raise ArgumentError, "no such test file: #{arg}" unless File.file?(file)
+
+      file
+    end
+
+    def glob?(arg) = arg.match?(/[*?\[{]/)
+
+    def absolute(path) = File.expand_path(path, @root)
+  end
+end

data/lib/padded_cell/timings.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module PaddedCell
+  # Seconds per test id from earlier runs, kept as "id<TAB>seconds" lines.
+  # The scheduler starts the slowest tests first.
+  module Timings
+    module_function
+
+    def load(path)
+      return {} unless path && File.file?(path)
+
+      File.foreach(path, chomp: true).to_h do |line|
+        id, seconds = line.split("\t", 2)
+        [id, Float(seconds)]
+      end
+    end
+
+    # Replaces the file atomically.
+    def save(path, timings)
+      return unless path
+
+      FileUtils.mkdir_p(File.dirname(path))
+      temp = "#{path}.#{Process.pid}"
+      File.write(temp, timings.sort.map { |id, seconds| "#{id}\t#{seconds}\n" }.join)
+      File.rename(temp, path)
+    end
+  end
+end