summaryrefslogtreecommitdiff
path: root/examples/noc/notes/perf.md
diff options
context:
space:
mode:
Diffstat (limited to 'examples/noc/notes/perf.md')
-rw-r--r--examples/noc/notes/perf.md346
1 files changed, 346 insertions, 0 deletions
diff --git a/examples/noc/notes/perf.md b/examples/noc/notes/perf.md
new file mode 100644
index 0000000..b458b90
--- /dev/null
+++ b/examples/noc/notes/perf.md
@@ -0,0 +1,346 @@
+# perf: why the GPU vector renderer is no faster than the CPU one
+
+2026-10-30. The question: the flocking port draws 1000 boids at about 9 ms/frame with either
+`vector.Renderer(.cpu)` or `vector.Renderer(.gpu)`. Is the host's per-draw pipeline lookup
+the cause, and does fixing it change the answer?
+
+**Short answer.** Yes, it is the main cost in Debug (85% of the GPU path's host time). In
+ReleaseFast it is about a quarter of the frame (28% of `Gpu.run`). After three small host fixes, gpu mode at 1000 boids
+goes from 4.8 to 3.1 ms/frame in ReleaseFast and from 47 to 11 ms in Debug. Even so, the
+vector GPU path still costs about 30× more than drawing the same triangles in one draw (`raw`:
+0.1 ms). What is left is the per-draw cost of 4 draws per boid, with a pipeline switch on every
+draw. It shows up on the CPU in the NVIDIA driver and SDL_GPU, and on the GPU front end. It is
+not fill: with 1× MSAA the GPU time is the same as with 8×.
+
+## Method
+
+- Bench: a copy of the library and a bench app in
+ `/tmp/claude-1000/-home-goblin-00-projects/b03e088f-d250-44e5-b526-5614572b9fb9/scratchpad/perf/`.
+ `bench/src/main.zig` draws `BENCH_N` static boids (a filled triangle plus a 1 px stroke) at
+ 640×360. `BENCH_MODE` picks `cpu` (vector CPU renderer, then a `f.pixels` upload), `gpu`
+ (vector GPU renderer: stencil fan plus cover quad per fill, 8× MSAA) or `raw` (every triangle
+ plus three edge quads per boid in one `f.gpu` draw, 4× MSAA). Every boid has two fills (fill
+ and stroke), so the gpu mode makes 4 draws per boid: 4000 at N=1000 and 20000 at N=5000.
+- Runs are headless (`--headless --fresh --script`): `frames 330` in ReleaseFast and
+ `frames 130` in Debug. The first 30 frames are dropped as warm-up (pipeline creation and buffer
+ growth), so 300 or 100 frames are measured.
+- Instrumentation, in the copy only (`instr-*.patch`, not part of the fixes):
+ - `Host.zig` adds `SDL_GetTicksNS` timers around the sketch's `draw` ("sketch draw"), each
+ `Gpu.run` ("Gpu.run"), the 2D `gfx.draw` commands, and `RenderPresent` plus `endFrame`. At
+ exit it waits for the GPU to go idle and prints the totals. "wall" is the time from frame 30
+ to that idle point, divided by the frame count, so a GPU backlog would show up in it.
+ `Host.print` also prints in headless mode: the original drops headless logs.
+ - `gpu.zig --profile-gpu` already waits for an idle GPU before each pass, but it books its time
+ from *before* command recording, so it measures CPU recording plus GPU time (4.9 ms vs
+ 1.15 ms here). I added the time from submit to fence ("GPU exec"). That is GPU execution on
+ an otherwise idle GPU, plus about 0.03 ms of submit latency (an empty pass measures
+ 0.034–0.055 ms). It comes from a separate `--profile-gpu` run.
+- Matrix: modes {cpu, gpu, raw} × N {120, 1000, 5000} × {ReleaseFast, Debug}, 3 repeats, median
+ reported (`harness/bench.py`, `harness/table.py` in the scratchpad). To measure each fix on its
+ own I used interleaved A/B runs (orig, fix1, fix2, fix3 in turn: 6 rounds in ReleaseFast and 3
+ in Debug, median, `harness/ab.sh`). Separate matrix runs drifted by up to 30% on cells no
+ patch touches.
+- Profiling: `perf record -e cpu-clock:u -F 4999`, flat (self time by DSO and symbol). Call
+ graphs (fp, dwarf, lbr) are refused in this environment, so stack attribution comes from the
+ timers above.
+- Machine: 16 threads. GPU is an RTX 3050 on driver 615.78 through SDL_GPU Vulkan, with SDL
+ built from source in the same optimize mode as the app. **The GPU was shared**: the
+ compositor (driftwm), Xwayland, Chrome's GPU process, Firefox and two pardes-gui windows were
+ on it, at 13–26% utilization and P5 clocks before the runs. An unrelated `zig build-exe` used
+ one core during part of the runs (load average about 6). GPU-exec numbers depend on the clock
+ state; Debug runs leave the GPU idle longer, so their GPU exec reads higher (for example 13 ms
+ vs 7.9 ms at N=5000) for identical GPU work.
+- Correctness: the gpu-mode screenshots from orig, fix1, fix2 and fix3 are byte-identical
+ (sha256 4169017b…), and so are the cpu-mode ones.
+
+## Baseline (original host), median of 3, ms per frame
+
+wall ≈ host CPU in every cell, so the bench is CPU-bound throughout and the GPU never limits
+throughput. "2D+present" is the `gfx.draw` commands plus `RenderPresent`.
+
+| build | mode | N | wall | sketch draw | Gpu.run | 2D+present | GPU exec |
+|---|---|---:|---:|---:|---:|---:|---:|
+| Release | cpu | 120 | 0.98 | 0.42 | — | 0.56 | (SDL 2D, not profiled) |
+| Release | cpu | 1000 | 4.05 | 3.38 | — | 0.67 | — |
+| Release | cpu | 5000 | 17.4 | 16.5 | — | 0.97 | — |
+| Release | gpu | 120 | 0.55 | 0.08 | 0.46 | 0.02 | 0.18 |
+| Release | gpu | 1000 | **4.85** | 0.84 | **3.96** | 0.03 | 1.18 |
+| Release | gpu | 5000 | **28.2** | 5.05 | **23.2** | 0.06 | 7.9 |
+| Release | raw | 120 | 0.05 | 0.005 | 0.03 | 0.02 | 0.04 |
+| Release | raw | 1000 | **0.095** | 0.035 | 0.047 | 0.01 | 0.10 |
+| Release | raw | 5000 | 0.32 | 0.18 | 0.12 | 0.02 | 0.27 |
+| Debug | cpu | 120 | 2.46 | 1.81 | — | 0.66 | — |
+| Debug | cpu | 1000 | 14.5 | 13.6 | — | 0.86 | — |
+| Debug | cpu | 5000 | 67.0 | 65.4 | — | 1.97 | — |
+| Debug | gpu | 120 | 5.46 | 0.73 | 4.68 | 0.03 | 0.21 |
+| Debug | gpu | 1000 | **47.2** | 6.14 | **40.9** | 0.09 | 2.0 |
+| Debug | gpu | 5000 | **269** | 30.8 | **238** | 0.12 | 13.4 |
+| Debug | raw | 120 | 0.12 | 0.06 | 0.03 | 0.02 | 0.05 |
+| Debug | raw | 1000 | 0.50 | 0.42 | 0.05 | 0.02 | 0.11 |
+| Debug | raw | 5000 | 2.27 | 2.08 | 0.15 | 0.03 | 0.32 |
+
+Spread (half the max−min range over the median) was ≤4% in most cells, up to ±10–11% for
+release gpu at 5000 and raw at 1000. The porter's result matches: in ReleaseFast the gpu
+mode (4.85) is slower than cpu (4.05), and in Debug much slower (47 vs 14.5). In the gpu mode
+82–89% of the frame is `Gpu.run`, the host turning the pass into SDL calls. The sketch-side
+tessellation (`Polygons.fill/stroke`, `Gpu.record`) is 0.84 ms at N=1000.
+
+## Profile attribution: gpu mode, N=1000 (flat perf, share of all user samples)
+
+| | ReleaseFast orig (4.87 ms/frame) | ReleaseFast fix2 (3.50) | Debug orig (48.8) | Debug fix2 (12.8) |
+|---|---:|---:|---:|---:|
+| Wyhash of SPIR-V (`update`/`final`/`init`/`hash`) + `gpu.shader` | **15.4%** (≈0.75 ms) | 0 | **66.1%** (≈32 ms) | 0 |
+| NVIDIA driver (`libnvidia-glcore`: vkCmd*, descriptor writes) | 45.8% (≈2.2 ms) | 54.5% (≈1.9 ms) | 5.8% (≈2.8 ms) | 17.0% (≈2.2 ms) |
+| SDL_GPU Vulkan layer (BindGraphicsDescriptorSets, FetchDescriptorSet, TrackBuffer, Bind*/Push*) | ≈5% | ≈7% | ≈5% | ≈20% (≈2.6 ms) |
+| memcpy (likely Paint uniform blocks, 720 B each: built, copied, pushed) | 8.8% | 8.1% | 0.8% | 2.5% |
+| sketch: Drawing builder, Polygons, `Gpu.record`, arena | ≈16% | ≈23% | ≈12% | ≈50% (≈6.4 ms) |
+| libc locks, vdso clock, libm | ≈10% | ≈11% | ≈3% | ≈3% |
+
+How to read it:
+- **Debug, original:** two thirds of all CPU time is Wyhash going over each shader's whole
+ SPIR-V, twice per draw. A stencil draw hashes path.vert (1044 B) plus stencil.frag (288 B); a
+ cover draw hashes path.vert plus cover.frag (4828 B). That is about 14 MB per frame at
+ N=1000. Unoptimized Zig hashes it slowly.
+- **ReleaseFast, original:** hashing is 0.75 ms of 4.9. The largest item is the NVIDIA driver.
+ Every draw switches pipeline (stencil, cover, stencil, …), and SDL_GPU's
+ `VULKAN_BindGraphicsPipeline` then marks every descriptor set and uniform offset dirty. So
+ each of the 4000 draws gets a new descriptor set (`FetchDescriptorSet` plus
+ `vkUpdateDescriptorSets`), `vkCmdBindDescriptorSets`, `vkCmdBindPipeline`, a vertex-buffer
+ rebind, uniform pushes, stencil ref and scissor, then `vkCmdDraw`. The host cannot remove
+ this cost: it follows from one pipeline switch per draw.
+
+## Fixes (in the copy, each a separate patch against the original `src/host/gpu.zig`)
+
+Measured with interleaved A/B; median `Gpu.run` time in ms per frame, gpu mode (wall in
+parentheses). The sketch-draw column did not change, as expected (0.71–0.86 ms at N=1000 in
+ReleaseFast, 6.1 ms in Debug).
+
+| | Release N=120 | Release N=1000 | Release N=5000 | Debug N=1000 | Debug N=5000 |
+|---|---:|---:|---:|---:|---:|
+| orig | 0.454 (0.548) | 3.94 (4.77) | 24.5 (29.9) | 41.0 (47.3) | 221 (254) |
+| + fix1: pipeline per pass | 0.283 (0.376) | 2.82 (3.72) | 17.0 (22.0) | 6.14 (12.3) | 42.7 (73.9) |
+| + fix2: skip redundant state | 0.272 (0.366) | 2.46 (3.19) | 16.4 (21.6) | 5.84 (12.0) | 42.6 (75.1) |
+| + fix3: one vertex binding | 0.267 (0.359) | 2.37 (3.13) | 14.6 (19.8) | 4.80 (11.1) | 26.6 (57.8) |
+
+What each fix did on its own:
+- **fix1**: `Gpu.run` −38% at 120, −28 to −30% at 1000/5000 (ReleaseFast); −85% and −81% in
+ Debug. Wall at Debug N=1000 drops 47.3 → 12.3 ms (3.8×), at N=5000 254 → 74 ms.
+- **fix2**: −4% (ReleaseFast) and −0 to −5% (Debug). The A/B at 1000 shows −10% from fix1, but
+ fix1's median there carries one noisy round; a separate 8-round A/B gave −3.6%. Small; it only
+ avoids `vkCmdSetScissor`/`vkCmdSetStencilReference` and a 16-byte uniform copy per draw.
+- **fix3**: −4% at 1000 and −11% at 5000 (ReleaseFast); −18% at 1000 and −38% at 5000
+ (Debug). SDL's `TrackBuffer` does a linear search of the command buffer's used-buffer list,
+ and `vkCmdBindVertexBuffers` ran on every draw.
+- All three together: gpu-mode wall at N=1000 4.77 → 3.13 ms (ReleaseFast) and 47.3 → 11.1 ms
+ (Debug); at N=5000 29.9 → 19.8 and 254 → 58.
+
+### fix1: resolve each pass pipeline once per pass (the suspected culprit)
+
+```diff
+--- a/src/host/gpu.zig
++++ b/src/host/gpu.zig
+@@ -187,6 +187,12 @@
+ if (pass.width == 0 or pass.height == 0 or pass.draws.len == 0 and pass.clear == null) return;
+ const samples = g.supportedSamples(pass.samples);
+ const t = try g.renderTarget(images, pass.image, pass.width, pass.height, samples, pass.stencil);
++ // Each pipeline is looked up on first use in the pass, not per draw:
++ // the lookup hashes the shaders' code. Outer null: not looked up yet;
++ // inner null: it failed (warned once).
++ const built = try g.gpa.alloc(??*c.SDL_GPUGraphicsPipeline, pass.pipelines.len);
++ defer g.gpa.free(built);
++ @memset(built, null);
+
+ const start = g.startTiming();
+ // Every draw's vertices go up in one copy.
+@@ -235,13 +241,15 @@
+ for (pass.draws) |d| {
+ defer offset += @intCast(std.mem.alignForward(usize, d.vertices.len, 4));
+ if (d.pipeline >= pass.pipelines.len or d.vertex_count == 0) continue;
+- const built = g.pipeline(pass.pipelines[d.pipeline], samples, pass.stencil) catch |err| {
++ const slot = &built[d.pipeline];
++ if (slot.* == null) slot.* = g.pipeline(pass.pipelines[d.pipeline], samples, pass.stencil) catch |err| blk: {
+ std.log.warn("gpu pipeline {d}: {t} ({s})", .{ d.pipeline, err, c.SDL_GetError() });
+- continue;
++ break :blk @as(?*c.SDL_GPUGraphicsPipeline, null);
+ };
+- if (bound != built) {
+- c.SDL_BindGPUGraphicsPipeline(rp, built);
+- bound = built;
++ const chosen = slot.*.? orelse continue;
++ if (bound != chosen) {
++ c.SDL_BindGPUGraphicsPipeline(rp, chosen);
++ bound = chosen;
+ }
+ if (d.vertices.len > 0) c.SDL_BindGPUVertexBuffers(rp, 0, &.{ .buffer = g.vertices, .offset = offset }, 1);
+ var bound_storage: [8]*c.SDL_GPUBuffer = undefined;
+```
+
+A second effect: a failing pipeline now warns once per pass, not once per draw. Another option
+was caching the shader key by code pointer and length. I did not take it, because a reload can
+map new code at the same address.
+
+### fix2: skip redundant vertex-uniform push, stencil reference and scissor
+
+SDL documents pushed uniforms as staying in effect for later draws in the command buffer, and
+SDL's Vulkan backend keeps them across pipeline binds. The vector module passes one `viewport`
+slice to every draw, so comparing pointer and length is enough.
+
+```diff
+--- a/src/host/gpu.zig
++++ b/src/host/gpu.zig
+@@ -241,6 +241,10 @@
+ }
+ const rp = c.SDL_BeginGPURenderPass(cmd, &color, 1, if (pass.stencil) &depth else null) orelse return error.GpuRenderPass;
+ var bound: ?*c.SDL_GPUGraphicsPipeline = null;
++ // State already set in this pass, so draws that repeat it skip the call.
++ var vertex_uniforms: ?[]const u8 = null;
++ var stencil_reference: ?u8 = null;
++ var scissor: ?c.SDL_Rect = null;
+ var offset: u32 = 0;
+ for (pass.draws) |d| {
+ defer offset += @intCast(std.mem.alignForward(usize, d.vertices.len, 4));
+@@ -259,12 +263,24 @@
+ var bound_storage: [8]*c.SDL_GPUBuffer = undefined;
+ if (d.vertex_storage.len > 0) c.SDL_BindGPUVertexStorageBuffers(rp, 0, &bound_storage, g.resolve(d.vertex_storage, &bound_storage) catch continue);
+ if (d.fragment_storage.len > 0) c.SDL_BindGPUFragmentStorageBuffers(rp, 0, &bound_storage, g.resolve(d.fragment_storage, &bound_storage) catch continue);
+- if (d.vertex_uniforms.len > 0) c.SDL_PushGPUVertexUniformData(cmd, 0, d.vertex_uniforms.ptr, @intCast(d.vertex_uniforms.len));
++ // Pushed uniforms stay for later draws: the same bytes (sketches
++ // share one slice for a pass's viewport) need no second push.
++ if (d.vertex_uniforms.len > 0) if (vertex_uniforms == null or vertex_uniforms.?.ptr != d.vertex_uniforms.ptr or vertex_uniforms.?.len != d.vertex_uniforms.len) {
++ c.SDL_PushGPUVertexUniformData(cmd, 0, d.vertex_uniforms.ptr, @intCast(d.vertex_uniforms.len));
++ vertex_uniforms = d.vertex_uniforms;
++ };
+ if (d.fragment_uniforms.len > 0) c.SDL_PushGPUFragmentUniformData(cmd, 0, d.fragment_uniforms.ptr, @intCast(d.fragment_uniforms.len));
+- if (pass.stencil) c.SDL_SetGPUStencilReference(rp, d.stencil_reference);
++ if (pass.stencil and stencil_reference != d.stencil_reference) {
++ c.SDL_SetGPUStencilReference(rp, d.stencil_reference);
++ stencil_reference = d.stencil_reference;
++ }
+ const full: abi.Rect = .{ .w = @floatFromInt(pass.width), .h = @floatFromInt(pass.height) };
+ const s = d.scissor orelse full;
+- c.SDL_SetGPUScissor(rp, &.{ .x = @intFromFloat(@max(s.x, 0)), .y = @intFromFloat(@max(s.y, 0)), .w = @intFromFloat(@max(s.w, 0)), .h = @intFromFloat(@max(s.h, 0)) });
++ const rect: c.SDL_Rect = .{ .x = @intFromFloat(@max(s.x, 0)), .y = @intFromFloat(@max(s.y, 0)), .w = @intFromFloat(@max(s.w, 0)), .h = @intFromFloat(@max(s.h, 0)) };
++ if (scissor == null or !std.meta.eql(scissor.?, rect)) {
++ c.SDL_SetGPUScissor(rp, &rect);
++ scissor = rect;
++ }
+ c.SDL_DrawGPUPrimitives(rp, d.vertex_count, 1, 0, 0);
+ }
+ c.SDL_EndGPURenderPass(rp);
+```
+
+### fix3: one vertex-buffer binding; draws use `first_vertex`
+
+```diff
+--- a/src/host/gpu.zig
++++ b/src/host/gpu.zig
+@@ -245,6 +245,7 @@
+ var vertex_uniforms: ?[]const u8 = null;
+ var stencil_reference: ?u8 = null;
+ var scissor: ?c.SDL_Rect = null;
++ var vertex_base: ?u32 = null;
+ var offset: u32 = 0;
+ for (pass.draws) |d| {
+ defer offset += @intCast(std.mem.alignForward(usize, d.vertices.len, 4));
+@@ -259,7 +260,18 @@
+ c.SDL_BindGPUGraphicsPipeline(rp, chosen);
+ bound = chosen;
+ }
+- if (d.vertices.len > 0) c.SDL_BindGPUVertexBuffers(rp, 0, &.{ .buffer = g.vertices, .offset = offset }, 1);
++ // Vertices at a multiple of the stride are reached from one binding
++ // at 0 by the draw's first vertex; others get a binding of their own.
++ var first: u32 = 0;
++ if (d.vertices.len > 0) {
++ const stride = pass.pipelines[d.pipeline].stride;
++ const base = if (stride > 0 and offset % stride == 0) 0 else offset;
++ if (base == 0 and stride > 0) first = offset / stride;
++ if (vertex_base != base) {
++ c.SDL_BindGPUVertexBuffers(rp, 0, &.{ .buffer = g.vertices, .offset = base }, 1);
++ vertex_base = base;
++ }
++ }
+ var bound_storage: [8]*c.SDL_GPUBuffer = undefined;
+ if (d.vertex_storage.len > 0) c.SDL_BindGPUVertexStorageBuffers(rp, 0, &bound_storage, g.resolve(d.vertex_storage, &bound_storage) catch continue);
+ if (d.fragment_storage.len > 0) c.SDL_BindGPUFragmentStorageBuffers(rp, 0, &bound_storage, g.resolve(d.fragment_storage, &bound_storage) catch continue);
+@@ -281,7 +293,7 @@
+ c.SDL_SetGPUScissor(rp, &rect);
+ scissor = rect;
+ }
+- c.SDL_DrawGPUPrimitives(rp, d.vertex_count, 1, 0, 0);
++ c.SDL_DrawGPUPrimitives(rp, d.vertex_count, 1, first, 0);
+ }
+ c.SDL_EndGPURenderPass(rp);
+ try g.submit(cmd, if (pass.label.len > 0) pass.label else "pass", start);
+```
+
+A pass that mixes strides can still land some draws at an offset that is not a multiple of
+their stride. Those draws fall back to their own binding, as before. Aligning each draw's upload
+offset to its stride would remove that case, but the vector module never hits it: all its
+vertices are 8 bytes.
+
+The patch files (`fix1.patch`, `fix2.patch`, `fix3.patch`, `instr-gpu.patch`, `instr-host.patch`)
+are in `/tmp/claude-1000/-home-goblin-00-projects/b03e088f-d250-44e5-b526-5614572b9fb9/scratchpad/diffs/`.
+fixN applies on top of fix(N−1); `zig fmt --check` passes.
+
+## Fill test: is 8× MSAA plus stencil the GPU cost?
+
+Setup: `vector/Gpu.zig` `samples = 1` (in a scratch build only, since reverted), host at fix3,
+4 interleaved runs, GPU exec (submit to fence) in ms:
+
+| N | 8× MSAA | 1× |
+|---:|---|---|
+| 1000 | 1.14 / 1.16 / 1.16 / 1.19 | 1.13 / 1.14 / 1.16 / 1.16 |
+| 5000 | 6.64 / 6.64 / 6.83 / 6.97 | 6.29 / 6.38 / 7.83 / 7.90 |
+
+Result: no difference. The GPU time is a per-draw cost of about 0.28–0.33 µs per draw on the
+GPU front end, for state changes and draws. It is not samples or fill: the cover quads are about
+17×17 px. `raw` draws the same picture in 0.10 ms of GPU time (N=1000), 11× less.
+
+## Where the time goes now (gpu mode, after fix1+2+3, ReleaseFast)
+
+| | N=1000 | N=5000 |
+|---|---:|---:|
+| wall per frame | 3.13 | 19.8 |
+| sketch draw (Drawing builder, Polygons fill/stroke tessellation, `Gpu.record`, Paint blocks) | 0.73 | 5.2 |
+| `Gpu.run` host: about 80% NVIDIA driver plus SDL_GPU per-draw work (pipeline bind, descriptor set fetch and update, uniform pushes, draw); the rest is vertex upload memcpy and submit | 2.37 | 14.6 |
+| GPU exec (overlaps the CPU, never the limit here) | ≈1.15 | ≈6.6 |
+| `raw`, same picture, wall | 0.095 | 0.32 |
+
+In Debug at N=1000 (11.1 ms) it splits evenly: sketch tessellation is 6.1 ms (Debug Zig) and
+`Gpu.run` is 4.8 ms (Debug SDL C plus the driver).
+
+So in ReleaseFast the remaining cost is **draw-call overhead** (about 0.6–0.7 µs of CPU and 0.3 µs
+of GPU per draw, 4 draws per boid, with a pipeline switch on every draw), then **CPU
+tessellation** (about 0.7 µs per boid). **GPU fill with 8× MSAA plus stencil is not a factor.**
+In Debug, after fix1, tessellation and draw overhead are about equal.
+
+## What this means
+
+**(a) The vector module's GPU backend.** The fixes keep the host from being pathological, but
+the stencil-then-cover-per-fill design puts a floor of about 0.6 µs CPU per draw on any host
+built on SDL_GPU. A pipeline switch per draw also makes SDL write new descriptor sets on every
+draw. To beat the CPU renderer clearly on many small shapes, the backend needs fewer draws, not
+a faster host:
+1. Batch fills into one stencil draw plus one cover draw per group. For consecutive fills
+ whose cover boxes do not overlap, the result is the same as drawing them one at a time,
+ because the cover zeroes its own stencil. Paint then has to move from a per-draw uniform to
+ per-vertex data or a storage buffer indexed per vertex (`fragment_storage` already exists).
+ The 720-byte Paint uniform per cover (built, copied, then pushed) is the likely source of most of the 8% memcpy in the profile; flat profiles cannot confirm this.
+2. Convex fast path: a single convex contour under either fill rule needs no stencil. Draw the
+ fan directly with a per-vertex color, all in one pipeline and one draw. Boid fills qualify.
+ Strokes qualify only when opaque, since overlapping stroke pieces would double-blend
+ otherwise.
+3. Keep 8× MSAA: it costs nothing measurable here.
+
+**(b) The proposed `Command.shape`.** The `raw` numbers are what a batched-triangle command
+costs: at N=1000, 0.035 ms of sketch time plus 0.05 ms host plus 0.10 ms GPU. That is about 33×
+cheaper than the fixed vector GPU path and 40× cheaper than the CPU renderer. It scales close
+to linearly to 0.32 ms at 5000. That supports the porter's and critic's call that many small
+shapes want one batched triangle command with per-vertex color, not a different path renderer.
+Caveat: `raw`'s edges are plain quads at 4× MSAA. They have no joins or exact coverage and
+are fine only for opaque 1 px outlines. Exact strokes still need Polygons tessellation on the
+CPU (0.7 µs per boid), which `Command.shape` could take directly.
+
+For the flocking port itself (about 9 ms/frame, of which update is about 4.6 ms): with the fixes,
+GPU drawing is 3.1 ms vs 4.0 for the CPU renderer. That is now ahead, but `raw` or
+`Command.shape` would take drawing to about 0.1 ms, leaving the O(n²) update as the frame.