07.srt

1
00:00:00,000 --> 00:00:04,000
[字幕生成：BLACK 字幕校对：志宇]

2
00:00:07,000 --> 00:00:09,000
刚才刷完抖音刷到深夜

3
00:00:09,000 --> 00:00:11,000
然后现在睡不着了,起来录个课

4
00:00:17,000 --> 00:00:21,000
今天已经来到LLVM的第三节

5
00:00:21,000 --> 00:00:23,000
深度剖析LLVM

6
00:00:23,000 --> 00:00:27,000
今天要讲的内容主要是围绕LLVM的后端

7
00:00:27,000 --> 00:00:32,000
就是后端CodeGen生成会员代码或者生成一些代码的指令

8
00:00:32,000 --> 00:00:36,000
接着会聊一聊基于LLVM的一些AI项目

9
00:00:38,000 --> 00:00:39,000
在进入正式的内容之前

10
00:00:39,000 --> 00:00:41,000
其实我有一个非常大的疑问

11
00:00:41,000 --> 00:00:44,000
就是一开始我做一些MySQL的进阶视频的时候

12
00:00:44,000 --> 00:00:47,000
我的粉丝量永远不超过100个

13
00:00:47,000 --> 00:00:51,000
也就是说我没有一个视频是超过100的浏览量

14
00:00:51,000 --> 00:00:53,000
几乎没有人看

15
00:00:58,000 --> 00:01:02,000
但是当我就发现我要不要做一些AI系统

16
00:01:02,000 --> 00:01:05,000
AI框架计算图比较通用性的东西

17
00:01:05,000 --> 00:01:07,000
于是我就做了一些视频

18
00:01:07,000 --> 00:01:11,000
然后这些视频的浏览量都不超过200到300

19
00:01:11,000 --> 00:01:14,000
那时候我的粉丝量的增加非常可怜

20
00:01:14,000 --> 00:01:18,000
基本上运作了两三个月也就300多个粉丝

21
00:01:18,000 --> 00:01:21,000
然后我想着最近大模型非常火

22
00:01:21,000 --> 00:01:25,000
要不要来搞些大模型的教程呢

23
00:01:26,000 --> 00:01:28,000
于是我又去系列的去梳理了大模型

24
00:01:28,000 --> 00:01:31,000
从张量并行,流水型并行,通讯原语

25
00:01:31,000 --> 00:01:34,000
各种大模型相关的技术全部都梳理了一遍之后

26
00:01:34,000 --> 00:01:36,000
然后我就发现

27
00:01:36,000 --> 00:01:39,000
似乎都好像也不爱看这玩意

28
00:01:39,000 --> 00:01:42,000
我的粉丝量永远上不去600

29
00:01:42,000 --> 00:01:44,000
也就是我耕耘了两个月之后

30
00:01:44,000 --> 00:01:46,000
我发现还是没有什么观看

31
00:01:46,000 --> 00:01:56,000
结果什么鬼

32
00:01:56,000 --> 00:02:01,000
我一开始以为LLVM这种老到掉渣

33
00:02:01,000 --> 00:02:03,000
而且还很硬很难啃的技术

34
00:02:03,000 --> 00:02:06,000
 居然浏览量

35
00:02:06,000 --> 00:02:10,000
居然浏览量是我发过所有视频里面最高的

36
00:02:10,000 --> 00:02:11,000
我就想问问

37
00:02:11,000 --> 00:02:13,000
就是给我涨粉的这些粉丝

38
00:02:13,000 --> 00:02:14,000
你们给我弹幕

39
00:02:14,000 --> 00:02:16,000
或者你看到这条视频的人

40
00:02:16,000 --> 00:02:20,000
你告诉我为什么你会去看LLVM

41
00:02:20,000 --> 00:02:22,000
那要是后面我讲完LLVM之后呢

42
00:02:22,000 --> 00:02:24,000
我讲完传统编译器

43
00:02:24,000 --> 00:02:25,000
又去讲AI编译器

44
00:02:25,000 --> 00:02:28,000
我估计又没什么人来观看了

45
00:02:28,000 --> 00:02:29,000
好了

46
00:02:29,000 --> 00:02:31,000
吐槽的东西或者我的疑问呢

47
00:02:31,000 --> 00:02:36,000
我现在真的是满头包

48
00:02:36,000 --> 00:02:37,000
回到正式的内容

49
00:02:37,000 --> 00:02:40,000
这一节还是介绍LLVM的一个架构

50
00:02:40,000 --> 00:02:41,000
那主要是集中在后端

51
00:02:41,000 --> 00:02:43,000
可以看到回顾一下上两节的内容

52
00:02:43,000 --> 00:02:46,000
上一节讲了LLVM的前端

53
00:02:46,000 --> 00:02:48,000
前端主要是对高级语言

54
00:02:48,000 --> 00:02:50,000
做一些词法的分析

55
00:02:50,000 --> 00:02:51,000
把那些词呢

56
00:02:51,000 --> 00:02:53,000
把高级语言的特性的编上token

