Swift進階之內存模型和方法調度

前言

Apple今年推出了Swift3.0，較2.3來說，3.0是一次重大的升級。關於這次更新，在這裏都可以找到，最主要的還是提高了Swift的性能，優化了Swift API的設計（命名）規範。

前段時間對之前寫的一個項目ImageMaskTransition做了簡單遷移，先保證能在3.0下正常運行，只用了不到30分鐘。總的來說，這次遷移還是非常輕鬆的。但是，有一點要注意：3.0的API設計規範較2.3有了質變，建議做遷移的開發者先看下WWDC的Swift API Design Guidelines。後面有時間了，我有可能也會總結下。

---

內存分配

通過查看Github上Swift的源代碼語言分佈

可以看到

• Swift語言是用C++寫的
• Swift的核心Library是用Swift自身寫的。

對於C++來說，內存區間如下

• 堆區
• 棧區
• 代碼區
• 全局靜態區

Swift的內存區間和C++類似。也有存儲代碼和全局變量的區間，這兩種區間比較簡單，本文更多專注於以下兩個內存區間。

• Stack（棧），存儲值類型的臨時變量，函數調用棧，引用類型的臨時變量指針
• Heap（堆），存儲引用類型的實例

棧

在棧上分配和釋放內存的代價是很小的，因爲棧是一個簡單的數據結構。通過移動棧頂的指針，就可以進行內存的創建和釋放。但是，棧上創建的內存是有限的，並且往往在編譯期就可以確定的。

舉個很簡單的例子：當一個遞歸函數，陷入死循環，那麼最後函數調用棧會溢出。

例如，一個沒有引用類型Struct的臨時變量都是在棧上存儲的

struct Point{
    var x:Double // 8 Bytes
    var y:Double // 8 bytes
}
let size = MemoryLayout<Point>.size
print(size) // 16
let point1 = Point(x:5.0,y:5.0)
let instanceSize = MemoryLayout<Point>.size(ofValue: point1)
print(instanceSize) //16

那麼，這個內存結構如圖

Tips: 圖中的每一格都是一個Word大小，在64位處理器上，是8個字節

堆

在堆上可以動態的按需分配內存，每次在堆上分配內存的時候，需要查找堆上能提供相應大小的位置，然後返回對應位置，標記指定位置大小內存被佔用。

在堆上能夠動態的分配所需大小的內存，但是由於每次要查找，並且要考慮到多線程之間的線程安全問題，所以性能較棧來說低很多。

比如，我們把上文的struct改成class,

class PointClass{
    var x:Double = 0.0
    var y:Double = 0.0
}
let size2 = MemoryLayout<PointClass>.size
print(size2) //8 
let point2 = Point(x:5.0,y:5.0)
let instanceSize = MemoryLayout<Point>.size(ofValue: point2)
print(instanceSize) //8

這時候的內存結構如圖

Tips: 圖中的每一格都是一個Word大小，在64位處理器上，是8個字節

Memory Alignment（內存對齊）

和C/C++/OC類似，Swift也有Memory Alignment的概念。舉個直觀的例子
我們定義這樣兩個Struct

struct S{
    var x:Int64
    var y:Int32
}
struct SReverse{
    var y:Int32
    var x:Int64
}

然後，用MemoryLayout來獲取兩個結構體的大小

let sSize = MemoryLayout<S>.size //12
let sReverseSize = MemoryLayout<SReverse>.size //16

可以看到，只不過調整了結構體中的聲明順序，其佔用的內存大小就改變了，這就是內存對齊。

我們來看看，內存對齊後的內存空間分佈：

內存對齊的原因是，

現代CPU每次讀數據的時候，都是讀取一個word（32位處理器上是4個字節，64位處理器上是8個字節）。

內存對齊的優點很多

• 保證對一個成員的訪問在一個Transition中，提高了訪問速度，同時還能保證一次操作的原子性。除了這些，內存對齊還有很多優點，可以看看這個SO答案

---

自動引用計數(ARC)

提到ARC，不得不先講講Swift的兩種基本類型：

• 值類型，在賦值的時候，會進行值拷貝
• 引用類型，在賦值的時候，只會進行引用（指針）拷貝

