10

我正在用 Swift 构建一个物理引擎。在最近对引擎进行了一些添加并运行了基准测试之后，我注意到性能大大降低了。例如，在下面的屏幕截图中，您可以看到 FPS 如何从 60 FPS 下降到 3 FPS（FPS 在右下角）。最终，我将问题追溯到一行代码：

final class Shape {
    ...
    weak var body: Body! // This guy
    ...
}

在我的补充中，我添加了一个从Shape类到Body类的弱引用。这是为了防止强引用循环，因为Body也有强引用Shape.

不幸的是，弱引用似乎有很大的开销（我想将它归零的额外步骤）。我决定通过构建下面的物理引擎的大规模简化版本并对不同的参考类型进行基准测试来进一步研究这一点。

import Foundation

final class Body {
    let shape: Shape
    var position = CGPoint()
    init(shape: Shape) {
        self.shape = shape
        shape.body = self
        
    }
}

final class Shape {
    weak var body: Body! //****** This line is the problem ******
    var vertices: [CGPoint] = []
    init() {
        for _ in 0 ..< 8 {
            self.vertices.append( CGPoint(x:CGFloat.random(in: -10...10), y:CGFloat.random(in: -10...10) ))
        }
    }
}

var bodies: [Body] = []
for _ in 0 ..< 1000 {
    bodies.append(Body(shape: Shape()))
}

var pairs: [(Shape,Shape)] = []
for i in 0 ..< bodies.count {
    let a = bodies[i]
    for j in i + 1 ..< bodies.count {
        let b = bodies[j]
        pairs.append((a.shape,b.shape))
    }
}

/*
 Benchmarking some random computation performed on the pairs.
 Normally this would be collision detection, impulse resolution, etc.
 */
let startTime = CFAbsoluteTimeGetCurrent()
for (a,b) in pairs {
    var t: CGFloat = 0
    for v in a.vertices {
        t += v.x*v.x + v.y*v.y
    }
    for v in b.vertices {
        t += v.x*v.x + v.y*v.y
    }
    a.body.position.x += t
    a.body.position.y += t
    b.body.position.x -= t
    b.body.position.y -= t
}
let time = CFAbsoluteTimeGetCurrent() - startTime

print(time)

结果

以下是每种参考类型的基准时间。在每次测试中，body对类的引用都发生了Shape变化。该代码是使用发布模式 [-O] 和面向 macOS 10.15 的 Swift 5.1 构建的。

weak var body: Body!: 0.1886 秒

var body: Body!: 0.0167 秒

unowned body: Body!: 0.0942 秒

您可以看到在上面的计算中使用强引用而不是弱引用会导致性能提高 10 倍以上。使用unowned帮助，但不幸的是它仍然慢了 5 倍。通过分析器运行代码时，似乎执行了额外的运行时检查，从而导致大量开销。

所以问题是，我有什么选择可以让一个简单的反向指针指向 Body 而不会产生这个 ARC 开销。此外，为什么这种开销看起来如此极端？我想我可以保持强参考周期并手动打破它。但我想知道是否有更好的选择？

更新： 根据答案，结果
unowned(unsafe) var body: Body!如下：0.0160 s

Update2： 从 Swift 5.2 (Xcode 11.4) 开始，我注意到 unowned(unsafe) 的开销要大得多。这是现在的结果 unowned(unsafe) var body: Body!：0.0804 s

注意：从 Xcode 12/Swift 5.3 开始仍然如此

4

1 回答 1

5

在我撰写/调查这个问题时，我最终找到了解决方案。要拥有一个没有开销检查的简单反向指针，weak或者unowned您可以将 body 声明为：

unowned(unsafe) var body: Body!

根据 Swift 文档：

Swift 还为您需要禁用运行时安全检查的情况（例如，出于性能原因）提供不安全的无主引用。与所有不安全的操作一样，您有责任检查该代码的安全性。

你可以通过写 unowned(unsafe) 来表示一个不安全的无主引用。如果您在其引用的实例被释放后尝试访问不安全的无主引用，您的程序将尝试访问该实例曾经所在的内存位置，这是一个不安全的操作

因此很明显，这些运行时检查会在性能关键代码中产生严重的开销。

更新：从 Swift 5.2 (Xcode 11.4) 开始，我注意到它unowned(unsafe)有更多的开销。我现在只是简单地使用强引用并手动中断保留周期，或者尝试在性能关键代码中完全避免它们。

注意：从 Xcode 12/Swift 5.3 开始仍然如此

于 2019-10-31T00:13:08.587 回答