Menggunakan Grand Central Dispatch di Swift untuk memparalelkan dan mempercepat loop "untuk"?

Sebuah "iterasi multi-utas" dapat dilakukan dengan 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 {
       // ...
    }
}

(Anda harus mengetahui hubungan terbaik antara hitungan luar dan dalam.)

Ada dua hal yang perlu diperhatikan:

• arc4random() menggunakan mutex internal, yang membuatnya sangat lambat ketika dipanggil dari beberapa thread secara paralel, lihat Kinerja kode bersamaan menggunakan pengiriman_group_async JAUH lebih lambat dibandingkan versi single-threaded. Dari jawaban yang diberikan di sana, rand_r() (dengan benih terpisah untuk setiap utas) tampaknya merupakan alternatif yang lebih cepat.

• Variabel hasil winner tidak boleh diubah dari beberapa thread secara bersamaan. Anda dapat menggunakan array di mana setiap thread memperbarui elemennya sendiri, dan hasilnya ditambahkan setelahnya. Metode thread-safe telah dijelaskan di https://stackoverflow.com/a/26790019/1187415.

Maka kira-kira akan terlihat seperti ini:

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)

Hanya untuk memperbarui sintaksis kontemporer, kami sekarang menggunakan concurrentPerform (yang menggantikan dispatch_apply).

Jadi kita bisa menggantinya

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

Dengan

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

Perlu diperhatikan, paralelisasi menimbulkan sedikit overhead, baik dalam mekanisme pengiriman GCD dasar, maupun sinkronisasi hasilnya. Jika Anda memiliki 32 iterasi dalam loop paralel, ini tidak akan menjadi masalah, tetapi Anda memiliki satu juta iterasi, dan iterasi tersebut akan mulai bertambah.

Kami biasanya menyelesaikan masalah ini dengan “melangkah”: Daripada memparalelkan 1 juta iterasi, Anda mungkin hanya melakukan 100 iterasi paralel, yang masing-masing melakukan 10.000 iterasi. Misalnya. sesuatu seperti:

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 {
            ...
        }
    }
}