比如，如下代碼

struct Point{ //Swift中，struct是值類型
    var x,y:Double
}
class Person{//Swift中，class是引用類型
    var name:String
    var age:Int
    init(name:String,age:Int){
        self.name = name
        self.age = age
    }
}
var point1 = Point(x: 10.0, y: 10.0)
var point2 = point1
point2.x = 9.0
print(point1.x) //10.0

var person1 = Person(name: "Leo", age: 24)
var person2 = person1
person2.age = 25
print(person1.age)//9.0

我們先看看對應內存的使用值類型有很多優點，其中主要的優點有兩個 - 線程安全，每次都是獲得一個copy，不存在同時修改一塊內存 - 不可變狀態，使用值類型，不需要考慮別處的代碼可能會對當前代碼有影響。也就沒有side effect。ARC是相對於引用類型的。> ARC是一個內存管理機制。當一個引用類型的對象的reference count(引用計數)爲0的時候，那麼這個對象會被釋放掉。我們利用XCode 8和iOS開發，來直觀的查看下一個值類型變量的引用計數變化。新建一個iOS單頁面工程，語言選擇Swift，然後編寫如下代碼然後，當斷點停在24行處的時候，Person的引用計數如下這裏，底部的`thread_2673`是主線程堆Person對象的持有，是iOS系統默認添加。所以,` var leo = Person(name: “Leo”, age: 25)`這一行後，準確的說是引用計數加一，並不是引用計數爲一。當然，這些系統自動創建的也會自動銷燬，我們無須考慮。可以看到，person唯一的引用就是來自`VM:Stack thread`，也就是棧上。因爲引用計數的存在，Class在堆上需要額外多分配一個Word來存儲引用計數：

 

當棧上代碼執行完畢，棧會斷掉對Person的引用，引用計數也就減一，系統會斷掉自動創建的引用。這時候，person的引用計數位0，內存釋放。

---

方法調度(method dispatch)

Swift的方法調度分爲兩種

• 靜態調度 static dispatch. 靜態調度在執行的時候，會直接跳到方法的實現，靜態調度可以進行inline和其他編譯期優化。
• 動態調度 dynamic dispatch. 動態調度在執行的時候，會根據運行時(Runtime)，採用table的方式，找到方法的執行體，然後執行。動態調度也就沒有辦法像靜態那樣，進行編譯期優化。

Struct

對於Struct來說，方法調度是靜態的。

struct Point{
    var x:Double // 8 Bytes
    var y:Double // 8 bytes
    func draw(){
        print("Draw point at\(x,y)")
    }
}
let point1 = Point(x: 5.0, y: 5.0)
point1.draw()
print(MemoryLayout<Point>.size) //16

可以看到，由於是Static Dispatch，在編譯期就能夠知道方法的執行體。所以，在Runtime也就不需要額外的空間來存儲方法信息。編譯後，方法的調用，直接就是變量地址的傳入，存在了代碼區中。

如果開啓了編譯器優化，那麼上述代碼被優化成Inline後，

let point1 = Point(x: 5.0, y: 5.0)
print("Draw point at\(point1.x,point1.y)")
print(MemoryLayout<Point>.size) //16

Class

Class是Dynamic Dispatch的，所以在添加方法之後，Class本身在棧上分配的仍然是一個word。堆上，需要額外的一個word來存儲Class的Type信息，在Class的Type信息中，存儲着virtual table(V-Table)。根據V-Table就可以找到對應的方法執行體。

class Point{
    var x:Double // 8 Bytes
    var y:Double // 8 bytes
    init(x:Double,y:Double) {
        self.x = x
        self.y = y
    }
    func draw(){
        print("Draw point at\(x,y)")
    }
}
let point1 = Point(x: 5.0, y: 5.0)
point1.draw()
print(MemoryLayout<Point>.size) //8

繼承

因爲Class的實體會存儲額外的Type信息，所以繼承理解起來十分容易。子類只需要存儲子類的Type信息即可。
例如

