我试图通过至少在两个不同的核心上分布它来加速一个减慢我的主线程的进程。

我认为我可以做到这一点的原因是每个单独的操作都是独立的，只需要两个点和一个 float 。

然而，我的第一个尝试是在执行 queue.asnc 与 queue.sync 时代码运行速度明显变慢，我不知道为什么!

这里是同步运行的代码

var block = UnsafeMutablePointer<Datas>.allocate(capacity: 0)
var outblock = UnsafeMutablePointer<Decimal>.allocate(capacity: 0)
func initialise()
{
    outblock = UnsafeMutablePointer<Decimal>.allocate(capacity: testWith * 4 * 2)

    block = UnsafeMutablePointer<Datas>.allocate(capacity: particles.count)
}

func update()
{
    var i = 0
    for part in particles
    {
        part.update()

        let x1 = part.data.p1.x; let y1 = part.data.p1.y
        let x2 = part.data.p2.x; let y2 = part.data.p2.x;

        let w = part.data.size * rectScale
        let w2 = part.data.size * rectScale

        let dy = y2 - y1; let dx = x2 - x1
        let length = sqrt(dy * dy + dx * dx)
        let calcx = (-(y2 - y1) / length)
        let calcy = ((x2 - x1) / length)
        let calcx1 = calcx * w
        let calcy1 = calcy * w
        let calcx2 = calcx * w2
        let calcy2 = calcy * w2
        outblock[i] = x1 + calcx1
        outblock[i+1] = y1 + calcy1

        outblock[i+2] = x1 - calcx1
        outblock[i+3] = y1 - calcy1

        outblock[i+4] = x2 + calcx2
        outblock[i+5] = y2 + calcy2

        outblock[i+6] = x2 - calcx2
        outblock[i+7] = y2 - calcy2

        i += 8
    }
}

这是我在多个内核之间分配工作负载的尝试

let queue = DispatchQueue(label: "construction_worker_1", attributes: .concurrent)

let blocky = block
let oblocky = outblock
for i in 0..<particles.count
{
    particles[i].update()
    block[i] = particles[i].data//Copy the raw data into a thead safe format
    queue.async {
        let x1 = blocky[i].p1.x; let y1 = blocky[i].p1.y
        let x2 = blocky[i].p2.x; let y2 = blocky[i].p2.x;

        let w = blocky[i].size * rectScale
        let w2 = blocky[i].size * rectScale

        let dy = y2 - y1; let dx = x2 - x1
        let length = sqrt(dy * dy + dx * dx)
        let calcx = (-(y2 - y1) / length)
        let calcy = ((x2 - x1) / length)
        let calcx1 = calcx * w
        let calcy1 = calcy * w
        let calcx2 = calcx * w2
        let calcy2 = calcy * w2

        let writeIndex = i * 8
        oblocky[writeIndex] = x1 + calcx1
        oblocky[writeIndex+1] = y1 + calcy1

        oblocky[writeIndex+2] = x1 - calcx1
        oblocky[writeIndex+3] = y1 - calcy1

        oblocky[writeIndex+4] = x2 + calcx2
        oblocky[writeIndex+5] = y2 + calcy2

        oblocky[writeIndex+6] = x2 - calcx2
        oblocky[writeIndex+7] = y2 - calcy2
    }
}

我真的不知道为什么会出现这种放缓!我正在使用 UnsafeMutablePointer，因此数据是线程安全的，并且我确保没有变量可以同时被多个线程读取或写入。

这是怎么回事？

最佳答案

如 Performing Loop Iterations Concurrently 中所述，将每个 block 分派(dispatch)到某个后台队列都会产生开销。因此，您需要“跨越”数组，让每次迭代处理多个数据点，而不仅仅是一个。

此外，dispatch_apply，在 Swift 3 及更高版本中称为 concurrentPerform，专为并行执行循环而设计，并针对特定设备的内核进行了优化。结合跨步，您应该获得一些性能优势:

DispatchQueue.global(qos: .userInitiated).async {
    let stride = 100
    DispatchQueue.concurrentPerform(iterations: particles.count / stride) { iteration in
        let start = iteration * stride
        let end = min(start + stride, particles.count)
        for i in start ..< end {
            particles[i].update()
            block[i] = particles[i].data//Copy the raw data into a thead safe format
            queue.async {
                let x1 = blocky[i].p1.x; let y1 = blocky[i].p1.y
                let x2 = blocky[i].p2.x; let y2 = blocky[i].p2.x

                let w = blocky[i].size * rectScale
                let w2 = blocky[i].size * rectScale

                let dy = y2 - y1; let dx = x2 - x1
                let length = hypot(dy, dx)
                let calcx = -dy / length
                let calcy = dx / length
                let calcx1 = calcx * w
                let calcy1 = calcy * w
                let calcx2 = calcx * w2
                let calcy2 = calcy * w2

                let writeIndex = i * 8
                oblocky[writeIndex] = x1 + calcx1
                oblocky[writeIndex+1] = y1 + calcy1

                oblocky[writeIndex+2] = x1 - calcx1
                oblocky[writeIndex+3] = y1 - calcy1

                oblocky[writeIndex+4] = x2 + calcx2
                oblocky[writeIndex+5] = y2 + calcy2

                oblocky[writeIndex+6] = x2 - calcx2
                oblocky[writeIndex+7] = y2 - calcy2
            }
        }
    }
}

您应该尝试不同的 stride 值，看看性能如何变化。

我无法运行此代码(我没有示例数据，我没有Datas 的定义等)，所以如果我引入任何问题，我深表歉意。但是不要关注这里的代码，而是关注更广泛的问题，即使用 concurrentPerform 执行并发循环，并努力确保每个线程都有足够的工作，因此线程开销并不会超过并行运行线程带来的更广泛的好处。

有关详细信息，请参阅 https://stackoverflow.com/a/22850936/1271826在这里对问题进行更广泛的讨论。

关于ios - 同步排队比异步排队时代码运行得更快。不应该相反吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46498928/