第4章 处理器（CPU） 4.1 引言 4.2 逻辑设计的一般方法 4.3 建立数据通路 4.4 一个简单的实现机制 4.5 多周期实现机制

4.1 引言 一. 计算机的组成 Control unit Path: multiplexors CPU ALU Registers 一. 计算机的组成 Computer CPU Memory I/O interface Control unit Datapath Path: multiplexors ALU Registers ……

4.1 引言 二. CPU的基本功能： （1）程序控制 （2）操作控制 自动地、连续地取出指令、解释指令、执行指令。 一条指令的功能往往是由若干个操作信号的组合来实现的。

4.1 引言 （3）时间控制 对各种操作实施时间上的控制称为时间控制. 各种指令的操作信号均受到时间的严格控制； 一条指令的整个执行过程也受到时间的严格控制。 （4）数据加工

4.1 引言 三. 一个基本的MIPS实现 存储器访问指令 lw 和 sw 算术逻辑指令 add, sub, and, or, slt 分支指令 beq j

四. MIPS子集的基本实现 1. CPU主要功能单元 不能直接将数据线简单连在一起 使用多选器

2. 增加了多选器和控制信号的CPU

4.2 逻辑设计的一般方法 一. 主要的逻辑单元 1. 组合单元：一个操作单元，如与门或ALU。 处理数据值 输出是输入的函数 2. 状态单元：一个存储单元（元件），如寄存器或存储器。 存放信息 至少有两个输入（要写入的数据值和决定何时写入的时钟信号）

4.2 逻辑设计的一般方法 二. 时序系统 1. 时序发生器：产生时钟周期节拍、脉冲等时序信号的部件。 振荡器 分频器 一个脉冲源： 又称主振荡器，提供CPU的时钟基准 一组计数分频逻辑： 主振的输出经过一系列计数分频，产生时钟周期（节拍）信号。 振荡器 分频器 基准时钟 时钟周期(节拍)

4.2 逻辑设计的一般方法 2. 时钟：一个具有固定周期时间的不停运转的信号。 时钟周期 低电平时钟 高电平时钟 上升沿 下降沿 3. 时钟同步方法：一种根据时钟来决定数据何时有效和稳定的方法。 又称为时钟方法，即同步控制方式。 与之相反的即异步控制方式

4.2 逻辑设计的一般方法 4. 边沿触发时钟：一种时钟机制，在这种机制下所有的状态改变都发生在时钟边沿。 如：在一个时钟周期内向寄存器写数： 由时钟信号决定何时更新寄存器中的数据。 边沿触发：当时钟信号从0变为1（上升沿）时更新。 Clk D Q D Clk Q

4.2 逻辑设计的一般方法 如：带”写”控制信号的寄存器 控制信号：用于决定选择或可操作的信号，与数据信号相对应。 只有在”写”控制信号为1，且在时钟边沿才能更新。 Write D Q Clk D Clk Q Write

4.2 逻辑设计的一般方法 三. 同步时序逻辑设计 组合逻辑单元的操作在一个时钟周期内完成。 状态 单元1 单元2 组合逻辑 输出 写入 组合逻辑单元的操作在一个时钟周期内完成。 数据信号从状态单元1输出到状态单元2所需的时间决定了时钟周期的长度。

4.2 逻辑设计的一般方法 一种边沿触发方法 状态 单元 组合逻辑 读出 写入 支持状态单元在同一个时钟周期内同时读写

4.3 建立数据通路 一. 主要的数据通路部件 1. 数据通路部件：指用来操作或保存处理器中数据的单元。 2. 包括： 指令存储器 数据存储器 寄存器堆 ALU 加法器等

程序计数器（PC）：存放将要被执行指令的地址的寄存器。

4.3 建立数据通路 二. MIPS指令实现（执行）过程 取指 : 从指令存储器中取出一条指令 修改PC使其指向下一条指令 指令译码& 读操作数: 将指令转换成一组机器控制命令 读寄存器中的操作数（无论以后是否会使用） 执行: 控制ALU实现相应操作

4.3 建立数据通路 存储器访问: 从存储器中读/写数据 只适用于 LW/SW指令 写结果到寄存器: R型指令：结果写到Rd I型指令：结果写到Rt

4.3 建立数据通路 三. MIPS寻址模式回顾 立即数寻址： addi $s0,$s0,4 寄存器寻址： add $s0,$s1,$s2 基址寻址： lw $s1,0($s0) PC相对寻址：beq $s0,$s1,L1 伪直接寻址： j Address1

+ B y t e H a l f w o r d W R g i s M m 1 . I n 2 3 4 P C - v 5 u c p

from which instruction 4.3 建立数据通路 四. 创建一个简单的数据通路 1. 取指令 Instruction width is 4 bytes! so add 4 PC keeps the current memory address from which instruction is fetched Instruction read from Memory – send to rest Of data path

4.3 建立数据通路 2. 译码/读寄存器 寄存器堆：包含一系列寄存器的状态单元，可以通过提供寄存器号进行读写。 5 bits

