华科微机原理实验报告

微机原理实验报告

课程：微机原理

指导老师

姓名：

学号：

实验名称：Lab 02: MIPS处理器部件实现A

微机原理实验报告

一、实验目的

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

二、实验原理及说明

MIPS的基本架构如图1所示，包括Control，ALU这样的组合逻辑单元，也包括如instruction memory，Data memory和Registers file存储单元。本实验主要实现CPU Control和ALU两个部分。

（一）CPU控制器的实现

CPU Control单元输入为指令的opCode字段，即操作码;以及R指令的funct编码。操作码和Funct编码经过主控制单元的译码，给ALU，Data Memory，Registers ，Muxs等部件输出正确的控制信号。

图2. MIPS基本指令格式

图: 控制模块的IO定义

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

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

图4. Funct，ALUOp与ALU Control编码关系

(二) ALU的实现

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

算术操作的编码

三、实验verilog代码

（一）CPU控制器的实现

module Ctr(

input [5:0] OpCode,

input [5:0] Funct,

output regRegDst,

output regALUSrc,

output regRegWrite,

output regMemWrite,

output regMemRead,

output regMemtoReg,

output reg Branch,

output reg Jump,

output reg [3:0] ALUControl

);

reg [1:0] ALUOp;

always @(OpCode)

begin

case(OpCode)

//R type

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 @(ALUOp or Funct)

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的实现

module ALU(

input [31:0] SrcA,

input [31:0] SrcB,

input [3:0] ALUCtr,

output Zero,

output reg [31:0] ALURes

);

