xlsxrb 0.1.4 → 0.1.6

data/benchmark.rb

@@ -1,400 +1,376 @@
 # frozen_string_literal: true
+# rubocop:disable all
 
-ENV["GEM_HOME"] = File.expand_path("tmp/vendor/bundle", __dir__)
-ENV["GEM_PATH"] = ENV.fetch("GEM_HOME", nil)
-
+require "json"
+require "open3"
+require "fileutils"
 require "bundler/inline"
 
-gemfile do
+puts "Ensuring benchmark peer ecosystem gems are available (bundler/inline)..."
+gemfile(true) do
   source "https://rubygems.org"
-  gem "benchmark", "0.5.0"
-  gem "rexml", "3.4.4"
-  gem "zlib", "3.2.3"
+  gem "caxlsx", "4.5.0"
   gem "xlsxtream", "3.1.0"
-  gem "caxlsx", "4.4.2"
-  gem "rubyXL", "3.4.35"
-  gem "fast_excel", "0.5.0"
+  gem "fast_excel", "0.5.0", platform: :mri
+  gem "rubyXL", "3.4.38"
   gem "roo", "3.0.0"
   gem "creek", "2.6.3"
-  gem "csv", "3.3.2"
-  gem "xsv", "1.4.0"
-  gem "base64", "0.2.0"
-  gem "opentelemetry-sdk", "1.11.0"
+  gem "xsv", "1.4.1"
 end
 
-require "json"
-require "benchmark"
-require "fileutils"
-require "objspace"
-require_relative "lib/xlsxrb"
-
-args = ARGV.dup
-KEEP_FILES = args.delete("--keep-files")
-
-ROWS = (args[0] || 10_000).to_i
-COLS = 10
-ITERATIONS = 5
-READ_TEST_FILE = "tmp/benchmark_read_test.xlsx"
-
-OUTPUT_FILES = {
-  "xlsxrb (Streaming)" => "tmp/write_xlsxrb_stream.xlsx",
-  "xlsxrb (In-Memory)" => "tmp/write_xlsxrb_mem.xlsx",
-  "caxlsx (In-Memory)" => "tmp/write_caxlsx.xlsx",
-  "xlsxtream (Streaming)" => "tmp/write_xlsxtream.xlsx",
-  "fast_excel (Streaming)" => "tmp/write_fast_excel.xlsx",
-  "rubyXL (In-Memory)" => "tmp/write_rubyXL.xlsx",
-  "Read source file" => READ_TEST_FILE
-}.freeze
-
-puts "Target: #{ROWS} rows x #{COLS} columns (#{ROWS * COLS} cells)"
-puts "Iterations: #{ITERATIONS}"
-puts "Keep generated files: #{KEEP_FILES ? "yes" : "no"}"
-puts "Preparing test file for read benchmarks..."
-
-# Prepare test file for read benchmarks
-Xlsxrb.generate(READ_TEST_FILE) do |w|
-  w.add_sheet("Test") do |s|
-    ROWS.times do |r|
-      row_data = Array.new(COLS) { |c| (r * COLS) + c }
-      s.add_row(row_data)
+RUNS = (ENV["RUNS"] || "3").to_i
+ROWS = (ARGV[0] || "100000").to_i
+COLS = (ARGV[1] || "10").to_i
+
+AVAILABLE_GEMS = {
+  "xlsxrb_stream" => true,
+  "xlsxrb_inmemory" => true,
+  "xlsxtream" => true,
+  "fast_excel" => true,
+  "caxlsx" => true,
+  "rubyXL" => true,
+  "creek" => true,
+  "roo" => true,
+  "xsv" => true
+}
+
+puts "=" * 80
+puts "Benchmarking Excel Libraries (#{ROWS} rows x #{COLS} cols = #{ROWS * COLS} cells)"
+puts "Runs per benchmark: #{RUNS} (Median reported, Mean calculated)"
+puts "Ruby: #{RUBY_DESCRIPTION}"
+puts "=" * 80
+
+RUNNER_SCRIPT = <<~'RUBY'
+  require "json"
+  require "stringio"
+
+  def measure
+    gc_before = GC.stat[:count]
+    t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    
+    yield
+    
+    t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    gc_after = GC.stat[:count]
+    
+    # Peak memory in MB via /proc/self/status or getrusage
+    peak_mb = 0.0
+    if File.exist?("/proc/self/status")
+      status = File.read("/proc/self/status")
+      if status =~ /VmHWM:\s+(\d+)\s+kB/i
+        peak_mb = $1.to_f / 1024.0
+      elsif status =~ /VmRSS:\s+(\d+)\s+kB/i
+        peak_mb = $1.to_f / 1024.0
+      end
     end
