ecs-performance-audit

Performance bottlenecks in ECS stem from inefficient entity iteration, excessive memory allocations in hot loops, and poor cache coherency. Analyze your OnUpdate and rendering loops for LINQ materializations (.ToList, .ToArray), boxing, closure captures, and O(n²) patterns. Profile frame-time drops by inspecting system execution order, component data layout (Structure of Arrays vs Array of Structures), and reflection usage to pinpoint the slowest paths.

Frame rate drops under heavy entity counts typically result from memory allocations in tight loops, inefficient component lookups, and poor data locality. LINQ allocations, reflection in tight paths, suboptimal system scheduling order, and cache-incoherent data access patterns force the CPU to stall. Audit your iteration patterns and prioritize eliminating allocations and optimizing data layout for sequential memory access.

Optimize entity iteration by replacing LINQ materializations with direct iteration, eliminating boxing and closure captures, and validating system execution order for parallelization potential. Restructure component data layout for cache coherency—prefer Structure of Arrays over Array of Structures—and reduce reflection usage. Measure allocations and frame time before and after each change to quantify performance gains.

Yes. ECS performance optimization targets C# implementations by analyzing OnUpdate loops, rendering systems, and event handlers for allocation patterns, data layout efficiency, and cache coherency. The approach applies directly to C#-based game engines and custom ECS frameworks, focusing on LINQ usage, component access patterns, and memory allocation detection in hot paths.

Watch for LINQ materializations (.ToList, .ToArray, .Where/.Select), boxing from value types, closure captures in delegates, and reflection-based component lookups in tight loops. These allocations fragment the heap, increase garbage collection pressure, and cause frame stutters. Refactor to use direct iteration, pre-computed component handles, and stack-allocated structures to eliminate per-frame allocations.

Cache coherency determines whether CPU caches can efficiently access entity component data. Array of Structures layouts scatter related components across memory, causing cache misses. Structure of Arrays packs each component type contiguously, enabling sequential memory access and cache-friendly prefetching. Poor data locality forces expensive main-memory stalls; optimizing layout can significantly reduce frame time under large entity counts.