0
00:00:00,000-->00:00:07,200


1
00:00:07,240-->00:00:09,920
接下来 我们对这学期的教学内容

2
00:00:09,960-->00:00:12,480
做一个整体上的介绍

3
00:00:12,520-->00:00:14,600
在这里包括我们要讲的内容

4
00:00:14,640-->00:00:16,120
我们要做的实验内容

5
00:00:16,160-->00:00:18,360
和课程设计的内容

6
00:00:18,400-->00:00:19,760
操作系统课 

7
00:00:19,800-->00:00:23,520
涉及到计算机系统当中资源管理

8
00:00:23,560-->00:00:26,480
所以我们围绕着操作系统的实现

9
00:00:26,520-->00:00:28,640
来介绍相关的内容

10
00:00:28,680-->00:00:30,080
主要分成这样几个部分

11
00:00:30,120-->00:00:33,000
第一个操作系统软件的结构

12
00:00:33,040-->00:00:35,240
任何一个软件在设计的时候

13
00:00:35,280-->00:00:38,120
和在实现的时候它都有自己结构特点

14
00:00:38,160-->00:00:39,600
那对于操作系统来说

15
00:00:39,640-->00:00:40,920
它有什么样的结构特点

16
00:00:40,960-->00:00:42,960
我们在这里需要来讨论的问题

17
00:00:43,000-->00:00:45,400
第二个是中断及系统调用

18
00:00:45,440-->00:00:48,080
这说的是操作系统这个软件

19
00:00:48,120-->00:00:51,360
它和外界打交道这些接口

20
00:00:51,400-->00:00:54,680
中断是操作系统和硬件打交道的接口

21
00:00:54,720-->00:00:56,320
操作系统在服务过程当中

22
00:00:56,360-->00:00:58,880
外部如果有设备有请求

23
00:00:58,920-->00:01:01,560
比如说你敲键盘网络有数据包来了

24
00:01:01,600-->00:01:03,640
这个时候操作系统如何对它进行响应

25
00:01:03,680-->00:01:06,760
那么这是中断里要讨论内容

26
00:01:06,800-->00:01:08,960
硬件上已经有了一些机制

27
00:01:09,000-->00:01:10,720
能够对外边做一些响应

28
00:01:10,760-->00:01:13,000
但是这个时候它只是做了其中第一步

29
00:01:13,040-->00:01:14,920
比如说你敲键盘的时候

30
00:01:14,960-->00:01:17,280
这个时候的硬件机构

31
00:01:17,320-->00:01:20,320
已经能把数据存到相应缓冲区里头

32
00:01:20,360-->00:01:22,680
但是缓冲区如何到应用程序里

33
00:01:22,720-->00:01:25,480
那是操作系统需要解决的问题

34
00:01:25,520-->00:01:27,200
而系统调用是操作系统

35
00:01:27,240-->00:01:29,720
对上层应用提供服务接口

36
00:01:29,760-->00:01:31,400
也就是说上层应用

37
00:01:31,440-->00:01:34,840
要想利用操作系统提供的服务

38
00:01:34,880-->00:01:36,280
来实现自己的功能

39
00:01:36,320-->00:01:38,360
必须使用系统调用

40
00:01:38,400-->00:01:40,280
在这里头系统调用

41
00:01:40,320-->00:01:42,880
如何从用户应用程序里头

42
00:01:42,920-->00:01:46,240
获取用户想使用服务的类型

43
00:01:46,280-->00:01:48,200
和相应的输入数据

44
00:01:48,240-->00:01:50,960
都必须从系统调用接口来

45
00:01:51,000-->00:01:53,840
这里系统调用的介绍

46
00:01:53,880-->00:01:56,960
如何让用户的输入能够到系统里来

47
00:01:57,000-->00:02:00,800
系统处理完的结果如何能回到用户态

48
00:02:00,840-->00:02:02,960
而接下来的这几个部分是