+    
+    {
+      time: (t1 - t0),
+      peak_memory_mb: peak_mb,
+      gc_count: (gc_after - gc_before)
+    }
   end
-end
 
-def run_in_subprocess(_name, &block)
-  File.write("tmp/bench_task.rb", <<~RUBY)
-    ENV['BUNDLE_GEMFILE'] = ''
-    ENV['BUNDLE_IGNORE_CONFIG'] = '1'
-    ENV['GEM_HOME'] = File.expand_path('tmp/vendor/bundle', __dir__)
-    ENV['GEM_PATH'] = ENV['GEM_HOME']
-
-    require 'bundler/inline'
-    gemfile do
-      source 'https://rubygems.org'
-      gem 'benchmark', '0.5.0'
-      gem 'rexml', '3.4.4'
-      gem 'zlib', '3.2.3'
-      gem 'xlsxtream', '3.1.0'
-      gem 'caxlsx', '4.4.2'
-      gem 'rubyXL', '3.4.35'
-      gem 'fast_excel', '0.5.0'
-      gem 'roo', '3.0.0'
-      gem 'creek', '2.6.3'
-      gem 'csv', '3.3.2'
-      gem 'xsv', '1.4.0'
-      gem 'base64', '0.2.0'
-      gem 'opentelemetry-sdk', '1.11.0'
+  def generate_row(r, cols)
+    base = [r + 1, "User #{r + 1}", 123.45, true, "Active", (r + 1) * 10, "Tokyo", 99.9, false, "Item #{r % 50}"]
+    if cols <= base.size
+      base.first(cols)
+    else
+      base + Array.new(cols - base.size) { |c| "col_#{c}_#{r}" }
     end
-    require 'csv'
-    require 'base64'
-    require 'json'
-    require 'benchmark'
-    require 'opentelemetry/sdk'
-    require_relative '../lib/xlsxrb'
-
-    ROWS = #{ROWS}
-    COLS = 10
-    READ_TEST_FILE = "tmp/benchmark_read_test.xlsx"
-
-    def get_io_stats
-      return { rchar: 0, wchar: 0, read_bytes: 0, write_bytes: 0 } unless File.exist?('/proc/self/io')
+  end
 
-      stats = {}
-      File.readlines('/proc/self/io').each do |line|
-        key, value = line.split(':')
-        stats[key.strip.to_sym] = value.to_i if key && value
+  lib = ARGV[0]
+  mode = ARGV[1] # "write" or "read"
+  rows = ARGV[2].to_i
+  cols = ARGV[3].to_i
+  filename = ARGV[4]
+
+  result = case [lib, mode]
+  when ["xlsxtream", "write"]
+    require "xlsxtream"
+    measure do
+      Xlsxtream::Workbook.open(filename) do |wb|
+        wb.write_worksheet("Data") do |sheet|
+          rows.times do |r|
+            sheet << generate_row(r, cols)
+          end
+        end
       end
-      stats
     end
