Oil Paint performance

2026-10-22. One change removes repeated work from the existing Oil Paint line integral convolution.

The LIC takes 21 bilinear samples and 20 tangent lookups per output pixel, and each of those computed a rounded sample coordinate with f32::floor or f32::round. On the baseline x86-64 target (SSE2, no SSE4.1 round instruction) both of those are library calls: rustc -O --emit asm on fn f(x: f32) -> f32 { x.floor() } produces jmp floorf, and f32::round produces jmp roundf. That made 42 floorf and 40 roundf calls per pixel, which is where most of the filter's time went.

• sample(): x.floor() as usize became x as usize. The two arguments are clamped to 0 ..= w-1 on the lines above, so truncation is floor for every input the function can see (NaN truncates to 0 either way, which is the same sample the old code read).
• Tangent and bristle lookups: round became round_i32(v) = (v as f64 + 0.5 * sign(v)) as i32. f32::round is round-half-away-from-zero, which is truncation of v ± 0.5 when that sum is exact. In f32 it is not always: 0.49999997 + 0.5 (0.5 - 2^-25) rounds up to 1.0, so an f32 sum gives 1 where f32::round gives 0. In f64 the sum is exact for every f32 the i32 cast does not saturate, so the integer is identical for every input; a unit test checks every f32 bit pattern in [-4096, 4096] against f32::round. round_index adds the clamp(0, n-1) the tangent lookup already applied; NaN casts to 0 and ±∞ casts to an end of the clamp range in both versions, so the clamped results match for every input, including non-finite ones.

No public API, FilterParams, tile size, halo or perf/budgets.toml entry changed. The change is pure arithmetic: no new dependency, no allocation, no threading, so the single-threaded wasm path is unaffected.

Output equivalence

Bit-identical. Six 600x400 fixtures were rendered through kernel() on the base and on the changed tree and serialized as little-endian f32 bits, then compared with cmp and per channel:

cmp reported no differences over 21.6 MB of samples; every per-channel maximum was 0.0. The fixture is px = [(x % 256), ((3x + y) / 7 % 256), ((x ^ y) % 251), ((x + 2y) % 199), 128 or 255] on the 600x400 grid, read as RGBA8 / RGB8 / CMYKA8.

Timings

Intel Core i5-10300H (4 cores / 8 threads), 16 GB, Windows 11, rustc 1.98.1 (48a229cea 2026-09-01), default release profile, 6000x4000 RGBA8, Oil Paint at stylization 4, cleanliness 5, scale 1, bristle detail 5, lighting on. Before and after are the same bench_filters2 binary arguments, built from origin/main and from this change.

Nothing else was running: five runs per side, alternating (before, after, after, before, before, after, after, before, before, after), both binaries already built, on an otherwise idle machine.

Before: 8.36, 9.68, 9.54, 8.36, 9.36 (median 9.36). After: 6.82, 7.55, 7.84, 6.92, 7.85 (median 7.55, so 1.24x on the medians). An earlier pass took its numbers while other builds shared the machine and read 1.88x off inflated absolute times; the table above is the quiet measurement.

f32::floor and f32::round are libm calls at this target's baseline ISA — rustc --emit asm -O for the host target prints callq floorf and callq roundf, while x as usize inlines — so the LIC paid 42 of those calls per pixel. The change replaces them with a truncation (the argument was clamped two lines earlier, so truncation is floor) and a half-away-from-zero cast. What is left is the gathers themselves.

The remaining time is the 21 bilinear gathers per pixel. Those are not removable without changing the walk itself:

• Streamline reuse is not faithful. A neighbouring start does not share the walk. The tangent is read at the rounded position, the step h = max(len / 10, 1) is at least a pixel, and the bilinear taps land on different sub-pixel phases for every start, so no two starts produce the same samples. Reusing a walk would change the filter, not just its cost.
• The bristle noise plane, hoisted step weights, whole-pixel slices and a precomputed relief height plane were built and measured as one variant against the change in this note: three alternating pairs gave 28.94/29.13, 27.16/26.96 and 30.12/31.97, so the difference is inside the spread of the machine and in both directions. They are not in the diff.
• The per-tile halo work is small. A 256x256 tile reads a 308x308 source window, and the tensor stage plus both gauss_blur_n passes are about 11% of the filter, so bounding the halo is worth at most ~3%.

Reproduce

# base tree
git worktree add --detach ../picto-oil-base origin/main

# same example, both trees
(cd ../picto-oil-base && cargo build --release -p picto-algo --example bench_filters2)
cargo build --release -p picto-algo --example bench_filters2

# 24 MP Oil Paint, no other builds or benchmarks running
../picto-oil-base/target/release/examples/bench_filters2.exe oil
target/release/examples/bench_filters2.exe oil

Repeat each measurement at least three times, alternating before/after and after/before, and compare the minima. For the equivalence check, call kernel(&FilterParams::OilPaint { .. }, &Image::read(&surface, rect), rect, &ctx) on both trees for the fixtures in the table, write v.to_bits().to_le_bytes() in order and cmp the files.

Checks

• cargo fmt --all --check, cargo clippy -p picto-algo --all-targets -- -D warnings
• cargo check -p picto-algo --target wasm32-unknown-unknown still builds.
• cargo test --release -p picto-algo: 605 passed, 1 failed. The failure is pixelate::tests::facet_reuse_matches_scalar_in_every_model, which reports sample 56: NaN != NaN (0x7FC00000 against 0xFFC00000) and fails in exactly the same way on the unmodified base commit on this machine, so this change did not cause it.
• The oil tests pass: oil_paint_smooths_along_strokes and the new rounding_matches_the_standard_library, which compares round_i32 and round_index with f32::round and the clamped cast on a 0.25 grid from -40 to 2100 plus NaN and ±∞.