49
00:02:03,000-->00:02:05,160
我们操作系统要管理的资源

50
00:02:05,200-->00:02:07,560
第一个是内存资源

51
00:02:07,600-->00:02:10,760
也就是说在计算机系统当中有内存

52
00:02:10,800-->00:02:12,520
随机访问存储器

53
00:02:12,560-->00:02:14,080
这部分存储能力

54
00:02:14,120-->00:02:15,760
会有很多应用程序要使用

55
00:02:15,800-->00:02:19,040
那如何协调各个应用对内存的使用

56
00:02:19,080-->00:02:21,040
可能会是说有的应用

57
00:02:21,080-->00:02:23,960
它需要大量的内存空间来存储数据

58
00:02:24,000-->00:02:25,760
有的应用需要不多

59
00:02:25,800-->00:02:27,720
那么这个时候对于我们操作系统来说

60
00:02:27,760-->00:02:29,600
需要要么是应用程序告诉你

61
00:02:29,640-->00:02:30,440
我需要多少

62
00:02:30,480-->00:02:33,720
要么是你在使用过程中动态进行调节

63
00:02:33,760-->00:02:37,560
而这种调节和内存分配和回收

64
00:02:37,600-->00:02:39,160
是我们操作系统要做的事情

65
00:02:39,200-->00:02:41,840
接下来一个是操作系统需要管理

66
00:02:41,880-->00:02:44,320
用户程序的执行过程

67
00:02:44,360-->00:02:47,200
也就是说任何一个程序在执行

68
00:02:47,240-->00:02:49,680
首先需要系统给它分配

69
00:02:49,720-->00:02:51,320
它执行所需要资源

70
00:02:51,360-->00:02:54,640
比如说CPU内存和相应访问的

71
00:02:54,680-->00:02:58,960
一些外部设备和数据资源

72
00:02:59,000-->00:03:01,360
有了这些资源之后程序开始运行

73
00:03:01,400-->00:03:05,440
在运行过程中这些执行的状态

74
00:03:05,480-->00:03:07,160
也是在不断变化的过程当中

75
00:03:07,200-->00:03:10,200
它可能会占用CPU执行指令

76
00:03:10,240-->00:03:12,840
也可能会由于等待用户输入

77
00:03:12,880-->00:03:14,320
而进入暂停状态

78
00:03:14,360-->00:03:15,760
这些状态的维护

79
00:03:15,800-->00:03:18,440
就是我们这里所说进程和线程

80
00:03:18,480-->00:03:20,320
操作系统需要维护每一个

81
00:03:20,360-->00:03:22,840
正在执行的程序它的状态

82
00:03:22,880-->00:03:25,280
以便于在它们执行结束之后

83
00:03:25,320-->00:03:27,440
能够回收相应的资源

84
00:03:27,480-->00:03:32,080
这是进程管理需要讨论的问题

85
00:03:32,120-->00:03:34,360
接下来一个是处理机调度

86
00:03:34,400-->00:03:38,560
处理机调度是指说我们有多个进程

87
00:03:38,600-->00:03:41,840
在计算机系统当中交替运行

88
00:03:41,880-->00:03:44,280
如果说你只有一个CPU

89
00:03:44,320-->00:03:46,400
或者说你的应用进程数目

90
00:03:46,440-->00:03:47,840
是大于CPU的数目

91
00:03:47,880-->00:03:49,960
做不到每一个进程

92
00:03:50,000-->00:03:51,960
有一个完全独占的CPU来使用

93
00:03:52,000-->00:03:52,760
这个时候

94
00:03:52,800-->00:03:56,440
大家是交替使用CPU来执行指令

95
00:03:56,480-->00:03:58,920
这种交替就需要有一个调度

96
00:03:58,960-->00:04:01,640
到底一个正在执行的进程

97
00:04:01,680-->00:04:03,760
到什么时候让出CPU使用权

