Unit — Burst

01why

State the single principle that explains why Burst compiles a subset of C# and why that subset is fast.

1. aSmaller languages compile faster, so Burst limits scope for build speed
2. bLLVM makes code fast by reasoning about the program (disjoint memory, no hidden side effects); the subset — blittable, no managed references, no virtual/GC/exception constructs — is exactly the set of programs that reasoning stays valid for
3. cThe subset is temporary until Unity finishes Burst
4. dStructs are inherently faster than classes regardless of the compiler

02why

Why does the SoA chunk layout from Module 1 do double duty for Burst?

1. aIt only helps with cache locality; Burst is unrelated
2. bThe dense contiguous per-component span gives both cache locality AND the aligned-consecutive-elements shape that makes vectorization legal — one layout, two wins
3. cIt lets Burst skip the garbage collector
4. dIt makes the archetype smaller so it compiles faster

03why

Aliasing is 'can two pointers overlap?' Why is Burst's no-alias-by-default both its speed advantage and its most dangerous footgun?

1. aIt's neither; aliasing doesn't affect Burst
2. bAssuming disjoint memory lets Burst vectorize loops managed C# must leave scalar (the advantage), but if you pass overlapping buffers the transform is valid only under a false premise — producing silently wrong results that vary by vector width (the footgun)
3. cIt speeds up compilation but slows execution
4. dIt only matters for integer math

04how

Which loop-body element does NOT silently prevent vectorization?

1. aAn inter-iteration data dependency (iteration n needs n−1's result)
2. bA per-element branch that makes lanes do different work
3. cOperating on float4 values with + and math.* intrinsics
4. dA call into managed code the optimizer can't inline

05why

A Burst benchmark reports an impossibly fast result. Name the cause and the fix in one.

1. aThe CPU throttled; add cooling
2. bDead-code elimination deleted the unused loop — make the result observable (store to a NativeArray / return it) so the compiler can't prove the work is dead
3. cThe array was too small; make it bigger
4. dBurst was disabled; enable it

06howmeasure

Build the Burst-vs-no-Burst comparison from the lab (same vectorizable loop, [BurstCompile] on vs off, warmed up, DCE defeated). Enter time_noBurst / time_Burst.

07howmeasure

Now isolate vectorization: keep Burst on for both, add an inter-iteration carry to force scalar in one. Enter time_scalarForced / time_clean.