4.3 建立数据通路 Reg. address Data output 读寄存器 5 bits 32 bits Reg. address

4.3 建立数据通路 写寄存器 Write signals rd or rt 5 bits Reg. address 32 bits

4.3 建立数据通路 3. 不同的指令类型，操作不同，数据通路也不同。 R-型指令数据通路 算术逻辑运算指令 I-型指令数据通路 访存指令 条件分支指令 J-型指令数据通路 跳转指令

R type Instruction & Data stream ALU 控制线 功能 0000 与 0001 或 0010 加 0110 减 0111 小于则置位 1100 或非 op(6) rs(5) rt(5) rd(5) shamt func(6) control ALU operation ALUC bit21-25 RegWrite 4 rs rt rd Registers Read reg. address1 Read reg. address2 Write reg. address Write data Read data1 Read data2 ALU result Zero ALU bit16-20 bit11-15 32bits data

I type Instruction & Data stream lw $t0, 200($s2) sw $t0, 200($s2) control ALUop ALUC RegWrite bit21-25 ALU operation 4 rs Registers Read reg. address1 bit16-20 Read data1 rt ALU Read reg. address2 Zero op(6) rs(5) rt(5) Immediate data MenWrite rt Write reg. address ALU result address Read data2 Read data Write data Data Memory Write data bit0-15 Sign extend 32 MenRead 16 32bits data lw $t0, 200($s2) if $s2=1000，it will load word in element number 1200 to $t0

I type Instruction & Data stream of beq PC+4 from instructiondatapath control ADD To PC Shift left 2 bit21-25 RegWrite Branch rs Registers Read reg. address1 bit16-20 ALUC ALUop Read data1 op(6) rs(5) rt(5) offset rt Read reg. address2 4 ALU operation Write reg. address ALU Zero Read data2 Write data ALU result Sign extend 16 bit0-15 32

J type Instruction bit25-00 bit21-25 bit16-20 bit0-15 op(6) control PC+4[31:28]##bit25-00##00 ## Shift left 2 To PC 28 bit25-00 PC+4[31:28] control ADD Shift left 2 Jump bit21-25 RegWrite Branch rs Registers Read reg. address1 bit16-20 op(6) rs(5) rt(5) offset Read data1 rt Read reg. address2 4 ALU operation Write reg. address ALU Zero Read data2 Write data ALU result Sign extend 16 bit0-15 32 J Loop

4. 合并数据通路 rs rt rd 比较: add $t0,$t1,$t2 lw $t0,4($t1) 注：该通路不包含跳转指令的实现 Write register # selection imm ALU control bits from I[5:0] 比较: add $t0,$t1,$t2 lw $t0,4($t1) Funct!

4.4 一个简单的实现机制 在数据通路上加入控制信号 (注：该通路不包含跳转指令的实现) 操作码

1：写寄存器的目标寄存器号来自rd字段(15:11) 一.各控制信号的作用 RegDst 0：写寄存器的目标寄存器号来自rt字段(20:16) 1：写寄存器的目标寄存器号来自rd字段(15:11)

一.各控制信号的作用 RegWrite 0：无 1：寄存器堆写使能有效

一.各控制信号的作用 ALUScr 0：第二个ALU操作数来自寄存器堆的第二个输出 (Read data 2)

一.各控制信号的作用 PCSrc PCSrc(Branch) 0：PC 由PC+4取代 1：PC由分支目标地址取代

一.各控制信号的作用 MemRead 0：无 1：数据存储器读使能有效

一.各控制信号的作用 MemWrite 0：无 1：将写数据端（Write data）的数 据写入到指定地址的存储单元中

一.各控制信号的作用 MemtoReg 0:写入寄存器的数据来自ALU 1:写入寄存器的数据来自数据存储器

一.各控制信号的作用 ALUOp：ALU的控制位，共两位。 用于 与R型指令的funct字段一起译码形成4 位ALU控制信号。

各控制信号的作用小结（对照P177 图4-17） 信号名 无效时(=0)的含义 有效时(=1)的含义 RegDst 写寄存器的目标寄存器号来自rt字段(20:16) 写寄存器的目标寄存器号来自rd字段(15:11) RegWrite 无 寄存器堆写使能有效 ALUScr 第二个ALU操作数来自寄存器堆的第二个输出 (Read data 2) 第二个ALU操作数为指令低16位的符号扩展 PCSrc (Branch) PC 由PC+4取代 PC由分支目标地址取代 MemRead 数据存储器读使能有效 MemWrite 将写数据端（Write data）的数据写入到指定地址的存储单元中 MemtoReg 写入寄存器的数据来自ALU 写入寄存器的数据来自数据存储器 ALUOp：ALU的控制位，共两位。 用于与R型指令的funct字段一起译码形成4位ALU控制信号。

4.4 一个简单的实现机制 两级译码： First 主控制单元 op(6) rs(5) rt(5) rd(5) shamt func(6) Second ALU 控制单元 Signals for Other Components (7) op(6) rs(5) rt(5) rd(5) shamt func(6) ALU Op(2) ALU operation(4)