98
00:04:03,800-->00:04:05,840
下一个选择又是谁

99
00:04:05,880-->00:04:10,160
这是我们调度算法要进行解决的问题

100
00:04:10,200-->00:04:13,000
接下来一个是进程间通讯

101
00:04:13,040-->00:04:14,240
或者叫同步互斥 

102
00:04:14,280-->00:04:16,800
这里指的是我们任何一个应用进程

103
00:04:16,840-->00:04:18,280
它在执行过程当中

104
00:04:18,320-->00:04:20,680
都不会是自己一个

105
00:04:20,720-->00:04:22,680
在那封闭着进行执行

106
00:04:22,720-->00:04:24,800
它不会跟外界做任何交道

107
00:04:24,840-->00:04:26,920
我们计算机上的程序

108
00:04:26,960-->00:04:28,760
它所做到最大好处是

109
00:04:28,800-->00:04:31,280
由于用户输入的不同

110
00:04:31,320-->00:04:34,520
那我给出不同的处理结果

111
00:04:34,560-->00:04:36,840
而这个处理是可以重复进行的

112
00:04:36,880-->00:04:38,320
所以我们在这里才会

113
00:04:38,360-->00:04:42,440
有计算机程序来实现自动化处理

114
00:04:42,480-->00:04:45,120
那为了实现这个计算机上的

115
00:04:45,160-->00:04:46,280
各个应用进程之间

116
00:04:46,320-->00:04:48,960
它们是需要有一些通讯交流的

117
00:04:49,000-->00:04:52,360
这种交流就是我们这里的同步互斥

118
00:04:52,400-->00:04:54,160
也就是说两个进程之间

119
00:04:54,200-->00:04:55,400
要想进行通讯

120
00:04:55,440-->00:04:56,600
那这个通讯是在

121
00:04:56,640-->00:04:58,760
操作系统控制下完成的

122
00:04:58,800-->00:05:00,080
操作系统控制下

123
00:05:00,120-->00:05:04,200
如何让进程间的信息交流

124
00:05:04,240-->00:05:08,080
做的流畅安全

125
00:05:08,120-->00:05:10,320
这是我们这部分要讨论的

126
00:05:10,360-->00:05:13,160
而下一个文件系统是说

127
00:05:13,200-->00:05:14,960
计算机系统当中数据

128
00:05:15,000-->00:05:16,400
大到一定程度之后

129
00:05:16,440-->00:05:17,920
这个时候就不能简单

130
00:05:17,960-->00:05:21,200
我整一张线性表来存这些数据

131
00:05:21,240-->00:05:23,320
我们必须把这个数据管理起来

132
00:05:23,360-->00:05:26,000
做持久性的保存

133
00:05:26,040-->00:05:27,960
而这一部分大到一定程度的时候

134
00:05:28,000-->00:05:29,480
就变成系统了

135
00:05:29,520-->00:05:30,680
在这个系统中

136
00:05:30,720-->00:05:33,760
我们如何来组织这些文件

137
00:05:33,800-->00:05:37,800
以便于方便用户的读写和查找

138
00:05:37,840-->00:05:42,040
这也是操作系统也解决问题之一

139
00:05:42,080-->00:05:44,720
最后一个是I/O子系统

140
00:05:44,760-->00:05:47,760
计算机系统当中CPU 内存

141
00:05:47,800-->00:05:50,680
这两个部分种类相对来说比较少

142
00:05:50,720-->00:05:52,080
而对于它所能够

143
00:05:52,120-->00:05:54,800
涉及的外设会很多种

144
00:05:54,840-->00:05:56,800
那据一种不完全的统计

145
00:05:56,840-->00:06:00,080
我们能够连到PC机上的外部设备的

146
00:06:00,120-->00:06:01,840
种类应该是上万种

147
00:06:01,880-->00:06:05,280
这些差异非常大的这些外部设备

