408/CS408
1
0
Fork 0
mirror of https://github.com/Didnelpsun/CS408.git synced 2026-10-31 12:24:51 +08:00
Code Issues Projects Releases Wiki Activity

更新进程管理

Browse Source
This commit is contained in:
Didnelpsun
2021-08-18 23:10:06 +08:00
parent 12614c3a33
commit a1a0b210ab
4 changed files with 289 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@@ -1,4 +1,9 @@
*.pdf
*.png
*.jpg
*.jpeg
*.html
*.htm
*.vs/
*.idea/
*Debug/

40
Computer-Organization/0-summary-ex.md
View File

@@ -20,4 +20,42 @@ $C.$Ⅳ、Ⅰ
$D.$Ⅳ、Ⅲ
解：$D$。解释程序的特点是翻译一句执行一句，边翻译边执行；由高级语言转化为汇编语言的过程称为编译，把汇编语言源程序翻译成机器语言程序的过程称为汇编。
解：$D$。解释程序的特点是翻译一句执行一句，边翻译边执行；由高级语言转化为汇编语言的过程称为编译，把汇编语言源程序翻译成机器语言程序的过程称为汇编。
## 计算机系统层次结构
**例题** 以下说法错误的是()。
$A.$硬盘是外部设备
$B.$软件的功能与硬件的功能在逻辑上是等效的
$C.$硬件实现的功能一般比软件实现具有更高的执行速度
$D.$软件的功能不能用硬件取代
解：$D$。软件和硬件具有逻辑上的等效性，硬件实现具有更高的执行速度，软件实现具有更好的灵活性。执行频繁、硬件实现代价不是很高的功能通常由硬件实现。因此选$D$。
**例题** 将高级语言源程序转换为机器级目标代码文件的程序是()。
$A.$汇编程序
$B.$链接程序
$C.$编译程序
$D.$解释程序
解：$C$。翻译程序是指把高级语言源程序转换成机器语言程序（目标代码）的软件。翻译程序有两种：一种是编译程序，它将高级语言源程序一次全部翻译成目标程序，每次执行程序时，只需执行目标程序，因此只要源程序不变，就无须重新编译。另一种是解释程序，它将源程序的一条语句翻译成对应的机器目标代码，并立即执行，然后翻译下一条源程序语句并执行，直至所有源程序语句全部被翻译并执行完。所以解释程序的执行过程是翻译一句执行一句，并且不会生成目标程序或机器级目标代码文件。汇编程序也是一种语言翻译程序，它把汇编语言源程序翻译为机器语言程序。汇编语言是一种面向机器的低级语言，是机器语言的符号表示，与机器语言一一对应。
**例题** 关于相联存储器，下列说法中正确的是()。
$A.$只可以按地址寻址
$B.$只可以按内容寻址
$C.$既可按地址寻址又可按内容寻址
$D.$以上说法均不完善
解：$C$。相联存储器既可以按地址寻址又可以按内容（通常是某些字段）寻址，为与传统存储器区别，又称按内容寻址的存储器。

205
Computer-Organization/0-summary.md
View File