4.4 一个简单的实现机制 主控制单元的功能 ALUop (2) 两组共7个控制信号 4 Mux 3 R/W ALU op (2) 主控制器 LW 00 SW Beq 01 R-type 10 主控制器 RegDst ALUScr PCSrc MemtoReg ALU op (2) 指令操作码(6) Mux (4) R/W (3) MemRead MemWrite RegWrite

(Ainvert Bnegate Operation) 4.4 一个简单的实现机制 二. ALU 控制 ALU功能控制表 ALU 控制信号 (Ainvert Bnegate Operation) 功能 0000 与 0001 或 0010 加 0110 减 0111 小于则置位 1100 或非 Load/Store指令: 使用加法计算地址 相等则分支指令: 使用减法判断是否相等 R型指令: 依赖funct 字段执行前5种操作中的一种

当ALUOp为00或01时，ALU动作不依赖于funct字段。 4.4 一个简单的实现机制 ALU 控制信号的形成 指令操作码 ALUOp 指令操作 funct字段 ALU 动作 ALU 控制信号 lw 00 取字 XXXXXX add 0010 sw 存字 beq 01 相等则分支 subtract 0110 R-type 10 加 100000 减 100010 与 100100 AND 0000 或 100101 OR 0001 小于则置位 101010 set-on-less-than 0111 当ALUOp为00或01时，ALU动作不依赖于funct字段。 建立真值表，最终形成门电路。

4.4 一个简单的实现机制 建立真值表 ALUOp Funct 字段 操作 Operation F5 F4 F3 F2 F1 F0 X X 0010 1 0110 0000 0001 0111

建立逻辑关系式 化简后： 思考： 另外两位操作信号的产生逻辑式? F0 F3 ALUOp Funct 字段 操作 Operation F5 X 0010 1 0110 0000 0001 0111 建立逻辑关系式 F0 化简后： 思考： 另外两位操作信号的产生逻辑式? F3

4.4 一个简单的实现机制 形成门电路

4.4 一个简单的实现机制 三. 主控制单元的设计 1. 基本控制原理 32位指令是相关控制信息的产生依据 其中操作码确定相关操作（如：算术逻辑运算、读/写等） 通过主控制单元发出各种控制信号来控制数据的传送 （如控制多选器的输入） 指令类型和function字段共同决定ALU的操作

4.4 一个简单的实现机制 2.MIPS子集指令格式 3.各类指令在数据通路中的操作 R-format instruction (add, sub, and, or, slt) 31 21 25 21 25 16 15 11 10 6 5 0 Op Rs Rt Rd Shamt Funct 6 bits 5bits 6bits I-format instruction (lw, sw, beq) Immediate 16bits J-format instruction (j) address 26bits 3.各类指令在数据通路中的操作

The Datapath in operation for R-type M U X 1 1 M U X Instruction [25-0] Shift left 2 jump address[31-0] Add 26 28 PC+4[31-28] ALU result Shift left 2 Add 4 Control RegDst Branch MemRead MemtoReg ALUOp MemWrite ALUSrc RegWrite jump Instruction [31-26] pc Read address Instruction [31-0] Instruction [25-21] Read register 1 Read data 1 Instruction memory Instruction [20-16] Zero Read register 2 ALU 1 M U X Address M U X 1 ALU result Read data M U X 1 Read data 2 Write register add sub and or slt R-type Op rs rt rd shamt Funct Data memory Write data Instruction [15-11] Registers Write data I-type Op rs rt Immediate Sign extend ALU control 16 32 Instruction [15-0] Jump-type Op address Instruction [5-0]

The Datapath in operation for load M U X 1 1 M U X Instruction [25-0] Shift left 2 jump address[31-0] Add 26 28 PC+4[31-28] ALU result Shift left 2 Add 4 Control RegDst Branch MemRead MemtoReg ALUOp MemWrite ALUSrc RegWrite jump Instruction [31-26] pc Read address Instruction [31-0] Instruction [25-21] Read register 1 Read data 1 Instruction memory Instruction [20-16] Zero Read register 2 ALU 1 M U X Address M U X 1 ALU result Read data M U X 1 Read data 2 Write register load instruction R-type Op rs rt rd shamt Funct Data memory Write data Instruction [15-11] Registers Write data I-type Op rs rt Immediate Sign extend ALU control 16 32 Instruction [15-0] Jump-type Op address Instruction [5-0]

The Datapath in operation for store M U X 1 1 M U X Instruction [25-0] Shift left 2 jump address[31-0] Add 26 28 PC+4[31-28] ALU result Shift left 2 Add 4 Control RegDst Branch MemRead MemtoReg ALUOp MemWrite ALUSrc RegWrite jump Instruction [31-26] pc Read address Instruction [31-0] Instruction [25-21] Read register 1 Read data 1 Instruction memory Instruction [20-16] Zero Read register 2 ALU 1 M U X Address M U X 1 ALU result Read data M U X 1 Read data 2 Write register store instruction R-type Op rs rt rd shamt Funct Data memory Write data Instruction [15-11] Registers Write data I-type Op rs rt Immediate Sign extend ALU control 16 32 Instruction [15-0] Jump-type Op address Instruction [5-0]

