Parallel for loop in Swift - parallel-processing

Question

What is the closest Swift equivalent of the following C & OpenMP code (assume that n is huge and f is simple):
#openmp parallel for
for (int i = 0; i < n; ++i) {
a[i] = f(b[i]);
}
Parallelising a for loop with striding and dispatch_apply seems like a lot of work for such a routine task. Is there any clever shortcut?

Answer 1

If your code has loops, and the work being done each time through the loop is independent of the work being done in the other iterations, you might consider reimplementing that loop code using the dispatch_apply or dispatch_apply_f function. These functions submit each iteration of a loop separately to a dispatch queue for processing. When used in conjunction with a concurrent queue, this feature lets you perform multiple iterations of the loop concurrently.
Read here: https://developer.apple.com/library/content/documentation/General/Conceptual/ConcurrencyProgrammingGuide/ThreadMigration/ThreadMigration.html#//apple_ref/doc/uid/TP40008091-CH105-SW2
For swift: https://developer.apple.com/documentation/dispatch/dispatchqueue/2016088-concurrentperform
DispatchQueue.concurrentPerform(iterations: 1000) { (index) in
print("current: \(index)")
}

Answer 2

It appears (from the iBook) that there's not yet a swift-specific API/language feature for parallelism. Using GCD seems like the best option at this point, performance-wise. If you're looking for code brevity, you can just use the standard Objective-C idiom for concurrent array enumeration:
var array : Int[] = [1,2,3,4]
array.bridgeToObjectiveC().enumerateObjectsWithOptions(NSEnumerationOptions.Concurrent, {(obj: AnyObject!, index: Int, outStop: CMutablePointer<ObjCBool>) -> Void in
// Do stuff
});

Answer 3

The clue in above answer about using concurrentPerform is correct, but not expanded. So here's the simples solution:
class ConcurrentCalculator<T> {
func calc(for b: [T], _ f: (T) -> T) -> [T?] {
let n = b.count
var a: [T?] = Array(repeating: nil, count: n)
DispatchQueue.concurrentPerform(iterations: n) { i in
a[i] = f(b[i])
}
return a
}
}
And here's the test:
let myB = Array(1...100)
func myF(b: Int) -> Int {
b * b
}
let myCalc = ConcurrentCalculator<Int>()
let myA = myCalc.calc(for: myB, myF)
print(myA)
The output will look like
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801, 10000]
Of course this is a basic solution: it's not thread safe, and also it may run into memory issues with large arrays. This can be added later.
The beauty of this approach is that you don't need to count available threads, etc. It will just use all available threads.

Answer 4

For parallelism of for loop in Swift, you must use
DispatchQueue.concurrentPerform(iteration: execute:)

Answer 5

You can convert a Swift array to NSArray and use enumerateObjectsWithOptions without bridging - see simple example below:
let kCompanyListFileNames :[String] = [
"nyse_companylist",
"nasdaq_companylist",
"amex_companylist"
]
let companyListFileNames:NSArray = kCompanyListFileNames as NSArray
companyListFileNames.enumerateObjectsWithOptions(NSEnumerationOptions.Concurrent) {
(companyName:AnyObject!, index:Int, stop:UnsafeMutablePointer<ObjCBool>) -> Void in
println(companyName)
}