@@ -25,11 +25,11 @@
### 软件的发展
+ 机器语言。
+ 汇报语言。
+ 高级语言。
+ 机器语言：唯一可以被计算机识别和执行的语言。
+ 汇编语言：必须经过汇编程序的翻译。
+ 高级语言：转换为汇编程序或直接翻译为机器语言。
### 计算机的分离
### 计算机的分类
电子计算机分为：
@@ -57,8 +57,7 @@
+ 运算器：算术运算和逻辑运算。
+ 控制器：协调其他部件与解析存储器中的程序或指令。
+ 输出设备：将结果转换为人类熟悉的形式。
2. 指令和数据以同等地位存于存储
器，可按地址寻访。
2. 指令和数据以同等地位存于存储器，可按地址寻访。
3. 指令和数据用二进制表示。
4. 指令由操作码（指令序列号，用来表示处理的指令）和地址码（操作数据存储的地址）组成。
5. 存储程序：指将指令以二进制代码的形式事先输入计算机的主存储器，然后按其在存储器中的首地址执行程序的第一条指令，以后就按该程序的规定顺序执行其他指令，直至程序执行结束。
@@ -72,7 +71,7 @@
+ 运算器。
+ 控制器。
+ 主存。
+ I/O设备：
+ $I/O$设备：
+ 辅存。
+ 输入设备。
+ 输出设备。
@@ -80,23 +79,41 @@
### 硬件构成
#### 主存储器
#### I/O设备
+ 存储体：存储数据的主体，按地址存储。
+ MAR：（Memory Address Register）存储地址寄存器。MAR位数反映存储单元个数的幂值。
+ MDR：（Memory Data Register）存储数据寄存器。MDR位数=存储字长。
+ 现代MAR和MDR被划分进入了$CPU$。
输入设备：将程序和数据以机器所能识别和接受的信息形式输入计算机。
输出设备：将计算机处理的结果以人们所能接受的形式或其他系统所要求的信息形式输出
#### 存储器
用于存放程序和数据。分为主存（主存储器、内存储器）和辅存（辅助存储器、外存储器），$CPU$直接访问主存，只有调入主存才能被$CPU$访问。
存储器结构：
+ 存储体：存储数据的主体，按地址存取。（相联存储器按内容访存）
+ $MAR$：（$Memory\,Address\,Register$）存储地址寄存器，用于访存地址，经过存放地址译码后所选的存储单元。$MAR$位数反映存储单元个数的幂值，与$PC$（程序计数器）长度相等，如$MAR$有$10$位，则有$2^{10}=1024$个存储单元。
+ $MDR$：（$Memory\,Data\,Register$）存储数据寄存器，用于暂存要从存储器中读或写的信息。$MDR$位数=存储字长，一般为字节的二次幂的整数倍。
+ 时序控制逻辑：产生存储器操作时所需的各种时序信号。
存储器相关概念：
+ 现代$MAR$和$MDR$被划分进入了$CPU$。
+ 存储单元：每个存储单元存放一串二进制代码。
+ 存储字（word）：存储单元中二进制代码的组合。
+ 存储字长：存储单元中二进制代码的位数。
+ 存储元：即存储二进制的电子元件，每个存储元可存储1bit。
+ 存储字（$word$）：存储单元中二进制代码的组合。
+ 存储字长：存储单元中二进制代码的位数，为$1B$或字节的偶数倍。
+ 存储元：即存储二进制的电子元件，每个存储元可存储$1bit$。
#### 运算器
+ ACC：累加器，用于存放操作数，或运算结果。
+ MQ：乘商寄存器，在乘、除运算时，用于存放操作数或运算结果。
+ X：通用的操作数寄存器，用于存放操作数。
+ ALU：算术逻辑单元，是核心单元，通过内部复杂的电路实现算数运算、逻辑运算。
用于算术运算和逻辑运算。
+ $ALU$：算术逻辑单元，是核心单元，通过内部复杂的电路实现算数运算、逻辑运算。
+ $ACC$：累加器，用于存放操作数，或运算结果。
+ $MQ$：乘商寄存器，在乘、除运算时，用于存放操作数或运算结果。
+ $X$：操作数寄存器，通用的操作数寄存器，用于存放操作数。
+ $PSW$：程序状态寄存器，也称标志寄存器，用于存放$ALU$运算得到的一些标志信息或处理机的状态信息，如结果是否溢出、有无产生进位或借位、结果是否为负等。
+ 还有变址寄存器（$IX$），主要用于存放存储单元在段内的偏移量，基址寄存器（$BR$），用来存放操作数或中间结果，以减少对存储器的访问次数的数据寄存器。这些都不一定具备。
 |加|减|乘|除
