系统硬件综合设计

计算机与信息学院

系统硬件综合设计》

课程设计报告

学生姓名：李

学号：1234567890

专业班级：计算机

2017 年07 月01 日

1.pcf 部分

always @(posedge Clk)

begin

PCPlus4F_Reg = PCPlus4F;

if (BranchM&ZeroM) PCF = PCBranchM;

else PCF = PCPlus4F;

InstructionF_Reg = InstructionF;

if (InstructionF[31:26] == 6'b000010)

begin

PCF = {6'h0,InstructionF[25:0]};

PCF = PCF << 2;

end

End

assign PCPlus4F = PCF + 4;

assign ImemRdAddrF = PCF;

每个时钟上升沿到来，根据上一个时钟的PCSrcM判断是否为分支指令，若是，则选择

PCBranchM作为这个时钟的指令地址，否则选PCF+4作为这个指令的指令地址，另外对于J 类指令，我设计了一个特定的OpCode=“= 000010”，即为跳转指令，因为每个指令以字节格式存储，占用,4 个字节，故将后26 位立即数进行位扩展后将其左移两位，效果等同于乘4，再将其赋值给PCF，这样下一跳的指令地址即为所要跳转的地址。对于这个部分，我起先是准备将其设计成一个模块的，之后由于模块接口连接时出现了无法解决的错误：输出PCF要作为Instruction Memory 的输入，又要作为自身模块下一跳的输入，导致三者关联一起变化，程序报错，后来我又想到将PCF的输出改成两个，PCFout 及PCFnext，PCFout 作为Instruction Memory的输入，PCFnext 作为自身模块下一跳的输入，但是程序仍无法正常运行，最后我想到了在top 模块中对PCF进行处理并得以实

现。

2. Instruction Memory 模块

initial begin

$readmemh("instruction", InstMem, 8'h0);

end

always @(ImemRdAddr) begin

Instruction <= InstMem[ImemRdAddr>>2];

end

这个模块很简单，主要是通过instructin 文档来存储指令，以PCF作为地址取出指令输出至Control ，SignExtend ，Register 三个模块。

3.Ctr 模块

always @(OpCode) begin case(OpCode) // R-I // addiu 6'b001001:

begin

RegDstD = 1;

ALUSrcD = 1;

MemtoRegD = 0;

RegWriteD = 1;

MemWriteD = 0;

BranchD = 0;

ALUOp = 2'b10; end //addi

endcase

end

always @(ALUOp or Funct)

begin

casex({OpC

ode ,ALUOp

, Funct})

14'b10001100xxxxxx: ALUControlD = 5'b00010; // LW : add

14'b00010001xxxxxx: ALUControlD = 5'b00110; // SW : substract beq

endcase end

endmodule

Control 模块主要对来自Instruction Memory模块的指令进行分解，得到

OpCode(指令高六位) ，Funct(指令低六位) ，在通过分析OpCode得到RegDstD，ALUSrcD ，MemtoRegD，RegWriteD ，BranchD ，ALUOp这六个信号量，用于后面的运算，再使用OpCode, ALUOp, Funct 三者的组合对指令的运算方法进行分析，得到相应的ALUControlD 输出至ALU模块。

4.Register模块

initial

begin

$readmemh("register", regFile, 32'h0);

end

// write on falling clock edge

always @(posedge Clk)

begin

if(RegWrite == 1'b1)

regFile[RegWrAddr] <= RegWrData;

end

assign RegARdData = (RegARdAddr >= 0)? regFile[RegARdAddr]:0;

assign RegBRdData = (RegBRdAddr >= 0)? regFile[RegBRdAddr]:0;

通过信号量RegWrite 来判断读写操作，RegWrite=1 即为写操作，0 为读操作，读写皆操作于建立的register 文档中，另在top 模块中有

assign RegARdAddr = InstructionD[25:21];

assign RegBRdAddr = InstructionD[20:16]; 对寄存器地址赋值，register 读出的两个数可供ALU选择使用。

5.ALU 模块

assign Zero = (ALURes == 0)? 1:0;//ALURes 0 跳转

always @(SrcA or SrcB or ALUCtr)

begin

OverFlow = 0;

TmpForSrcB = 0;

HI = 0;

LO = 0;

A = 0;

B = 0;

case(ALUCtr)

5'b10011:

begin

TmpForSrcB = SrcB;

TmpForSrcB[31] = (TmpForSrcB[31]+1)%2;

ALURes = SrcA + TmpForSrcB;

if ((SrcA[31] != TmpForSrcB[31]) || (SrcA[31] == TmpForSrcB[31] && ALURes[31] == SrcA[31]))

begin

OverFlow = 1'b0; end

else

if (SrcA[31] == TmpForSrcB[31] && ALURes[31] != SrcA[31]) begin

OverFlow = 1'b1;

end

default: ALURes = 32'h0;

endcase

end

ALU模块进行的是运算操作，本模块通过来自Control 模块的ALUCtr 判断所要执行的运算，在通过Register 模块读出的值或者从Instruction 中得到的立即数进行运算，结果ALURes根据信号量MemToReg来判断是否写入DataMemory，这一块写在top 中，另外ALU还对Zero 信号量进行了赋值，Zero 信号量用于对分支指令的判断。

6.Data Memory 模块

initial

begin

$readmemh("Data", DataMem, 10'h0);

end

always @(posedge Clk)

begin

if(DmemWrite == 1'b1)

DataMem[DmemAddr>>2] <= DmemWrData;

end

assign DmemRdData = (DmemWrite == 1'b0)? DataMem[DmemAddr>>2]:0;

endmodule

本模块通过从Ctr 模块得来的信号量DmemWrite选择进行读写操作，读写皆操作于所建立的Data 文档，另外DmemAdd左r 移两位跟上述PCF左移两位异曲同工。

7.top 模块

这个模块相比前面的 6 个模块要复杂得多，也是我在实验时出现问题最多，所花时间最长的模块。Top 模块主要用于各个模块之间的数据连接，以及一些模块外的操作。PCF 的设计我是放在这个模块的，另外像二选一数据选择器我也是放在这里的，本来是写了一个小模块来做这个工作，但是本次试验用到太多次二选一数据选择器了，为了防止数据传输紊乱，我决定在top 中解决这个小操作。由于本模块代码太长，这里就不一一阐

述，仅以Ctr 的例化和接口连接为例简要说明：

Ctr Ctr(

.OpCode(OpCode),

.Funct(Funct),

.RegWriteD(RegWriteForCtrD),

.MemtoRegD(MemtoRegD),

.MemWriteD(MemWriteD),

.BranchD(BranchD),

.ALUControlD(ALUControlD),

.ALUSrcD(ALUSrcD),

.RegDstD(RegDstD)

);

assign OpCode = InstructionD[31 : 26];

assign Funct = InstructionD[5 : 0];

assign RegWrDataD = (MemtoRegW)? ReadDataW : ALUOutW;

always @(posedge Clk)

begin

MemtoRegD_Reg = MemtoRegD;

MemWriteD_Reg = MemWriteD;

BranchD_Reg = BranchD;

ALUControlD_Reg = ALUControlD;

ALUSrcD_Reg = ALUSrcD;

RegDstD_Reg = RegDstD;

end

输入来源OpCode来自于取指阶段Instruction 的高 6 位，Funct 来自于取指阶段Instruction 的低 6 位，RegWriteD 通过信号量MemToRegW来选择ReadDataW 或ALUOutW，

输出信号量MemtoRegD，MemWriteD，BranchD，ALUControlD ，ALUSrcD，RegDstD作为Reg模块的输入。

二、指令设计

本次试验实现了 3 种34 条指令，实验时原以为指令格式为固定的，查阅很多资料都没得到想要的OpCode与指令操作一一对应的关系，问了指导实验的学长才知道，OpCode 是自己设计的，后又参考《自己动手写cpu》的指令设计技巧，才总结设计出指令。

3 种指令：

R 类型：具体操作由 OpCode，Funct 来控制， rs，rt 为源寄存器， rd 为目的寄存器， sa 为移位位数。

I 类型：具体操作由 OpCode 控制，低 16 位是立即数，经过位扩展作为另一个源

操作数参与用算。

J 类型：具体操作由 OpCode 控制，一般是跳转指令，低 26 位经过位扩展作为目标地址。34条指令：

32'b101011 00001 00100 000000000000010

ALURes = SrcA - SrcB;

Store 指令，判断 00001 号寄存器的值是否等于 00100 号寄存器的值，若相等，则当前指令地址加 00000000000000010 ，否则执行下一条指令； 32'b000000 00001 00010 00011 00000 100000 TmpForSrcB = SrcB;

TmpForSrcB[31] = (TmpForSrcB[31]+1)%2;

ALURes = SrcA + TmpForSrcB;

if ((SrcA[31] != TmpForSrcB[31]) || (SrcA[31] == TmpForSrcB[31] && ALURes[31] == SrcA[31]))

begin

OverFlow = 1'b0;

end

else

if (SrcA[31] == TmpForSrcB[31] && ALURes[31] != SrcA[31]) begin OverFlow = 1'b1;

end

Add 指令，有符号加法指令，实现将 00001 号寄存器和 00002 号寄存器的值进行有符号加法，结果放到 00003 号寄存器中；

32'b000101 00001 00010 0000000000000010

ALURes = ~(SrcA - SrcB);

Bne 指令，实现将 00001 号寄存器和 00002 号寄存器的值进行比较，若不相等，则当前指令

地址加 00000000000000010 ，否则执行下一条指令；

32'b000100 00001 00010 0000000000000010

ALURes = SrcA - SrcB;

Beq 指令，实现将 00001 号寄存器和 00002 号寄存器的值进行比较，若相等，则当前指令地 址加 00000000000000010 ，否则执行下一条指令；

Addu 指令，无符号加法指令，实现将 00001 号寄存器和 00002 号寄存器的值进行无符号加 法，结果放到 00003 号寄存器中； 32'b100011 00001 00010 00011 00000 100011 ALURes = SrcA - SrcB;

subu 指令，无符号减法指令，实现将 00001 号寄存器和 00002 号寄存器的值进行无符号减 法，结果放到 00003 号寄存器中； 32'b000000 00001 00010 00011 00000 100100

ALURes = SrcA & SrcB;

And 指令，与操作，实现将 00001 号寄存器和 00002 号寄存器的值进行与操作，结果放到 00003 号寄存器中； 32'b000000 00001 00010 00011 00000 100101

ALURes = SrcA | SrcB;

OR 指令，或操作，实现将 00001 号寄存器和 00002 号寄存器的值进行或运算， 结果放到 00003

号寄存器中； 32'b000000 00001 00010 00011 00000 101010

ALURes = SrcA < SrcB ? 1:0;

slt 指令，有符号比较操作，实现将 00001号寄存器和 00002号寄存器的值进行有符号比较， 若 SrcA < SrcB ，则置 1 ，否则置 0； 32'b000000 00001 00010 00011 00000 101010 ALURes = SrcA < SrcB ? 1:0;

32'b000001 00001 00000

0000000000000010 ALURes = (SrcA >=

0)?0:1;

Bgez 指令，实现 00001 号寄存器的值

与 00000000000000010，否则执行下一

条指令；

32'b000111 00001 00000

0000000000000010 ALURes = (SrcA >

0)?0:1;

Bgtz 指令，实现 00001 号寄存器的值

与 00000000000000010，否则执行下一

条指令；

32'b000110 00001 00000

0000000000000010 ALURes = (SrcA <=

0)?0:1;

Blez 指令，实现 00001 号寄存器的值

与 00000000000000010，否则执行下一

条指令；

32'b010001 00001 00000 0000000000000010 0 比较，若大于等

于

0，则当前指令地址

加

0，

则当前指令地址加

0 比较，若大于 0 比较，若小于等

于

， 则当前指令地址加

0 比较，若小于 0， 则当前指令地址

加

32'b000000 00001 00010 00011 00000 100110

ALURes = (SrcB >>SrcA);

xor 指令，异或指令，实现将 00001 号寄存器的值和 00002 号寄存器进行异或，结

果放到

00003 号寄存器中；

sltu 指令，无符号比较操作， 实现将 00001 号寄存器和 若 SrcA < SrcB ，则置 1 ，否则置 0； 32'b000000 00001 00010 00011 00000 011010

ALURes = SrcA / SrcB; LO = SrcA / SrcB; HI = SrcA % SrcB;

div 指令，有符号除法指令， 实现将 00001 号寄存器和 00002 号寄存器的值进行有符号除法， 结果放到 00003 号寄存器中； 32'b000000 00001 00010 00011 00000 011000

A = SrcA[31:31]?{32'hffffffff, SrcA} : {32'h00000000, SrcA};

B = SrcB[31:31]?{32'hffffffff, SrcB} : {32'h00000000, SrcB}; Temp = A * B ;

ALURes = Temp[31:0]; HI = Temp[63:32]; LO = Temp[31:0];

mul 指令，有符号乘法指令， 实现将 00001 号寄存器和 00002 号寄存器的值进行有符号乘法， 结果放到 00003 号寄存器中； 32'b000000 00001 00010 00011 00000 000100

ALURes = (SrcB << SrcA);

sllv 指令，逻辑可变左移指令，实现将 00001 号寄存器的值左移 00002 号寄存器的值位，结 果放到 00003 号寄存器中； 32'b000000 00001 00010 00011 00000 000100

ALURes = (SrcB >>SrcA);

srlv 指令，逻辑可变右移指令，实现将 00001 号寄存器的值右移 00002 号寄存器的

值位， 结果放到 00003 号寄存器中；

32'b000000 00001 00010 00011 00000 100110

ALURes = (SrcA ^ SrcB);

xor 指令，异或指令，实现将 00001 号寄存器的值和 00002 号寄存器进行异或，结

果放到 00003 号寄存器中；

32'b001001 00001 00010 00011 00000 000000

ALURes = SrcA + SrcB;

addiu 指令，无符号立即数加法指令， 实现将 00001 号寄存器的值和立即数进行无

符号加法， 结果放到 00003 号寄存器中； 32'b001100 00001 00010 00011 00000 000000

ALURes = SrcA + SrcB;

addi 指令，有符号立即数加法指令， 实现将 00001 号寄存器的值和立即数进行有符

号加法， 结果放到 00003 号寄存器中； 32'b001101 00001 00010 00011 00000 000000

ALURes = SrcA | SrcB;

ori 指令，立即数或指令， 实现将 00001 号寄存器的值和立即数进行或运算， 结果放到 00002 号寄存器中； 32'b001101 00001 00010 00011 00000 000000 ALURes = SrcA < SrcB ? 1:0;

slti 指令，有符号立即数比较操作，实现将 00001 号寄存器的值和立即数进行有符00002 号寄存器的值进行无符号比较，

号比较，若 SrcA < SrcB ，则置 1 ，否则置 0； 32'b001110 00001 00010 00011 00000 000000

ALURes = (SrcA ^ SrcB);

xori 指令，立即数异或指令，实现将 00001 号寄存器的值和立即数进行异或运算，结果放到 00002 号寄存器中； 32'b001011 00001 00010 00011 00000 000000 ALURes = SrcA < SrcB ? 1:0;

slti 指令，无符号立即数比较操作，实现将 00001 号寄存器的值和立即数进行无符号比较，若 SrcA < SrcB ，则置 1 ，否则置 0； 32'b000000 00001 00010 00011 00001 000000 ALURes = (SrcB << SrcA);

sll 指令，逻辑左移指令，实现将 00001 号寄存器的值左移 sa位，结果存入00002 号寄存器；

32'b000000 00001 00010 00011 00001 000010

ALURes = (SrcB >> SrcA);

srl 指令，逻辑右移指令，实现将 00001 号寄存器的值右移 sa位，结果存入00002 号寄存器；

32'b000000 00001 00010 00011 00001 000111

j = SrcB[31:31];

TmpForSrcB = SrcB;

TmpForSrcA = SrcA;

/*

for(i = 0; i < TmpForSrcA; i = i+1) begin

ALURes = {j,31'h0} | (ALURes >> 1);

srav指令，算术可变右移指令，实现将 00001 号寄存器的值算术右移 sa位，结果存入 00002 号寄存器；

32'b000000 00001 00010 00011 00001 000011

j = SrcB[31:31];

TmpForSrcB = SrcB;

TmpForSrcA = SrcA;

TmpForSrcB = TmpForSrcB>>SrcA;

if (j)

begin

ALURes = {~(TmpForSrcB[31:31]), TmpForSrcB[30:0]};

end

else

begin

ALURes = TmpForSrcB;

end

sra指令，算术右移指令，实现将 00002 号寄存器的值算术右移 00001 号寄存器的值位，结果存入 00003 号寄存器；

32'b000000 00001 00010 00011 00000 100010

ALURes = SrcA - SrcB;

sub指令，有符号减法指令，实现将 00001 号寄存器和 00002 号寄存器的值进行有符号减法，结果放到 00003 号寄存器中；

32'b001000 00001 00010 00011 00000 000000

ALURes = SrcA + SrcB;

addi 指令，立即数加法指令，实现将 00001号寄存器和 00 立即数进行有符号加法，结果放到 00003 号寄存器中；

32'b000000 00001 00010 00011 00000 011000

ALURes = SrcA / SrcB;

mulu 指令，无符号乘法指令，实现将 00001 号寄存器和 00002 号寄存器的值进行无符号乘法，结果放到 00003 号寄存器中；

32'b000000 00001 00010 00011 00000 011000

ALURes = SrcA / SrcB;

divu 指令，无符号除法指令，实现将 00001 号寄存器和 00002 号寄存器的值进行无符号除法，

结果放到 00003 号寄存器中； 32'b000010 00000000000000000000000003

PCF = {6'h0,InstructionF[25:0]}; PCF = PCF << 2;

Jump 指令，跳转指令，实现跳转到立即数的指令地址，执行程序。

三、实验结果截图及分析

如图所示进行了三条指令，我仅以此三条指令的结果进行分析： 1. 32'h00221820

OpCode=000000,Funct=100000, 为有符号加法运算，从 00001 号寄存器取出第一个操作数 00000002 ，第二个寄存器取出第二个数 00000003，相加得到 ALUResE=00000005 ； 2.32'h08000003

OpCode=000010, 为 跳 转 指 令 ， 立 即 数 为 00000003 ， 故 跳 转 到 第 三 条 指 令 执 行 ， PCF=0000000c ； 3.32'hac240001

OpCode=101011, 为分支指令，立即数为 0001，故 PCF=PCF+4;

四、实验感想

本次试验，我经历了历时 13 天的 cpu 设计，从刚开始的一无所知，只是拿到了五个基础实 验和《自己动手写 cpu 》，到最后做出来，过程之艰辛无法言说，记忆深刻的地方是在写模 块连接时， 我按照书上的连接方法写模块连接，总是会报错， 卡了将近一天时间， 后来问老 师，老师给我们讲了模块连接的部分， 才解决了这个问题。 写 cpu 的过程中用到了很多知识， 计算机组成原理的有符号乘法， 算术移位， 计算机体系结构的五级流水等等， 通过本次实验 不仅学会了怎样做 cpu ，

还将学过的课程复习了一遍，觉得受益良多。最后以一句《自己动

手写 cpu 》上的话来

结尾

一个人的旅行是孤单

的

一个人的冬季是寒冷

的

但是

一个人的处理器是骄

傲的

让我们骄傲一次