57
00:02:53,000 --> 00:02:55,000
然后给语法分析

58
00:02:55,000 --> 00:02:56,000
语法分析主要是分析

59
00:02:56,000 --> 00:02:58,000
我这句话有没有写错

60
00:02:58,000 --> 00:03:00,000
而语意分析才是真正的去分析

61
00:03:00,000 --> 00:03:03,000
写的代码的逻辑有没有问题

62
00:03:03,000 --> 00:03:05,000
在这一步语法到语意分析

63
00:03:05,000 --> 00:03:07,000
它传输的是一个AST

64
00:03:07,000 --> 00:03:09,000
语法数这么一个概念

65
00:03:09,000 --> 00:03:12,000
那像这种就是所谓的语法数

66
00:03:12,000 --> 00:03:14,000
语法分析这个环节呢

67
00:03:14,000 --> 00:03:15,000
输出一个语法数

68
00:03:15,000 --> 00:03:16,000
给语意分析

69
00:03:16,000 --> 00:03:17,000
然后去分析每一句话

70
00:03:17,000 --> 00:03:18,000
逻辑

71
00:03:18,000 --> 00:03:20,000
代码到底错在哪里

72
00:03:20,000 --> 00:03:21,000
到底有没有错

73
00:03:21,000 --> 00:03:24,000
接着呢就走到了LLVM的优化层了

74
00:03:24,000 --> 00:03:26,000
优化层有非常多的Path

75
00:03:26,000 --> 00:03:28,000
不同的Path处理不同的任务

76
00:03:28,000 --> 00:03:30,000
那中间的所有的箭头都是处理

77
00:03:30,000 --> 00:03:33,000
LLVM这个数据结构的

78
00:03:33,000 --> 00:03:35,000
Path里面呢主要有两个概念

79
00:03:35,000 --> 00:03:37,000
第一个是分析的Path

80
00:03:37,000 --> 00:03:38,000
第二个是转换的Path

81
00:03:38,000 --> 00:03:41,000
而转换的Path才是真正处理的Path

82
00:03:41,000 --> 00:03:43,000
那接着呢今天要讲讲

83
00:03:43,000 --> 00:03:45,000
LLVM的后端CodeGene

84
00:03:45,000 --> 00:03:47,000
如何生成代码

85
00:03:50,000 --> 00:03:51,000
在这一节里面呢

86
00:03:51,000 --> 00:03:52,000
就会把编译器的前端

87
00:03:52,000 --> 00:03:55,000
优化层还有后端都讲了

88
00:03:55,000 --> 00:03:56,000
那在后端里面呢

89
00:03:56,000 --> 00:03:57,000
其实是最复杂的

90
00:03:57,000 --> 00:03:59,000
也是跟硬件强相关的

91
00:03:59,000 --> 00:04:01,000
所以看到每一个后端呢

92
00:04:01,000 --> 00:04:03,000
它都跟实际的硬件是相关的

93
00:04:03,000 --> 00:04:05,000
但是即使是硬件相关呢

94
00:04:05,000 --> 00:04:06,000
LLVM的后端呢

95
00:04:06,000 --> 00:04:08,000
也对它们做了一个约束

96
00:04:08,000 --> 00:04:09,000
做了一些指定的选择

97
00:04:09,000 --> 00:04:10,000
计算机的分配在做调度

98
00:04:10,000 --> 00:04:11,000
代码布局

99
00:04:11,000 --> 00:04:13,000
最后做到代码的组装

100
00:04:13,000 --> 00:04:14,000
那在这一步工作呢

101
00:04:14,000 --> 00:04:15,000
大部分都叫它

102
00:04:15,000 --> 00:04:18,000
CodeGene代码生成

103
00:04:18,000 --> 00:04:19,000
总的来说呢

104
00:04:19,000 --> 00:04:20,000
就是把LLVM的IR呢

105
00:04:20,000 --> 00:04:22,000
变成目标代码

106
00:04:22,000 --> 00:04:24,000
或者汇编代码

107
00:04:24,000 --> 00:04:25,000
在后端的处理呢

108
00:04:25,000 --> 00:04:27,000
实际上呢是非常复杂的

109
00:04:27,000 --> 00:04:29,000
整个后端的Pipeline流水线呢

110
00:04:29,000 --> 00:04:30,000
用到了不同的IR

111
00:04:30,000 --> 00:04:31,000
不同的指令

112
00:04:31,000 --> 00:04:32,000
那第一个呢

113
00:04:32,000 --> 00:04:33,000
就是LLVM的IR

114
00:04:33,000 --> 00:04:35,000
还有Selection DAG图

115
00:04:35,000 --> 00:04:36,000
还有Machine Instruction

116
00:04:36,000 --> 00:04:38,000
还有MC Instruction

117
00:04:38,000 --> 00:04:39,000
在最后一个阶段呢

118
00:04:39,000 --> 00:04:40,000
把LLVM的IR呢

119
00:04:40,000 --> 00:04:42,000
转换成为目标的汇编代码了

