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

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

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

0]OpCode,

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

b000100:

RegDst=1'

bx;

RegWrite=0;

MemtoReg=1'

Branch=1;

b01;

//lw

b100011:

RegDst=0;

ALUSrc=1;

MemRead=1;

MemtoReg=1;

b00;

//sw

b101011:

MemWrite=1;

//Jump

b000010:

ALUSrc=0;

MemtoReg=0;

RegWrite=0;

MemRead=0;

MemWrite=0;

Branch=0;

ALUOp=2'

Jump=1;

endcase

end

always@（ALUOporFunct）

casex（{ALUOp,Funct}）

8'

b00xxxxxx:

ALUControl=4'

b0010;

b01xxxxxx:

b0110;

b1xxx0000:

b1xxx0010:

b1xxx0100:

b0000;

b1xxx0101:

b0001;

b1xxx1010:

b0111;

default:

endcase

endmodule

moduleALU（

input[31:

0]SrcA,

0]SrcB,

input[3:

0]ALUCtr,

outputZero,

outputreg[31:

0]ALURes

assignZero=（ALURes==1'

b0）;

always@（SrcAorSrcBorALUCtr）

case（ALUCtr）

4'

b0000:

ALURes=SrcA&

SrcB;

//AND

b0001:

ALURes=SrcA|SrcB;

//OR

b0010:

ALURes=SrcA+SrcB;

//add

b0110:

ALURes=SrcA-SrcB;

//substract

b0111:

ALURes=SrcA<

SrcB?

1:

0;

//setonlessthan

b1100:

ALURes=~（SrcA|SrcB）;

//NOR

defaultALURes=32'

h0;

end

四、仿真测试

1.代码

moduleCtr_tb;

//Inputs

reg[5:

0]OpCode;

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;

b100010;

//Lw

b100011;

bxxxxxx;

//Sw

b101011;

//Beq

b000100;

//R-typeAND

b100100;

//R-typeOR

b100101;

//R-typesetonlessthan

b101010;

//Jump

b000010;

moduleALU_tb;

reg[31:

0]SrcA;

0]SrcB;

reg[3:

0]ALUCtr;

wireZero;

wire[31:

0]ALURes;

ALUuut（

.SrcA（SrcA）,

.SrcB（SrcB）,

.ALUCtr（ALUCtr）,

.Zero（Zero）,

.ALURes（ALURes）

//AND

SrcA=32'

hf0f0ffff;

SrcB=32'

h0000f0f0;

ALUCtr=0;

//OR

ALUCtr=4'

//Add

//Subtract

//setonlessthan

//NOR

b1100;

//Othersituation

b1111;

2.仿真截图

五、实验总结

Lab03:

MIPS处理器部件实现B

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

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

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

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

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

1．Instructionmemory的实现

2．DataMemory的实现

3．Register的实现

4．有符号扩展的实现

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

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

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

而Datamemory和Register的读操作用组合逻辑实现，而写操作用时序逻辑来实现。

图2.MIPS存储设备

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

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

（一）Instructionmemory的实现

moduleInstruction_memory（

0]ImemRdAddr,

0]Instruction

reg[31:

0]InstMem[0:

255];

//memoryspaceforstoringinstructions

//initialtheinstructionanddatamemory

initial

$readmemh（"

instruction"

InstMem,8'

h0）;

always@（ImemRdAddr）

Instruction<

=InstMem[ImemRdAddr];

（二）DataMemory的实现

moduleData_memory（

inputClk,

0]DmemAddr,

output[31:

0]DmemRdData,

inputDmemWrite,

0]DmemWrData

0]DataMem[0:

Data"

DataMem,10'

always@（posedgeClk）

if（DmemWrite==1'

b1）

DataMem[DmemAddr]<

=DmemWrData;

assignDmemRdData=（DmemWrite==1'

b0）?

DataMem[DmemAddr]:

（三）Register的实现

moduleregister（

input[4:

0]RegARdAddr,

0]RegBRdAddr,

0]RegWrAddr,

0]RegWrData,

inputRegWrite,

0]RegARdData,

0]RegBRdData

0]regFile[0:

31];

register"

regFile,32'

//writeonfallingclockedge

always@（negedgeClk）

if（RegWrite==1'

regFile[RegWrAddr]<

=RegWrData;

assignRegARdData=（RegARdAddr!

=0）?

regFile[RegARdAddr]:

assignRegBRdData=（RegBRdAddr!

regFile[RegBRdAddr]:

moduleInstruction_memory_tb;

0]ImemRdAddr;

0]Instruction;

Instruction_memoryuut（

.ImemRdAddr（ImemRdAddr）,

.Instruction（Instruction）

reg[7:

0]index;

//InitializeInputs

ImemRdAddr=0;

index=0;

$readmemh（"

//Wait10nsforglobalresettofinish

for（index=0;

index<

=255;

index=index+1）

begin

ImemRdAddr<

=index;

end

//Addstimulushere

moduleData_memory_tb;

regClk;

0]DmemAddr;

regDmemWrite;

0]DmemWrData;

0]DmemRdData;

Data_memoryuut（

.Clk（Clk）,

.DmemAddr（DmemAddr）,

.DmemRdData（DmemRdData）,

.DmemWrite（DmemWrite）,

.DmemWrData（DmemWrData）

reg[7:

Clk=0;

DmemAddr=0;

DmemWrite=1;

DmemWrData=0;

//writedataintomemory

for（index=0;

=7;

DmemAddr<

DmemWrData<

//readdatafrommemory

DmemWrite=0;

//ClockGenerator

always#2Clk=!

Clk;

moduleregister_tb;

reg[4:

0]RegARdAddr;

0]RegBRdAddr;

0]RegWrAddr;

0]RegWrData;

regRegWrite;

0]RegARdData;

0]RegBRdData;

registeruut（

.RegARdAddr（RegARdAddr）,

.RegBRdAddr（RegBRdAddr）,

.RegWrAddr（RegWrAddr）,

.RegWrData（RegWrData）,

.RegARdData（RegARdData）,

.RegBRdData（RegBRdData）

RegARdAddr=0;

RegBRdAddr=0;

RegWrAddr=0;

RegWrData=0;

RegWrite=1;

//writedataintomemory

RegWrAddr<

RegWrData<

=6;

RegARdAddr<

RegBRdAddr<

五、实验总结