148
00:06:05,320-->00:06:07,320
对于计算机系统来说如何连上来

149
00:06:07,360-->00:06:08,640
实际上是一个很大挑战

150
00:06:08,680-->00:06:12,480
对于这部分是由操作系统I/O子系统

151
00:06:12,520-->00:06:13,880
来负责管理的

152
00:06:13,920-->00:06:16,440
我们需要把这些差异非常大的

153
00:06:16,480-->00:06:18,560
这些设备连到同一个系统上来

154
00:06:18,600-->00:06:23,120
并且都能对它们进行高效的控制

155
00:06:23,160-->00:06:25,960
比如说我们键盘的速度是很慢的

156
00:06:26,000-->00:06:28,440
这个时候你两只手一起敲

157
00:06:28,480-->00:06:32,000
你一秒钟也就最多敲几十个按键

158
00:06:32,040-->00:06:35,160
而如果说我们用的网络接口是10G的

159
00:06:35,200-->00:06:36,720
那这个时候它数据量

160
00:06:36,760-->00:06:38,800
在一秒钟就是10G BPS

161
00:06:38,840-->00:06:41,120
两者之间的差异是非常大的

162
00:06:41,160-->00:06:43,960
操作系统需要在里头提供一个

163
00:06:44,000-->00:06:46,880
尽可能统一的接口来管理

164
00:06:46,920-->00:06:50,640
尽可能范围大的这些外部设备

165
00:06:50,680-->00:06:52,880
从这个角度讲我们这学期

166
00:06:52,920-->00:06:55,600
操作系统涉及内容是非常广泛

167
00:06:55,640-->00:06:58,120
所以我们这门操作系统课

168
00:06:58,160-->00:07:00,360
也是一种介绍性的课程

169
00:07:00,400-->00:07:02,920
对于每一个部分深入介绍下去

170
00:07:02,960-->00:07:05,040
都会是一个非常专门的

171
00:07:05,080-->00:07:07,160
后续课程讨论内容

172
00:07:07,200-->00:07:09,080
而围绕着教学内容的安排

173
00:07:09,120-->00:07:11,440
我们每一段教学内容

174
00:07:11,480-->00:07:13,320
都有相应的课堂练习

175
00:07:13,360-->00:07:16,240
这是对大家掌握知识情况的了解

176
00:07:16,280-->00:07:18,360
和成绩评定的一部分内容

177
00:07:18,400-->00:07:20,960
另一个内容是实验

178
00:07:21,000-->00:07:23,200
实验基本上围绕着我们前面

179
00:07:23,240-->00:07:26,000
教学内容形成八个实验

180
00:07:26,040-->00:07:27,440
这里的实验0

181
00:07:27,480-->00:07:31,520
是我们教学实验环境的准备

182
00:07:31,560-->00:07:34,080
我们在这门课程里头不会去讲

183
00:07:34,120-->00:07:37,040
如何使用Linux 如何使用Windows

184
00:07:37,080-->00:07:38,160
但是你要想

185
00:07:38,200-->00:07:40,680
在已有操作系统上来做我们实验

186
00:07:40,720-->00:07:43,640
那你必须知道Windows  Linux如何使用

187
00:07:43,680-->00:07:45,960
那这是建立实验环境

188
00:07:46,000-->00:07:49,560
希望大家下去之后能够看相关的资料

189
00:07:49,600-->00:07:52,320
尽可能熟练使用相应的系统

190
00:07:52,360-->00:07:54,440
而下面这八个实验基本上

191
00:07:54,480-->00:07:56,400
是围绕着我们前面内容

192
00:07:56,440-->00:07:57,600
起动和中断 

193
00:07:57,640-->00:07:59,840
对应着我们中断和系统调用

194
00:07:59,880-->00:08:03,640
而内存管理到我们这里分成两个实验

195
00:08:03,680-->00:08:06,760
物理内存和虚拟存储管理

