Swift粒子模拟：withTaskGroup多核运行速度为何变慢？

我在做粒子模拟时遇到了反常现象：n个粒子需要执行n*n次计算。单核心实现的computeVelocitiesSingle()处理400个粒子耗时约38ms；为了利用M1 Max的10核心性能，我用withTaskGroup把粒子切片拆分到多任务并行执行，但测试结果显示核心数越多总耗时反而越长：2核心约46ms，4核心约67ms，8核心约147ms，10核心约130ms。哪怕把粒子数增加到4000，这个现象也没有改善，而且Activity Monitor显示CPU占用率约900%（所有核心都在活跃计算）。

单核心实现代码 #

private func computeVelocitiesSingle() async {
    // over all particles
    (0 ..< self.particles.count).forEach { i in
        let p = self.particles[i]
        // over all other paricles
        self.particles.forEach { q in
            // doing some computation                   
            p.vx += f * dx
            p.vy += f * dy
        }
    }
}

多核并行实现代码 #

private func computeVelocities() async {
    await withTaskGroup(of: Void.self) { group in
        self.taskSlices.forEach { (i0, i1) in
            group.addTask {
                let clock = ContinuousClock()
                let elapsed = await clock.measure {
                    (i0 ..< i1).forEach { i in
                        let p = self.particles[i]
                        // all other particles
                        self.particles.forEach { q in
                            // doing some computation
                            // updating the 'outer' particle
                            p.vx += f * dx
                            p.vy += f * dy
                        }
                    }
                }
                print("\(i0) ..< \(i1) -> \(elapsed)")
            }
        }
    }
}

问题原因 #

• 缓存失效与内存竞争：多个任务同时读写particles数组中的粒子对象，更新p.vx/p.vy时会触发CPU缓存行失效。不同任务操作同一缓存行内的数据，频繁的缓存同步开销远超过并行计算带来的收益。
• 全局遍历的带宽浪费：每个任务都要遍历完整的particles数组，导致所有核心都要重复读取整个数组，占用大量内存带宽，进一步拖慢计算速度。
• 直接修改共享数据的冲突：原代码中任务直接修改共享的粒子对象，即使没有显式的线程安全问题，也会导致隐式的缓存一致性开销，这是多核心性能下降的核心原因。

优化方案 #

1. 重构计算逻辑，避免重复计算 #

粒子间的相互作用大多是对称的（如引力、斥力），可以只计算i < j的粒子对，同时更新两个粒子的速度，将计算量从n²降至n(n-1)/2，单核心和并行版本都能直接受益。

2. 采用"局部计算+批量合并"模式消除缓存竞争 #

不要直接在共享数组上修改粒子速度，每个任务先计算负责区间内粒子的速度增量，存储到局部数组，所有任务完成后再统一合并到原数组：

private func computeVelocitiesOptimized() async {
    let particleCount = self.particles.count
    // 预分配速度增量数组，每个任务仅写入自身负责的区间
    var velocityDeltas = Array(repeating: (vx: 0.0, vy: 0.0), count: particleCount)
    
    await withTaskGroup(of: Void.self) { group in
        self.taskSlices.forEach { (start, end) in
            group.addTask {
                for i in start ..< end {
                    var dvx = 0.0
                    var dvy = 0.0
                    let particleI = self.particles[i]
                    
                    for particleQ in self.particles {
                        // 执行力计算逻辑
                        let dx = particleQ.x - particleI.x
                        let dy = particleQ.y - particleI.y
                        let distanceSq = dx * dx + dy * dy
                        let force = // 替换为你的力计算公式
                        
                        dvx += force * dx
                        dvy += force * dy
                    }
                    
                    velocityDeltas[i] = (dvx, dvy)
                }
            }
        }
    }
    
    // 批量更新原粒子速度
    for i in 0 ..< particleCount {
        self.particles[i].vx += velocityDeltas[i].vx
        self.particles[i].vy += velocityDeltas[i].vy
    }
}

3. 优化内存布局提升缓存命中率 #

• 如果Particle是类类型，改为结构体类型。Swift结构体是值类型，particles数组会是连续的内存块，CPU缓存能更高效地预取和存储数据。
• 保持数组的连续访问模式，避免随机索引跳转，最大化利用CPU的缓存预取机制。

4. 调整任务粒度减少调度开销 #

根据核心数和粒子数合理划分切片，确保每个任务处理足够多的粒子（比如每个任务处理几百个粒子），减少任务创建、调度和上下文切换的开销。例如10核心处理4000个粒子时，每个任务分配400个粒子是合理的粒度。

5. 利用SIMD或GPU加速 #

对于粒子模拟这种高度并行的计算场景，可进一步利用：

• SIMD指令：使用Swift的SIMD类型（如SIMD2<Double>）同时计算多个粒子的力，单核心就能获得数倍性能提升。
• Metal GPU计算：将粒子计算逻辑编写为Metal Shader，利用GPU的海量并行核心，性能提升会远超过CPU多核心优化。

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