如何更快填充像素缓冲区？Swift 2D游戏引擎性能优化求助

问题背景 #

我正在做一个业余项目：开发一款2D游戏引擎，需要逐帧用调色板颜色绘制每个像素，目标是至少维持60fps帧率。目前还没加任何游戏逻辑，只是单纯通过调色板更新像素值。为了避免编译器对固定值做循环优化，我给索引加了取模操作。

基础实现代码：

struct BGRA
{
    let blue: UInt8
    let green: UInt8
    let red: UInt8
    let alpha: UInt8
}

let BGRAPallet =
[
    BGRA(blue: 124, green: 124, red: 124, alpha: 0xff),
    BGRA(blue: 252, green: 0, red: 0, alpha: 0xff),
// ... 代码里还有62个值，这里省略
]

private func test()
{
    let screenWidth: Int = 256
    let screenHeight: Int = 240
    let pixelBufferPtr = UnsafeMutableBufferPointer<BGRA>.allocate(capacity: screenWidth * screenHeight)
    let runCount = 1000
    let start = Date.now
    for _ in 0 ..< runCount
    {
        for index in 0 ..< pixelBufferPtr.count
        {
            pixelBufferPtr[index] = BGRAPallet[index % BGRAPallet.count]
        }
    }
    let elapsed = Date.now.timeIntervalSince(start)
    print("Average time per run: \((Int(elapsed) * 1000) / runCount) ms")
}

当前性能：iPhone 12 Pro上每次更新像素平均耗时43ms，M1 Mac模拟器上15ms，无法预留足够资源给后续游戏逻辑。瓶颈在CPU，希望在非并行前提下优化，Instruments显示耗时集中在IndexingIterator.next()。

优化方案（非并行） #

1. 替换for-in循环为手动计数的while循环，消除迭代器开销

Swift的for-in循环会生成IndexingIterator，其next()调用是你看到的主要耗时点。改用手动维护索引的while循环，直接操作指针或下标，彻底避免迭代器的额外开销。

2. 用位运算替代取模操作，减少CPU计算量

你的调色板长度是64（2+62），刚好是2的幂。对于2^n的数值，index % 64完全等价于index & 63（63=64-1），位运算的执行速度远快于取模运算。

3. 直接操作原始指针，跳过数组边界检查

Swift默认会对数组下标访问做边界检查，带来额外开销。通过withUnsafeBufferPointer获取调色板和缓冲区的原始指针，直接进行内存操作，既能跳过边界检查，又能提升访问速度。

4. 批量内存复制（针对像素数是调色板整数倍的场景）

你的屏幕像素数是256*240=61440，刚好是64的960倍。可以直接用memcpy一次性复制整个调色板的内存块到缓冲区，重复960次即可填满屏幕。memcpy是系统高度优化的函数，利用CPU缓存和批量操作特性，比逐个像素赋值快得多。

优化后的代码示例 #

@frozen struct BGRA {
    let blue: UInt8
    let green: UInt8
    let red: UInt8
    let alpha: UInt8
}

let BGRAPallet =
[
    BGRA(blue: 124, green: 124, red: 124, alpha: 0xff),
    BGRA(blue: 252, green: 0, red: 0, alpha: 0xff),
// ... 剩余62个调色板值
]

private func optimizedTest() {
    let screenWidth: Int = 256
    let screenHeight: Int = 240
    let pixelCount = screenWidth * screenHeight
    let paletteCount = BGRAPallet.count
    let paletteMask = paletteCount - 1 // 63，替代取模的位掩码
    
    // 分配像素缓冲区，记得最后释放
    let pixelBufferPtr = UnsafeMutableBufferPointer<BGRA>.allocate(capacity: pixelCount)
    defer { pixelBufferPtr.deallocate() }
    
    // 获取调色板和缓冲区的原始指针
    let palettePtr = BGRAPallet.withUnsafeBufferPointer { $0.baseAddress! }
    let destPtr = pixelBufferPtr.baseAddress!
    
    let runCount = 1000
    let start = Date.now
    
    for _ in 0..<runCount {
        // 因为像素数是调色板的整数倍，直接批量复制
        let fullCopies = pixelCount / paletteCount
        for copyIdx in 0..<fullCopies {
            let destOffset = copyIdx * paletteCount
            memcpy(destPtr + destOffset, palettePtr, paletteCount * MemoryLayout<BGRA>.stride)
        }
        
        // 如果像素数不是调色板整数倍，处理剩余像素（此处不需要）
        // var remainingIdx = fullCopies * paletteCount
        // while remainingIdx < pixelCount {
        //     destPtr[remainingIdx] = palettePtr[remainingIdx & paletteMask]
        //     remainingIdx += 1
        // }
    }
    
    let elapsed = Date.now.timeIntervalSince(start)
    print("Optimized average time per run: \((Int(elapsed * 1000)) / runCount) ms")
}

额外小优化 #

• 给BGRA结构体加上@frozen：告诉编译器结构体布局固定，允许更多编译优化。
• 提前计算常量：把pixelCount、paletteCount等常量放在循环外，避免重复计算。
• 复用缓冲区：实际引擎中不要每次帧都重新分配像素缓冲区，复用已分配的内存可以避免内存分配/释放的开销。

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