华科微机原理实验报告.docx

华科微机原理实验报告.docx

《华科微机原理实验报告.docx》由会员分享，可在线阅读，更多相关《华科微机原理实验报告.docx（21页珍藏版）》请在冰豆网上搜索。

华科微机原理实验报告

微机原理实验报告

课程：

微机原理

指导老师

姓名：

学号：

实验名称：

Lab02:

MIPS处理器部件实现A

微机原理实验报告

专业:

班级：

日期：

2013.10.19

成绩:

学生姓名（签名）

指导教师（签名）

一、实验目的

本实验旨在实现MIPS处理器的部件—控制器和ALU,理解CPU控制器,理解ALU的原理,使用Verilog语言设计CPU控制器和ALU,使用ISim进行行为仿真。

二、实验原理及说明

MIPS的基本架构如图1所示，包括Control，ALU这样的组合逻辑单元，也包括如instructionmemory，Datamemory和Registersfile存储单元。

本实验主要实现CPUControl和ALU两个部分。

（一）CPU控制器的实现

CPUControl单元输入为指令的opCode字段，即操作码;以及R指令的funct编码。

操作码和Funct编码经过主控制单元的译码，给ALU，DataMemory，Registers，Muxs等部件输出正确的控制信号。

图2.MIPS基本指令格式

图:

控制模块的IO定义

注：

Jump指令编码是000010，Jump输出信号为1，其他输出信号都为0

图3.OpCode与控制输出的编码关系

图4.Funct，ALUOp与ALUControl编码关系

（二）ALU的实现

ALU是CPU核心的计算单元，实现诸如加，减，或，与等操作。

算术操作的编码

三、实验verilog代码

（一）CPU控制器的实现

moduleCtr（

input[5:

0]OpCode,

input[5:

0]Funct,

outputregRegDst,

outputregALUSrc,

outputregRegWrite,

outputregMemWrite,

outputregMemRead,

outputregMemtoReg,

outputregBranch,

outputregJump,

outputreg[3:

0]ALUControl

）;

reg[1:

0]ALUOp;

always@（OpCode）

begin

case（OpCode）

//Rtype

6'b000000:

begin

RegDst=1;

ALUSrc=0;

RegWrite=1;

MemWrite=0;

MemRead=0;

MemtoReg=0;

Branch=0;

ALUOp=2'b10;

Jump=0;

end

//beq

6'b000100:

begin

RegDst=1'bx;

ALUSrc=0;

RegWrite=0;

MemWrite=0;

MemRead=0;

MemtoReg=1'bx;

Branch=1;

ALUOp=2'b01;

Jump=0;

end

//lw

6'b100011:

begin

RegDst=0;

ALUSrc=1;

RegWrite=1;

MemWrite=0;

MemRead=1;

MemtoReg=1;

Branch=0;

ALUOp=2'b00;

Jump=0;

end

//sw

6'b101011:

begin

RegDst=1'bx;

ALUSrc=1;

RegWrite=0;

MemWrite=1;

MemRead=0;

MemtoReg=1'bx;

Branch=0;

ALUOp=2'b00;

Jump=0;

end

//Jump

6'b000010:

begin

RegDst=0;

ALUSrc=0;

MemtoReg=0;

RegWrite=0;

MemRead=0;

MemWrite=0;

Branch=0;

ALUOp=2'b00;

Jump=1;

end

endcase

end

always@（ALUOporFunct）

begin

casex（{ALUOp,Funct}）

8'b00xxxxxx:

ALUControl=4'b0010;

8'b01xxxxxx:

ALUControl=4'b0110;

8'b1xxx0000:

ALUControl=4'b0010;

8'b1xxx0010:

ALUControl=4'b0110;

8'b1xxx0100:

ALUControl=4'b0000;

8'b1xxx0101:

ALUControl=4'b0001;

8'b1xxx1010:

ALUControl=4'b0111;

default:

ALUControl=4'b0000;

endcase

end

endmodule

（二）ALU的实现

moduleALU（

input[31:

0]SrcA,

input[31:

0]SrcB,

input[3:

0]ALUCtr,

outputZero,

outputreg[31:

0]ALURes

）;

assignZero=（ALURes==1'b0）;

always@（SrcAorSrcBorALUCtr）

begin

case（ALUCtr）

4'b0000:

ALURes=SrcA&SrcB;//AND

4'b0001:

ALURes=SrcA|SrcB;//OR

4'b0010:

ALURes=SrcA+SrcB;//add

4'b0110:

ALURes=SrcA-SrcB;//substract

4'b0111:

ALURes=SrcA

1:

0;//setonlessthan

4'b1100:

ALURes=~（SrcA|SrcB）;//NOR

defaultALURes=32'h0;

endcase

end

endmodule

四、仿真测试

1.代码

（一）CPU控制器的实现

moduleCtr_tb;

//Inputs

reg[5:

0]OpCode;

