Swift之通过减少动态派发来提升性能

Swift是OO(面向对象)的语言,所以少不了方法和属性的重载等特性,程序只能在运行时来确定具体的方法或属性来间接调用或间接访问,这就叫做动态派发。从性能上考虑,对于动态派发的方法,会有常量时间的运行时开销。接下来将介绍三种方法来移除这样的动态性,finalprivate,全模块优化(Whole Module Optimization),以此提升性能。

考虑下面的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class ParticleModel {
var point = ( 0.0, 0.0 )
var velocity = 100.0

func updatePoint(newPoint: (Double, Double), newVelocity: Double) {
point = newPoint
velocity = newVelocity
}

func update(newP: (Double, Double), newV: Double) {
updatePoint(newP, newVelocity: newV)
}
}

var p = ParticleModel()
for i in stride(from: 0.0, through: 360, by: 1.0) {
p.update((i * sin(i), i), newV:i*1000)
}

如上述代码所示,调用过程为:

  1. 调用变量pupdate方法。
  2. 调用pupdatePoint方法。
  3. 获取p的元组类型变量point
  4. 获取p的属性velocity。

由于ParticleModel可以被子类,所以其方法和属性就能被重载,这就不可避免的需要使用动态调用。

在Swift中,动态调用是通过在一个方法表中找到方法然后执行间接的调用(类似于C++的虚函数表),对于这种先查找再调用的过程,其效率是要低于方法的直接调用,而且间接调用会阻止许多编译器优化,这将加重间接调用的开销。接下来将列举一些技巧来禁用动态派发的行为,以达到提升性能的目的。

当属性、方法、或类不需要被重载时,可在其声明的地方加上final关键字

在属性,方法或类声明时加上final关键字,表示其不能被重载,这将允许编译器安全的移除动态派发。如下代码所示,pointvelocity将直接从对象的存储属性中加载,updatePoint()方法将被直接调用;另外,update()依然会通过动态派发的方式来调用,这样,ParticleModel的子类就可以重载update()来自定义实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
class ParticleModel {
final var point = ( x: 0.0, y: 0.0 )
final var velocity = 100.0

final func updatePoint(newPoint: (Double, Double), newVelocity: Double) {
point = newPoint
velocity = newVelocity
}

func update(newP: (Double, Double), newV: Double) {
updatePoint(newP, newVelocity: newV)
}
}

除了上面所示,在属性和方法声明前加final关键字,还可以直接在类上加final,表示该类将不能作为父类被子类化,隐含的表明该类的所有的方法和属性都是final的。

1
2
3
4
5
final class ParticleModel {
var point = ( x: 0.0, y: 0.0 )
var velocity = 100.0
// ...
}

在属性、方法、或类声明前加private关键字,将限制其只能在同一个文件中被引用

在声明前加private关键字,将限制其只能在当前文件中被引用,这将允许编译器在当前文件中找到所有潜在的重载声明,编译器会对这些private关键字的方法或属性进行优化,移除间接的方法调用以及属性访问。

假设在当前文件中没有类重载ParticleModel,那么编译器将移除所有带有private声明的动态派发调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
class ParticleModel {
private var point = ( x: 0.0, y: 0.0 )
private var velocity = 100.0

private func updatePoint(newPoint: (Double, Double), newVelocity: Double) {
point = newPoint
velocity = newVelocity
}

func update(newP: (Double, Double), newV: Double) {
updatePoint(newP, newVelocity: newV)
}
}

如上代码所示,pointvelocity将直接访问,updatePoint()方法也将直接被调用,而update()方法由于没有加private关键字,依然是只能间接调用。
同样,private可以加在类的声明前,等同于类的所有方法和属性都将加上private关键字。

1
2
3
4
5
private class ParticleModel {
var point = ( x: 0.0, y: 0.0 )
var velocity = 100.0
// ...
}

在使用internal的声明中通过使用Whole Module Optimization来隐式的推断出final

默认的情况下,Xcode将单独编译源文件,这会限制编译器优化的程度,Xcode 7后,增加了Whole Module Optimization选项,它能允许编译器在同一个模块(Module)中分析所有的源文件来进行优化,可以在Xcode的Building Settings中开启该选项,如下图所示。

在开启Whole Module Optimization选项,且声明为internal(默认级别)的情况下,模块的所有文件将同时被编译,这将允许编译器对整个模块一起分析,并对没有被重载且声明为internal级别的类、方法或属性添加final关键字。
如下代码所示,我们修改一下ParticleModel类,添加public关键字:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 public class ParticleModel {
var point = ( x: 0.0, y: 0.0 )
var velocity = 100.0

func updatePoint(newPoint: (Double, Double), newVelocity: Double) {
point = newPoint
velocity = newVelocity
}

public func update(newP: (Double, Double), newV: Double) {
updatePoint(newP, newVelocity: newV)
}
}

var p = ParticleModel()
for i in stride(from: 0.0, through: times, by: 1.0) {
p.update((i * sin(i), i), newV:i*1000)
}

如上代码,当开启Whole Module Optimization选项的情况下,编译器能在属性point,velotity,以及updatePoint()方法上推断出final,既相当于在pointvelocityupdatePoint()声明前加上final关键字,而update()方法由于是public级别,所以无法推断出final关键字,其仍将是间接调用。

总结:

  • 当使用privatefinal关键字,或者在开启Whole Module Optimization选项,声明为internal级别的没有被重载的方法下,将直接调用,在编译时确定。
  • 运行时决定的动态派发的情形包括:
    • 继承自NSObject或者方法有@objc前缀。
    • 使用Swift的方法表的方式,除去上述情况下,将采用这种方式。