120
00:04:42,000 --> 00:04:44,000
需要经过非常多的

121
00:04:44,000 --> 00:04:45,000
若干的步骤

122
00:04:45,000 --> 00:04:46,000
就是下面看到的

123
00:04:46,000 --> 00:04:48,000
这个Pipeline

124
00:04:48,000 --> 00:04:49,000
LLVM IR最后呢

125
00:04:49,000 --> 00:04:51,000
就会变成跟后端

126
00:04:51,000 --> 00:04:52,000
非常之亲密友好的

127
00:04:52,000 --> 00:04:54,000
一些具体的指令

128
00:04:54,000 --> 00:04:55,000
函数或者全局变量的

129
00:04:55,000 --> 00:04:56,000
具体的表示

130
00:04:56,000 --> 00:04:58,000
还有寄存器的表示

131
00:04:58,000 --> 00:05:00,000
流水线越往下走呢

132
00:05:00,000 --> 00:05:01,000
就越贴近

133
00:05:01,000 --> 00:05:03,000
实际硬件的目标指令

134
00:05:03,000 --> 00:05:05,000
图中白色的这些Path呢

135
00:05:05,000 --> 00:05:07,000
就是一些非必要的Path

136
00:05:07,000 --> 00:05:08,000
而这些灰色的Path呢

137
00:05:08,000 --> 00:05:10,000
就叫做必须的Path

138
00:05:10,000 --> 00:05:12,000
也叫做Super Path

139
00:05:12,000 --> 00:05:13,000
下面可以看到

140
00:05:13,000 --> 00:05:15,000
这里面有五个Super Path

141
00:05:15,000 --> 00:05:16,000
也会逐个的Super Path

142
00:05:16,000 --> 00:05:18,000
去展开

143
00:05:18,000 --> 00:05:19,000
第一个Super Path呢

144
00:05:19,000 --> 00:05:21,000
叫做指令选择

145
00:05:21,000 --> 00:05:23,000
Instruction Selection

146
00:05:23,000 --> 00:05:25,000
LLVM IR呢

147
00:05:25,000 --> 00:05:26,000
作为指令选择的

148
00:05:26,000 --> 00:05:27,000
一个输入

149
00:05:27,000 --> 00:05:28,000
然后在输入的时候呢

150
00:05:28,000 --> 00:05:29,000
就会把它变成一个

151
00:05:29,000 --> 00:05:30,000
Selection DAG

152
00:05:30,000 --> 00:05:31,000
那DAG呢

153
00:05:31,000 --> 00:05:32,000
就是有相无款图

154
00:05:32,000 --> 00:05:33,000
把IR

155
00:05:33,000 --> 00:05:35,000
变成正正的一个图

156
00:05:35,000 --> 00:05:36,000
每一个DAG图呢

157
00:05:36,000 --> 00:05:37,000
就表示

158
00:05:37,000 --> 00:05:39,000
单一的一个基本块的计算

159
00:05:39,000 --> 00:05:40,000
那既然是图

160
00:05:40,000 --> 00:05:41,000
那就有节点和编

161
00:05:41,000 --> 00:05:43,000
节点就表示

162
00:05:43,000 --> 00:05:44,000
具体执行的指令

163
00:05:44,000 --> 00:05:45,000
而边呢

164
00:05:45,000 --> 00:05:46,000
就代表编码之间的

165
00:05:46,000 --> 00:05:48,000
一个数据流的依赖关系

166
00:05:48,000 --> 00:05:49,000
目标呢

167
00:05:49,000 --> 00:05:50,000
就是家出的这一行

168
00:05:50,000 --> 00:05:52,000
希望把LLVM的代码

169
00:05:52,000 --> 00:05:53,000
或者LLVM的IR呢

170
00:05:53,000 --> 00:05:55,000
生成程序库

171
00:05:55,000 --> 00:05:56,000
能够运行呢

172
00:05:56,000 --> 00:05:57,000
基于数的模式匹配的

173
00:05:57,000 --> 00:05:59,000
指令选择的算法

174
00:05:59,000 --> 00:06:00,000
这句话呢

175
00:06:00,000 --> 00:06:01,000
有点拗口

176
00:06:01,000 --> 00:06:02,000
其实到这个步骤为止呢

177
00:06:02,000 --> 00:06:03,000
指令选择

178
00:06:03,000 --> 00:06:05,000
把LLVM IR变成

179
00:06:05,000 --> 00:06:07,000
一个DAG图

180
00:06:07,000 --> 00:06:08,000
这个DAG图呢

181
00:06:08,000 --> 00:06:09,000
其实就是目标的

182
00:06:09,000 --> 00:06:11,000
机器代码的一个节点

183
00:06:11,000 --> 00:06:12,000
这些节点呢

184
00:06:12,000 --> 00:06:13,000
就代表目标的

185
00:06:13,000 --> 00:06:14,000
机器的指令了

186
00:06:14,000 --> 00:06:16,000
而不是LLVM的指令了

187
00:06:16,000 --> 00:06:17,000
LLVM的指令

