Использование Grand Central Dispatch в Swift для распараллеливания и ускорения циклов for?

«Многопоточная итерация» может быть выполнена с помощью dispatch_apply():

let outerCount = 100    // # of concurrent block iterations
let innerCount = 10000  // # of iterations within each block

let the_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(UInt(outerCount), the_queue) { outerIdx -> Void in
    for innerIdx in 1 ... innerCount {
       // ...
    }
}

(Вы должны выяснить наилучшее соотношение между внешними и внутренними счетами.)

Есть две вещи, на которые стоит обратить внимание:

• arc4random() использует внутренний мьютекс, что делает его чрезвычайно медленным при параллельном вызове из нескольких потоков, см. Производительность параллельного кода с использованием dispatch_group_async НАМНОГО медленнее, чем в однопоточной версии. Судя по приведенным там ответам, rand_r() (с отдельными семенами для каждого потока) кажется более быстрой альтернативой.

• Переменная результата winner не должна изменяться из нескольких потоков одновременно. Вместо этого вы можете использовать массив, где каждый поток обновляет свой собственный элемент, а результаты добавляются позже. Поточно-ориентированный метод описан в https://stackoverflow.com/a/26790019/1187415.

Тогда это будет выглядеть примерно так:

let outerCount = 100     // # of concurrent block iterations
let innerCount = 10000   // # of iterations within each block

let the_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

var winners = [Int](count: outerCount, repeatedValue: 0)
winners.withUnsafeMutableBufferPointer { winnersPtr -> Void in

    dispatch_apply(UInt(outerCount), the_queue) { outerIdx -> Void in
        var seed = arc4random() // seed for rand_r() in this "thread"

        for innerIdx in 1 ... innerCount {
            var points = 0
            var ability = 500

            for i in 1 ... 1000 {
                let chance = Int(rand_r(&seed) % 1001)
                if chance < (ability-points) { ++points }
                else {points = points - 1}
            }
            if points > 0 {
                winnersPtr[Int(outerIdx)] += 1
            }
        }
    }
}

// Add results:
let winner = reduce(winners, 0, +)
println(winner)

Просто чтобы обновить это для современного синтаксиса, мы теперь используем concurrentPerform (который заменяет dispatch_apply).

Таким образом, мы можем заменить

for j in 0 ..< 1_000_000 {
    for i in 0 ..< 1000 {
        ...
    }
}

С участием

DispatchQueue.concurrentPerform(1_000_000) { j in
    for i in 0 ..< 1000 {
        ...
    }
}

Обратите внимание, что распараллеливание вносит небольшие накладные расходы как в базовый механизм диспетчеризации GCD, так и в синхронизацию результатов. Если бы у вас было 32 итерации в параллельном цикле, это было бы несущественно, но у вас есть миллион итераций, и они начнут складываться.

Обычно мы решаем это путем «шагания»: вместо того, чтобы распараллеливать 1 миллион итераций, вы можете сделать только 100 параллельных итераций, выполняя по 10 000 итераций каждая. Например. что-то типа:

let totalIterations = 1_000_000
let stride = 10_000
let (quotient, remainder) = totalIterations.quotientAndRemainder(dividingBy: stride)
let iterations = quotient + remainder == 0 ? 0 : 1

DispatchQueue.concurrentPerform(iterations: iterations) { iteration in
    for j in iteration * stride ..< min(totalIterations, (iteration + 1) * stride) {
        for i in 0 ..< 1000 {
            ...
        }
    }
}