← all workloads

complexity_ladder

A single shader that ramps *several* realistic dimensions together as n grows, modelling how a real shader's compile cost behaves going from simple to highly complex — as opposed to the single-axis stressors, which isolate one pass. Each step adds: a branchy helper (control flow / SSA + phi), a generic call (sema + specialization), a small bounded inner loop, resource reads, and a dynamic-dispatch site. Helpers are chained in bounded-depth groups (call graph depth) so doubling n roughly doubles total work across all of front-end, IR opt, and codegen at once. Sweep this to get the holistic complexity->compile-time curve and a floor+slope fit. Scaling reference (not a null): several axes co-scale, so the sweep's linear line means 'cost tracks code size' — a user-meaningful reference. Standing super-linearity here is expected; the actionable signal is its release-over-release movement.

bucket: realistic_scaling  ·  mode: target  ·  flags: -target spirv -emit-spirv-directly

Phase composition vs N (stacked sub-counters)

compileInner split into phase buckets (named leaves + (self) residuals) stacked across the sweep sizes — the top edge is compileInner, so you can see which phase drives the scaling.

complexity_ladder — phase composition vs N (v2026.5, median ms) complexity_ladder 12.7× over N 160→1280 0.0 1595 3191 160 320 640 1280 N complexity_ladder — parseTranslationUnit complexity_ladder — SemanticChecking complexity_ladder — generateIR complexity_ladder — frontEndExecute (self) complexity_ladder — specializeModule complexity_ladder — simplifyIR complexity_ladder — linkIR complexity_ladder — unrollLoopsInModule complexity_ladder — legalizeResourceTypes complexity_ladder — legalizeExistentialTypeLayout complexity_ladder — performMandatoryEarlyInlining complexity_ladder — performForceInlining complexity_ladder — linkAndOptimizeIR (self) complexity_ladder — generateOutput (self) complexity_ladder — compileInner (self) phase buckets parseTranslationUnit SemanticChecking generateIR frontEndExecute (self) specializeModule simplifyIR linkIR unrollLoopsInModule legalizeResourceTypes legalizeExistentialTypeLayout performMandatoryEarlyInlining performForceInlining linkAndOptimizeIR (self) emitEntryPointsSourceFromIR generateOutput (self) compileInner (self)

Scaling analysis

floor-subtracted power-law fit (t − floor) = a·Nk; floor = the minimal workload (fixed per-compile cost), k the global exponent, top-2× the local high-end doubling ratio.

N rangefloor (ms)k (work)fit R²t(Nmin)t(Nmax)top-2×
160–128091.240.99723229542.65×

Growth attribution (N=160 → N=1280)

compileInner grows by 2722 ms across the sweep; the mutually-exclusive phase buckets below partition that growth exactly (no nested-timer double counting). × lin is the same metric as the top-level panels, per bucket: the end point vs a linear expectation anchored to the bucket's share of the minimal floor and fitted on the low-N half — 1.0 = grew exactly linearly, >1 bends up. The super-linearity lives where × lin (and k) are red.

buckett@N=160t@N=1280Δ msshare× lin∝Nk
generateOutput (self)721258+118644%1.87×1.38
simplifyIR25379+35413%1.77×1.30
linkAndOptimizeIR (self)24293+26810%1.46×1.21
SemanticChecking65302+2379%0.74×0.77
legalizeExistentialTypeLayout5231+2268%3.55×1.83

Also growing (below top-5): legalizeResourceTypes (+224 ms, 8%), specializeModule (+99 ms, 4%), generateIR (+92 ms, 3%).

Near-constant (≤2% of growth each): linkIR (3→13 ms), parseTranslationUnit (2→12 ms), performMandatoryEarlyInlining (1→9 ms), performForceInlining (1→4 ms), unrollLoopsInModule (0→2 ms), frontEndExecute (self) (0→0 ms), compileInner (self) (1→0 ms).

Sweep numbers (median ms)

NcompileInnerfrontEndExecutelinkAndOptimizeIRsimplifyIR
160232837825
32048713317655
6401114232440128
128029544231274379