The Datapath in operation for beq M U X 1 1 M U X Instruction [25-0] Shift left 2 jump address[31-0] Add 26 28 PC+4[31-28] ALU result Shift left 2 Add 4 Control RegDst Branch MemRead MemtoReg ALUOp MemWrite ALUSrc RegWrite jump Instruction [31-26] pc Read address Instruction [31-0] Instruction [25-21] Read register 1 Read data 1 Instruction memory Instruction [20-16] Zero Read register 2 ALU 1 M U X Address M U X 1 ALU result Read data M U X 1 Read data 2 Write register beq instruction R-type Op rs rt rd shamt Funct Data memory Write data Instruction [15-11] Registers Write data I-type Op rs rt Immediate Sign extend ALU control 16 32 Instruction [15-0] Jump-type Op address Instruction [5-0]

4.4 一个简单的实现机制 4.形成控制单元的输入输出表 Input Output 000000 1 100011 101011 X Instruction OPCode　 RegDst ALUSrc Memto-Reg Reg Write Mem Read Mem Write Branch ALUOp1 ALUOp0 R-format 000000 1 Lw(I-Type) 100011 sw(I-Type) 101011 X beq(I-Type) 000100

4.4 一个简单的实现机制 5.形成控制单元电路

The Datapath in operation for Jump M U X 1 1 M U X Instruction [25-0] Shift left 2 jump address[31-0] Add 26 28 PC+4[31-28] ALU result Shift left 2 Add 4 Control RegDst Branch MemRead MemtoRead ALUOp MemWrite ALUSrc RegWrite jump Instruction [31-26] pc Read address Instruction [31-0] Instruction [25-21] Read register 1 Read data 1 Instruction memory Instruction [20-16] Zero Read register 2 ALU M U X 1 Address M U X 1 ALU result Read data M U X 1 Read data 2 Write register jump instruction R-type Op rs rt rd shamt Funct Data memory Write data Instruction [15-11] Registers Write data I-type Op rs rt Immediate Sign extend ALU control 16 32 Instruction [15-0] Jump-type Op address Instruction [5-0]

4.4 一个简单的实现机制 四. 为什么不使用单周期实现方式 1. 单周期实现 也称为单时钟周期实现，即一个时钟周期执行一条指令的实现机制 每一条指令从一个时钟周期的上升沿（或下降沿）开始，在下一个时钟周期的上升沿（或下降沿）结束。 简单，容易理解 太慢不实用，效率低 时钟周期要由执行时间最长的那条指令决定

4.4 一个简单的实现机制 2 . 单周期下各类指令对各功能单元的使用及执行时间

4.5 多周期实现机制 一. 什么是多周期实现 将一条指令的执行过程划分成多个阶段，每个阶段占用一个时钟周期 在每个周期末尾： 每个阶段的工作量尽量均等 每个周期只使用一个主功能单元 在每个周期末尾： 增加额外的内部寄存器 暂存后续周期会使用的数据 不同类型的指令占用不同的时钟周期数

在每个功能单元后都增加相应的寄存器用于暂存该单元的输出结果直到在下一个周期将其内容送往下一个功能单元。 4.5 多周期实现机制 二. 多周期的数据通路 将指令存储器和数据存储器合为一个存储器 将ALU和两个加法器合为一个ALU 在每个功能单元后都增加相应的寄存器用于暂存该单元的输出结果直到在下一个周期将其内容送往下一个功能单元。 资源共享

4.5 多周期实现机制 指令寄存器（IR）：从内存中取出的指令放到IR中 数据缓冲寄存器（MDR）：从内存中取出的数据放到MDR中 A、B寄存器：从寄存器rs 和 rt 中读出的操作数存放到A和B 两个寄存器中 ALUOut：存放ALU 的运算结果

4.5 多周期实现机制 三. MIPS指令执行过程划分为五个周期： 1. IF：取指 2. ID：译码和读寄存器 3. EX（BC）：执行/地址计算（分支完成） 4. MEM（WB）：存储器访问（R型指令写回） 5. WB：写回 每一条指令通常占用3 - 5 个周期！

4.5 多周期实现机制 取指周期（IF）： 根据PC从存储器中取出一条指令并送到指令寄存器（IR）中。 IR = Memory[PC]; 将PC的内容加4并写到PC中。 PC = PC + 4; 该周期的操作可使用RTL （Register-Transfer Language）简单描述为： IR = Memory[PC]; PC = PC + 4;

4.5 多周期实现机制 IR = Memory[PC]; PC = PC + 4; 4 PC + 4