-
-    class BenchmarkSpanProcessor < OpenTelemetry::SDK::Trace::SpanProcessor
-      def on_start(span, _parent_context)
-        return unless span.name == 'benchmark_task'
-    #{"    "}
-        span.set_attribute('bench.gc.count.start', GC.stat[:count])
-        span.set_attribute('bench.alloc.objects.start', GC.stat[:total_allocated_objects])
-        span.set_attribute('bench.time.start', Process.clock_gettime(Process::CLOCK_MONOTONIC))
-        span.set_attribute('bench.cpu.utime.start', Process.times.utime)
-        span.set_attribute('bench.cpu.stime.start', Process.times.stime)
-        @io_start = get_io_stats
-    #{"    "}
-        @max_mem_mb = 0.0
-        @watcher = Thread.new do
-          loop do
-            mem = `ps -o rss= -p \#{Process.pid}`.to_f / 1024.0
-            @max_mem_mb = mem if mem > @max_mem_mb
-            sleep 0.05
+  when ["fast_excel", "write"]
+    require "fast_excel"
+    measure do
+      wb = FastExcel.open(filename)
+      sheet = wb.add_worksheet("Data")
+      rows.times do |r|
+        sheet.append_row(generate_row(r, cols))
+      end
+      wb.close
+    end
+  when ["caxlsx", "write"]
+    require "caxlsx"
+    measure do
+      p = Axlsx::Package.new
+      wb = p.workbook
+      wb.add_worksheet(name: "Data") do |sheet|
+        rows.times do |r|
+          sheet.add_row(generate_row(r, cols))
+        end
+      end
+      p.serialize(filename)
+    end
+  when ["rubyXL", "write"]
+    require "rubyXL"
+    measure do
+      wb = RubyXL::Workbook.new
+      sheet = wb[0]
+      sheet.sheet_name = "Data"
+      rows.times do |r|
+        row_data = generate_row(r, cols)
+        row_data.each_with_index do |val, c|
+          sheet.add_cell(r, c, val)
+        end
+      end
+      wb.write(filename)
+    end
+  when ["xlsxrb_stream", "write"]
+    require_relative "lib/xlsxrb"
+    measure do
+      Xlsxrb.generate(filename) do |wb|
+        wb.sheet("Data") do |sheet|
+          rows.times do |r|
+            sheet.row(generate_row(r, cols))
           end
         end
       end
-
-      def on_finish(span)
-        return unless span.name == 'benchmark_task'
-    #{"    "}
-        @watcher.kill
-        mem = `ps -o rss= -p \#{Process.pid}`.to_f / 1024.0
-        @max_mem_mb = mem if mem > @max_mem_mb
-
-        gc_start = span.attributes['bench.gc.count.start']
-        alloc_start = span.attributes['bench.alloc.objects.start']
-        time_start = span.attributes['bench.time.start']
-        utime_start = span.attributes['bench.cpu.utime.start']
-        stime_start = span.attributes['bench.cpu.stime.start']
-        io_end = get_io_stats
-    #{"    "}
-        gc_diff = GC.stat[:count] - gc_start
-        alloc_diff = GC.stat[:total_allocated_objects] - alloc_start
-
-        written_bytes = io_end[:wchar] - @io_start[:wchar]
-        read_bytes = io_end[:rchar] - @io_start[:rchar]
-
-        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        end_times = Process.times
-
-        elapsed = end_time - time_start
-        cpu_time = (end_times.utime - utime_start) + (end_times.stime - stime_start)
-        cpu_percent = elapsed > 0 ? (cpu_time / elapsed) * 100 : 0.0
-
-        puts JSON.dump({
-          time: elapsed,
-          cpu: cpu_percent,
-          memory: @max_mem_mb,
-          gc_count: gc_diff,
-          alloc_objects: alloc_diff,
-          rchar: read_bytes,
-          wchar: written_bytes
-        })
+    end
+  when ["xlsxrb_inmemory", "write"]
+    require_relative "lib/xlsxrb"
+    measure do
+      wb = Xlsxrb.build do |b|
+        b.sheet("Data") do |s|
+          rows.times do |r|
+            s.row(generate_row(r, cols))
+          end
+        end
       end
+      Xlsxrb.write(filename, wb)
     end
