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

发表于 更新于 分类于

Swift是OO（面向对象）的语言，所以少不了方法和属性的重载等特性，程序只能在运行时来确定具体的方法或属性来间接调用或间接访问，这就叫做动态派发。从性能上考虑，对于动态派发的方法，会有常量时间的运行时开销。接下来将介绍三种方法来移除这样的动态性，final，private，全模块优化（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. 调用变量p的update方法。
  2. 调用p的updatePoint方法。
  3. 获取p的元组类型变量point。
  4. 获取p的属性velocity。

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

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

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

在属性，方法或类声明时加上final关键字，表示其不能被重载，这将允许编译器安全的移除动态派发。如下代码所示，point和velocity将直接从对象的存储属性中加载，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)
	}
}

如上代码所示，point和velocity将直接访问，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，既相当于在point、velocity、updatePoint()声明前加上final关键字，而update()方法由于是public级别，所以无法推断出final关键字，其仍将是间接调用。

总结：

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