4.5 多周期实现机制 2. 译码和读寄存器周期（ID）： 读寄存器rs和rt中的操作数（无论以后是否会使用）。 若是分支指令，则计算分支目标地址。 为什么？ 原因一：ALU当前空闲 原因二：ALUOut可以暂存目标地址 RTL: A = Reg[IR[25-21]]; B = Reg[IR[20-16]]; ALUOut =PC+(sign-extend(IR[15-0]) << 2);

4.5 多周期实现机制 A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(IR[15-0]) << 2) PC + 4 Branch Target Address Reg[rs] Reg[rt]

4.5 多周期实现机制 3.执行/地址计算周期（EX）： 根据指令类型的不同，执行不同操作： 访存指令( lw / sw ): ALUOut = A + sign-extend(IR[15-0]); R型指令: ALUOut = A op B; 条件分支: if (A==B) PC = ALUOut; 跳转指令: PC = {PC[31-28],(IR[25-0] << 2)};

4.5 多周期实现机制 lw/sw :ALUOut = A + sign-extend(IR[15-0]); Reg[rs] Mem. Reg[rt] PC + 4 Mem. Address

4.5 多周期实现机制 R型指令: ALUOut = A op B Reg[rs] Reg[rt] PC + 4 R-Type Result

4.5 多周期实现机制 条件分支: if (A == B) PC = ALUOut; Branch Reg[rs] Target Reg[rt] Branch Target Address Branch Target Address

4.5 多周期实现机制 跳转指令:PC = {PC[31-28],(IR[25-0] << 2)} Branch Reg[rs] Reg[rt] Branch Target Address Jump Address

4.5 多周期实现机制 4.访存周期（ MEM ） /R型指令写回周期（WB）： 根据指令类型的不同，执行不同操作： Load/stores指令： MDR = Memory[ALUOut]; # for lw Memory[ALUOut] = B; # for sw R型指令完成： Reg[rd] = Reg[IR[15-11]] = ALUOut; 注：写操作实际发生在该时钟周期的后沿时刻。

4.5 多周期实现机制 lw ：MDR = Memory[ALUOut]; Reg[rs] Mem. Address PC + 4 Mem. Reg[rt] Mem. Address Mem. Data

4.5 多周期实现机制 Sw: Memory[ALUOut] = B; PC + 4 Reg[rs] Reg[rt]

4.5 多周期实现机制 R型指令: Reg[IR[15:11]] = ALUOUT Reg[rs] R-Type Result PC + 4 Reg[rt] PC + 4

4.5 多周期实现机制 5. 写回周期（WB）： 写结果到寄存器 Load指令 Reg[rt]=Reg[IR[20-16]]= MDR;

4.5 多周期实现机制 Reg[IR[20-16]] = MDR; Reg[rs] Address PC + 4 Mem. Reg[rt] Data Address

4.5 多周期实现机制 四. 各类指令在多周期中的执行 Step name R-type memory-reference branches jumps Instruction fetch IR = Memory[PC] PC = PC + 4 Instruction A = Reg [IR[25-21]] decode/register fetch B = Reg [IR[20-16]] ALUOut = PC + (sign-extend (IR[15-0]) << 2) Execution, address ALUOut = A op B ALUOut = A + sign-extend if (A ==B) then PC = {PC [31-28], computation, branch/ (IR[15-0]) PC = ALUOut (IR[25-0]<<2)} jump completion Memory access or R-type Reg [IR[15-11]] = Load: MDR = Memory[ALUOut] completion ALUOut or Store: Memory [ALUOut] = B Memory read completion Load: Reg[IR[20-16]] = MDR 1: IF 2: ID 3: EX 4: MEM 5: WB Step

R-type： Instruction fetch IR <= Memory[PC]; sub $t0,$t1,$t2 PC <= PC + 4; Decode instruction/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; rt ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution ALUOut <= A op B; op = add, sub, and, or,… Completion Reg[IR[15:11]] <= ALUOut; $t0 <= ALU result

lw： Instruction fetch Instruction Decode/register read Execution IR <= Memory[PC]; lw $t0,-12($t1) PC <= PC + 4; Instruction Decode/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution ALUOut <= A + sign-extend(IR[15:0]); $t1 + -12 (sign extended) Memory Access MDR <= Memory[ALUOut]; M[$t1 + -12] Write-back Load: Reg[IR[20:16]] <= MDR; $t0 <= M[$t1 + -12]

Sw： Instruction fetch IR <= Memory[PC]; sw $t0,-12($t1) PC <= PC + 4; Decode/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; rt ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution ALUOut <= A + sign-extend(IR[15:0]); $t1 + -12 (sign extended) Memory Access Memory[ALUOut] <= B; M[$t1 + -12] <= $t0

beq: Instruction fetch Decode/register read Execution IR <= Memory[PC]; beq $t0,$t1,label PC <= PC + 4; Decode/register read A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; rt ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution if (A == B) then PC <= ALUOut; if $t0 == $t1 perform branch 注：此处ALU用于判断A和B是否相等，作为分支条件

