fast locking in a parallel concurrentPerform swift loop - swift

Question

I tried many different code to have a parallel loop faster than a sequential one.
My latest attempt :
startTime = CFAbsoluteTimeGetCurrent()
var totaliter = 0
for x in stride(from: -2.0, to: 2.0, by: delta) {
for y in stride(from: -2.0, to: 2.0, by: delta) {
let cx : Double = x
let cy : Double = y
var zx : Double = 0.0
var zy : Double = 0.0
var iteration : Int = 0
while (zx * zx + zy * zy < 4.0 && iteration < maxIter) {
let tmp = zx * zx - zy * zy + cx
zy = 2.0 * zx * zy + cy
zx = tmp
iteration += 1
totaliter += 1
}
}
}
print(totaliter)
print("\tTime : \(CFAbsoluteTimeGetCurrent() - startTime)")
this sequential code take 4s.
The following using swift-atomic code take 29s :
startTime = CFAbsoluteTimeGetCurrent()
let atomicInc = ManagedAtomic<UInt32>(0)
DispatchQueue.concurrentPerform(iterations: Int(4/delta)) { (xIter) in
for y in stride(from: -2.0, to: 2.0, by: delta) {
let x = -2.0 + (Double(xIter) * delta)
let cx : Double = x
let cy : Double = y
var zx : Double = 0.0
var zy : Double = 0.0
var iteration : Int = 0
while (zx * zx + zy * zy < 4.0 && iteration < maxIter) {
let tmp = zx * zx - zy * zy + cx
zy = 2.0 * zx * zy + cy
zx = tmp
iteration += 1
atomicInc.wrappingIncrement(ordering: AtomicUpdateOrdering.relaxed)
}
}
}
print("\n\tMeaningless number (race condition) : ",atomicInc.load(ordering: .relaxed))
print("\tTime : \(CFAbsoluteTimeGetCurrent() - startTime)")
Replacing the atomicInc.wrappingIncrement by a NSLock lock/unlock take forever, I never had the patience to let it finish. my guess is around 10mn and the cpu is 80% busy on "system" load (as opposed to user load)
I simply can't find a way to have a parallel loop that is faster than the sequential version. All my attempts either failed or had a race condition.
For reference, my previous attempt with a different computation was like this (and, yes, the sequential version was faster than the swift-atomic or the NSLock version, I assumed that drand48 was the culprit, but it seems I was wrong)
DispatchQueue.concurrentPerform(iterations: 100) { (_) in
for _ in 1...iteration / 100 {
let rand_x : Float = Float(drand48())
let rand_y : Float = Float(drand48())
let origin_dist : Float = rand_x * rand_x + rand_y * rand_y
if (origin_dist <= 1) {
atomicinside.wrappingIncrement(ordering: AtomicUpdateOrdering.relaxed)
}
}
}
How would you do a parallel loop that require updating a non-thread-local variable ? Anything will do as long as it's fast. I'm using concurrentPerform because I don't know any better, but I'm open to suggestions.
fun fact : the parallel version is slower while using 4~8x more CPU.

Answer 1

You should take the locking increment out of the inner loop and do a locking
totaliter += iteration