188
00:06:17,000 --> 00:06:18,000
就是3D子结构嘛

189
00:06:18,000 --> 00:06:19,000
在上一节里面

190
00:06:19,000 --> 00:06:20,000
讲到了

191
00:06:20,000 --> 00:06:21,000
而现在呢

192
00:06:21,000 --> 00:06:23,000
就是真正的机器的指令

193
00:06:23,000 --> 00:06:24,000
变成DAG

194
00:06:24,000 --> 00:06:25,000
那DAG是一个图

195
00:06:25,000 --> 00:06:27,000
图非常方便用于建树

196
00:06:27,000 --> 00:06:29,000
通过指令选择算法呢

197
00:06:29,000 --> 00:06:31,000
去执行DAG的指令

198
00:06:31,000 --> 00:06:33,000
那第二个步骤呢

199
00:06:33,000 --> 00:06:34,000
就是指令调度

200
00:06:34,000 --> 00:06:36,000
Instruction Scheduling

201
00:06:36,000 --> 00:06:37,000
第二个步骤

202
00:06:37,000 --> 00:06:38,000
可以看到

203
00:06:38,000 --> 00:06:39,000
实际上有两个

204
00:06:39,000 --> 00:06:41,000
Instruction Scheduling

205
00:06:41,000 --> 00:06:42,000
从Pipeline里面呢

206
00:06:42,000 --> 00:06:43,000
可以看到

207
00:06:43,000 --> 00:06:45,000
它有两个Instruction Scheduling

208
00:06:45,000 --> 00:06:47,000
就是两个指令调度

209
00:06:47,000 --> 00:06:48,000
现在讲讲

210
00:06:48,000 --> 00:06:50,000
第一次指令调度的工作

211
00:06:50,000 --> 00:06:51,000
也就是我做一个

212
00:06:51,000 --> 00:06:53,000
寄存器的预分配

213
00:06:53,000 --> 00:06:54,000
刚才的第一步工作呢

214
00:06:54,000 --> 00:06:55,000
已经把它变成一个

215
00:06:55,000 --> 00:06:56,000
DAG的图了

216
00:06:56,000 --> 00:06:58,000
我对这些DAG的图的指令呢

217
00:06:58,000 --> 00:06:59,000
做一个排序

218
00:06:59,000 --> 00:07:01,000
就是对节点进行排序

219
00:07:01,000 --> 00:07:02,000
尽可能多的

220
00:07:02,000 --> 00:07:03,000
去发现这些

221
00:07:03,000 --> 00:07:04,000
可以并行的一些指令

222
00:07:04,000 --> 00:07:06,000
同时把指令呢

223
00:07:06,000 --> 00:07:08,000
变成另外一种表示形式

224
00:07:08,000 --> 00:07:09,000
那这种表示形式

225
00:07:09,000 --> 00:07:10,000
其实也叫做IR

226
00:07:10,000 --> 00:07:11,000
但是这个IR呢

227
00:07:11,000 --> 00:07:13,000
叫做Machine Instruction

228
00:07:13,000 --> 00:07:15,000
三地址的表示方式

229
00:07:15,000 --> 00:07:16,000
在第三个步骤呢

230
00:07:16,000 --> 00:07:19,000
就是寄存器的分配

231
00:07:19,000 --> 00:07:21,000
Register Allocation

232
00:07:21,000 --> 00:07:23,000
在前面的章节里面

233
00:07:23,000 --> 00:07:24,000
其实已经谈到了

234
00:07:24,000 --> 00:07:26,000
寄存器是非常昂贵的

235
00:07:26,000 --> 00:07:28,000
而每一个硬件的寄存器

236
00:07:28,000 --> 00:07:29,000
都是有限的

237
00:07:29,000 --> 00:07:30,000
但是LVM IR里面呢

238
00:07:30,000 --> 00:07:32,000
就有两个比较重要的特性

239
00:07:32,000 --> 00:07:34,000
一个是SSA

240
00:07:34,000 --> 00:07:35,000
那第二个特性呢

241
00:07:35,000 --> 00:07:37,000
就是寄存器假设是无限的

242
00:07:37,000 --> 00:07:39,000
所以LVM IR里面用百分

243
00:07:39,000 --> 00:07:41,000
还代表无限的寄存器

244
00:07:41,000 --> 00:07:42,000
这个特性呢

245
00:07:42,000 --> 00:07:43,000
保持到这一步为止呢

246
00:07:43,000 --> 00:07:44,000
就终止了

247
00:07:44,000 --> 00:07:46,000
把LVM IR里面

248
00:07:46,000 --> 00:07:47,000
无限虚拟的寄存器呢

249
00:07:47,000 --> 00:07:49,000
转换成为实际上有目标

250
00:07:49,000 --> 00:07:50,000
有地址

251
00:07:50,000 --> 00:07:52,000
有定位的寄存器集合

252
00:07:52,000 --> 00:07:53,000
诶 ZOMI老师

253
00:07:53,000 --> 00:07:54,000
我想问一下