j: Instruction fetch Decode/register read Execution IR <= Memory[PC]; j label PC <= PC + 4; Decode/register read A <= Reg[IR[25:21]]; B <= Reg[IR[20:16]]; ALUOut <= PC + (sign-extend(IR[15:0])<<2); Execution PC <= {PC[31:28],IR[25:0],2’b00};

4.5 多周期实现机制 五. 多周期CPU的CPI CPI：每条指令的平均周期数，表示执行某个程序或程序片断时每条指令所需的时钟周期平均数。 例：某CPU按以上多周期方式执行一段程序，其中load 指令占指令总数的22% ，store指令占11% , R-type 指令占49% , branch指令占16% , jump指令占2% 。假设各类指令每个阶段占用一个时钟周期，求其CPI值是多少？ 解：各类指令分别占用的周期数为： Load：5, store ：4, R-type ：4, branch ：3, jump： 3

4.5 多周期实现机制 解：各类指令分别占用的周期数为： Load：5, store ：4, R-type ：4, branch ：3, jump： 3 CPI = CPU 总周期数/ 指令总条数 =  (指令条数class i  CPIclass i) /指令总条数 =  (指令条数class i /指令总条数)  CPIclass i = 0.22  5 + 0.11  4 + 0.49  4 + 0.16  3 + 0.02  3 = 4.04

4.5 多周期实现机制 六. 多周期实现 1. 完善数据通路

4.5 多周期实现机制 2. 添加控制信号

3. 建立最终版数据通路

4. 各控制信号的功能 IorD 0:PC 提供存储器访问地址 1:ALUOut提供存储器访问地址

4. 各控制信号的功能 IRWrite 0：无 1：将存储器中取出的指令写入IR

4. 各控制信号的功能 PCWrite 0：无 1：PC写使能有效

4. 各控制信号的功能 PCWriteCond 0：无 1：带条件的PC写使能有效（Zero输出有效）

4. 各控制信号的功能 ALUScrA 0： ALU 第一个操作数来源于PC 1： ALU 第一个操作数来源于A 寄存器

4. 各控制信号的功能 ALUScrB 00： ALU 第二个操作数来源于B 寄存器 01： ALU 第二个操作数是常数4 10： ALU 第二个操作数是由IR中低16位 立即数字段经扩展后得到 11： ALU 第二个操作数是由IR中低16位 立即数字段经扩展后并左移两位得到

4. 各控制信号的功能 PCSource 00： ALU的运算结果(PC+4) 被送往PC待写 01： ALUOut 中的内容(分支目标地址)被送往PC待写 10：跳转目标地址(IR[25:0]左移 2 位与PC+4[31:28] 拼接)被送往PC待写

各控制信号的功能小结 信号名 无效时(=0)的含义 有效时(=1)的含义 RegDst 写寄存器的目标寄存器号来自rt字段(20:16) 写寄存器的目标寄存器号来自rd字段(15:11) RegWrite 无 寄存器堆写使能有效 ALUScrA ALU 第一个操作数来源于PC ALU 第一个操作数来源于A 寄存器 MemRead 数据存储器读使能有效 MemWrite 将写数据端（Write data）的数据写入到指定地址的存储单元中 MemtoReg 写入寄存器的数据来源于ALUOut 写入寄存器的数据来源于MDR IorD PC 提供存储器访问地址 ALUOut提供存储器访问地址 IRWrite 将存储器中取出的指令写入IR PCWrite PC写使能有效 PCWriteCond 带条件的PC写使能有效（Zero输出有效）

各控制信号的功能小结（续） 5. 指令执行过程中控制信号的设置 00 01 10 11 信号名 值 功能 ALUOp ALU执行加法运算 由 funct 字段决定ALU的具体操作 ALUScrB ALU 第二个操作数来源于B 寄存器 ALU 第二个操作数是常数4 ALU 第二个操作数是由IR中低16位立即数字段经扩展后得到 11 ALU 第二个操作数是由IR中低16位立即数字段经扩展后并左移两位得到 PCSource ALU的运算结果(PC+4) 被送往PC待写 ALUOut 中的内容(分支目标地址)被送往PC待写 跳转目标地址(IR[25:0]左移 2 位与PC+4[31:28]拼接)被送往PC待写 5. 指令执行过程中控制信号的设置

第一阶段：取指 IR = Memory[PC]; PC = PC + 4; 1 1 X 010 X 1 1

第二阶段：译码 & 读寄存器 A = Reg[IR[25-21]]; (A = Reg[rs]) B = Reg[IR[20-15]]; (B = Reg[rt]) ALUOut = (PC + sign-extend(IR[15-0]) << 2); X X 010 X X 3

第三阶段：执行 —— 访存指令 ALUOut = A + sign-extend(IR[15-0]); X 1 X 010 X X 2

第三阶段：执行 —— R型指令 ALUOut = A op B; X 1 X ??? X X

第三阶段：执行 —— 分支指令 if (A == B) PC = ALUOut; 1 if Zero=1 X 1 X 011 1 X