196
00:08:06,800-->00:08:08,200
物理内存管理是

197
00:08:08,240-->00:08:11,560
负责物理存储的分配和回收

198
00:08:11,600-->00:08:13,760
而虚拟存储实际上相当于

199
00:08:13,800-->00:08:17,840
我们把物理存储的存储能力

200
00:08:17,880-->00:08:20,400
抽象成一个虚拟的存储界面

201
00:08:20,440-->00:08:22,120
让用户在使用的时候

202
00:08:22,160-->00:08:23,400
一种明显特征是说

203
00:08:23,440-->00:08:25,560
我可以用到比物理内存更大的

204
00:08:25,600-->00:08:28,400
一个存储空间

205
00:08:28,440-->00:08:31,320
而对于进程和线程

206
00:08:31,360-->00:08:33,920
在我们这里分成内核线程管理

207
00:08:33,960-->00:08:35,320
和用户进程管理

208
00:08:35,360-->00:08:39,000
这两个部分 接下来分别是

209
00:08:39,040-->00:08:41,800
处理机调度对应着 实验六

210
00:08:41,840-->00:08:45,040
而同步互斥对应 实验七

211
00:08:45,080-->00:08:47,040
文件系统对应着 实验八

212
00:08:47,080-->00:08:48,800
这样我们所有的这些上课内容

213
00:08:48,840-->00:08:50,320
主要内容在这里

214
00:08:50,360-->00:08:52,720
都有相应的实验内容和它对应起来

215
00:08:52,760-->00:08:55,200
同时我们在这里做的实验

216
00:08:55,240-->00:08:58,000
它是一个相互关联的整体

217
00:08:58,040-->00:08:59,680
我们在一开始的时候

218
00:08:59,720-->00:09:02,000
就给大家一个实验基准代码

219
00:09:02,040-->00:09:04,520
然后后面你就往上添你的功能

220
00:09:04,560-->00:09:06,720
你每添上一个功能的时候

221
00:09:06,760-->00:09:09,640
你的实验系统它处理能力

222
00:09:09,680-->00:09:11,320
就比原来会强一些

223
00:09:11,360-->00:09:13,480
那你在后续实验的时候

224
00:09:13,520-->00:09:16,240
有可能会用到你前面实现的功能

225
00:09:16,280-->00:09:18,120
所以在这大家在做实验的时候

226
00:09:18,160-->00:09:21,080
一定不要说我在前面做实验的时候

227
00:09:21,120-->00:09:22,680
能通过测试就算完成任务了

228
00:09:22,720-->00:09:24,280
有可能在后面做实验的时候

229
00:09:24,320-->00:09:28,840
会发现前面的实验的代码会有问题

230
00:09:28,880-->00:09:30,800
所以在这对前面的实验

231
00:09:30,840-->00:09:32,040
要认真仔细去做

232
00:09:32,080-->00:09:35,640
可以方便你后边加快你的实验进度

233
00:09:35,680-->00:09:38,800
好 这是实验和练习内容

234
00:09:38,840-->00:09:40,280
对于学有余力的

235
00:09:40,320-->00:09:43,280
我们可以安排课程设计

236
00:09:43,320-->00:09:45,640
目前阶段我们课程设计

237
00:09:45,680-->00:09:48,400
还是围绕着ucore来进行

238
00:09:48,440-->00:09:50,960
大家做实验的环境叫ucore

239
00:09:51,000-->00:09:53,040
我们同时维护了一个

240
00:09:53,080-->00:09:55,760
它的扩展版本叫ucore+

241
00:09:55,800-->00:09:58,680
在那里头我们现在的实验环境

242
00:09:58,720-->00:10:00,760
是在X86环境下运行

243
00:10:00,800-->00:10:07,720
但是我们的ucore+可以在X86、ARM、MIPS

244
00:10:07,760-->00:10:10,440
等几种不同的CPU平台上运行