254
00:07:54,000 --> 00:07:55,000
你刚才说到了

255
00:07:55,000 --> 00:07:57,000
LVM IR里面的寄存器

256
00:07:57,000 --> 00:07:58,000
是无限的

257
00:07:58,000 --> 00:08:00,000
但实际上硬件的寄存器

258
00:08:00,000 --> 00:08:01,000
是非常昂贵

259
00:08:01,000 --> 00:08:02,000
非常少量的

260
00:08:02,000 --> 00:08:04,000
如果实际物理意义上的寄存器不够

261
00:08:04,000 --> 00:08:05,000
那怎么办呢

262
00:08:06,000 --> 00:08:07,000
很简单啊

263
00:08:07,000 --> 00:08:09,000
直接把它speed到内存里面嘛

264
00:08:09,000 --> 00:08:10,000
你不够塞

265
00:08:10,000 --> 00:08:12,000
那你就先缓存起来嘛

266
00:08:12,000 --> 00:08:14,000
所以寄存器不够的时候呢

267
00:08:14,000 --> 00:08:15,000
就会把它speed到内存

268
00:08:15,000 --> 00:08:17,000
就把它挤到内存里面

269
00:08:17,000 --> 00:08:19,000
等下一次能够用的时候再用

270
00:08:20,000 --> 00:08:21,000
第四步呢

271
00:08:21,000 --> 00:08:22,000
就是刚才的

272
00:08:22,000 --> 00:08:23,000
instruction scheduling

273
00:08:23,000 --> 00:08:25,000
就是第二次指令的调度

274
00:08:26,000 --> 00:08:27,000
在第一次指令调度的时候呢

275
00:08:27,000 --> 00:08:28,000
其实做了一个

276
00:08:28,000 --> 00:08:30,000
寄存器的预分配

277
00:08:31,000 --> 00:08:33,000
在第二次的指令调度呢

278
00:08:33,000 --> 00:08:34,000
要叫做

279
00:08:34,000 --> 00:08:35,000
后寄存器分配啊

280
00:08:35,000 --> 00:08:37,000
多了个后字

281
00:08:37,000 --> 00:08:38,000
这个时候呢

282
00:08:38,000 --> 00:08:39,000
就可以获得

283
00:08:39,000 --> 00:08:41,000
寄存器的实际的一些信息

284
00:08:42,000 --> 00:08:43,000
如果程序呢

285
00:08:43,000 --> 00:08:44,000
分析到刚才

286
00:08:44,000 --> 00:08:45,000
有些寄存器呢

287
00:08:45,000 --> 00:08:47,000
是存不下数据的

288
00:08:47,000 --> 00:08:49,000
或者存在计算延迟的风险呢

289
00:08:49,000 --> 00:08:50,000
这个时候呢

290
00:08:50,000 --> 00:08:52,000
就可以再次通过指令的调度

291
00:08:52,000 --> 00:08:54,000
改变指令的执行顺序

292
00:08:55,000 --> 00:08:56,000
那最后一步呢

293
00:08:56,000 --> 00:08:58,000
叫做code admission

294
00:08:58,000 --> 00:09:00,000
也就是代码的输出

295
00:09:00,000 --> 00:09:01,000
刚才在第一次

296
00:09:01,000 --> 00:09:02,000
指令调度的时候呢

297
00:09:02,000 --> 00:09:03,000
就把DAG变成

298
00:09:03,000 --> 00:09:05,000
machine instruction

299
00:09:05,000 --> 00:09:06,000
那在代码输出阶段呢

300
00:09:06,000 --> 00:09:08,000
就会把machine instruction

301
00:09:08,000 --> 00:09:09,000
转换成为

302
00:09:09,000 --> 00:09:11,000
MC instruction的一个

303
00:09:11,000 --> 00:09:12,000
对象或者实例

304
00:09:13,000 --> 00:09:14,000
MC instruction这个结构呢

305
00:09:14,000 --> 00:09:16,000
就更贴近实际输出的

306
00:09:16,000 --> 00:09:18,000
一个硬件的物理的定义

307
00:09:18,000 --> 00:09:19,000
为的就是方便

308
00:09:19,000 --> 00:09:21,000
汇编器和链接器

309
00:09:21,000 --> 00:09:23,000
用于输出真正的汇编的代码

310
00:09:23,000 --> 00:09:25,000
或者输出二进制的

311
00:09:25,000 --> 00:09:26,000
目标代码格式

312
00:09:26,000 --> 00:09:27,000
那从整个pipeline

313
00:09:27,000 --> 00:09:28,000
可以看到啊

314
00:09:28,000 --> 00:09:29,000
pass呢

315
00:09:29,000 --> 00:09:31,000
从一开始的LLVM的pass

316
00:09:31,000 --> 00:09:33,000
有无线的继承器

317
00:09:33,000 --> 00:09:35,000
然后有高度的抽象的三地址

318
00:09:35,000 --> 00:09:37,000
在instruction selection