reg[5:

0]Funct;

//Outputs

wireRegDst;

wireALUSrc;

wireRegWrite;

wireMemWrite;

wireMemRead;

wireMemtoReg;

wireBranch;

wireJump;

wire[3:

0]ALUControl;

//InstantiatetheUnitUnderTest（UUT）

Ctruut（

.OpCode（OpCode）,

.Funct（Funct）,

.RegDst（RegDst）,

.ALUSrc（ALUSrc）,

.RegWrite（RegWrite）,

.MemWrite（MemWrite）,

.MemRead（MemRead）,

.MemtoReg（MemtoReg）,

.Branch（Branch）,

.Jump（Jump）,

.ALUControl（ALUControl）

）;

initialbegin

//R-typeAdd

OpCode=6'b000000;

Funct=6'b100000;

//R-typeSubtract

#10;

OpCode=6'b000000;

Funct=6'b100010;

//Lw

#10;

OpCode=6'b100011;

Funct=6'bxxxxxx;

//Sw

#10;

OpCode=6'b101011;

Funct=6'bxxxxxx;

//Beq

#10;

OpCode=6'b000100;

Funct=6'bxxxxxx;

//R-typeAND

#10;

OpCode=6'b000000;

Funct=6'b100100;

//R-typeOR

#10;

OpCode=6'b000000;

Funct=6'b100101;

//R-typesetonlessthan

#10;

OpCode=6'b000000;

Funct=6'b101010;

//Jump

#10;

OpCode=6'b000010;

end

endmodule

（二）ALU的实现

moduleALU_tb;

//Inputs

reg[31:

0]SrcA;

reg[31:

0]SrcB;

reg[3:

0]ALUCtr;

//Outputs

wireZero;

wire[31:

0]ALURes;

//InstantiatetheUnitUnderTest（UUT）

ALUuut（

.SrcA（SrcA）,

.SrcB（SrcB）,

.ALUCtr（ALUCtr）,

.Zero（Zero）,

.ALURes（ALURes）

）;

initialbegin

//AND

SrcA=32'hf0f0ffff;

SrcB=32'h0000f0f0;

ALUCtr=0;

//OR

#10;

ALUCtr=4'b0001;

//Add

#10;

ALUCtr=4'b0010;

//Subtract

#10;

ALUCtr=4'b0110;

//setonlessthan

#10;

ALUCtr=4'b0111;

//NOR

#10;

ALUCtr=4'b1100;

//Othersituation

#10;

ALUCtr=4'b1111;

end

endmodule

2.仿真截图

（一）CPU控制器的实现

（二）ALU的实现

五、实验总结

实验名称：

Lab03:

MIPS处理器部件实现B

微机原理实验报告

专业:

班级：

日期：

2013.10.19

成绩:

学生姓名（签名）

指导教师（签名）

一、实验目的

本实验旨在使读者实现MIPS处理器的部件—Datamemory,Instructionmemory和Registers三大存储器件。

理解CPU的寄存器和内存,使用Verilog语言设计存储器件,使用ISim进行行为仿真。

二、实验原理及说明

本实验旨在使读者掌握MIPS处理器中内存和寄存器的设计。

在本实验中，利用VerilogHDL语言描述硬件逻辑实现和仿真内存和寄存器。

实验由以下几个部分组成：

1．Instructionmemory的实现

2．DataMemory的实现

3．Register的实现

4．有符号扩展的实现

MIPS的基本架构如图1所示，包括Control，ALU这样的组合逻辑单元，也包括如instructionmemory，Datamemory和Registersfile存储单元。

本实验主要实现三大存储单元。

处理器指令运行过程可以包括取指令、指令译码、执行、内存操作、寄存器回写，这些操作会对三种存储设备进行读或者写，但是不会同时对同一存储设备进行读写。

所以为了实现单周期的MIPS，做这样一个设计，InstructionMemory用组合逻辑实现，完成类似于ROM的功能，仅作读操作；而Datamemory和Register的读操作用组合逻辑实现，而写操作用时序逻辑来实现。

图2.MIPS存储设备

Datamemory是用来存储运行完成的数据，或者初始化的数据。

其中用于控制Datamemory的读写信号，可以由一个信号来控制，高低电平控制读写，分别用两个信号来控制读写

三、实验verilog代码

（一）Instructionmemory的实现

moduleInstruction_memory（

input[31:

0]ImemRdAddr,

outputreg[31:

0]Instruction

）;

reg[31:

0]InstMem[0:

255];//memoryspaceforstoringinstructions

//initialtheinstructionanddatamemory

initial

begin

$readmemh（"instruction",InstMem,8'h0）;

end

always@（ImemRdAddr）

begin

Instruction<=InstMem[ImemRdAddr];

end

endmodule

（二）DataMemory的实现

moduleData_memory（

inputClk,

input[31:

0]DmemAddr,

output[31:

0]DmemRdData,

