vfcsv 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 30c8959e89b63c211bb93b9a3ba56a290688a2fefdd8b8644c57d95b55d2ccfb
+  data.tar.gz: 2e1ff95060b5c3a9ef9edc6187d6546c72a5bb4b5811e480bc542e48ef4540b7
+SHA512:
+  metadata.gz: '0695ec5e9e3e1b92489eb46ef250a62d939d671f113357809cbf88444e3198aa6f244488240cabc941c83f15be8d5578d8be64a5fb99e7ab182dd359ffff274f'
+  data.tar.gz: 5e41903584067f08c8597d5c5358e9ad866b93f2dd11530b870e5db375ebb097f1c207b2b614ce2011339c89785119b7c27c6c46b01737bcff7b3bdc6d65e0e9

data/.tool-versions

@@ -0,0 +1 @@
+ruby 4.0.0

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "csv"  # Not in default gems since Ruby 3.4+
+
+group :development, :test do
+  gem "rake-compiler"
+  gem "rspec"
+  gem "benchmark-ips"
+  gem "minitest"
+end

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    vfcsv (0.1.0)
+      rb_sys (~> 0.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    benchmark-ips (2.14.0)
+    csv (3.3.5)
+    diff-lcs (1.6.2)
+    minitest (5.27.0)
+    rake (13.3.1)
+    rake-compiler (1.3.1)
+      rake
+    rake-compiler-dock (1.11.0)
+    rb_sys (0.9.124)
+      rake-compiler-dock (= 1.11.0)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.7)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
+
+PLATFORMS
+  arm64-darwin-25
+  ruby
+
+DEPENDENCIES
+  benchmark-ips (~> 2.0, >= 0)
+  csv
+  minitest (~> 5.0, >= 0)
+  rake (~> 13.0)
+  rake-compiler (~> 1.2, >= 0)
+  rb_sys (~> 0.9)
+  rspec
+  vfcsv!
+
+CHECKSUMS
+  benchmark-ips (2.14.0) sha256=b72bc8a65d525d5906f8cd94270dccf73452ee3257a32b89fbd6684d3e8a9b1d
+  csv (3.3.5) sha256=6e5134ac3383ef728b7f02725d9872934f523cb40b961479f69cf3afa6c8e73f
+  diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
+  minitest (5.27.0)
+  rake (13.3.1) sha256=8c9e89d09f66a26a01264e7e3480ec0607f0c497a861ef16063604b1b08eb19c
+  rake-compiler (1.3.1) sha256=6b351612b6e2d73ddd5563ee799bb58685176e05363db6758504bd11573d670a
+  rake-compiler-dock (1.11.0) sha256=eab51f2cd533eb35cea6b624a75281f047123e70a64c58b607471bb49428f8c2
+  rb_sys (0.9.124) sha256=513476557b12eaf73764b3da9f8746024558fe8699bda785fb548c9aa3877ae7
+  rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587
+  rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d
+  rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836
+  rspec-mocks (3.13.7) sha256=0979034e64b1d7a838aaaddf12bf065ea4dc40ef3d4c39f01f93ae2c66c62b1c
+  rspec-support (3.13.6) sha256=2e8de3702427eab064c9352fe74488cc12a1bfae887ad8b91cba480ec9f8afb2
+  vfcsv (0.1.0)
+
+BUNDLED WITH
+  4.0.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chris Hasinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,268 @@
+# VFCSV - Very Fast CSV
+
+**The only SIMD-accelerated CSV parser for Ruby with full stdlib API compatibility.**
+
+[![Gem Version](https://badge.fury.io/rb/vfcsv.svg)](https://badge.fury.io/rb/vfcsv)
+
+VFCSV is a drop-in replacement for Ruby's CSV library that delivers 2-6x faster parsing through SIMD acceleration (NEON on ARM64, AVX2 on x86_64), while maintaining 100% API compatibility with Ruby's CSV—including `Row`, `Table`, converters, and all standard options.
+
+## Why VFCSV?
+
+| Library | Speed | Drop-in? | Row/Table | Converters | SIMD | Dependencies |
+|---------|-------|----------|-----------|------------|------|--------------|
+| **VFCSV** | **2-6x** | **✓** | **✓** | **✓** | **✓** | Pure Rust |
+| zsv-ruby | 5-6x | Partial | ✗ | ✗ | ✓ | C (zsv) |
+| OSV | 8x | ✗ | ✗ | ✗ | ✗ | Rust |
+| FastCSV | 1.5x | ✓ | ✓ | ✓ | ✗ | C (Ragel) |
+| FastestCSV | 3x | ✗ | ✗ | ✗ | ✗ | C |
+| CSV (stdlib) | 1x | N/A | ✓ | ✓ | ✗ | None |
+
+**VFCSV is the only library that combines SIMD acceleration with full API compatibility.**
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'vfcsv'
+```
+
+Or install directly:
+
+```bash
+gem install vfcsv
+```
+
+Requires Rust toolchain for compilation. Works on Ruby 3.0+ (optimized for Ruby 4.0).
+
+## Quick Start
+
+```ruby
+# Just replace your require
+require 'vfcsv'  # instead of require 'csv'
+
+# Use exactly like Ruby's CSV
+data = VFCSV.parse("name,age\nAlice,30\nBob,25", headers: true)
+data[0]["name"]  # => "Alice"
+data["age"]      # => ["30", "25"]
+
+# All the same methods work
+VFCSV.read("data.csv")
+VFCSV.foreach("data.csv") { |row| puts row }
+VFCSV.generate { |csv| csv << [1, 2, 3] }
+```
+
+## Performance
+
+Benchmarks on Apple M1 (Ruby 4.0, no YJIT):
+
+| Data Type | CSV stdlib | VFCSV | Speedup |
+|-----------|------------|-------|---------|
+| Simple CSV | 40 MB/s | 90 MB/s | **2.2x** |
+| Quoted CSV | 21 MB/s | 120 MB/s | **5.6x** |
+| With Headers | 10.7 i/s | 27.0 i/s | **2.5x** |
+
+SIMD excels at quote detection, making quoted CSV parsing significantly faster.
+
+```ruby
+# Check your SIMD capabilities
+VFCSV.simd_info
+# => {neon: true, arch: "aarch64", backend: "vfcsv-simd"}
+```
+
+## Full API Compatibility
+
+### Parsing
+
+```ruby
+# Basic parsing
+VFCSV.parse("a,b,c\n1,2,3")
+# => [["a", "b", "c"], ["1", "2", "3"]]
+
+# With headers (returns Table with Row objects)
+table = VFCSV.parse("name,age\nAlice,30", headers: true)
+table.class        # => VFCSV::Table
+table[0].class     # => VFCSV::Row
+table[0]["name"]   # => "Alice"
+table[0][0]        # => "Alice"
+table["name"]      # => ["Alice"]
+
+# Parse single line
+VFCSV.parse_line("a,b,c")  # => ["a", "b", "c"]
+
+# File operations
+VFCSV.read("file.csv")
+VFCSV.foreach("file.csv") { |row| process(row) }
+VFCSV.table("file.csv")  # Shortcut for read with headers
+```
+
+### Converters
+
+```ruby
+# Built-in converters
+VFCSV.parse("a,b\n1,2.5", headers: true, converters: :numeric)
+# => a: 1 (Integer), b: 2.5 (Float)
+
+# Available: :integer, :float, :numeric, :date, :date_time, :all
+
+# Custom converters
+upcase = ->(val) { val.upcase rescue val }
+VFCSV.parse("a\nhello", headers: true, converters: [upcase])
+# => a: "HELLO"
+```
+
+### Header Converters
+
+```ruby
+# Downcase headers
+VFCSV.parse("NAME,AGE\na,1", headers: true, header_converters: :downcase)
+# headers: ["name", "age"]
+
+# Symbol headers
+VFCSV.parse("Name,Age\na,1", headers: true, header_converters: :symbol)
+# headers: [:name, :age]
+# Access: row[:name]
+```
+
+### Row Class
+
+Full `CSV::Row` compatibility:
+
+```ruby
+row = table[0]
+row.headers        # => ["name", "age"]
+row.fields         # => ["Alice", "30"]
+row["name"]        # => "Alice"
+row[0]             # => "Alice"
+row.to_h           # => {"name" => "Alice", "age" => "30"}
+row.to_csv         # => "Alice,30\n"
+row.header?("name") # => true
+row.field?("Alice") # => true
+
+# Mutation
+row["city"] = "NYC"
+row << ["country", "USA"]
+row.delete("country")
+```
+
+### Table Class
+
+Full `CSV::Table` compatibility:
+
+```ruby
+table.headers      # => ["name", "age"]
+table.size         # => 2
+table[0]           # => Row
+table["name"]      # => ["Alice", "Bob"] (column)
+
+# Access modes
+table.by_col["name"]  # Column access
+table.by_row[0]       # Row access
+
+# Mutation
+table << ["Carol", "35"]
+table.delete(0)
+
+# Output
+table.to_csv       # Full CSV string with headers
+table.to_a         # Array of arrays
+```
+
+### Generation
+
+```ruby
+# Generate CSV string
+csv = VFCSV.generate do |out|
+  out << ["name", "age"]
+  out << ["Alice", 30]
+end
+# => "name,age\nAlice,30\n"
+
+# Generate single line
+VFCSV.generate_line([1, 2, 3])          # => "1,2,3\n"
+VFCSV.generate_line([1, 2], col_sep: "|") # => "1|2\n"
+
+# Force quotes
+VFCSV.generate_line([1, 2], force_quotes: true)  # => "\"1\",\"2\"\n"
+
+# Write to file
+VFCSV.open("out.csv", "w") do |csv|
+  csv << [1, 2, 3]
+end
+```
+
+### Options
+
+All standard CSV options are supported:
+
+```ruby
+VFCSV.parse(data,
+  col_sep: ",",           # Column separator
+  row_sep: :auto,         # Row separator (:auto, "\n", "\r\n")
+  quote_char: '"',        # Quote character
+  headers: false,         # First row as headers
+  converters: nil,        # Value converters
+  header_converters: nil, # Header converters
+  skip_blanks: false,     # Skip empty rows
+  skip_lines: nil,        # Regexp to skip lines
+  force_quotes: false,    # Quote all fields on output
+  liberal_parsing: false  # Lenient parsing
+)
+```
+
+## Architecture
+
+VFCSV uses a two-stage SIMD-accelerated parsing approach inspired by simdjson:
+
+1. **Stage 1: Structural Detection** - SIMD instructions process 16 bytes at a time to identify commas, quotes, and newlines
+2. **Stage 2: Field Extraction** - Extract fields based on structural indices with optimized quote handling
+
+The Rust core is wrapped with Magnus for zero-copy Ruby string handling.
+
+```
+┌───────────────────────────────────────────────┐
+│                   Ruby API                    │
+│   VFCSV.parse / Row / Table / Generator       │
+├───────────────────────────────────────────────┤
+│                  Magnus FFI                   │
+├───────────────────────────────────────────────┤
+│               Rust SIMD Parser                │
+│  ┌─────────────┐    ┌───────────────────┐     │
+│  │ NEON (ARM64)│    │ Portable Fallback │     │
+│  └─────────────┘    └───────────────────┘     │
+└───────────────────────────────────────────────┘
+```
+
+## When to Use VFCSV
+
+**Use VFCSV when:**
+- You need faster CSV parsing without changing your code
+- You're processing large CSV files
+- You need full CSV API compatibility (Row, Table, converters)
+- You want SIMD acceleration with zero C dependencies
+
+**Consider alternatives when:**
+- You only need hash output (OSV might be faster)
+- You don't need Row/Table classes (zsv-ruby is comparable speed)
+- You need streaming for files larger than memory
+
+## Running Tests
+
+```bash
+bundle exec rake test    # Run all tests (136 tests)
+bundle exec rake bench   # Run benchmarks
+```
+
+## Contributing
+
+Bug reports and pull requests welcome at https://github.com/khasinski/vfcsv.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.
+
+## Acknowledgments
+
+- Inspired by [simdjson](https://github.com/simdjson/simdjson)'s SIMD parsing techniques
+- Built with [Magnus](https://github.com/matsadler/magnus) for Ruby bindings
+- Benchmarked against [zsv-ruby](https://github.com/sebyx07/zsv-ruby), [OSV](https://github.com/njaremko/osv), and [FastCSV](https://github.com/jpmckinney/fastcsv)

data/Rakefile

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+require "rake/testtask"
+
+RSpec::Core::RakeTask.new(:spec)
+
+# Minitest task for CSV compatibility tests
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/test_*.rb"]
+  t.verbose = true
+end
+
+# Rust extension (via rb_sys)
+Rake::ExtensionTask.new("vfcsv_rust") do |ext|
+  ext.lib_dir = "lib/vfcsv"
+end
+
+task default: %i[compile test]
+
+namespace :bench do
+  desc "Benchmark against stdlib CSV"
+  task :stdlib do
+    ruby "bench/vs_stdlib.rb"
+  end
+
+  desc "Benchmark against all CSV libraries"
+  task :all do
+    ruby "bench/vs_all.rb"
+  end
+end
+
+task bench: "bench:stdlib"

data/bench/run_all_jit.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+set -e
+
+cd "$(dirname "$0")/.."
+
+echo "=================================================="
+echo "VFCSV vs CSV - All JIT Modes Comparison"
+echo "=================================================="
+
+echo ""
+echo "==================== NO JIT ===================="
+bundle exec ruby bench/vs_stdlib.rb
+
+echo ""
+echo "==================== YJIT ===================="
+RUBY_YJIT_ENABLE=1 bundle exec ruby bench/vs_stdlib.rb
+
+echo ""
+echo "==================== ZJIT ===================="
+RUBY_ZJIT_ENABLE=1 bundle exec ruby bench/vs_stdlib.rb

data/bench/vs_competitors.rb

@@ -0,0 +1,253 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Comprehensive benchmark comparing VFCSV against all major CSV libraries
+#
+# Competitors:
+# - csv (stdlib) - Ruby's built-in CSV
+# - fastcsv - Ragel-based, drop-in replacement
+# - fastest-csv - C-based, fastest pure parsing
+# - smarter_csv - Feature-rich, hash output
+# - zsv-ruby - SIMD-accelerated (wraps C zsv library)
+# - osv - Rust-based (wraps csv-rs)
+
+require "bundler/setup"
+require "benchmark/ips"
+require "csv"
+require_relative "../lib/vfcsv"
+
+# Try to load optional competitors
+COMPETITORS = {}
+
+begin
+  require "fastcsv"
+  COMPETITORS[:fastcsv] = true
+rescue LoadError
+  COMPETITORS[:fastcsv] = false
+end
+
+begin
+  require "fastest-csv"
+  COMPETITORS[:fastest_csv] = true
+rescue LoadError
+  COMPETITORS[:fastest_csv] = false
+end
+
+begin
+  require "smarter_csv"
+  COMPETITORS[:smarter_csv] = true
+rescue LoadError
+  COMPETITORS[:smarter_csv] = false
+end
+
+begin
+  require "zsv"
+  COMPETITORS[:zsv] = true
+rescue LoadError
+  COMPETITORS[:zsv] = false
+end
+
+begin
+  require "osv"
+  COMPETITORS[:osv] = true
+rescue LoadError
+  COMPETITORS[:osv] = false
+end
+
+puts "=" * 70
+puts "VFCSV vs All Competitors - Comprehensive Benchmark"
+puts "=" * 70
+puts
+puts "Ruby: #{RUBY_VERSION}"
+puts "YJIT: #{defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled? ? 'enabled' : 'disabled'}"
+puts "VFCSV SIMD: #{VFCSV.simd_info.inspect}"
+puts
+puts "Competitors available:"
+puts "  - csv (stdlib): ✓"
+COMPETITORS.each do |name, available|
+  puts "  - #{name}: #{available ? '✓' : '✗ (not installed)'}"
+end
+puts
+
+# Generate test data
+def generate_csv(rows, cols)
+  header = (1..cols).map { |i| "col#{i}" }.join(",")
+  data = (1..rows).map do |r|
+    (1..cols).map { |c| "value#{r}_#{c}" }.join(",")
+  end.join("\n")
+  "#{header}\n#{data}\n"
+end
+
+def generate_quoted_csv(rows, cols)
+  header = (1..cols).map { |i| "\"col#{i}\"" }.join(",")
+  data = (1..rows).map do |r|
+    (1..cols).map { |c| "\"value #{r}, col #{c}\"" }.join(",")
+  end.join("\n")
+  "#{header}\n#{data}\n"
+end
+
+def generate_numeric_csv(rows, cols)
+  header = (1..cols).map { |i| "col#{i}" }.join(",")
+  data = (1..rows).map do |r|
+    (1..cols).map { |c| (r * c * 1.5).to_s }.join(",")
+  end.join("\n")
+  "#{header}\n#{data}\n"
+end
+
+# Test datasets
+SMALL_CSV = generate_csv(1000, 10)
+MEDIUM_CSV = generate_csv(10_000, 10)
+LARGE_CSV = generate_csv(50_000, 10)
+QUOTED_CSV = generate_quoted_csv(5000, 10)
+NUMERIC_CSV = generate_numeric_csv(5000, 10)
+
+puts "Test data sizes:"
+puts "  Small:   #{SMALL_CSV.bytesize / 1024}KB (1,000 rows x 10 cols)"
+puts "  Medium:  #{MEDIUM_CSV.bytesize / 1024}KB (10,000 rows x 10 cols)"
+puts "  Large:   #{LARGE_CSV.bytesize / 1024}KB (50,000 rows x 10 cols)"
+puts "  Quoted:  #{QUOTED_CSV.bytesize / 1024}KB (5,000 rows x 10 cols, quoted)"
+puts "  Numeric: #{NUMERIC_CSV.bytesize / 1024}KB (5,000 rows x 10 cols, numeric)"
+puts
+
+# Verify correctness first
+puts "-" * 70
+puts "Correctness Check (comparing output to CSV stdlib)"
+puts "-" * 70
+
+csv_result = CSV.parse(SMALL_CSV)
+vfcsv_result = VFCSV.parse(SMALL_CSV)
+puts "VFCSV:       #{csv_result == vfcsv_result ? '✓ PASS' : '✗ FAIL'}"
+
+if COMPETITORS[:fastcsv]
+  fastcsv_result = FastCSV.parse(SMALL_CSV)
+  puts "FastCSV:     #{csv_result == fastcsv_result ? '✓ PASS' : '✗ FAIL'}"
+end
+
+if COMPETITORS[:fastest_csv]
+  fastest_result = FastestCSV.parse(SMALL_CSV)
+  puts "FastestCSV:  #{csv_result == fastest_result ? '✓ PASS' : '✗ FAIL (known - multiline issues)'}"
+end
+
+puts
+
+# Run benchmarks
+[
+  ["Small (1K rows)", SMALL_CSV],
+  ["Medium (10K rows)", MEDIUM_CSV],
+  ["Large (50K rows)", LARGE_CSV],
+  ["Quoted (5K rows)", QUOTED_CSV],
+].each do |name, csv_data|
+  puts "-" * 70
+  puts "Benchmark: #{name}"
+  puts "-" * 70
+
+  Benchmark.ips do |x|
+    x.config(time: 3, warmup: 1)
+
+    x.report("CSV (stdlib)") { CSV.parse(csv_data) }
+    x.report("VFCSV (SIMD)") { VFCSV.parse(csv_data) }
+
+    if COMPETITORS[:fastcsv]
+      x.report("FastCSV") { FastCSV.parse(csv_data) }
+    end
+
+    if COMPETITORS[:fastest_csv]
+      x.report("FastestCSV") { FastestCSV.parse(csv_data) }
+    end
+
+    if COMPETITORS[:zsv]
+      x.report("ZSV") { ZSV.parse(csv_data) }
+    end
+
+    if COMPETITORS[:osv]
+      x.report("OSV") { OSV.for_each(StringIO.new(csv_data), result_type: :array).to_a }
+    end
+
+    x.compare!
+  end
+  puts
+end
+
+# Headers benchmark
+puts "-" * 70
+puts "Benchmark: With Headers (returns hash/Row objects)"
+puts "-" * 70
+
+Benchmark.ips do |x|
+  x.config(time: 3, warmup: 1)
+
+  x.report("CSV (headers)") { CSV.parse(MEDIUM_CSV, headers: true).map(&:to_h) }
+  x.report("VFCSV (headers)") { VFCSV.parse(MEDIUM_CSV, headers: true).map(&:to_h) }
+
+  if COMPETITORS[:fastcsv]
+    x.report("FastCSV (headers)") { FastCSV.parse(MEDIUM_CSV, headers: true).map(&:to_h) }
+  end
+
+  if COMPETITORS[:smarter_csv]
+    x.report("SmarterCSV") { SmarterCSV.parse(MEDIUM_CSV) }
+  end
+
+  if COMPETITORS[:osv]
+    x.report("OSV (hash)") { OSV.for_each(StringIO.new(MEDIUM_CSV), result_type: :hash).to_a }
+  end
+
+  x.compare!
+end
+
+# Throughput summary
+puts
+puts "=" * 70
+puts "THROUGHPUT SUMMARY (MB/s)"
+puts "=" * 70
+
+results = {}
+
+[SMALL_CSV, MEDIUM_CSV, LARGE_CSV].each_with_index do |csv_data, i|
+  size_mb = csv_data.bytesize / 1_000_000.0
+  iterations = [1000, 100, 20][i]  # Adjust based on size
+
+  # CSV stdlib
+  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  iterations.times { CSV.parse(csv_data) }
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  csv_mbs = (size_mb * iterations) / (t1 - t0)
+
+  # VFCSV
+  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  iterations.times { VFCSV.parse(csv_data) }
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  vfcsv_mbs = (size_mb * iterations) / (t1 - t0)
+
+  results[["Small", "Medium", "Large"][i]] = {
+    csv: csv_mbs,
+    vfcsv: vfcsv_mbs,
+    speedup: vfcsv_mbs / csv_mbs
+  }
+end
+
+puts
+puts "| Dataset | CSV (MB/s) | VFCSV (MB/s) | Speedup |"
+puts "|---------|------------|--------------|---------|"
+results.each do |name, data|
+  puts "| #{name.ljust(7)} | #{data[:csv].round(1).to_s.rjust(10)} | #{data[:vfcsv].round(1).to_s.rjust(12)} | #{data[:speedup].round(1)}x     |"
+end
+
+puts
+puts "=" * 70
+puts "FEATURE COMPARISON"
+puts "=" * 70
+puts
+puts "| Feature                    | CSV | VFCSV | FastCSV | FastestCSV | ZSV | OSV |"
+puts "|----------------------------|-----|-------|---------|------------|-----|-----|"
+puts "| Drop-in replacement        | N/A | ✓     | ✓       | ✗          | ~   | ✗   |"
+puts "| SIMD acceleration          | ✗   | ✓     | ✗       | ✗          | ✓   | ✗   |"
+puts "| Row/Table classes          | ✓   | ✓     | ✓       | ✗          | ✗   | ✗   |"
+puts "| Converters (:integer, etc) | ✓   | ✓     | ✓       | ✗          | ✗   | ✗   |"
+puts "| Header converters          | ✓   | ✓     | ✓       | ✗          | ✗   | ✗   |"
+puts "| Multiline fields           | ✓   | ✓     | ✓       | ✗          | ✓   | ✓   |"
+puts "| Quoted fields              | ✓   | ✓     | ✓       | ✓          | ✓   | ✓   |"
+puts "| Custom col_sep             | ✓   | ✓     | ✓       | ✗          | ✓   | ✓   |"
+puts "| Ruby 4.0 compatible        | ✓   | ✓     | ?       | ?          | ?   | ✓   |"
+puts "| Pure Rust/no C deps        | N/A | ✓     | ✗       | ✗          | ✗   | ✓   |"
+puts
+puts "Legend: ✓ = supported, ✗ = not supported, ~ = partial, ? = unknown"