C# Archetype式ECS中最快迭代技术及缓存优化问询

问题背景 #

我正在C#中开发一款基于Archetype的小型ECS，目标是通过缓存高效的迭代实现极致性能。当前迭代代码如下：

var chunks = archetype.Chunks; // Property that returns a Chunk[] array
for (var chunkIndex = 0; chunkIndex < archetype.Size; chunkIndex++) {
    ref var chunk = ref chunks[chunkIndex];
    var transforms = chunk.GetArray<Transform>();  // Returns a Transform[] array
    var rotations = chunk.GetArray<Rotation>();    // Returns a Rotation[] array

    for (var index = 0; index < chunk.Capacity; index++) {
        ref var transform = ref transforms[index];
        ref var rotation = ref rotations[index];

        transform.x++;
        rotation.w++;
    }
}

相关结构定义：

public struct Transform{ float x; float y; }
public struct Rotation{ float x; float y; float z; float w; }

T[] (chunk).GetArray<T>(){
   return fittingTightlyPackedManagedArrayForT as T[]; // Pseudocode
}

int (chunk).Capacity{ get; set; }  // Just a property of how big each array is in the chunk, all having the same size

我已尝试通过unsafe变体减少边界检查，但缓存命中率下降，性能提升微乎其微。请问还有哪些方法可以提升迭代速度并提高缓存命中率？

优化方案 #

1. 重组组件内存布局，提升缓存局部性 #

当前实现是纯SoA（数组结构），每个组件单独存储，迭代时需要跨两个离散内存块访问数据，会频繁触发缓存行切换。可以调整为：

• AoS-of-SoA混合结构：将同实体的Transform和Rotation打包成复合结构体，再按chunk存储该结构体的数组：

[StructLayout(LayoutKind.Sequential, Pack = 16)]
public struct TransformRotationPair
{
    public Transform Transform;
    public Rotation Rotation;
}

这样每个实体的两个组件数据在内存中连续，迭代时一次缓存加载即可覆盖所需数据，大幅降低缓存 miss 率。

• 若需保留SoA灵活性，可在chunk内将各组件数组的起始地址对齐到缓存行（通常64字节），且不同组件数组间隔至少一个缓存行，避免伪共享导致的缓存无效化。

2. 用Span<T>替代数组，消除不必要开销 #

GetArray<T>()返回的数组会带来隐式边界检查，改用Span<T>可让JIT优化为无边界检查的访问，同时避免数组装箱或间接内存访问：

// 修改Chunk的组件获取方法
public Span<Transform> GetTransformSpan() => new Span<Transform>(_transformBuffer, 0, Capacity);
public Span<Rotation> GetRotationSpan() => new Span<Rotation>(_rotationBuffer, 0, Capacity);

迭代时直接使用Span：

var transforms = chunk.GetTransformSpan();
var rotations = chunk.GetRotationSpan();
for (int i = 0; i < transforms.Length; i++)
{
    ref var t = ref transforms[i];
    ref var r = ref rotations[i];
    t.x++;
    r.w++;
}

Span的索引访问会被JIT优化为无边界检查，性能接近unsafe指针操作，但更安全。

3. 手动循环展开，减少分支开销 #

内层循环的控制逻辑（索引递增、边界判断）会占用CPU指令周期，手动展开循环可让指令流水线更高效，尤其适合操作简单的场景：

int i = 0;
int batchSize = 4;
// 批量处理实体
for (; i <= chunk.Capacity - batchSize; i += batchSize)
{
    ref var t0 = ref transforms[i];
    ref var r0 = ref rotations[i];
    ref var t1 = ref transforms[i+1];
    ref var r1 = ref rotations[i+1];
    ref var t2 = ref transforms[i+2];
    ref var r2 = ref rotations[i+2];
    ref var t3 = ref transforms[i+3];
    ref var r3 = ref rotations[i+3];

    t0.x++; r0.w++;
    t1.x++; r1.w++;
    t2.x++; r2.w++;
    t3.x++; r3.w++;
}
// 处理剩余实体
for (; i < chunk.Capacity; i++)
{
    ref var t = ref transforms[i];
    ref var r = ref rotations[i];
    t.x++; r.w++;
}

JIT可能自动做部分展开，但手动展开可针对你的场景精准优化。

4. 缓存行对齐与伪共享规避 #

• 分配组件内存时，确保起始地址对齐到64字节（x86/x64平台缓存行大小），可使用Marshal.AllocHGlobal指定对齐参数，或用Memory<T>的对齐重载。
• 不同组件数组之间的内存间隔至少为一个缓存行，避免两个数组的缓存行重叠导致伪共享（比如Transform数组末尾与Rotation数组开头在同一缓存行，会触发CPU缓存无效化）。

5. 提前缓存循环依赖数据 #

避免在循环内重复访问属性或调用方法，提前将Capacity、组件数组等数据缓存到局部变量，减少内存间接访问：

var chunks = archetype.Chunks;
int chunkCount = archetype.Size;
for (var chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++)
{
    ref var chunk = ref chunks[chunkIndex];
    var transforms = chunk.GetArray<Transform>();
    var rotations = chunk.GetArray<Rotation>();
    int capacity = chunk.Capacity; // 提前缓存Capacity

    for (var index = 0; index < capacity; index++)
    {
        ref var transform = ref transforms[index];
        ref var rotation = ref rotations[index];
        transform.x++;
        rotation.w++;
    }
}

6. 精准使用unsafe指针操作 #

若必须用unsafe代码，直接获取组件内存的起始指针而非数组的unsafe访问，彻底消除数组边界检查和间接开销：

unsafe
{
    var chunks = archetype.Chunks;
    int chunkCount = archetype.Size;
    for (var chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++)
    {
        ref var chunk = ref chunks[chunkIndex];
        Transform* transformPtr = (Transform*)chunk.GetTransformPointer(); // 新增返回指针的方法
        Rotation* rotationPtr = (Rotation*)chunk.GetRotationPointer();
        int capacity = chunk.Capacity;

        for (int i = 0; i < capacity; i++)
        {
            transformPtr[i].x++;
            rotationPtr[i].w++;
        }
    }
}

注意必须保证指针指向的内存连续、对齐，且管理好内存生命周期，避免野指针。

内容的提问来源于stack exchange，提问作者genaray