319
00:09:37,000 --> 00:09:38,000
指令选择的时候呢

320
00:09:38,000 --> 00:09:39,000
把LLVM IR

321
00:09:39,000 --> 00:09:40,000
变成一个DAG图

322
00:09:40,000 --> 00:09:42,000
做了进一步的抽象和提取

323
00:09:42,000 --> 00:09:43,000
那这个提取呢

324
00:09:43,000 --> 00:09:45,000
没有LLVM所抽象

325
00:09:45,000 --> 00:09:46,000
那再往下走了

326
00:09:46,000 --> 00:09:48,000
就是更贴近底层了

327
00:09:48,000 --> 00:09:49,000
所以每一次执行之后呢

328
00:09:49,000 --> 00:09:51,000
都会把一些抽象的概念

329
00:09:51,000 --> 00:09:53,000
变成实际的物理意义

330
00:09:55,000 --> 00:09:57,000
总体来回顾一下

331
00:09:57,000 --> 00:09:59,000
整个编译器的流程

332
00:09:59,000 --> 00:10:00,000
整个编译器呢

333
00:10:00,000 --> 00:10:01,000
输入C和C++

334
00:10:01,000 --> 00:10:02,000
或者Objective C

335
00:10:02,000 --> 00:10:03,000
这些高级的语言

336
00:10:03,000 --> 00:10:05,000
输给前端

337
00:10:05,000 --> 00:10:06,000
经过词法分析

338
00:10:06,000 --> 00:10:07,000
语法分析

339
00:10:07,000 --> 00:10:08,000
语义分析之后呢

340
00:10:08,000 --> 00:10:10,000
就变成AST树

341
00:10:10,000 --> 00:10:11,000
那AST树之后呢

342
00:10:11,000 --> 00:10:12,000
在进入第一个pass之前呢

343
00:10:12,000 --> 00:10:14,000
它会转换成为IR

344
00:10:14,000 --> 00:10:16,000
也就是IR generation

345
00:10:16,000 --> 00:10:17,000
而LLVM IR呢

346
00:10:17,000 --> 00:10:20,000
全都是SSA三地址指令

347
00:10:20,000 --> 00:10:22,000
去表示 IR的一个结构

348
00:10:22,000 --> 00:10:23,000
那表示完之后呢

349
00:10:23,000 --> 00:10:25,000
会有非常多的 IR

350
00:10:25,000 --> 00:10:26,000
不同的 IR

351
00:10:26,000 --> 00:10:28,000
去优化这个LLVM的代码

352
00:10:28,000 --> 00:10:29,000
优化完之后呢

353
00:10:29,000 --> 00:10:30,000
就会把LLVM的代码呢

354
00:10:30,000 --> 00:10:32,000
变成一个DAG图

355
00:10:32,000 --> 00:10:33,000
那这个呢

356
00:10:33,000 --> 00:10:35,000
就是实际的DAG图

357
00:10:35,000 --> 00:10:37,000
DAG里面的每个节点呢

358
00:10:37,000 --> 00:10:38,000
就是对应的指令

359
00:10:38,000 --> 00:10:40,000
节点跟节点之间的边呢

360
00:10:40,000 --> 00:10:42,000
就是数据的流向

361
00:10:42,000 --> 00:10:43,000
经过指令选择

362
00:10:43,000 --> 00:10:44,000
指令调度

363
00:10:44,000 --> 00:10:45,000
进行其分配

364
00:10:45,000 --> 00:10:47,000
再进行第二次的指令调度

365
00:10:47,000 --> 00:10:49,000
就会生成目标代码

366
00:10:49,000 --> 00:10:50,000
或者机器代码

367
00:10:50,000 --> 00:10:53,000
就是整个LLVM的编译器的流程

368
00:10:53,000 --> 00:10:55,000
或者LLVM编译器的过程

369
00:10:55,000 --> 00:10:56,000
里面的每一个模块

370
00:10:56,000 --> 00:10:58,000
每一个Path都可以独立的去运作

371
00:10:58,000 --> 00:11:00,000
都可以把它抽出来

372
00:11:00,000 --> 00:11:01,000
如果你不想要这个Path

373
00:11:01,000 --> 00:11:02,000
你通过命令行

374
00:11:02,000 --> 00:11:03,000
OPT的这个命令行

375
00:11:03,000 --> 00:11:04,000
直接把它删掉

376
00:11:04,000 --> 00:11:06,000
或者告诉Path Manager

377
00:11:06,000 --> 00:11:08,000
我不需要这个Path就好了

378
00:11:08,000 --> 00:11:10,000
如果你需要新增的一个Path

379
00:11:10,000 --> 00:11:11,000
你告诉Path Manager

380
00:11:11,000 --> 00:11:13,000
去新增一个Path就行了

381
00:11:13,000 --> 00:11:14,000
所以Path Manager的管理呢

382
00:11:14,000 --> 00:11:16,000
是非常强大的

383
00:11:17,000 --> 00:11:18,000
到这里为止呢

384
00:11:18,000 --> 00:11:20,000
已经是传统编译器LLVM的