-
-    OpenTelemetry::SDK.configure do |c|
-      c.add_span_processor(BenchmarkSpanProcessor.new)
+  when ["xlsxrb_stream", "read"]
+    require_relative "lib/xlsxrb"
+    measure do
+      count = 0
+      Xlsxrb.foreach(filename) do |sheet|
+        sheet.each do |row|
+          row.cells.each do |cell|
+            _val = cell.value
+            count += 1
+          end
+        end
+      end
     end
-
-    tracer = OpenTelemetry.tracer_provider.tracer('benchmark')
-    GC.start
-
-    tracer.in_span('benchmark_task') do
-      # --- TASK START ---
-      #{block.call}
-      # --- TASK END ---
+  when ["xlsxrb_inmemory", "read"]
+    require_relative "lib/xlsxrb"
+    measure do
+      wb = Xlsxrb.read(filename)
+      count = 0
+      wb.sheets.each do |sheet|
+        sheet.rows.each do |row|
+          row.cells.each do |cell|
+            _val = cell.value
+            count += 1
+          end
+        end
+      end
     end
-  RUBY
-
-  output = Bundler.with_unbundled_env do
-    `ruby tmp/bench_task.rb 2>/dev/null`
-  end
-  begin
-    JSON.parse(output, symbolize_names: true)
-  rescue StandardError => e
-    puts "Error: #{e.message} with output: #{output.inspect}"
-    nil
-  end
-end
-
-def median(array)
-  return 0.0 if array.empty?
-
-  sorted = array.sort
-  len = sorted.length
-  (sorted[(len - 1) / 2] + sorted[len / 2]) / 2.0
-end
-
-def run_benchmark(name, snippet)
-  print format("%-25s", name)
-  results = ITERATIONS.times.map do
-    print "."
-    run_in_subprocess(name) { snippet }
-  end
-  puts
-
-  valid_results = results.compact
-
-  median_time = median(valid_results.map { |r| r[:time] }.compact)
-  median_cpu = median(valid_results.map { |r| r[:cpu] }.compact)
-  median_mem = median(valid_results.map { |r| r[:memory] }.compact)
-  median_gc = median(valid_results.map { |r| r[:gc_count] }.compact)
-  median_alloc = median(valid_results.map { |r| r[:alloc_objects] }.compact)
-  median_wchar = median(valid_results.map { |r| r[:wchar] }.compact)
-  median_rchar = median(valid_results.map { |r| r[:rchar] }.compact)
-
-  {
-    name: name,
-    time: median_time,
-    cpu: median_cpu,
-    memory: median_mem,
-    gc_count: median_gc,
-    alloc_m: median_alloc / 1_000_000.0,
-    wchar_mb: median_wchar / 1_048_576.0,
-    rchar_mb: median_rchar / 1_048_576.0
-  }
-end
-
-def format_row(result)
-  format("| %-25<name>s | %8.2<time>f s | %9.1<memory>f MB | %8.1<gc_count>f |", result)
-end
-
-puts "\n--- Write Benchmarks ---"
-write_results = []
-
-write_results << run_benchmark("xlsxrb (Streaming)", <<~RUBY
-  Xlsxrb.generate("tmp/write_xlsxrb_stream.xlsx") do |writer|
-    writer.add_sheet("Sheet1") do |sheet|
-      ROWS.times do |r|
-        row_data = Array.new(COLS) { |c| r * COLS + c }
-        sheet.add_row(row_data)
+  when ["creek", "read"]
+    require "creek"
+    measure do
+      creek = Creek::Book.new(filename)
+      count = 0
+      creek.sheets.each do |sheet|
+        sheet.rows.each do |row|
+          row.each_value do |_val|
+            count += 1
+          end
+        end
       end
     end
-  end
-RUBY
-)
-
-write_results << run_benchmark("xlsxrb (In-Memory)", <<~RUBY
-  workbook = Xlsxrb.build do |w|
-    w.add_sheet("Sheet1") do |sheet|
-      ROWS.times do |r|
-        row_data = Array.new(COLS) { |c| r * COLS + c }
-        sheet.add_row(row_data)
+  when ["roo", "read"]
+    require "roo"
+    measure do
+      xlsx = Roo::Excelx.new(filename)
+      count = 0
+      xlsx.each_row_streaming do |row|
+        row.each do |cell|
+          _val = cell&.value
+          count += 1
+        end
       end
     end
-  end
-  Xlsxrb.write("tmp/write_xlsxrb_mem.xlsx", workbook)
-RUBY
-)
-
-write_results << run_benchmark("caxlsx (In-Memory)", <<~RUBY
-  begin
-    p = Axlsx::Package.new
-    sheet = p.workbook.add_worksheet(name: "Sheet1")
-    ROWS.times do |r|
-      sheet.add_row(Array.new(COLS) { |c| r * COLS + c })
+  when ["xsv", "read"]
+    require "xsv"
+    measure do
+      x = Xsv.open(filename)
+      count = 0
+      x.sheets.each do |sheet|
+        sheet.each do |row|
+          row.each do |_val|
+            count += 1
+          end
+        end
+      end
     end
-    p.serialize("tmp/write_caxlsx.xlsx")
-  rescue Zlib::BufError => e
-    File.write("tmp/write_caxlsx.xlsx", "")
-  end
-RUBY
-)
-
-write_results << run_benchmark("xlsxtream (Streaming)", <<~RUBY
-  begin
-    Xlsxtream::Workbook.open("tmp/write_xlsxtream.xlsx") do |workbook|
-      workbook.write_worksheet("Sheet1") do |sheet|
-        ROWS.times do |r|
-          sheet << Array.new(COLS) { |c| r * COLS + c }
+  when ["rubyXL", "read"]
+    require "rubyXL"
+    measure do
+      wb = RubyXL::Parser.parse(filename)
+      count = 0
+      wb.worksheets.each do |sheet|
+        sheet.each do |row|
+          next unless row
+          row.cells.each do |cell|
+            _val = cell&.value
+            count += 1
+          end
         end
       end
     end
-  rescue Zlib::BufError => e
-    File.write("tmp/write_xlsxtream.xlsx", "")
+  else
+    raise "Unknown benchmark target: #{lib} #{mode}"
   end
-RUBY
-)
-
-write_results << run_benchmark("fast_excel (Streaming)", <<~RUBY
-  File.delete("tmp/write_fast_excel.xlsx") if File.exist?("tmp/write_fast_excel.xlsx")
-  workbook = FastExcel.open("tmp/write_fast_excel.xlsx", constant_memory: true)
-  sheet = workbook.add_worksheet("Sheet1")
-  ROWS.times do |r|
-    sheet.append_row(Array.new(COLS) { |c| r * COLS + c })
-  end
-  workbook.close
-RUBY
-)
 