245
00:10:10,480-->00:10:12,960
并且可以在多种硬件平台上

246
00:10:13,000-->00:10:14,760
能直接跑起来

247
00:10:14,800-->00:10:16,840
我们目前这个改进和完善工作

248
00:10:16,880-->00:10:18,120
还在继续进行

249
00:10:18,160-->00:10:22,600
我们现在工作重点是它的模块化

250
00:10:22,640-->00:10:25,600
我们已经可以在一些平台上

251
00:10:25,640-->00:10:28,800
支持ucore可加载内核模块

252
00:10:28,840-->00:10:30,520
那实际上在这里我们希望

253
00:10:30,560-->00:10:32,080
能够把这些工作做的更完善

254
00:10:32,120-->00:10:36,680
最极致的目标我们希望和Linux内核

255
00:10:36,720-->00:10:39,160
可加载模块的接口兼容

256
00:10:39,200-->00:10:41,440
以至于Linux可加载模块

257
00:10:41,480-->00:10:43,280
可以在我们ucore上不用修改

258
00:10:43,320-->00:10:45,600
就直接能够编译运行

259
00:10:45,640-->00:10:47,280
这样一来我们的ucore

260
00:10:47,320-->00:10:49,040
就可以有更多算法

261
00:10:49,080-->00:10:50,440
可以加在上头去了

262
00:10:50,480-->00:10:52,840
应用程序 如果支持动态链接的话

263
00:10:52,880-->00:10:55,800
你可以在里面利用其它资源也会很多

264
00:10:55,840-->00:10:59,240
目前我们已经能够在X86-32上

265
00:10:59,280-->00:11:00,520
能够有很好的支持

266
00:11:00,560-->00:11:03,480
在ARM和X86-64上

267
00:11:03,520-->00:11:05,240
也有一些基本支持了

268
00:11:05,280-->00:11:08,000
我们希望继续有同学来完善这个

269
00:11:08,040-->00:11:10,440
对于我们现在已经实现的

270
00:11:10,480-->00:11:11,800
这些ucore内核功能

271
00:11:11,840-->00:11:13,160
我们希望能够对它

272
00:11:13,200-->00:11:15,040
进行模块化的改造

273
00:11:15,080-->00:11:17,040
文件系统 调度算法

274
00:11:17,080-->00:11:19,280
内存置换算法和设备驱动

275
00:11:19,320-->00:11:21,200
现在这里头文件系统

276
00:11:21,240-->00:11:22,840
处理机调度算法和置换算法

277
00:11:22,880-->00:11:24,520
都已经有了一些基本的

278
00:11:24,560-->00:11:25,920
模块化的实现

279
00:11:25,960-->00:11:28,400
如果说我们这个工作继续做完善

280
00:11:28,440-->00:11:30,880
以后大家做的操作系统的实验

281
00:11:30,920-->00:11:32,240
就可能是让大家

282
00:11:32,280-->00:11:33,880
我给你一个已经实现的模块

283
00:11:33,920-->00:11:36,840
让你去实现另一个完整的模块

284
00:11:36,880-->00:11:38,280
这样的话就比我们目前

285
00:11:38,320-->00:11:41,480
往里头去添代码片断

286
00:11:41,520-->00:11:44,200
能够有更好的训练效果

287
00:11:44,240-->00:11:46,080
同时你是一整块有参考

288
00:11:46,120-->00:11:48,760
那这个时候它的难度也会有所下降

289
00:11:48,800-->00:11:51,960
如果说这些内容你都觉得没有兴趣

290
00:11:52,000-->00:11:54,040
那么我们在这里还有更进一步的

291
00:11:54,080-->00:11:57,000
我们希望能在真实的硬件环境下去

292
00:11:57,040-->00:12:00,600
运用我们的ucore+现在我们的ucore+

293
00:12:00,640-->00:12:03,840
已经能在树莓派上运行了