assign Zero=(ALURes==1'b0);

always @(SrcA or SrcB or ALUCtr)

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

default ALURes=32'h0;

endcase

end

endmodule

四、仿真测试

1.代码

（一）CPU控制器的实现

module Ctr_tb;

// Inputs

reg [5:0] OpCode;

reg [5:0] Funct;

// Outputs

wire RegDst;

wire ALUSrc;

wire RegWrite;

wire MemWrite;

wire MemRead;

wire MemtoReg;

wire Branch;

wire Jump;

wire [3:0] ALUControl;

// Instantiate the Unit Under Test (UUT)

Ctruut (

.OpCode(OpCode),

.Funct(Funct),

.RegDst(RegDst),

.ALUSrc(ALUSrc),

.RegWrite(RegWrite),

.MemWrite(MemWrite),

.MemRead(MemRead),

.MemtoReg(MemtoReg),

.Branch(Branch),

.Jump(Jump),

.ALUControl(ALUControl) );

initial begin

// R-type Add

OpCode=6'b000000;

Funct=6'b100000;

// R-type Subtract

#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-type AND

#10;

OpCode=6'b000000;

Funct=6'b100100;

// R-type OR

#10;

OpCode=6'b000000;

Funct=6'b100101;

// R-type set on less than

#10;

OpCode=6'b000000;

Funct=6'b101010;

// Jump

#10;

OpCode=6'b000010;

end

endmodule

(二) ALU的实现

module ALU_tb;

// Inputs

reg [31:0] SrcA;

reg [31:0] SrcB;

reg [3:0] ALUCtr;

// Outputs

wire Zero;

wire [31:0] ALURes;

// Instantiate the Unit Under Test (UUT)

ALU uut (

.SrcA(SrcA),

.SrcB(SrcB),

.ALUCtr(ALUCtr),

.Zero(Zero),

.ALURes(ALURes)

);

initial begin

// AND

SrcA =32'hf0f0ffff;

SrcB =32'h0000f0f0;

ALUCtr =0;

// OR

#10;

ALUCtr =4'b0001;

// Add

#10;

ALUCtr =4'b0010;

// Subtract

#10;

ALUCtr =4'b0110;

// set on less than

#10;

ALUCtr =4'b0111;

//NOR

#10;

ALUCtr =4'b1100;

//Other situation

#10;

ALUCtr =4'b1111;

end

endmodule

2.仿真截图

（一）CPU控制器的实现

(二) ALU的实现

五、实验总结

实验名称：Lab03: MIPS处理器部件实现B

微机原理实验报告

一、实验目的

本实验旨在使读者实现MIPS处理器的部件—Data memory, Instruction memory和Registers 三大存储器件。理解CPU的寄存器和内存,使用Verilog语言设计存储器件,使用ISim进行行为仿真。

二、实验原理及说明

本实验旨在使读者掌握MIPS处理器中内存和寄存器的设计。在本实验中，利用Verilog HDL语言描述硬件逻辑实现和仿真内存和寄存器。

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

1．Instruction memory的实现

2．Data Memory的实现

3．Register的实现

4．有符号扩展的实现

MIPS的基本架构如图1所示，包括Control，ALU这样的组合逻辑单元，也包括如instruction memory，Data memory和Registers file存储单元。本实验主要实现三大存储单元。

处理器指令运行过程可以包括取指令、指令译码、执行、内存操作、寄存器回写，这些操作会对三种存储

设备进行读或者写，但是不会同时对同一存储设备进行读写。所以为了实现单周期的MIPS，做这样一个设计，Instruction Memory用组合逻辑实现，完成类似于ROM的功能，仅作读操作；而Data memory 和Register 的读操作用组合逻辑实现，而写操作用时序逻辑来实现。

图2. MIPS存储设备

Data memory是用来存储运行完成的数据，或者初始化的数据。其中用于控制Data memory的读写信号，可以由一个信号来控制，高低电平控制读写，分别用两个信号来控制读写

三、实验verilog代码

（一）Instruction memory的实现

module Instruction_memory(

input [31:0] ImemRdAddr,

output reg [31:0] Instruction

);

reg [31:0] InstMem [0:255];//memory space for storing instructions

//initial the instruction and data memory

initial

begin

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

end

always @ (ImemRdAddr)

begin

Instruction <=InstMem[ImemRdAddr];

end

endmodule

（二）Data Memory的实现

module Data_memory(

input Clk,

input [31:0] DmemAddr,

output [31:0] DmemRdData,

input DmemWrite,

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

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

（三）Register 的实现

module register(

input Clk,

input [4:0] RegARdAddr,

input [4:0] RegBRdAddr,

input [4:0] RegWrAddr,

input [31:0] RegWrData,

input RegWrite,

output [31:0] RegARdData,

output [31:0] RegBRdData

);

reg [31:0] regFile[0:31];

initial

begin

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

end

//write on falling clock edge

always @ (negedgeClk)

if(RegWrite==1'b1)

regFile[RegWrAddr]<=RegWrData;

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

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

四、仿真测试

1.代码

（一）Instruction memory的实现

module Instruction_memory_tb;

// Inputs

reg [31:0] ImemRdAddr;

// Outputs

wire [31:0] Instruction;

// Instantiate the Unit Under Test (UUT) Instruction_memoryuut (

.ImemRdAddr(ImemRdAddr),

.Instruction(Instruction)

);

reg [7:0] index;

reg [31:0] InstMem [0:255];

initial begin

// Initialize Inputs

ImemRdAddr = 0;

index=0;

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

// Wait 10 ns for global reset to finish #10;

for(index=0;index<=255;index=index+1) begin

#10;

ImemRdAddr<=index;

end

// Add stimulus here

end

endmodule

（二）Data Memory的实现

module Data_memory_tb;

// Inputs

regClk;

reg [31:0] DmemAddr;

regDmemWrite;

reg [31:0] DmemWrData;

// Outputs

wire [31:0] DmemRdData;

// Instantiate the Unit Under Test (UUT) Data_memoryuut (

.Clk(Clk),

.DmemAddr(DmemAddr),

.DmemRdData(DmemRdData),

.DmemWrite(DmemWrite),

.DmemWrData(DmemWrData)

);

reg [31:0] DataMem [0:255];

reg [7:0] index;

initial begin

// Initialize Inputs

Clk = 0;

DmemAddr = 0;

DmemWrite = 1;

DmemWrData = 0;

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

//write data into memory

for(index=0;index<=7;index=index+1)

begin

#10;

DmemAddr<=index;

DmemWrData<=index;

end

//read data from memory

DmemWrite=0;

for(index=0;index<=7;index=index+1)

begin

#10;

DmemAddr<=index;

end

end

//Clock Generator

always #2 Clk=!Clk;

endmodule

（三）Register 的实现

module register_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];

// Instantiate the Unit Under Test (UUT)

register uut (

.Clk(Clk),

.RegARdAddr(RegARdAddr),

.RegBRdAddr(RegBRdAddr),

.RegWrAddr(RegWrAddr),

.RegWrData(RegWrData),

.RegWrite(RegWrite),

.RegARdData(RegARdData),

.RegBRdData(RegBRdData)

);

reg [7:0] index;

initial begin

// Initialize Inputs

index=0;

Clk = 0;

RegARdAddr = 0;

RegBRdAddr = 0;

RegWrAddr = 0;

RegWrData = 0;

RegWrite = 1;

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

// Wait 10 ns for global reset to finish

#10;

// Add stimulus here

//write data into memory

for(index=0;index<=7;index=index+1)

begin

#10;

RegWrAddr<=index;

RegWrData<=index;

end

//read data from memory

RegWrite=0;

for(index=0;index<=6;index=index+1)

begin

#10;

RegARdAddr<=index;

RegBRdAddr<=index;

end

end

//Clock Generator

always #2 Clk=!Clk;

endmodule

2.仿真截图

（一）Instruction memory的实现

（二）Data Memory的实现

（三）Register 的实现

五、实验总结