goo rendering benchmarks¶

what rebuild, diff, and apply actually cost in goo, measured two ways.

in goo, every UI class extends GooPanel<TRoot>. you implement Build(), which returns a tree of blobs describing the UI you want. goo runs Build(), compares the new tree against the prior one (the diff step), and mutates the engine Panel tree to match (the apply step). Rebuild() schedules the next Build() run. see build method for the full explanation.

the benchmarks measure two distinct phases:

1. out of editor (Code.Tests/, vanilla .NET test host). diff-only: Build plus the reconciler's diff pass. allocation is reported via GC.GetAllocatedBytesForCurrentThread(), and wall-clock via Stopwatch. the apply step (mutating real engine panels) is excluded because there is no engine in the test host.
2. in editor (s&box runtime). end-to-end wall-clock: each benchmark component exposes a Tick method that calls Rebuild(), which triggers Build(), the diff pass, and the apply pass against a real Sandbox.UI.Panel tree. the panels are hosted inside an s&box ScreenPanel component (the engine's built-in host for 2D world UI, not a goo type).

the diff-only numbers are the floor on goo's per-frame cost. the in-editor numbers are the truth, since the apply pass mutates real engine panels.

out of editor¶

allocations (bytes)¶

Init is the one-time cost when the screen first appears. Per-iter is the steady-state cost on every redraw after that.

wall-clock per iteration (microseconds)¶

what this means¶

• every cell uses zero memory per redraw.
• this is achieved by using memory pools, keeping containers alive between redraws. each redraw they are cleared, refilled, read, then handed back to the pool.
• first mount uses memory once. bigger screens cost more.
• DeepNest is the fastest shape, around 8 microseconds.

in editor¶

the in-editor benchmark harness was removed from the source tree. the numbers below were captured from an earlier run and are preserved here as a reference. re-running them requires re-implementing a ConCmd harness in the s&box runtime.

wall-clock per iteration (microseconds)¶

in-editor allocations (qualitative)¶

captured from the s&box editor's allocations panel during the pre-pooling run. every dominant goo type from that baseline is now pool-backed:

BuildContext is the internal per-build scratch context that the reconciler uses to track the current path and keyed sets. the out-of-editor alloc table above is the source of truth for diff-side cost. the in-editor panel reflects the same pooling, qualitatively.

what this means¶

• simple screens match in and out within a few microseconds.
• AnimatedShape is slower in the engine. the engine sets the size every redraw.
• DiffKeyed-500 Reverse is the slowest case. the engine moves 500 panels.

harness¶

• Build: Release (dotnet test --configuration Release for out-of-editor. in-editor benchmark numbers above are from Release-loaded addons).
• Trial structure: 5 trials per cell, each = 10 warmup iterations + 100 measured iterations. Reported value = median of the 5 trial means.
• Out-of-editor timer: Stopwatch.Elapsed.TotalMicroseconds divided by iteration count.
• Out-of-editor allocation: GC.GetAllocatedBytesForCurrentThread() delta divided by iteration count.
• In-editor timer: DateTime.UtcNow.Ticks (100ns resolution, monotonic). Time.Now is frame-locked and stays constant during a synchronous ConCmd loop. Stopwatch and GC.* are not on the addon whitelist.
• Out-of-editor source: Code.Tests/AllocationProfileTests.cs, Code.Tests/DiffKeyedPerfTests.cs.

caveats¶

1. No GC-pause attribution. Wall-clock includes any gen-0 collections that fire during the measured loop. DiffKeyed-500 cells (90-131KB alloc) plausibly trigger collections that inflate wall-clock somewhat, but the share is not separable from useful work.
2. Single hardware sample. Numbers are valid for one Windows 11 machine. cross-machine comparison requires re-running the harness.
3. In-editor numbers assume the bench surface is the only thing rendering. A real frame would mix this work with other engine work. the per-iter numbers here are isolated cost, not frame-budget share.

surfaces¶

• Flat: 1 container, 300 text children. SingleTextEdit swaps child 0 per iter.
• ShallowGrid: 1 container, 15 column containers, 20 text children each (316 nodes). SingleTextEdit swaps cell (0,0) per iter.
• DeepNest: 16 nested containers, 1 leaf text. SingleTextEdit swaps the leaf per iter.
• RealisticUI: 9 styled containers, 26 text children, depth 5, 12-field style profile per container. Typed init-properties. SingleTextEdit swaps card child 0 per iter.
• Counter: 1 styled container, 1 text label, 1 child button container with click handler and 1 text child. SingleTextEdit swaps the label per iter.
• AnimatedShape: 200x16 progress bar, child filled width driven by a float sampled from a damper in the runner. Identical holds the fill at 1. SingleTextEdit toggles fill between 0 and 1 per iter.
• DiffKeyed-500: 1 container, 500 keyed text children. Stable rebuilds same order. Reverse rebuilds reversed order on alternating iterations.

see also¶

• build method - Rebuild() mechanics, the structural diff, and the apply pass in detail.
• animations - damper types including the float dampers used to drive the AnimatedShape surface.
• shapes - the shape primitives (Sector, Arc, Polygon) available as blob types.