385
00:11:20,000 --> 00:11:22,000
一个最后的环节

386
00:11:22,000 --> 00:11:24,000
GLLVM的项目

387
00:11:24,000 --> 00:11:26,000
在介绍LLVM的项目之前呢

388
00:11:26,000 --> 00:11:29,000
我非常推荐YouTube的一个视频

389
00:11:29,000 --> 00:11:30,000
这个视频呢

390
00:11:30,000 --> 00:11:31,000
就是LLM之父Christ

391
00:11:31,000 --> 00:11:34,000
在2021年的一个Presentation

392
00:11:34,000 --> 00:11:37,000
编译器的黄金时代

393
00:11:37,000 --> 00:11:39,000
LLVM之父Christ

394
00:11:39,000 --> 00:11:41,000
在发表了这篇文章之后呢

395
00:11:41,000 --> 00:11:42,000
没过几个月

396
00:11:42,000 --> 00:11:43,000
他就离职了

397
00:11:43,000 --> 00:11:45,000
然后去创建了一家新的公司

398
00:11:45,000 --> 00:11:46,000
叫做Modular

399
00:11:46,000 --> 00:11:47,000
他的目标呢

400
00:11:47,000 --> 00:11:48,000
是重建全球的

401
00:11:48,000 --> 00:11:50,000
AI和机器学习的基础设施

402
00:11:50,000 --> 00:11:52,000
包括编译器运行时异构计算

403
00:11:53,000 --> 00:11:54,000
从边缘到中心的并用

404
00:11:54,000 --> 00:11:55,000
那这个Modular

405
00:11:55,000 --> 00:11:56,000
也可以看到

406
00:11:56,000 --> 00:11:57,000
是模块化

407
00:11:57,000 --> 00:11:59,000
他到底会给AI编译器

408
00:11:59,000 --> 00:12:01,000
带来哪些模块化的工作呢

409
00:12:01,000 --> 00:12:03,000
而Christ后面的中心工作

410
00:12:03,000 --> 00:12:05,000
也是转到AI编译器上面

411
00:12:05,000 --> 00:12:06,000
可以看到

412
00:12:06,000 --> 00:12:07,000
AI编译器

413
00:12:07,000 --> 00:12:09,000
未来肯定是市场非常大

414
00:12:09,000 --> 00:12:11,000
技术含量非常高

415
00:12:11,000 --> 00:12:13,000
非常值得探索的一个领域

416
00:12:13,000 --> 00:12:14,000
下面呢

417
00:12:14,000 --> 00:12:15,000
讲讲几个利用到了

418
00:12:15,000 --> 00:12:17,000
LLVM的一些编译器

419
00:12:17,000 --> 00:12:18,000
第一个呢

420
00:12:18,000 --> 00:12:19,000
就是XLA

421
00:12:19,000 --> 00:12:20,000
那XLA呢

422
00:12:20,000 --> 00:12:21,000
是谷歌推出的一个

423
00:12:21,000 --> 00:12:23,000
模块机学习的一个编译器

424
00:12:23,000 --> 00:12:24,000
可能你没听过XLA

425
00:12:24,000 --> 00:12:25,000
没关系

426
00:12:25,000 --> 00:12:26,000
但是TensorFlow里面的

427
00:12:26,000 --> 00:12:27,000
大部分代码

428
00:12:27,000 --> 00:12:28,000
或者大部分算子呢

429
00:12:28,000 --> 00:12:31,000
都是通过XLA进行一个编译的

430
00:12:31,000 --> 00:12:32,000
然后呢

431
00:12:32,000 --> 00:12:33,000
你可能会非常多的

432
00:12:33,000 --> 00:12:35,000
听过TensorFlow

433
00:12:35,000 --> 00:12:36,000
那TensorFlow底层呢

434
00:12:36,000 --> 00:12:37,000
就是用XLA

435
00:12:37,000 --> 00:12:38,000
XLA的底层呢

436
00:12:38,000 --> 00:12:39,000
就是用LLVM

437
00:12:40,000 --> 00:12:41,000
那第二个呢

438
00:12:41,000 --> 00:12:42,000
就是JAX

439
00:12:42,000 --> 00:12:43,000
那JAX呢

440
00:12:43,000 --> 00:12:44,000
这也是谷歌

441
00:12:44,000 --> 00:12:45,000
他推出的

442
00:12:45,000 --> 00:12:46,000
一个把Autobrain的

443
00:12:46,000 --> 00:12:48,000
就是自动微分和XLA

444
00:12:48,000 --> 00:12:50,000
结合的一个深度学习的库

445
00:12:50,000 --> 00:12:52,000
那我刚才说的是

446
00:12:52,000 --> 00:12:53,000
深度学习库

447
00:12:53,000 --> 00:12:54,000
因为他最近呢

448
00:12:54,000 --> 00:12:56,000
用在做一些深度学习的工作

449
00:12:56,000 --> 00:12:57,000
但实际上

450
00:12:57,000 --> 00:12:58,000
他是一个高性能的