-write_results << run_benchmark("rubyXL (In-Memory)", <<~RUBY
-  workbook = RubyXL::Workbook.new
-  sheet = workbook.worksheets[0]
-  ROWS.times do |r|
-    COLS.times do |c|
-      sheet.add_cell(r, c, r * COLS + c)
-    end
-  end
-  workbook.write("tmp/write_rubyXL.xlsx")
+  puts result.to_json
 RUBY
-)
 
-puts "\n--- Read Benchmarks ---"
-read_results = []
+runner_file = "benchmark_runner.rb"
+File.write(runner_file, RUNNER_SCRIPT)
 
-read_results << run_benchmark("xlsxrb (Streaming)", <<~RUBY
-  count = 0
-  Xlsxrb.foreach(READ_TEST_FILE) do |row|
-    count += row.cells.size
+def run_isolated(lib, mode, rows, cols, filename)
+  cmd = ["ruby", "-Ilib", "benchmark_runner.rb", lib, mode, rows.to_s, cols.to_s, filename]
+  stdout, stderr, status = Bundler.with_unbundled_env do
+    Open3.capture3(*cmd)
   end
-RUBY
-)
-
-read_results << run_benchmark("xlsxrb (In-Memory)", <<~RUBY
-  workbook = Xlsxrb.read(READ_TEST_FILE)
-  count = 0
-  workbook.sheets[0].rows.each do |row|
-    count += row.cells.size
+  unless status.success?
+    warn "Failed to run #{lib} #{mode}: #{stderr}"
+    return nil
   end
-RUBY
-)
+  JSON.parse(stdout.strip, symbolize_names: true)
+end
 
