Add basic benchmarking harness for vello_common + vello_cpu (linebender#867)

Author: LaurenzV

Cargo.lock

@@ -14,6 +14,7 @@ members = [
     "examples/with_winit",
 
     "sparse_strips/vello_api",
+    "sparse_strips/vello_bench",
     "sparse_strips/vello_common",
     "sparse_strips/vello_cpu",
     "sparse_strips/vello_hybrid",
@@ -122,3 +123,7 @@ web-time = "1.1.0"
 wgpu-profiler = "0.21.0"
 scenes = { path = "examples/scenes" }
 svg = "0.18.0"
+criterion = { version = "0.5.1", default-features = false }
+rand = { version = "0.9.0", default-features = false, features = ["std_rng"] }
+usvg = { version = "0.45.0" }
+once_cell = "1.21.1"

Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "vello_bench"
+description = "Benchmarking harness for sparse strips."
+categories = ["rendering", "graphics"]
+keywords = ["2d", "vector-graphics"]
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = false
+
+[dependencies]
+vello_common = { workspace = true }
+vello_cpu = { workspace = true }
+criterion = { workspace = true }
+rand = { workspace = true }
+usvg = { workspace = true }
+
+[[bench]]
+name = "main"
+harness = false
+
+[lints]
+workspace = true

sparse_strips/vello_bench/Cargo.toml

@@ -0,0 +1,9 @@
+# Setup
+
+In order to run the integration benchmarks with custom SVGs, you need to add the SVGs you want to run into the `data` folder. For each SVG file in that folder, a corresponding integration test will be generated automatically.
+
+If you don't add any SVGs, the benchmarking harness will only use the ghostscript tiger by default.
+
+In order to run the benches, you can simply run `cargo bench`. However, in most cases you probably don't
+want to rerun all benchmarks, in which case you can also provide a filter for the name of the benchmarks
+you want to run, like `cargo bench -- fine/fill`

sparse_strips/vello_bench/README.md

@@ -0,0 +1,13 @@
+// Copyright 2025 the Vello Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#![allow(missing_docs, reason = "Not needed for benchmarks")]
+
+use criterion::{criterion_group, criterion_main};
+use vello_bench::{cpu_fine, strip, tile};
+
+criterion_group!(ff, cpu_fine::fill);
+criterion_group!(fs, cpu_fine::strip);
+criterion_group!(tt, tile::tile);
+criterion_group!(srs, strip::render_strips);
+criterion_main!(tt, srs, ff, fs);

sparse_strips/vello_bench/benches/main.rs

@@ -0,0 +1 @@
+*.svg

sparse_strips/vello_bench/data/.gitignore

@@ -0,0 +1,61 @@
+// Copyright 2025 the Vello Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use crate::SEED;
+use criterion::Criterion;
+use rand::prelude::StdRng;
+use rand::{Rng, SeedableRng};
+use vello_common::coarse::WideTile;
+use vello_common::color::palette::css::ROYAL_BLUE;
+use vello_common::tile::Tile;
+use vello_cpu::fine::Fine;
+
+pub fn fill(c: &mut Criterion) {
+    let mut g = c.benchmark_group("fine/fill");
+
+    macro_rules! fill_single {
+        ($name:ident, $paint:expr) => {
+            g.bench_function(stringify!($name), |b| {
+                let mut out = vec![];
+                let mut fine = Fine::new(WideTile::WIDTH, Tile::HEIGHT, &mut out);
+
+                b.iter(|| {
+                    fine.fill(0, WideTile::WIDTH as usize, $paint);
+
+                    std::hint::black_box(&fine);
+                })
+            });
+        };
+    }
+
+    fill_single!(opaque, &ROYAL_BLUE.into());
+    fill_single!(transparent, &ROYAL_BLUE.with_alpha(0.2).into());
+}
+
+pub fn strip(c: &mut Criterion) {
+    let mut g = c.benchmark_group("fine/strip");
+    let mut rng = StdRng::from_seed(SEED);
+
+    let mut alphas = vec![];
+
+    for _ in 0..WideTile::WIDTH * Tile::HEIGHT {
+        alphas.push(rng.random());
+    }
+
+    macro_rules! strip_single {
+        ($name:ident, $paint:expr) => {
+            g.bench_function(stringify!($name), |b| {
+                let mut out = vec![];
+                let mut fine = Fine::new(WideTile::WIDTH, Tile::HEIGHT, &mut out);
+
+                b.iter(|| {
+                    fine.strip(0, WideTile::WIDTH as usize, &alphas, $paint);
+
+                    std::hint::black_box(&fine);
+                })
+            });
+        };
+    }
+
+    strip_single!(basic, &ROYAL_BLUE.into());
+}

sparse_strips/vello_bench/src/cpu_fine.rs

@@ -0,0 +1,239 @@
+// Copyright 2025 the Vello Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use std::path::Path;
+use std::sync::OnceLock;
+use usvg::tiny_skia_path::PathSegment;
+use usvg::{Group, Node};
+use vello_common::flatten::Line;
+use vello_common::kurbo::{Affine, BezPath, Stroke};
+use vello_common::peniko::Fill;
+use vello_common::strip::Strip;
+use vello_common::tile::Tiles;
+use vello_common::{flatten, strip};
+
+static DATA: OnceLock<Vec<DataItem>> = OnceLock::new();
+
+pub fn get_data_items() -> &'static [DataItem] {
+    DATA.get_or_init(|| {
+        let data_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("data");
+        let mut data = vec![];
+
+        // Always use ghostscript tiger.
+        data.push(DataItem::from_path(
+            &Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("../../examples/assets/Ghostscript_Tiger.svg"),
+        ));
+
+        for entry in std::fs::read_dir(&data_dir).unwrap() {
+            let entry = entry.unwrap();
+            let path = entry.path();
+
+            if path.extension().and_then(|e| e.to_str()) == Some("svg") {
+                data.push(DataItem::from_path(&path));
+            }
+        }
+
+        data
+    })
+}
+
+#[derive(Clone, Debug)]
+pub struct DataItem {
+    pub name: String,
+    pub fills: Vec<BezPath>,
+    pub strokes: Vec<BezPath>,
+    pub width: u16,
+    pub height: u16,
+}
+
+impl DataItem {
+    fn from_path(path: &Path) -> Self {
+        let file_name = { path.file_stem().unwrap().to_string_lossy().to_string() };
+
+        let data = std::fs::read(path).unwrap();
+        let tree = usvg::Tree::from_data(&data, &usvg::Options::default()).unwrap();
+        let mut ctx = ConversionContext::new();
+        convert(&mut ctx, tree.root());
+
+        Self {
+            name: file_name,
+            fills: ctx.fills,
+            strokes: ctx.strokes,
+            #[allow(
+                clippy::cast_possible_truncation,
+                reason = "It's okay to ignore for benchmarking."
+            )]
+            width: tree.size().width() as u16,
+            #[allow(
+                clippy::cast_possible_truncation,
+                reason = "It's okay to ignore for benchmarking."
+            )]
+            height: tree.size().height() as u16,
+        }
+    }
+
+    /// Get the raw flattened lines of both fills and strokes.
+    ///
+    /// A stroke width of 2.0 is assumed.
+    pub fn lines(&self) -> Vec<Line> {
+        let mut line_buf = vec![];
+        let mut temp_buf = vec![];
+
+        for path in &self.fills {
+            flatten::fill(path, Affine::default(), &mut temp_buf);
+            line_buf.extend(&temp_buf);
+        }
+
+        let stroke = Stroke {
+            // Obviously not all strokes have that width, but it should be good enough
+            // for benchmarking.
+            width: 2.0,
+            ..Default::default()
+        };
+
+        for path in &self.strokes {
+            flatten::stroke(path, &stroke, Affine::default(), &mut temp_buf);
+            line_buf.extend(&temp_buf);
+        }
+
+        line_buf
+    }
+
+    /// Get the unsorted tiles.
+    pub fn unsorted_tiles(&self) -> Tiles {
+        let mut tiles = Tiles::new();
+        let lines = self.lines();
+        tiles.make_tiles(&lines, self.width, self.height);
+
+        tiles
+    }
+
+    /// Get the sorted tiles.
+    pub fn sorted_tiles(&self) -> Tiles {
+        let mut tiles = self.unsorted_tiles();
+        tiles.sort_tiles();
+
+        tiles
+    }
+
+    /// Get the alpha buffer and rendered strips.
+    pub fn strips(&self) -> (Vec<u8>, Vec<Strip>) {
+        let mut strip_buf = vec![];
+        let mut alpha_buf = vec![];
+        let lines = self.lines();
+        let tiles = self.sorted_tiles();
+
+        strip::render(
+            &tiles,
+            &mut strip_buf,
+            &mut alpha_buf,
+            Fill::NonZero,
+            &lines,
+        );
+
+        (alpha_buf, strip_buf)
+    }
+}
+
+fn convert(ctx: &mut ConversionContext, g: &Group) {
+    ctx.push(convert_transform(&g.transform()));
+
+    for child in g.children() {
+        match child {
+            Node::Group(group) => {
+                convert(ctx, group);
+            }
+            Node::Path(p) => {
+                let converted = convert_path_data(p);
+
+                if p.fill().is_some() {
+                    ctx.add_filled_path(converted.clone());
+                }
+
+                if p.stroke().is_some() {
+                    ctx.add_stroked_path(converted);
+                }
+            }
+            Node::Image(_) => {}
+            Node::Text(_) => {}
+        }
+    }
+
+    ctx.pop();
+}
+
+#[derive(Debug)]
+struct ConversionContext {
+    stack: Vec<Affine>,
+    fills: Vec<BezPath>,
+    strokes: Vec<BezPath>,
+}
+
+impl ConversionContext {
+    fn new() -> Self {
+        Self {
+            stack: vec![],
+            fills: vec![],
+            strokes: vec![],
+        }
+    }
+
+    fn push(&mut self, transform: Affine) {
+        let new = *self.stack.last().unwrap_or(&Affine::IDENTITY) * transform;
+        self.stack.push(new);
+    }
+
+    fn add_filled_path(&mut self, path: BezPath) {
+        self.fills.push(self.get() * path);
+    }
+
+    fn add_stroked_path(&mut self, path: BezPath) {
+        self.strokes.push(self.get() * path);
+    }
+
+    fn get(&self) -> Affine {
+        *self.stack.last().unwrap_or(&Affine::IDENTITY)
+    }
+
+    fn pop(&mut self) {
+        self.stack.pop();
+    }
+}
+
+fn convert_transform(transform: &usvg::Transform) -> Affine {
+    Affine::new([
+        transform.sx as f64,
+        transform.ky as f64,
+        transform.kx as f64,
+        transform.sy as f64,
+        transform.tx as f64,
+        transform.ty as f64,
+    ])
+}
+
+fn convert_path_data(path: &usvg::Path) -> BezPath {
+    let mut bez_path = BezPath::new();
+
+    for e in path.data().segments() {
+        match e {
+            PathSegment::MoveTo(p) => {
+                bez_path.move_to((p.x, p.y));
+            }
+            PathSegment::LineTo(p) => {
+                bez_path.line_to((p.x, p.y));
+            }
+            PathSegment::QuadTo(p1, p2) => {
+                bez_path.quad_to((p1.x, p1.y), (p2.x, p2.y));
+            }
+            PathSegment::CubicTo(p1, p2, p3) => {
+                bez_path.curve_to((p1.x, p1.y), (p2.x, p2.y), (p3.x, p3.y));
+            }
+            PathSegment::Close => {
+                bez_path.close_path();
+            }
+        }
+    }
+
+    bez_path
+}

sparse_strips/vello_bench/src/data.rs

@@ -0,0 +1,16 @@
+// Copyright 2025 the Vello Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#![allow(missing_docs, reason = "Not needed for benchmarks")]
+
+use std::path::PathBuf;
+use std::sync::LazyLock;
+
+pub mod cpu_fine;
+pub mod data;
+pub mod strip;
+pub mod tile;
+
+pub(crate) const SEED: [u8; 32] = [0; 32];
+pub static DATA_PATH: LazyLock<PathBuf> =
+    LazyLock::new(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("data"));