451
00:12:58,000 --> 00:12:59,000
数字计算的库

452
00:12:59,000 --> 00:13:00,000
就他可以做很多

453
00:13:00,000 --> 00:13:01,000
传统HPC

454
00:13:01,000 --> 00:13:03,000
所用到的计算

455
00:13:04,000 --> 00:13:05,000
第三个呢

456
00:13:05,000 --> 00:13:07,000
毫无疑问就是TensorFlow

457
00:13:07,000 --> 00:13:09,000
那TensorFlow可能很多

458
00:13:09,000 --> 00:13:10,000
在学术界或者学生

459
00:13:10,000 --> 00:13:12,000
可能会用的比较少

460
00:13:12,000 --> 00:13:13,000
但是在工业界

461
00:13:13,000 --> 00:13:14,000
包括现在

462
00:13:14,000 --> 00:13:16,000
接触到的一些客户

463
00:13:16,000 --> 00:13:17,000
字节跳动

464
00:13:17,000 --> 00:13:18,000
腾讯阿里巴巴

465
00:13:18,000 --> 00:13:19,000
这样的大库库

466
00:13:19,000 --> 00:13:21,000
他们大部分都会用TensorFlow

467
00:13:21,000 --> 00:13:22,000
或者没有完全

468
00:13:22,000 --> 00:13:24,000
从PyTorch转过来

469
00:13:24,000 --> 00:13:25,000
大家可以看一下

470
00:13:25,000 --> 00:13:26,000
我的AI框架基础里面

471
00:13:26,000 --> 00:13:27,000
去介绍PyTorch

472
00:13:27,000 --> 00:13:28,000
TensorFlow

473
00:13:28,000 --> 00:13:29,000
还有MineSmart

474
00:13:29,000 --> 00:13:30,000
这些新一代的

475
00:13:30,000 --> 00:13:31,000
AI框架之争

476
00:13:31,000 --> 00:13:32,000
里面就讲到了

477
00:13:32,000 --> 00:13:33,000
TensorFlow

478
00:13:33,000 --> 00:13:34,000
它是非常好的

479
00:13:34,000 --> 00:13:35,000
用在

480
00:13:35,000 --> 00:13:37,000
工业生产环境的

481
00:13:37,000 --> 00:13:38,000
而TensorFlow的底层呢

482
00:13:38,000 --> 00:13:39,000
依赖于刚才讲的

483
00:13:39,000 --> 00:13:40,000
XLA

484
00:13:40,000 --> 00:13:41,000
XLA呢又依赖于

485
00:13:41,000 --> 00:13:42,000
LVM

486
00:13:42,000 --> 00:13:44,000
之上去构建的

487
00:13:45,000 --> 00:13:46,000
那最后一个呢

488
00:13:46,000 --> 00:13:47,000
就是端到端的

489
00:13:47,000 --> 00:13:48,000
一个深度学习编译器

490
00:13:48,000 --> 00:13:49,000
TVM

491
00:13:49,000 --> 00:13:50,000
成天奇

492
00:13:50,000 --> 00:13:51,000
教授所发明的

493
00:13:51,000 --> 00:13:52,000
编译全栈

494
00:13:52,000 --> 00:13:53,000
里面呢

495
00:13:53,000 --> 00:13:54,000
就用到了LVM

496
00:13:54,000 --> 00:13:55,000
去对不同的硬件

497
00:13:55,000 --> 00:13:57,000
进行一个编译的

498
00:13:58,000 --> 00:13:59,000
最后一个就是

499
00:13:59,000 --> 00:14:00,000
Julia

500
00:14:00,000 --> 00:14:01,000
一种新的语言

501
00:14:01,000 --> 00:14:02,000
面向科学计算

502
00:14:02,000 --> 00:14:03,000
就是HPC的

503
00:14:03,000 --> 00:14:04,000
高性能动态语言

504
00:14:04,000 --> 00:14:05,000
里面呢

505
00:14:05,000 --> 00:14:07,000
就用了LVM的JIT编译

506
00:14:07,000 --> 00:14:08,000
就是Just-In-Time

507
00:14:08,000 --> 00:14:10,000
即时编译的能力

508
00:14:11,000 --> 00:14:12,000
好了

509
00:14:12,000 --> 00:14:13,000
关于传统编译器的介绍

510
00:14:13,000 --> 00:14:14,000
就这么多

511
00:14:14,000 --> 00:14:15,000
谢谢各位

512
00:14:16,000 --> 00:14:17,000
卷的不行了

513
00:14:17,000 --> 00:14:18,000
卷的不行了

514
00:14:18,000 --> 00:14:19,000
记得一键三连

515
00:14:19,000 --> 00:14:20,000
加关注哦

516
00:14:20,000 --> 00:14:21,000
所有的内容

517
00:14:21,000 --> 00:14:22,000
都会开源在

518
00:14:22,000 --> 00:14:23,000
下面这条链接里面

519
00:14:23,000 --> 00:14:24,000
拜拜