-read_results << run_benchmark("creek (Streaming)", <<~RUBY
-  creek = Creek::Book.new(READ_TEST_FILE)
-  sheet = creek.sheets[0]
-  count = 0
-  sheet.simple_rows.each do |row|
-    count += row.size
+def run_benchmark_series(name, lib, mode, rows, cols, filename, runs)
+  unless AVAILABLE_GEMS[lib]
+    puts "Skipping #{name} (gem not installed)"
+    return nil
   end
-RUBY
-)
 
-read_results << run_benchmark("roo (Streaming)", <<~RUBY
-  xlsx = Roo::Excelx.new(READ_TEST_FILE)
-  count = 0
-  xlsx.each_row_streaming do |row|
-    count += row.size
+  print "Running #{name} (#{runs} runs)... "
+  $stdout.flush
+  results = []
+  runs.times do |_i|
+    File.delete(filename) if File.exist?(filename) && mode == "write"
+    res = run_isolated(lib, mode, rows, cols, filename)
+    if res
+      results << res
+      print "#{res[:time].round(2)}s "
+      $stdout.flush
+    else
+      print "ERR "
+      $stdout.flush
+    end
   end
-RUBY
-)
+  puts
 
-read_results << run_benchmark("rubyXL (In-Memory)", <<~RUBY
-  workbook = RubyXL::Parser.parse(READ_TEST_FILE)
-  count = 0
-  workbook.worksheets[0].each do |row|
-    count += row.cells.size if row
-  end
-RUBY
-)
+  return nil if results.empty?
 
-read_results << run_benchmark("xsv (Streaming)", <<~RUBY
-  workbook = Xsv.open(READ_TEST_FILE)
-  count = 0
-  workbook[0].each do |row|
-    count += row.size
-  end
-RUBY
-)
+  times = results.map { |r| r[:time] }.sort
+  mems = results.map { |r| r[:peak_memory_mb] }.sort
+  gcs = results.map { |r| r[:gc_count] }.sort
 
-# Print markdown tables
-puts "\n\n### Write Performance (#{ROWS * COLS} cells)"
-puts "| Library                   | Time       | Peak Memory  | GC Count |"
-puts "|---------------------------|------------|--------------|----------|"
-write_results.sort_by { |r| r[:time] }.each { |r| puts format_row(r) }
+  median_time = times[times.size / 2]
+  mean_time = times.sum / times.size
+  median_mem = mems[mems.size / 2]
+  median_gc = gcs[gcs.size / 2]
 
-puts "\n### Read Performance (#{ROWS * COLS} cells)"
-puts "| Library                   | Time       | Peak Memory  | GC Count |"
-puts "|---------------------------|------------|--------------|----------|"
-read_results.sort_by { |r| r[:time] }.each { |r| puts format_row(r) }
+  {
+    name: name,
+    median_time: median_time,
+    mean_time: mean_time,
+    median_mem: median_mem,
+    median_gc: median_gc
+  }
+end
+
+# 1. Generate a standard reference file for reading benchmarks
+ref_file = "bench_reference_data.xlsx"
+puts "\n[Setup] Generating reference file (#{ROWS} x #{COLS}) for read benchmarks..."
+run_isolated("xlsxrb_stream", "write", ROWS, COLS, ref_file)
+
+# 2. Benchmark Write
+puts "\n=== Benchmarking Write Performance ==="
+write_targets = [
+  ["xlsxtream 3.1.0", "xlsxtream", "Streaming", "Inline String"],
+  ["xlsxrb (Streaming)", "xlsxrb_stream", "Streaming", "SST (Shared)"],
+  ["fast_excel 0.5.0 (C)", "fast_excel", "Streaming", "SST (Shared)"],
+  ["caxlsx 4.5.0", "caxlsx", "In-Memory", "Inline String"],
+  ["xlsxrb (In-Memory)", "xlsxrb_inmemory", "In-Memory", "SST (Shared)"],
+  ["rubyXL 3.4.38", "rubyXL", "In-Memory", "Inline String"]
+]
+
+write_results = []
+write_targets.each do |name, lib, model, storage|
+  target_file = "bench_write_#{lib}.xlsx"
+  res = run_benchmark_series(name, lib, "write", ROWS, COLS, target_file, RUNS)
+  if res
+    res[:model] = model
+    res[:storage] = storage
+    write_results << res
+  end
+  FileUtils.rm_f(target_file)
+end
 