第三阶段：执行 —— 跳转指令 PC = {PC[21-28]，(IR[25-0] << 2)}; 1 X X X XXX 2 第三阶段：执行 —— 跳转指令 PC = {PC[21-28]，(IR[25-0] << 2)}; 1 X X X XXX 2 X X

第四阶段：访存 —— lw指令 MDR = Memory[ALUOut]; 1 X X XXX X X 1 X

第四阶段：访存 —— sw指令 Memory[ALUOut] = B; 1 X 1 X XXX X X X

第四阶段：访存 —— R型指令完成 Reg[IR[15:11]] = ALUOut; (Reg[Rd] = ALUOut) X X 1 IRWrite I Instruction I jmpaddr 28 32 R <<2 CONCAT 5 I[25:0] PCWr* rs rt rd X 1 2 M U X MUX 1 X 32 RegDst IorD 5 5 1 XXX 5 ALUSrcA PC Operation M U X 1 MemWrite RN1 RN2 WN M U X 1 3 ADDR M M U X 1 Registers PCSource Memory D RD1 A Zero X RD R WD ALU ALU WD RD2 B M U X 1 2 3 OUT MemRead MemtoReg 4 RegWrite 1 E X T N D ALUSrcB immediate 16 32 <<2 X

第五阶段：写回 —— lw指令完成 Reg[IR[20-16]] = MDR; X X XXX X 1 1 X I R <<2 IRWrite I Instruction I 28 32 R jmpaddr 5 I[25:0] <<2 CONCAT PCWr* X rs rt rd X 1 2 M U X MUX 1 32 RegDst 5 5 XXX IorD 5 ALUSrcA PC Operation M U X 1 MemWrite RN1 RN2 WN M U X 1 3 ADDR M M U X 1 Registers PCSource Zero X Memory D RD1 A RD R WD ALU ALU OUT WD RD2 B M U X 1 2 3 MemRead MemtoReg 4 1 RegWrite 1 E X T N D ALUSrcB immediate 16 32 X <<2

4.5 多周期实现机制 6. 控制实现 不同控制信号值的产生依赖于： 被执行的指令类型 指令执行到了哪个阶段 ALU相关操作占用一个时钟周期，因此ALU控制单元和单周期实现中一样，无需修改。 如何设计主控制单元？ 两种实现方法： 有限状态机——组合逻辑控制器 微程序编程——微程序控制器

（Op=‘LW’）or (Op=‘SW’) （1） 有限状态机（FSM）状态图 MemRead ALUSrcA=0 IorD=0 IRWrite ALUSrcB=01 ALUOp=00 PCWrite PCSource=00 取指 ALUSrcB=11 译码/读寄存器 1 ALUSrcA=1 ALUSrcB=10 地址计算 2 ALUSrcB=00 ALUOp=10 执行 6 ALUOp=01 PCWriteCond PCSource=01 分支完成 8 PCSource=10 跳转完成 9 IorD=1 访存 3 MemWrite 5 RegDst=1 RegWrite MemtoReg=0 R-指令完成 7 RegDst=0 MemtoReg=1 LW完成 4 （Op=‘LW’）or (Op=‘SW’) （Op=R-type） （Op=‘beq’） （Op=‘j’） （Op=‘LW’） (Op=‘SW’) Start

（Op=‘LW’）or (Op=‘SW’) FSM放大图-1 MemRead ALUSrcA=0 IorD=0 IRWrite ALUSrcB=01 ALUOp=00 PCWrite PCSource=00 取指 ALUSrcB=11 译码/读寄存器 1 访存 FSM R-type FSM Branch FSM Jump FSM （Op=‘LW’）or (Op=‘SW’) （Op=R-type） （Op=‘beq’） （Op=‘j’） Start

（Op=‘LW’）or (Op=‘SW’) FSM放大图-1 MemRead ALUSrcA=0 IorD=0 IRWrite ALUSrcB=01 ALUOp=00 PCWrite PCSource=00 取指 ALUSrcB=11 译码/读寄存器 1 访存 FSM R-type FSM Branch FSM Jump FSM （Op=‘LW’）or (Op=‘SW’) （Op=R-type） （Op=‘beq’） （Op=‘j’） Start

（Op=‘LW’）or (Op=‘SW’) FSM放大图-2（访存指令） ALUSrcA=1 ALUSrcB=10 ALUOp=00 地址计算 2 MemRead IorD=1 访存 3 MemWrite 5 RegDst=0 RegWrite MemtoReg=1 LW完成 4 （Op=‘LW’）or (Op=‘SW’) （Op=‘LW’） (Op=‘SW’) From state 1 To state 0

（Op=‘LW’）or (Op=‘SW’) FSM放大图-2（访存指令） ALUSrcA=1 ALUSrcB=10 ALUOp=00 地址计算 2 MemRead IorD=1 访存 3 MemWrite 5 RegDst=0 RegWrite MemtoReg=1 LW完成 4 （Op=‘LW’）or (Op=‘SW’) （Op=‘LW’） (Op=‘SW’) From state 1 To state 0