inputDmemWrite,

input[31:

0]DmemWrData

）;

reg[31:

0]DataMem[0:

255];

initial

begin

$readmemh（"Data",DataMem,10'h0）;

end

always@（posedgeClk）

begin

if（DmemWrite==1'b1）

DataMem[DmemAddr]<=DmemWrData;

end

assignDmemRdData=（DmemWrite==1'b0）?

DataMem[DmemAddr]:

0;

endmodule

（三）Register的实现

moduleregister（

inputClk,

input[4:

0]RegARdAddr,

input[4:

0]RegBRdAddr,

input[4:

0]RegWrAddr,

input[31:

0]RegWrData,

inputRegWrite,

output[31:

0]RegARdData,

output[31:

0]RegBRdData

）;

reg[31:

0]regFile[0:

31];

initial

begin

$readmemh（"register",regFile,32'h0）;

end

//writeonfallingclockedge

always@（negedgeClk）

if（RegWrite==1'b1）

regFile[RegWrAddr]<=RegWrData;

assignRegARdData=（RegARdAddr!

=0）?

regFile[RegARdAddr]:

0;

assignRegBRdData=（RegBRdAddr!

=0）?

regFile[RegBRdAddr]:

0;

endmodule

四、仿真测试

1.代码

（一）Instructionmemory的实现

moduleInstruction_memory_tb;

//Inputs

reg[31:

0]ImemRdAddr;

//Outputs

wire[31:

0]Instruction;

//InstantiatetheUnitUnderTest（UUT）

Instruction_memoryuut（

.ImemRdAddr（ImemRdAddr）,

.Instruction（Instruction）

）;

reg[7:

0]index;

reg[31:

0]InstMem[0:

255];

initialbegin

//InitializeInputs

ImemRdAddr=0;

index=0;

$readmemh（"instruction",InstMem,8'h0）;

//Wait10nsforglobalresettofinish

#10;

for（index=0;index<=255;index=index+1）

begin

#10;

ImemRdAddr<=index;

end

//Addstimulushere

end

endmodule

（二）DataMemory的实现

moduleData_memory_tb;

//Inputs

regClk;

reg[31:

0]DmemAddr;

regDmemWrite;

reg[31:

0]DmemWrData;

//Outputs

wire[31:

0]DmemRdData;

//InstantiatetheUnitUnderTest（UUT）

Data_memoryuut（

.Clk（Clk）,

.DmemAddr（DmemAddr）,

.DmemRdData（DmemRdData）,

.DmemWrite（DmemWrite）,

.DmemWrData（DmemWrData）

）;

reg[31:

0]DataMem[0:

255];

reg[7:

0]index;

initialbegin

//InitializeInputs

Clk=0;

DmemAddr=0;

DmemWrite=1;

DmemWrData=0;

$readmemh（"Data",DataMem,10'h0）;

//writedataintomemory

for（index=0;index<=7;index=index+1）

begin

#10;

DmemAddr<=index;

DmemWrData<=index;

end

//readdatafrommemory

DmemWrite=0;

for（index=0;index<=7;index=index+1）

begin

#10;

DmemAddr<=index;

end

end

//ClockGenerator

always#2Clk=!

Clk;

endmodule

（三）Register的实现

moduleregister_tb;

//Inputs

regClk;

reg[4:

0]RegARdAddr;

reg[4:

0]RegBRdAddr;

reg[4:

0]RegWrAddr;

reg[31:

0]RegWrData;

regRegWrite;

//Outputs

wire[31:

0]RegARdData;

wire[31:

0]RegBRdData;

reg[31:

0]regFile[0:

31];

//InstantiatetheUnitUnderTest（UUT）

registeruut（

.Clk（Clk）,

.RegARdAddr（RegARdAddr）,

.RegBRdAddr（RegBRdAddr）,

.RegWrAddr（RegWrAddr）,

.RegWrData（RegWrData）,

.RegWrite（RegWrite）,

.RegARdData（RegARdData）,

.RegBRdData（RegBRdData）

）;

reg[7:

0]index;

initialbegin

//InitializeInputs

index=0;

Clk=0;

RegARdAddr=0;

RegBRdAddr=0;

RegWrAddr=0;

RegWrData=0;

RegWrite=1;

$readmemh（"register",regFile,32'h0）;

//Wait10nsforglobalresettofinish

#10;

//Addstimulushere

//writedataintomemory

for（index=0;index<=7;index=index+1）

begin

#10;

RegWrAddr<=index;

RegWrData<=index;

end

//readdatafrommemory

RegWrite=0;

for（index=0;index<=6;index=index+1）

begin

#10;

RegARdAddr<=index;

RegBRdAddr<=index;

end

end

//ClockGenerator

always#2Clk=!

Clk;

endmodule

2.仿真截图

（一）Instructionmemory的实现

（二）DataMemory的实现

（三）Register的实现

五、实验总结