294
00:12:03,880-->00:12:06,920
树莓派是一款开源的硬件平台

295
00:12:06,960-->00:12:09,840
它在这里支持有线的网卡Usb

296
00:12:09,880-->00:12:12,080
和HDMI视频接口

297
00:12:12,120-->00:12:15,360
那在上头能跑标准Linux

298
00:12:15,400-->00:12:17,000
我们的ucore最基本的版本

299
00:12:17,040-->00:12:18,360
也能在上头跑起来

300
00:12:18,400-->00:12:22,360
但是对它的HDMI接口支持并不是很好

301
00:12:22,400-->00:12:24,280
我们只能把它的HDMI接口

302
00:12:24,320-->00:12:28,160
当一个简单最基本VGA功能来使用

303
00:12:28,200-->00:12:31,040
我们希望能够在上面做更完善支持

304
00:12:31,080-->00:12:34,320
右边是别人已经做成的一个

305
00:12:34,360-->00:12:37,360
基于树莓派的集群系统

306
00:12:37,400-->00:12:40,440
那这是这个系统的作者和它结果

307
00:12:40,480-->00:12:41,960
我们希望有同学后面

308
00:12:42,000-->00:12:44,200
能给出来你的结果

309
00:12:44,240-->00:12:49,480
再有一个这是2014年英特尔新出的

310
00:12:49,520-->00:12:53,160
一个小的SOC

311
00:12:53,200-->00:12:55,680
这是Edison

312
00:12:55,720-->00:13:00,000
我们在前边也在Edison早期版本上

313
00:13:00,040-->00:13:01,440
运行过我们的ucore

314
00:13:01,480-->00:13:03,680
但是现在这个Edison

315
00:13:03,720-->00:13:05,160
我们还没有做到这件事情

316
00:13:05,200-->00:13:07,960
这个Edison相当于十多年前

317
00:13:08,000-->00:13:10,000
我们一台PC机的处理能力

318
00:13:10,040-->00:13:15,320
目前这个核心的部件上有WIFI  有蓝牙

319
00:13:15,360-->00:13:17,000
400M的双核的CPU

320
00:13:17,040-->00:13:19,760
并且有一个100M的MCU

321
00:13:19,800-->00:13:24,680
与此同时它还有1G的内存和4G的FLASH

322
00:13:24,720-->00:13:27,280
所有这些都是处理能力很强的

323
00:13:27,320-->00:13:29,920
我们希望在上面能跑起我们的ucore

324
00:13:29,960-->00:13:32,040
并且能够用它来做一些

325
00:13:32,080-->00:13:37,000
更有创意性的应用

326
00:13:37,040-->00:13:40,160
如果这些问题都不满足你的兴趣

327
00:13:40,200-->00:13:41,680
或者说你有更好的建议

328
00:13:41,720-->00:13:43,800
我们也支持自选的

329
00:13:43,840-->00:13:45,800
操作系统课程设计的题目

330
00:13:45,840-->00:13:48,840
如果你有这个兴趣你可以告诉老师

331
00:13:48,880-->00:13:51,200
你也可以从我们WiKi上

332
00:13:51,240-->00:13:55,680
看到往年做这些课程设计的同学

333
00:13:55,720-->00:13:57,240
他们给出来的结果

334
00:13:57,280-->00:13:59,000
我们希望到最后做出来之后

335
00:13:59,040-->00:14:01,880
你提供你的报告和你的视频

336
00:14:01,920-->00:14:04,680
我们来看做出来最后的结果

337
00:14:04,720-->00:14:07,240
希望这些介绍有利于大家掌握

338
00:14:07,280-->00:14:09,560
我们在操作系统里到底讲什么 

339
00:14:09,600-->00:14:10,880
大家能学到什么

340
00:14:10,920-->00:14:11,080


341
00:14:11,120-->00:14:11,120