（Op=‘LW’）or (Op=‘SW’) FSM放大图-2（访存指令） ALUSrcA=1 ALUSrcB=10 ALUOp=00 地址计算 2 MemRead IorD=1 访存 3 MemWrite 5 RegDst=0 RegWrite MemtoReg=1 LW完成 4 （Op=‘LW’）or (Op=‘SW’) （Op=‘LW’） (Op=‘SW’) From state 1 To state 0

（Op=‘LW’）or (Op=‘SW’) FSM放大图-2（访存指令） ALUSrcA=1 ALUSrcB=10 ALUOp=00 地址计算 2 MemRead IorD=1 访存 3 MemWrite 5 RegDst=0 RegWrite MemtoReg=1 LW完成 4 （Op=‘LW’）or (Op=‘SW’) （Op=‘LW’） (Op=‘SW’) From state 1 To state 0

FSM放大图3（R型指令） From state 1 （Op=R-type） 6 执行 ALUSrcA=1 ALUSrcB=00 ALUOp=10 执行 6 RegDst=1 RegWrite MemtoReg=0 R-指令完成 7 （Op=R-type） From state 1 To state 0

FSM放大图3（R型指令） From state 1 （Op=R-type） 6 执行 ALUSrcA=1 ALUSrcB=00 ALUOp=10 执行 6 RegDst=1 RegWrite MemtoReg=0 R-指令完成 7 （Op=R-type） From state 1 To state 0

FSM放大图4（分支和跳转指令） From state 1 （Op=‘beq’） （Op=‘j’） 分支完成 PCWrite To state 0 ALUSrcA=1 ALUSrcB=00 ALUOp=01 PCWriteCond PCSource=01 分支完成 8 PCWrite PCSource=10 9 （Op=‘beq’） （Op=‘j’）

FSM放大图4（分支和跳转指令） From state 1 （Op=‘beq’） （Op=‘j’） 分支完成 PCWrite To state 0 ALUSrcA=1 ALUSrcB=00 ALUOp=01 PCWriteCond PCSource=01 分支完成 8 PCWrite PCSource=10 9 （Op=‘beq’） （Op=‘j’）

（2）只依赖于状态输入的16位数据通路控制输出真值表

（3）简化的主控单元逻辑式

（4）FSM的实现：组合逻辑电路+寄存器（用于保存当前状态） Combinational Control logic State register Input from instruction Register opcode field Datapath control output Next state Outputs Inputs

4.5 多周期实现机制 七. 例：指令lw $t0,4($t1)的多周期实现过程 解：lw $t0,4($t1) rt rs 1. 转化为机器指令： opcode rs rt immediate （lw操作码编号为0x23，t0为8，t1为9） 100011 01001 01000 0000 0000 0000 0100 IR[31:26] IR[25:21] IR[20:16] IR[15:0]

4.5 多周期实现机制 2. 指令的执行过程（RTL描述） IF: IR <= Memory[PC]; //lw $t0,4($t1) PC <= PC + 4; ID: A <= Reg[IR[25:21]]; //rs B <= Reg[IR[20:16]]; ALUOut <= PC + (signextend(IR[15:0])<<2);

4.5 多周期实现机制 EXE: ALUOut <= A + sign-extend(IR[15:0]); //$t1 + 4(sign extended) MEM: MDR <= Memory[ALUOut]; //M[$t1 + 4] WB: Reg[IR[20:16]] <= MDR; //$t0 <= M[$t1 + 4]

3. 设置各周期控制信号: IF: IR <= Memory[PC]; lw $t0, 4($t1) PC <= PC + 4; 00 1 1 1 01 00

3. 设置各周期控制信号: rs rt ID: A <= Reg[IR[25:21]]; rs B <= Reg[IR[20:16]]; ALUOut <= PC + (signextend(IR[15:0])<<2); rs rt 11 00

3. 设置各周期控制信号: EXE: ALUOut <= A + sign-extend(IR[15:0]); $t1 + 4 (sign extended) 1 10 00

3. 设置各周期控制信号: MEM: MDR <= Memory[ALUOut]; M[$t1 + 4] 1 1

3. 设置各周期控制信号: WB: Reg[IR[20:16]] <= MDR; $t0 <= M[$t1 + 4] 1 1

4.5 多周期实现机制 七. 与单周期相比多周期实现的优势 八. 数据通路和控制器设计是所有现代计算机结构的核心 资源共享。对于单个指令来说，可以在不同周期中使用同一功能单元。 执行通路较短的指令占用的周期数较少，其执行完成所需时间也较短。 八. 数据通路和控制器设计是所有现代计算机结构的核心 九. 实际上，现代计算机为获取更高的性能，在多周期实现机制的基础上又提出了新的改进技术——流水线技术。

课后练习 1. 结合多周期数据通路图写出指令sub $t0,$t1,$t2的实现过程： （1）转化为机器指令 （2）用RTL描述该指令的执行过程 （3）写出各周期控制信号值