-puts "\n### Generated Files"
-puts "| Producer                  | File path                     | Status   |"
-puts "|---------------------------|-------------------------------|----------|"
-OUTPUT_FILES.each do |name, path|
-  status = File.exist?(path) ? "exists" : "missing"
-  puts format("| %-25<name>s | %-29<path>s | %-8<status>s |", name: name, path: path, status: status)
+# 3. Benchmark Read
+puts "\n=== Benchmarking Read Performance ==="
+read_targets = [
+  ["xlsxrb (Streaming)", "xlsxrb_stream", "Streaming"],
+  ["xlsxrb (In-Memory)", "xlsxrb_inmemory", "In-Memory"],
+  ["creek 2.6.3", "creek", "Streaming"],
+  ["roo 3.0.0", "roo", "Streaming"],
+  ["xsv 1.4.1", "xsv", "Streaming"],
+  ["rubyXL 3.4.38", "rubyXL", "In-Memory"]
+]
+
+read_results = []
+read_targets.each do |name, lib, model|
+  res = run_benchmark_series(name, lib, "read", ROWS, COLS, ref_file, RUNS)
+  if res
+    res[:model] = model
+    read_results << res
+  end
 end
 
 # Cleanup
-if KEEP_FILES
-  puts "\nKeeping generated files because --keep-files was specified."
-else
-  Dir.glob("tmp/write_*.xlsx").each { |f| FileUtils.rm(f) }
-  FileUtils.rm(READ_TEST_FILE)
+FileUtils.rm_f(ref_file)
+FileUtils.rm_f(runner_file)
+
+# Print Tables
+puts "\n" + ("=" * 80)
+puts "### Write Performance (#{ROWS * COLS} cells: #{ROWS} rows x #{COLS} cols)"
+puts ""
+puts "| Library                | Model       | Write String Storage | Time (Median) | Time (Mean) | Peak Memory | GC Count |"
+puts "| ---------------------- | ----------- | -------------------- | ------------- | ----------- | ----------- | -------- |"
+write_results.sort_by { |r| r[:median_time] }.each do |r|
+  printf "| %-22s | %-11s | %-20s | %6.2f s      | %6.2f s    | %7.1f MB  | %6.1f   |\n",
+         r[:name], r[:model], r[:storage], r[:median_time], r[:mean_time], r[:median_mem], r[:median_gc]
+end
+
+puts "\n### Read Performance (#{ROWS * COLS} cells: #{ROWS} rows x #{COLS} cols)"
+puts ""
+puts "| Library                | Model       | Time (Median) | Time (Mean) | Peak Memory | GC Count |"
+puts "| ---------------------- | ----------- | ------------- | ----------- | ----------- | -------- |"
+read_results.sort_by { |r| r[:median_time] }.each do |r|
+  printf "| %-22s | %-11s | %6.2f s      | %6.2f s    | %7.1f MB  | %6.1f   |\n",
+         r[:name], r[:model], r[:median_time], r[:mean_time], r[:median_mem], r[:median_gc]
 end
-FileUtils.rm_f("tmp/bench_task.rb")
+puts "=" * 80