run bench on CI with generated CSV

.github/workflows/bench.yaml

@@ -0,0 +1,25 @@
+name: Run Benchmarks
+on: pull_request
+
+jobs:
+  benchmark:
+    name: Benchmark
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo install cargo-criterion
+      - run: cargo criterion --output-format bencher 2>&1 | tee output.txt
+      - uses: benchmark-action/github-action-benchmark@v1
+        with:
+          name: Rust Benchmark
+          tool: "cargo"
+          output-file-path: output.txt
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          alert-threshold: "120%"
+          comment-always: true
+          fail-on-alert: true
+          gh-pages-branch: main
+          skip-fetch-gh-pages: true
+          save-data-file: false

Cargo.toml

@@ -10,7 +10,7 @@ thiserror = { version = "2.0.11", default-features = false }
 [dev-dependencies]
 criterion = "0.5.1"
 csv = "1.3.1"
-memmap2 = "0.9.5"
+rand = "0.8.5"
 
 [[bench]]
 name = "single_thread"

benches/single_thread.rs

@@ -1,20 +1,42 @@
-use std::{fs::File, hint::black_box, io::Cursor};
+use std::{hint::black_box, io::Cursor};
 
-use criterion::{criterion_group, criterion_main, Bencher, BenchmarkId, Criterion};
+use criterion::{criterion_group, criterion_main, Bencher, Criterion};
 use lazycsv::{Csv, CsvIterItem};
-use memchr::memchr_iter;
-use memmap2::Mmap;
-
-fn prepare(rows: usize) -> Vec<u8> {
-    let f = File::open(std::env::var("INPUT").unwrap()).unwrap();
-    let mmap = unsafe { Mmap::map(&f).unwrap() };
-    let mut lf_iter = memchr_iter(b'\n', &mmap);
-    let second_lf = lf_iter.nth(1).unwrap();
-    let ending_lf = lf_iter.nth(rows).unwrap();
-    let range = (second_lf + 1)..ending_lf;
-    let mut vec = Vec::with_capacity(range.len());
-    vec.extend_from_slice(&mmap[range]);
-    vec
+use rand::{Rng, SeedableRng as _};
+
+const CHARS: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\",";
+const ROWS: usize = 100_000;
+const COLS: usize = 30;
+const MIN_CHARS: usize = 3;
+const MAX_CHARS: usize = 100;
+
+fn gen_random_str<T: Rng>(rng: &mut T) -> String {
+    let content: String = (0..rng.gen_range(MIN_CHARS..MAX_CHARS))
+        .map(|_| CHARS[rng.gen_range(0..CHARS.len())] as char)
+        .collect();
+
+    if content.contains(',') || content.contains('"') {
+        format!("\"{}\"", content.replace("\"", "\"\""))
+    } else {
+        content
+    }
+}
+
+fn prepare() -> Vec<u8> {
+    let mut buf = Vec::with_capacity(ROWS * COLS * ((MAX_CHARS - MIN_CHARS) / 2 + MIN_CHARS));
+
+    let mut rng = rand::rngs::StdRng::from_seed(b"f3a90c67b3ca86afd62658c1b30f1f12".to_owned());
+    for _ in 0..ROWS {
+        for col in 0..COLS {
+            buf.extend_from_slice(gen_random_str(&mut rng).as_bytes());
+            if col != 29 {
+                buf.push(b',');
+            }
+        }
+        buf.push(b'\n');
+    }
+
+    buf
 }
 
 pub fn lazy_csv(b: &mut Bencher, slice: &[u8]) {
@@ -29,7 +51,7 @@ pub fn lazy_csv(b: &mut Bencher, slice: &[u8]) {
 
 pub fn lazy_csv_into_rows(b: &mut Bencher, slice: &[u8]) {
     b.iter(|| {
-        for row in Csv::new(slice).into_rows::<28>() {
+        for row in Csv::new(slice).into_rows::<COLS>() {
             for cell in row.unwrap() {
                 black_box(cell.try_as_str().unwrap());
             }
@@ -47,7 +69,7 @@ pub fn lazy_csv_raw(b: &mut Bencher, slice: &[u8]) {
 
 pub fn lazy_csv_into_rows_raw(b: &mut Bencher, slice: &[u8]) {
     b.iter(|| {
-        for row in Csv::new(slice).into_rows::<28>() {
+        for row in Csv::new(slice).into_rows::<COLS>() {
             for cell in row.unwrap() {
                 black_box(cell);
             }
@@ -72,23 +94,21 @@ pub fn csv(b: &mut Bencher, slice: &[u8]) {
 
 fn bench_parsers(c: &mut Criterion) {
     let mut group = c.benchmark_group("Parsers");
-    for i in [1_000, 10_000, 50_000, 100_000] {
-        group.bench_with_input(BenchmarkId::new("lazy_csv", i), &i, |b, i| {
-            lazy_csv(b, &prepare(*i))
-        });
-        group.bench_with_input(BenchmarkId::new("lazy_csv (into_rows)", i), &i, |b, i| {
-            lazy_csv_into_rows(b, &prepare(*i))
-        });
-        group.bench_with_input(BenchmarkId::new("lazy_csv (raw)", i), &i, |b, i| {
-            lazy_csv_raw(b, &prepare(*i))
-        });
-        group.bench_with_input(
-            BenchmarkId::new("lazy_csv (into_rows, raw)", i),
-            &i,
-            |b, i| lazy_csv_into_rows_raw(b, &prepare(*i)),
-        );
-        group.bench_with_input(BenchmarkId::new("csv", i), &i, |b, i| csv(b, &prepare(*i)));
-    }
+
+    group.sample_size(50);
+
+    let buf = prepare();
+    group.bench_with_input("lazy_csv", &buf.clone(), |b, buf| lazy_csv(b, buf));
+    group.bench_with_input("lazy_csv (into_rows)", &buf.clone(), |b, buf| {
+        lazy_csv_into_rows(b, buf)
+    });
+    group.bench_with_input("lazy_csv (raw)", &buf.clone(), |b, buf| {
+        lazy_csv_raw(b, buf)
+    });
+    group.bench_with_input("lazy_csv (into_rows, raw)", &buf.clone(), |b, buf| {
+        lazy_csv_into_rows_raw(b, buf)
+    });
+    group.bench_with_input("csv", &buf.clone(), |b, buf| csv(b, buf));
     group.finish();
 }