:-:|:-:|:-:|:-:|:-:
@@ -106,20 +123,26 @@ X|加数|减数|被乘数|除数
#### 控制器
+ CU：控制单元，分析指令，给出控制信号。
+ IR：指令寄存器，存放当前执行的指令。
+ PC：程序计数器，存放下一条指令地址，有自动加1功能。
+ $CU$：控制单元，分析指令，给出控制信号。
+ $IR$：指令寄存器，存放当前执行的指令，内容来自主存的$MDR$。指令中操作码$OP(IR)$送到$CU$分析指令并发出各种微操作命令序列，地址码$Ad(IR)$送到$MAR$来取操作数。
+ $PC$：程序计数器，存放下一条要指令地址，有自动加$1$以形成下一条指令地址的功能，与主存$MAR$有直接通路。
### 计算机工作过程
1. 把程序和数据装入主存储器。
2. 将源程序转成可执行问题。
3. 从可执行文件的首地址开始逐条执行指令。
完成一条指令：
1. 取指令，并调用PC加1。
2. 将指令放入IR，并分析指令。
3. 调用CU协同执行指令。
1. 取指令$PC\rightarrow MAR\rightarrow M\rightarrow MDR\rightarrow IR$，并调用$PC$加$1$。
2. 将指令放入$IR$，并分析指令$OP(IR)\rightarrow CU$。
3. 调用$CU$协同执行指令$Ad(IR)\rightarrow MAR\rightarrow M\rightarrow MDR\rightarrow ACC$。
如何区分指令和数据：
+ 通过不同的时间段来区分指令和数据，即在取指令阶段（或取指微程序）取出的为指令，在执行指令阶段（或相应微程序）取出的即为数据。
+ 如果通过地址来源区分，由PC提供存储单元地址的取出的是指令，由指令地址码部分提供存储单元地址的取出的是操作数。
+ 如果通过地址来源区分，由$PC$提供存储单元地址的取出的是指令，由指令地址码部分提供存储单元地址的取出的是操作数。
已知：
@@ -130,7 +153,7 @@ int main(){
}
```
根据计算发展，a乘b再加上c，简单的高级语言背后的转换为机器语言就变成：
根据计算过程，$a$乘$b$再加上$c$，简单的高级语言背后的转换为机器语言就变成：
主存地址|操作码|地址码|注释
:-----:|:----:|:----:|:--:
@@ -147,85 +170,85 @@ int main(){
7|0000000000000001|原始数据c=1
8|0000000000000000|原始数据y=0
1. 执行地址为0的指令，取指令1到4，分析指令5，执行指令6到8：
1. (PC)=0：程序计数器指向主存地址为0的指令。
2. (PC)->MAR，(MAR)=0：程序计数器将当前指向的指令地址通过系统总线传输给存储地址寄存器，从而存储地址寄存器的值现在置为0，表示它要处理的指令的主存地址为0。
3. M(MAR)->MDR，(MDR)=000001 0000000101：根据存储地址寄存器存储的地址0，在存储体中找到对应的指令000001 0000000101，并把它放入存储数据寄存器中。
4. (MDR)->IR，(IR)=000001 0000000101：将存储数据寄存器存储的指令放入指令寄存器中。
5. OP(IR)->CU：将指令寄存器的000001操作码传输给控制单元中，控制单元根据操作码知道这是“取数”的指令。
6. AD(IR)->MAR：控制单元根据取数指令，明白要从存储器中取出一个数，而取出的数的地址就是指令寄存器的0000000101，即取出存储地址为5的数据a=2，将这个地址交给存储地址寄存器负责取出。
7. M(MAR)->MDR，(MDR)=0000000000000010=2：存储体根据存储地址寄存器的0000000101地址找到地址为5的数据2，并把2放到存储数据寄存器中。
8. (MDR)->ACC，(ACC)=0000000000000010=2：将存储数据寄存器的数据放入累加器中，完成0这条指令。
2. 执行地址为1的指令，取指令1到4，分析指令5，执行指令6到10：
1. (PC)+=1，(PC)=1：程序计数器完成一条指令自动加一，从而现在指向地址为1的指令。
2. (PC)->MAR，(MAR)=1：存储地址寄存器的值现在置为1，表示它要处理的指令的主存地址为1。
3. M(MAR)->MDR，(MDR)=000100 0000000110：在存储体中找到地址为1的指令000100 0000000110，并把它放入存储数据寄存器中。
4. (MDR)->IR，(IR)=000100 0000000110：将存储数据寄存器存储的指令放入指令寄存器中。
5. OP(IR)->CU：将指令寄存器的000100操作码传输给控制单元中，控制单元根据操作码知道这是“乘法”的指令。
6. AD(IR)->MAR：控制单元根据乘法指令，在第一条指令中就得到了其中一个乘数a，现在要另一个乘数b，b的地址就是指令寄存器的0000000110，即取出存储地址为6的数据b=3，将这个地址交给存储地址寄存器负责取出。
7. M(MAR)->MDR，(MDR)=0000000000000011=3：存储体根据存储地址寄存器的0000000110地址找到地址为6的数据3，并把3放到存储数据寄存器中。
8. (MDR)->MQ，(MQ)=0000000000000011=3：由于需要乘法操作，所以将存储数据寄存器的3放入乘商寄存器中。
9. (ACC)->X，(X)=2：然后把a的值从累加器中放入通用寄存器中。（乘法操作中被乘数放入通用寄存器中，而乘数放入乘商寄存器中）。
10. (MQ)*(X)->ACC，(ACC)=6：控制单元通知算术逻辑单元，通过算术逻辑单元对ab进行相乘后放入累加器中。如果乘积太大则需要乘商寄存器辅助存储。
3. 执行地址为2的指令，取指令1到4，分析指令5，执行指令6到9：
1. (PC)+=1，(PC)=2：程序计数器完成一条指令自动加一，从而现在指向地址为2的指令。
2. (PC)->MAR，(MAR)=2：存储地址寄存器的值现在置为2，表示它要处理的指令的主存地址为2。
3. M(MAR)->MDR，(MDR)=000011 0000000111：根据存储地址寄存器存储的地址2，在存储体中找到对应的指令000011 0000000111，并把它放入存储数据寄存器中。
4. (MDR)->IR，(IR)=000011 0000000111：将存储数据寄存器存储的指令放入指令寄存器中。
5. OP(IR)->CU：将指令寄存器的000011操作码传输给控制单元中，控制单元根据操作码知道这是“加法”的指令。
6. AD(IR)->MAR：控制单元根据取数指令，从存储器中取出指令寄存器的地址为0000000111数，，即取出存储地址为7的数据c=1，将这个地址交给存储地址寄存器负责取出。
7. M(MAR)->MDR，(MDR)=0000000000000001=1：存储体根据存储地址寄存器的0000000111地址找到地址为7的数据1，并把1放到存储数据寄存器中。
8. (MDR)->X，X=0000000000000001=1：将存储数据寄存器的1放入通用寄存器中。（即加法操作中累加器存放被加数，通用寄存器中存放加数）。
9. (ACC)+(X)->ACC，(ACC)=7：控制单元通知算术逻辑单元，将ab与c相加并存回累加器中。
4. 执行地址为3的指令，取指令1到4，分析指令5，执行指令6到8：
1. (PC)+=1，(PC)=3：程序计数器完成一条指令自动加一，从而现在指向地址为3的指令。
2. (PC)->MAR，(MAR)=3：存储地址寄存器的值现在置为3，表示它要处理的指令的主存地址为3。
3. M(MAR)->MDR，(MDR)=000010 0000001000：根据存储地址寄存器存储的地址3，在存储体中找到对应的指令000010 0000001000，并把它放入存储数据寄存器中。
4. (MDR)->IR，(IR)=000010 0000001000：将存储数据寄存器存储的指令放入指令寄存器中。
5. OP(IR)->CU：将指令寄存器的000010操作码传输给控制单元中，控制单元根据操作码知道这是“存数”的指令。
6. AD(IR)->MAR，(MAR)=0000001000=8：控制单元根据存数指令，根据存储的目的地址为0000001000。
7. (ACC)->MDR，(MDR)=7，将运算的结果从累加器中传输为存储数据寄存器中。
8. (MDR)->地址为8的存储单元，y=7：控制单元根据控制总线，将存储数据寄存器中的数据存储到存储地址寄存器中所指向的地址，所以地址码为8的y的值就变成了7。
5. 执行地址为4的指令，取指令1到4，分析指令5，执行指令6：
1. (PC)+=1，(PC)=4：程序计数器完成一条指令自动加一，从而现在指向地址为4的指令。
2. (PC)->MAR，(MAR)=4：存储地址寄存器的值现在置为4，表示它要处理的指令的主存地址为4。
3. M(MAR)->MDR，(MDR)=000110 0000000000：根据存储地址寄存器存储的地址4，在存储体中找到对应的指令000110 0000000000，并把它放入存储数据寄存器中。
4. (MDR)->IR，(IR)=000110 0000000000：将存储数据寄存器存储的指令放入指令寄存器中。
5. OP(IR)->CU：将指令寄存器的000110操作码传输给控制单元中，控制单元根据操作码知道这是“停机”的指令。
1. 执行地址为$0$的指令，取指令$1$到$4$，分析指令$5$，执行指令$6$到$8$：
1. $(PC)=0$：程序计数器指向主存地址为$0$的指令。
2. $(PC)\rightarrow MAR$，$(MAR)=0$：程序计数器将当前指向的指令地址通过系统总线传输给存储地址寄存器，从而存储地址寄存器的值现在置为$0$，表示它要处理的指令的主存地址为$0$。
3. $M(MAR)\rightarrow MDR$，$(MDR)=000001\,0000000101$：根据存储地址寄存器存储的地址$0$，在存储体中找到对应的指令$000001\,0000000101$，并把它放入存储数据寄存器中。
4. $(MDR)\rightarrow IR$，$(IR)=000001\,0000000101$：将存储数据寄存器存储的指令放入指令寄存器中。
5. $OP(IR)\rightarrow CU$：将指令寄存器的$000001$操作码传输给控制单元中，控制单元根据操作码知道这是“取数”的指令。
6. $AD(IR)\rightarrow MAR$：控制单元根据取数指令，明白要从存储器中取出一个数，而取出的数的地址就是指令寄存器的$0000000101$，即取出存储地址为$5$的数据$a=2$，将这个地址交给存储地址寄存器负责取出。
7. $M(MAR)\rightarrow MDR$，$(MDR)=000000\,0000000010=2$：存储体根据存储地址寄存器的$0000000101$地址找到地址为$5$的数据$2$，并把$2$放到存储数据寄存器中。
8. $(MDR)\rightarrow ACC$，$(ACC)=000000\,0000000010=2$：将存储数据寄存器的数据放入累加器中，完成$0$这条指令。
2. 执行地址为$1$的指令，取指令$1$到$4$，分析指令$5$，执行指令$6$到$10$：
1. $(PC)+=1，(PC)=1$：程序计数器完成一条指令自动加一，从而现在指向地址为$1$的指令。
2. $(PC)\rightarrow MAR，(MAR)=1$：存储地址寄存器的值现在置为$1$，表示它要处理的指令的主存地址为$1$。
3. $M(MAR)\rightarrow MDR，(MDR)=000100\,0000000110$：在存储体中找到地址为$1$的指令$000100\,0000000110$，并把它放入存储数据寄存器中。
4. $(MDR)\rightarrow IR，(IR)=000100\,0000000110$：将存储数据寄存器存储的指令放入指令寄存器中。
5. $OP(IR)\rightarrow CU$：将指令寄存器的$000100$操作码传输给控制单元中，控制单元根据操作码知道这是“乘法”的指令。
6. $AD(IR)\rightarrow MAR$：控制单元根据乘法指令，在第一条指令中就得到了其中一个乘数a，现在要另一个乘数$b$，$b$的地址就是指令寄存器的$0000000110$，即取出存储地址为$6$的数据$b=3$，将这个地址交给存储地址寄存器负责取出。
7. $M(MAR)\rightarrow MDR$，$(MDR)=000000\,0000000011=3$：存储体根据存储地址寄存器的$0000000110$地址找到地址为$6$的数据$3$，并把$3$放到存储数据寄存器中。
8. $(MDR)\rightarrow MQ$，$(MQ)=000000\,0000000011=3$：由于需要乘法操作，所以将存储数据寄存器的$3$放入乘商寄存器中。
9. $(ACC)\rightarrow X$，$(X)=2$：然后把$a$的值从累加器中放入通用寄存器中。（乘法操作中被乘数放入通用寄存器中，而乘数放入乘商寄存器中）。
10. $(MQ)*(X)\rightarrow ACC$，$(ACC)=6$：控制单元通知算术逻辑单元，通过算术逻辑单元对ab进行相乘后放入累加器中。如果乘积太大则需要乘商寄存器辅助存储。
3. 执行地址为$2$的指令，取指令$1$到$4$，分析指令$5$，执行指令$6$到$9$：
1. $(PC)+=1$，$(PC)=2$：程序计数器完成一条指令自动加一，从而现在指向地址为2的指令。
2. $(PC)\rightarrow MAR$，$(MAR)=2$：存储地址寄存器的值现在置为$2$，表示它要处理的指令的主存地址为2。
3. $M(MAR)\rightarrow MDR$，$(MDR)=000011\,0000000111$：根据存储地址寄存器存储的地址$2$，在存储体中找到对应的指令$000011\,0000000111$，并把它放入存储数据寄存器中。
4. $(MDR)\rightarrow IR$，$(IR)=000011\,0000000111$：将存储数据寄存器存储的指令放入指令寄存器中。
5. $OP(IR)\rightarrow CU$：将指令寄存器的$000011$操作码传输给控制单元中，控制单元根据操作码知道这是“加法”的指令。
6. $AD(IR)\rightarrow MAR$：控制单元根据取数指令，从存储器中取出指令寄存器的地址为$0000000111$的数，即取出存储地址为$7$的数据$c=1$，将这个地址交给存储地址寄存器负责取出。
7. $M(MAR)\rightarrow MDR$，$(MDR)=000000\,0000000001=1$：存储体根据存储地址寄存器的$0000000111$地址找到地址为$7$的数据$1$，并把$1$放到存储数据寄存器中。
8. $(MDR)\rightarrow X，X=000000\,0000000001=1$：将存储数据寄存器的1放入通用寄存器中。（即加法操作中累加器存放被加数，通用寄存器中存放加数）。
9. $(ACC)+(X)\rightarrow ACC$，$(ACC)=7$：控制单元通知算术逻辑单元，将$ab$与$c$相加并存回累加器中。
4. 执行地址为$3$的指令，取指令$1$到$4$，分析指令$5$，执行指令$6$到$8$：
1. $(PC)+=1$，$(PC)=3$：程序计数器完成一条指令自动加一，从而现在指向地址为3的指令。
2. $(PC)\rightarrow MAR$，$(MAR)=3$：存储地址寄存器的值现在置为3，表示它要处理的指令的主存地址为3。
3. $M(MAR)\rightarrow MDR$，$(MDR)=000010\,0000001000$：根据存储地址寄存器存储的地址$3$，在存储体中找到对应的指令$000010\,0000001000$，并把它放入存储数据寄存器中。
4. $(MDR)\rightarrow IR$，$(IR)=000010\,0000001000$：将存储数据寄存器存储的指令放入指令寄存器中。
5. $OP(IR)\rightarrow CU$：将指令寄存器的000010操作码传输给控制单元中，控制单元根据操作码知道这是“存数”的指令。
6. $AD(IR)\rightarrow MAR$，$(MAR)=0000001000=8$：控制单元根据存数指令，根据存储的目的地址为$0000001000$。
7. $(ACC)\rightarrow MDR$，$(MDR)=7$：将运算的结果从累加器中传输为存储数据寄存器中。
8. $(MDR)\rightarrow$：地址为$8$的存储单元，$y=7$：控制单元根据控制总线，将存储数据寄存器中的数据存储到存储地址寄存器中所指向的地址，所以地址码为$8$的$y$的值就变成了$7$。
5. 执行地址为$4$的指令，取指令$1$到$4$，分析指令$5$，执行指令$6$：
1. $(PC)+=1$，$(PC)=4$：程序计数器完成一条指令自动加一，从而现在指向地址为$4$的指令。
2. $(PC)\rightarrow MAR$，$(MAR)=4$：存储地址寄存器的值现在置为$4$，表示它要处理的指令的主存地址为4。
3. $M(MAR)\rightarrow MDR$，$(MDR)=000110\,0000000000$：根据存储地址寄存器存储的地址$4$，在存储体中找到对应的指令$000110\,0000000000$，并把它放入存储数据寄存器中。
4. $(MDR)\rightarrow IR$，$(IR)=000110\,000000000$：将存储数据寄存器存储的指令放入指令寄存器中。
5. $OP(IR)\rightarrow CU$：将指令寄存器的$000110$操作码传输给控制单元中，控制单元根据操作码知道这是“停机”的指令。
6. 操作系统通过中断指令停止程序。
### 计算机层次
1. 微程序机器（微指令系统）：由硬件直接执行微指令。
2. 传统机器（用机器语言的机器）：执行二进制机器指令。
3. 虚拟机器（操作系统机器）：向上提供“广义指令”即系统调用。
2. 传统机器（用机器语言的机器）：执行二进制机器指令，微程序解释机器执行微指令。
3. 虚拟机器（操作系统机器）：由操作系统程序实现，向上提供“广义指令”即系统调用。也称为混合层。
4. 虚拟机器（汇编语言机器）：不能直接运行汇编语言，必须用汇编程序（汇编器）翻译成机器语言程序，所以是虚拟的。汇编语言与机器语言一一对应。
5. 虚拟机器（高级语言机器）：还是必须用编译程序（编译器或解释器）翻译成汇编语言程序。
5. 虚拟机器（高级语言机器）：面向用户，必须用编译程序（编译器或解释器）翻译成汇编语言程序。
+ 编译程序：将高级语言编写的源程序全部语句一次全部翻译成机器语言程序，而后再执行机器语言程序（只需翻译一次）。如C和CPP。
+ 解释程序：将源程序的一条语句翻译成对应于机器语言的语句，并立即执行。紧接着再翻译下一句（每次执行都要翻译）。如JS和Python。
+ 对于Java既可以编译也可以解释。
+ 编译程序：将高级语言编写的源程序全部语句一次全部翻译成机器语言程序，而后再执行机器语言程序（只需翻译一次）。如$C$和$CPP$。
+ 解释程序：将源程序的一条语句翻译成对应于机器语言的语句，并立即执行。紧接着再翻译下一句（每次执行都要翻译）。如$JS$和$Python$。
+ 对于$Java$既可以编译也可以解释。
## 计算机性能指标
### 存储器
### 主存储器
+ MAR位数反映存储单元的个数（最多支持多少个）。
+ MDR位数=存储字长=每个存储单元的大小。
+ 总容量=存储单元个数×存储字长。单位为bit。
+ 如MAR为32位，MDR为8位，总容量=$2^{32}\times8\div8=3^{32}$Byte，所以为4GB。
+ $MAR$位数反映存储单元的个数（最多支持多少个）。
+ $MDR$位数=存储字长=每个存储单元的大小。
+ 总容量=存储单元个数×存储字长。单位为$bit$。
+ 如$MAR$为$32$位，$MDR$为$8$位，总容量=$2^{32}\times8\div8=3^{32}Byte$，所以为$4GB$。
### 中央处理器
+ $CPU$主频：$CPU$内数字脉冲信号振荡的频率。单位为赫兹。
+ $CPU$时钟周期：$CPU$主频（时钟主频）=1÷$CPU$时钟周期。单位为纳秒或微秒。
+ CPI (Clock cycle Per Instruction）：执行一条指令所需的时钟周期数。
+ 执行一条指令的耗时= CPIx$CPU$时钟周期。
+ $CPU$执行时间（整个程序的耗时）=$CPU$时钟周期数÷主频=(指令条数×CPI)÷主频。
+ IPS（Instructions Per Second）：每秒执行多少条指令，IPS=主频÷平均CPI。
+ FLOPS（Floating-point Operations Per Second）：每秒执行多少次浮点运算。
+ $CPU$时钟周期：$CPU$主频（时钟主频）=$1\div CPU$时钟周期。单位为纳秒或微秒。
+ $CPI$（$Clock\,cycle\,Per\,Instruction$）：执行一条指令所需的时钟周期数。
+ 执行一条指令的耗时= $CPI\times CPU$时钟周期。
+ $CPU$执行时间（整个程序的耗时）=$CPU$时钟周期数÷主频=(指令条数×$CPI$)÷主频。
+ $IPS$（$Instructions\,Per\,Second$）：每秒执行多少条指令，$IPS$=主频÷平均$CPI$。也可以得到$MIPS$即每秒执行多少百万条指令。
+ $FLOPS$（$Floating-point\,Operations\,Per\,Second$）：每秒执行多少次浮点运算。
**例题** 某$CPU$主频为10o00Hz，某程序包含100条指令，平均来看指令任CPI=3，该程序在该$CPU$上执行需要多久？
**例题** 某$CPU$主频为10000Hz，某程序包含100条指令，平均来看指令任CPI=3，该程序在该$CPU$上执行需要多久？
100×3÷1000=0.3s。
@@ -233,5 +256,5 @@ int main(){
+ 数据通路带宽：数据总线一次所能并行传送信息的位数（各硬件部件通过数据总线传输数据）。
+ 吞吐量：指系统在单位时间内处理请求的数量。它取决于信息能多快地输入内存，$CPU$能多快地取指令，数据能多快地从内存取出或存入，以及所得结果能多快地从内存送给一台外部设备。这些步骤中的每一步都关系到主存，因此，系统吞吐量主要取决于主存的存取周期。
+ 响应时间：指从用户向计算机发送一个请求，到系统对该请求做出响应并获得它所需要的结果的等待时间。通常包括$CPU$时间（运行一个程序所花费的时间）与等待时间（用于磁盘访问、存储器访问、I/O操作、操作系统开销等时间）。
+ 响应时间：指从用户向计算机发送一个请求，到系统对该请求做出响应并获得它所需要的结果的等待时间。通常包括$CPU$时间（运行一个程序所花费的时间）与等待时间（用于磁盘访问、存储器访问、$I/O$操作、操作系统开销等时间）。
+ 基准程序是用来测量十算机处理速度的一种实用程序，以便于被测量的计算机性能可以与运行相向程序的其它计算机性能进行比较。

155
Operate-System/1-process-management-ex.md
View File

@@ -411,6 +411,27 @@ $D.$可重入的程序代码
### 信号量
#### PV操作
**例题** 下列关于$PV$操作的说法中，正确的是()。
Ⅰ.$PV$操作是一种系统调用命令
Ⅱ.$PV$操作是一种低级进程通信原语
Ⅲ.$PV$操作是由一个不可被中断的过程组成
Ⅳ.$PV$操作是由两个不可被中断的过程组成
$A.$Ⅰ、Ⅲ
$B.$Ⅱ、Ⅳ
$C.$Ⅰ、Ⅱ、Ⅳ
$D.$Ⅰ、Ⅳ
解：$B$。$PV$操作是一种低级的进程通信原语，不是系统调用，因此Ⅱ正确；$Р$操作和$V$操作都属于原子操作，所以$PV$操作由两个不可被中断的过程组成，因此Ⅳ正确。
#### 信号量含义
**例题** 设与某资源关联的信号量初值为$3$，当前值为$1$。若$M$表示该资源的可用个数，$N$表示等待该资源的进程数，则$M$，$N$分别是()。
$A.0,1$
@@ -423,30 +444,6 @@ $D.2,0$
解：$D$。信号量是一个特殊的整型变量，只有初始化和$PV$操作才能改变其值。通常，信号量分为互斥量和资源量，互斥量的初值一般为$1$，表示临界区只允许一个进程进入，从而实现互斥。当互斥量等于$0$时，表示临界区已有一个进程进入，临界区外尚无进程等待；当互斥量小于$0$时，表示临界区中有一个进程，互斥量的绝对值表示在临界区外等待进入的进程数。同理，资源信号量的初值可以是任意整数，表示可用的资源数，当资源量小于$0$时，表示所有资源已全部用完，而且还有进程正在等待使用该资源，等待的进程数就是资源量的绝对值。
**例题** 用$PV$操作实现进程同步，信号量的初值为()。
$A.-1$
$B.0$
$C.1$
$D.$由用户确定
解：$D$。与互斥信号量初值一般为$1$时不同，用$PV$操作实现进程同步，信号量的初值应根据具体情况来确定。若期望的消息尚未产生，则对应的初值应为$0$，若期望的消息已存在，则信号量的初值应设为一个非$0$的正整数。（一般看之前的同步互斥应用一般设置为$0$是因为还没有产生消息）
**例题** 有三个进程共享同一程序段，而每次只允许两个进程进入该程序段，若用$PV$操作同步机制，则信号量$S$的取值范围是()。
$A.2,1,0,-1$
$B.3,2,1,0$
$C.2,1,0,-1,-2$
$D.1,0,-1,-2$
解：$A$。因为每次允许两个进程进入该程序段，即资源（这里指可进入的空间）的最大容量为$2$，所以信号量最大值取$2$。至多有三个进程申请，则信号量最小为$-1$，即最多只存在一个进程在等待，所以信号量可以取$2,1,0,—1$。
**例题** 一个进程因在互斥信号量`mutex`上执行`V(mutex)`操作而导致唤醒另一个进程时，执行$V$操作后`mutex`的值为()。
$A.$大于$0$
@@ -459,4 +456,114 @@ $D.$小于等于$0$
解：$D$。由题意可知，$V$操作导致唤醒另一个进程，所以系统原来就存在等待进入临界区的进程，`mutex`小于等于$-1$，因此在执行`V(mutex)`操作后，`mutex`的值小于等于$0$。
#### 信号量初值
**例题** 用$PV$操作实现进程同步，信号量的初值为()。
$A.-1$
$B.0$
$C.1$
$D.$由用户确定
解：$D$。与互斥信号量初值一般为$1$时不同，用$PV$操作实现进程同步，信号量的初值应根据具体情况来确定。若期望的消息尚未产生，则对应的初值应为$0$，若期望的消息已存在，则信号量的初值应设为一个非$0$的正整数。（一般看之前的同步互斥应用一般设置为$0$是因为还没有产生消息）
**例题** 在$9$个生产者、$6$个消费者共享容量为$8$的缓冲器的生产者-消费者问题中，互斥使用缓冲器的信号量初始值为()。
$A.1$
$B.6$
$C.8$
$D.9$
解：$A$。所谓互斥使用某临界资源，是指在同一时间段只允许一个进程使用此资源，所以互斥信号量的初值都为$1$。
#### 信号量值范围
**例题** 有三个进程共享同一程序段，而每次只允许两个进程进入该程序段，若用$PV$操作同步机制，则信号量$S$的取值范围是()。
$A.2,1,0,-1$
$B.3,2,1,0$
$C.2,1,0,-1,-2$
$D.1,0,-1,-2$
解：$A$。因为每次允许两个进程进入该程序段，即资源（这里指可进入的空间）的最大容量为$2$，所以信号量最大值取$2$。至多有三个进程申请，则信号量最小为$-1$，即最多只存在一个进程在等待，所以信号量可以取$2,1,0,—1$。
### 进程同步与互斥应用
#### 进程互斥
**例题** 进程$P_1$和$P_2$均包含并发执行的线程，部分伪代码描述如下所示。
```cpp
// 进程P1
int x=0;
Thread1(){
int a;
a=1;
x+=1;
}
Thread2(){
int a;
a=2;
x+=2;
}
// 进程P2
int x=0;
Thread3(){
int a;
a=x;
x+=3;
}
Thread4(){
int b;
b=x;
x+=4;
}
```
下列选项中，需要互斥执行的操作是()。
$A.a=1$与$a=2$
$B.a=x$与$b=x$
$C.x+=1$与$x+=2$
$D.x+=1$与$x+=3$
解：$C$。只有对共享变量的赋值可能需要互斥操作。$P$中对$a$进行赋值，并不影响最终的结果，因此$a=1$与$a=2$不需要互斥执行，所以$A$不是。$a=x$与$b=x$执行先后不影响$a$与$b$的结果，无须互斥执行，$B$不是。在同一个进程中，$x+=1$与$x+=2$执行先后会影响$x$的结果，需要互斥执行，$C$需要。$P_1$中的x和$P_2$中的$x$虽然是共享变量，但是不同范围中的$x$，互不影响，不需要互斥执行，$D$不需要。所以其实$x+=3$和$x+=4$也要互斥运行。
### 管程
**例题** 以下关于管程的叙述中，错误的是()。
$A.$管程是进程同步工具，解决信号量机制大量同步操作分散的问题
$B.$管程每次只允许一个进程进入管程
$C.$管程中$signal$操作的作用和信号量机制中的$V$操作相同
$D.$管程是被进程调用的，管程是语法范围，无法创建和撤销
解：$C$。管程的$signal$操作与信号量机制中的$V$操作不同，信号量机制中的$V$操作一定会改变信号量的值$S=S+1$。而管程中的$signal$操作是针对某个条件变量的，若不存在因该条件而阻塞的进程，则$signal$不会产生任何影响。
**例题** 若$x$是管程内的条件变量，则当进程执行`x.wait()`时所做的工作是()。
$A.$实现对变量$x$的互斥访问
$B.$唤醒一个在$x$上阻塞的进程
$C.$根据$x$的值判断该进程是否进入阻塞态
$D.$阻塞该进程，并将之插入$x$的阻塞队列中
解：$D$。这是基本的概念，且由于进程已经执行`x.wait()`，证明判断条件为真应该阻塞，所以$C$不对。“条件变量”是管程内部说明和使用的一种特殊变量，其作用类似于信号量机制中的“信号量”，都用于实现进程同步。需要注意的是，在同一时刻，管程中只能有一个进程在执行。若进程$A$执行了`x.wait()`操作，则该进程会阻塞，并挂到条件变量`x`对应的阻塞队列上。这样，管程的使用权被释放，就可以有另一个进程进入管程。若进程$B$执行了`x.signal()`操作，则会唤醒`x`对应的阻塞队列的队首进程。在$Pascal$语言的管程中，规定只有一个进程要离开管程时才能调用`signal()`操作。