class Point{
    var x:Double // 8 Bytes
    var y:Double // 8 bytes
    init(x:Double,y:Double) {
        self.x = x
        self.y = y
    }
    func draw(){
        print("Draw point at\(x,y)")
    }
}
class Point3D:Point{
    var z:Double // 8 Bytes
    init(x:Double,y:Double,z:Double) {
        self.z = z
        super.init(x: x, y: y)
    }
    override func draw(){
        print("Draw point at\(x,y,z)")
    }
}
let point1 = Point(x: 5.0, y: 5.0)
let point2 = Point3D(x: 1.0, y: 2.0, z: 3.0)
let points = [point1,point2]
points.forEach { (p) in
    p.draw()
}
//Draw point at(5.0, 5.0)
//Draw point at(1.0, 2.0, 3.0)

協議

我們首先看一段代碼

struct Point:Drawable{
    var x:Double // 8 Bytes
    var y:Double // 8 bytes
    func draw(){
        print("Draw point at\(x,y)")
    }
}
struct Line:Drawable{
    var x1:Double // 8 Bytes
    var y1:Double // 8 bytes
    var x2:Double // 8 Bytes
    var y2:Double // 8 bytes
    func draw(){
        print("Draw line from \(x1,y1) to \(x2,y2)")
    }
}
let point = Point(x: 1.0, y: 2.0)
let memoryAsPoint = MemoryLayout<Point>.size(ofValue: point)
let memoryOfDrawable = MemoryLayout<Drawable>.size(ofValue: point)
print(memoryAsPoint)
print(memoryOfDrawable)

let line = Line(x1: 1.0, y1: 1.0, x2: 2.0, y2: 2.0)
let memoryAsLine = MemoryLayout<Line>.size(ofValue: line)
let memoryOfDrawable2 = MemoryLayout<Drawable>.size(ofValue: line)
print(memoryAsLine)
print(memoryOfDrawable2)

可以看到，輸出

16 //point as Point
40 //point as Drawable
32 //line as Line
40 //line as Drawable

16和32不難理解，Point含有兩個Double屬性，Line含有四個Double屬性。對應的字節數也是對的。那麼，兩個40是怎麼回事呢？而且，對於Point來說，40-16=24,多出了24個字節。而對於Line來說，只多出了40-32=8個字節。這是因爲Swift對於協議類型的採用如下的內存模型 - Existential Container。

 

Existential Container包括以下三個部分：

• 前三個word：Value buffer。用來存儲Inline的值，如果word數大於3，則採用指針的方式，在堆上分配對應需要大小的內存
• 第四個word：Value Witness Table(VWT)。每個類型都對應這樣一個表，用來存儲值的創建，釋放，拷貝等操作函數。
• 第五個word：Protocol Witness Table(PWT)，用來存儲協議的函數。

那麼，內存結構圖，如下

[ point ]

[ line ]

範型

範型讓代碼支持靜態多態。比如：

func drawACopy<T : Drawable>(local : T) {
  local.draw()
}
drawACopy(Point(...))
drawACopy(Line(...))

那麼，範型在使用的時候，如何調用方法和存儲值呢？

[ 範型 ]

範型並不採用Existential Container，但是原理類似。

1. VWT和PWT作爲隱形參數，傳遞到範型方法裏。
2. 臨時變量仍然按照ValueBuffer的邏輯存儲 - 分配3個word，如果存儲數據大小超過3個word，則在堆上開闢內存存儲。

範型的編譯器優化

1. 爲每種類合成具體的方法
比如

func drawACopy<T : Drawable>(local : T) {
  local.draw()
}

在編譯過後，實際會有兩個方法

func drawACopyOfALine(local : Line) {
  local.draw()
}
func drawACopyOfAPoint(local : Point) {
  local.draw()
}

然後,

drawACopy(local: Point(x: 1.0, y: 1.0))

會被編譯成爲

func drawACopyOfAPoint(local : Point(x: 1.0, y: 1.0))

Swift的編譯器優化還會做更多的事情，上述優化雖然代碼變多，但是編譯器還會對代碼進行壓縮。所以，實際上，並不會對二進制包大小有什麼影響。

---

參考資料

• WWDC 2016 - Understanding Swift Performance
• WWDC 2015 - Optimizing Swift Performance
• Does Swift guarantee the storage order of fields in classes and structs?