Report

Đồ án Vi xử lý và Cấu trúc máy tính- LAB 3: MIPS 32-bit single- cycle

Nhóm 14: Q.Bình – Q.Toản – V.Chục

ĐỒ ÁN MÔN HỌC

VI XỬ LÝ VÀ CẤU TRÚC MÁY TÍNH

Lab 3: Design MIPS 32-bit single- cycle CPU

SVTH: Tào Quang Bình. 09DT1

Trần Quốc Toản. 09DT2

Nguyễn Văn Chục. 09DT1

Nhóm: 14



Phân công nhiệm vụ và đánh giá

STT Tên thành viên Công việc Đóng góp

1

Tào Quang Bình

+ Tìm hiểu lại chương 4 sách COD

+Tìm hiểu hoạt động và thiết kế : Khối

Control, Khối mở rộng, Khối mô

phỏng Stimulate

+ Mô phỏng lệnh trên Quartus

+ Slide

33.33%

2

Trần Quốc Toản

+ Tìm hiểu lại LAB2: Thiết kế bộ tính

toán ALU.

+Tìm hiểu hoạt động và thiết kế: Thanh

ghi PC, Khối ALUControl , Các khối

Multiplexor

+ Báo cáo.

33.33%

3

Nguyễn Văn Chục

+ Tìm hiểu lại LAB 1: Thiết kế

RegisterFile 32 by 32

Tìm hiểu hoạt động và thiết kế:

ALUControl, MIPS, khối Add, Khối

dịch trái

+ Slide: phần II3,III.

+ Kiểm tra báo cáo + slide

33.33%



1. Yêu cầu lab 3:

o Thiết kế chip MIPS 32-bit single- cycle thực hiện được các lệnh: ADD, SUB,

SLT, XORI, LW, SW, J, JR, BNE.

o Dựa trên các module có sẵn: regfile, ALU, instrmem, datamem.

2. Tập lệnh:

o Các lệnh chia làm 3 nhóm: R- format, I- format, J- format

2.1. R- format.

- Ý nghĩa lệnh:

+ ADD rd, rs, rt:

Reg[rd] = Reg[rs] + Reg[rt].

+ SLT rd, rs, rt:

If (Reg[rs] < Reg[rt])

Reg[rd] = 1

else

Reg[rd] = 0.

+ SUB rd, rs, rt:

Reg[rd] = Reg[rs] – Reg[rt].

+ JR rs:

PC = Reg[rs].

- Khuôn dạng:

opcode rs rt rd Shamt function

6 bit 5 bit 5 bit 5 bit 5 bit 6 bit

2.2. I- format.

- Ý nghĩa lệnh:

+ BNE rs, rt, imm16:

if (Reg[rs] != Reg[rt])

PC = PC + 4 + Sign_ext(Imm16)<<2

else

PC = PC + 4.



+ LW rt, imm16(rs):

Reg[rt] = Mem[Reg[rs] + Sign_ext(Imm16)].

+ SW rt, imm16(rs):

Mem[Reg[rs] + Sign_ext(Imm16)] = Reg[rt].

+ XORI rt, rs, imm16:

Reg[rt] = Reg[rs] XOR Zero_ext(Imm16).

- Khuôn dạng:

opcode rs rt address/immediate

6 bit 5 bit 5 bit 16 bit

2.3. J-format:

- Ý nghĩa lệnh:

+ J target:

PC = { PC[31:28], target, 00 }.

- Khuôn dạng:

opcode target address

6 bit 26 bit

3. Thiết kế:

3.1. Sơ đồ khối tổng quát:



3.2. Thiết kế các module.

3.2.1. Khối tìm và lấy lệnh.

o Bộ nhớ lệnh: Instruction Memory: Dùng để lưu trữ lệnh dưới dạng mã máy.

Trong bài lab này, bộ nhớ lệnh được cho trong file: instrmem.v

o Thanh ghi PC: Là thanh ghi 32 bit, chứa địa chỉ của lệnh sắp được thực thi. Được

xây dựng trên các D_FF.

o Bộ cộng: Tăng giá trị thanh ghi PC lên 4.

o Mô hình khối tìm và lấy lệnh ban đầu.



o

3.2.2. Khối thanh ghi 32 bits

o Khối thanh ghi 32 bits này được hoàn thành ở lab 1. o Trong đó ReadRegister 1 và ReadRegister 2 là các thanh ghi dùng để lựa chọn 2

trong 32 thanh ghi, giá trị của chúng sẽ được đọc ở Read Data1 và Read Data 2.

o Writer Data là ngõ vào để lựa chọn đích cho thao tác ghi.

o RegWrite là tín hiệu điều khiển ghi. Nếu RegWrite = 1 thì dữ liệu ở ngõ vào sẽ

được ghi vào thanh ghi WriteData.

o Sơ đồ khối của 1 file thanh ghi như sau:

o o Sơ đồ chi tiết của 1 file thanh ghi như sau:



o

3.2.3. Bố số học và logic. (ALU- Arithmetic logic unit)

o Khối ALU này được hoàn thành ở lab 2.

o Cấu tạo MIPS ALU:

+ Hai ngõ vào BusA, BusB 32 bits.

+ Một ngõ ra 32 bits.

+ Các cờ ngõ ra: CarryOut, Overflow, Zero, Negative.

Cờ zero: được set khi ngõ ra bằng 0.

Cờ CarryOut (tràn khi thực hiện phép cộng trừ số không dấu): Xảy ra khi có

nhớ ở MSB.

Cờ Overflow (tràn khi thực hiện cộng trừ với số có dấu): Được set khi xảy ra

tràn.

Cờ Negative: Được set nếu kết quả âm.

+ Ngõ vào ALUControl.

3.2.4. Bộ nhớ dữ liệu (Datamemory)



o Địa chỉ để truy cập bộ nhớ là 32 bits. Tức là với 32bits địa chỉ, ta sẽ truy cập được

bytes hay words. Trong bài lab này, ta mô phỏng với 1024 bytes, tức

là

o Sơ đồ khối bộ nhớ dữ liệu:

o

3.2.5. Ghép nối bổ sung datapath

Tùy vào từng lệnh trong tập lệnh mà MIPS cần thực hiện để ghép nối bổ sung

databapath cho phù hợp.

Đối với các lệnh khuôn dạng R: Gồm ADD,SUB, SLT và JR

+ Các lệnh ADD, SUB, SLT yêu cầu: Lấy dữ liệu từ file thanh ghi, đưa sang

khối ALU tính toán, lưu lại vào file thanh ghi. Riêng lệnh JR thì chỉ cần lấy dữ

liệu từ file thanh ghi để thay đổi thanh ghi PC.

Thêm lệnh XORI:

XORI rt, rs, imm16: Reg[rt]=Reg[rs] XORZero_ext(Imm16).

Cần bổ sung:

- Khối Zero_extend

- Bộ Multiplexor chọn đầu vào cho ALU (ReadData2 hoặc Zero_ext(Imm16)

)

- Bộ Multiplexor chọn địa chỉ cho WriteRegister (rd hoặc rt )



Thêm các lệnh truy cập bộ nhớ LW, SW:

LW rt, imm16(rs): Reg[rt] = Mem[Reg[rs] + Sign_ext(Imm16)].

SW rt, imm16(rs): Mem[Reg[rs] + Sign_ext(Imm16)] = Reg[rt].

Cần thêm khối mở rộng dấu Sing_Extned.

- Thêm bộ Multiplexor2x32to32 để chọn giá trị cho WriteData: lấy kết quả tử

ALU hoặc DataMem.

3.2.6. Các khối điều khiển

3.2.6.1. Khối control

o Khối điều khiển trung tâm, có nhiệm vụ giải mã opcode của các lệnh thành tín

hiệu điều khiển: RegDst, ALUSrc, MemtoReg, RegWrite, MemWrite. Branch,

Jump.

R-format LW SW BNE XORI J

RegDst 1 0 X 0 0 X

ALUSrc 0 1 1 X 1 X

MemtoReg 0 1 X 0 0 X

MemRead 0 1 0 0 0 0

RegWrite 1 1 0 0 1 0

MemWrite 0 1 0 0 0 0

Branch 0 0 1 0 0 0

ALUOp 0 0 0 0 1 1 X

ALUOp 1 1 0 0 0 1 X

Signzero X 0 0 0 1 X



3.2.6.2. Khối ALUControl

Bảng giá trị tín hiệu điều khiển ở khối ALUControl

ALUOp Funtion ALUControl ALUOperation Instruction

11 XXXXXX 01 XOR XORI

00 XXXXXX 00 ADD LW-SW

01 XXXXXX 10 SUB BNE

10 100000 00 ADD R- format ADD

10 100010 10 SUB R- format SUB

10 101010 11 SLT R- format- SLT

Các tín hiệu điều khiển đối với các lệnh JR và BNE:

o JRControl:

+ Nếu ALUOp = 10 (R-format) và Function= 001000 thì

JRControl= 1, còn ngược lại thì JRControl = 0.

o bneControl:

+ bneControl = 1 nếu Branch = 1, ZeroFlag = 0.

+ Ngược lại bneControl = 0.

4. Module chính.

`timescale 1 ps / 100 fs

// MIPS 32BIT - SINGLE - CYLCE - CPU

module MIPS(clk, reset);

input clk, reset;

/************************************

************* KHAI BAO *************

************************************/

// KHAI BAO DIA CHI

wire [31:0] PCin,PC; // PCin: dia chi ngo vao cua thanh ghi PC

wire [31:0] PC_4, // PC_4 : Dia chi lenh tiep theo

PC_Bne, // PC_Bne : Dia chi neu thuc hien lenh Branch

PC_Jump, // PC_Jump: Dia chi neu thuc hien lenh Jump

PC_JR, // PC_JR : Dia chi neu thuc hien lenh Jump Register



Bne_Address, // Bne_Address: Dia chi Branch

Jump_Address, // Jump_Address: Dia chi Jump

JR_Address; // JR_Address: Dia chi Jump Register ( =

ReadData1)

// KHAI BAO INSTRUCTION MEMORY

wire [31:0] Instruction; // Lenh dang xu ly

wire [5:0] Opcode,Funct;

wire [4:0] Rs,Rt,Rd;

wire [15:0] Imm16; // gia tri 16bit immediate

assign Opcode = Instruction[31:26];

assign Rs = Instruction[25:21];

assign Rt = Instruction[20:16];

assign Rd = Instruction[15:11];

assign Funct = Instruction[5:0];

assign Imm16 = Instruction[15:0];

// KHAI BAO CONTROL UNIT

wire RegDst,

Jump,

Branch,

MemRead,

MemtoReg,

MemWrite,

ALUSrc,

RegWrite,

SignZero;

wire [1:0]ALUOp;

// KHAI BAO ALU

wire [31:0] ALUin1, // 2 ngo vao cua bo ALU

ALUin2;

wire [31:0] ALUResult; // Ket qua cua bo ALU

wire Zero,

Negative,



Overflow,

Carry; // Cac co` cua bo ALU

wire JR_Control; // Tin hieu dieu khien lenh Jump Register

wire Bne_Control; // Tin hieu dieu khien lenh BNE

wire [1:0] ALU_Control; // Tin hieu ra cua ALU_Control_Unit

wire [31:0] Extend; // 32bit mo rong dau cua 16bit immediate

// KHAI BAO REGISTER FILE

wire [31:0] ReadData1,ReadData2; // Gia tri cac thanh ghi

wire [31:0] Reg_WriteData; // Gia tri ghi vao thanh ghi dich

wire [4:0] WriteRegister; // Thanh ghi dich

// KHAI BAO DATA MEMORY

wire [31:0] Mem_ReadData, // Du lieu xuat ra tu bo nho

Mem_Address, // Dia chi DataMemory

Mem_WriteData; // Du lieu ghi vao bo nho ( = ReadData2)

// KHAI BAO SHIFTER

wire [31:0] Bne_shift_in, // Ngo vao bo dich trai (BNE)

Bne_shift_out, // Ngo ra bo dich trai (BNE)

Jump_shift_in, // Ngo vao bo dich trai (JUMP)

Jump_shift_out; // Ngo ra bo dich trai (JUMP)

/************************************

********* CAU TRUC MIPS ************

************************************/

/* KHOI THANH GHI PC */

PC_Register ProgramCounter( PC,

PCin,

reset,



clk);

// Dia chi lenh tiep theo duoc thuc hien

Add_32bit Adder_PC( PC, // PC_4 = PC + 4

{29'b0,3'b100},,,

PC_4);

/* INSTRUCTION MEMORY - BO NHO LENH */

InstructionMem InstructionMemory(Instruction, PC);

/* MAIN CONTROL UNIT - KHOI DIEU KHIEN CHINH */

Control_Unit Control( RegDst,

ALUSrc,

MemtoReg,

RegWrite,

MemRead,

MemWrite,

Branch,

ALUOp,

Jump,

SignZero,

Opcode );

/* REGISTER FILE - BO THANH GHI */

Mux_2x5to5 Mux_RegDst(WriteRegister,Rt,Rd,RegDst); // Chon

WriteRegister ( giua lenh R-type & I-type)

RegisterFile RegFile( ReadData1,

ReadData2,

Reg_WriteData,

Rs,

Rt,

WriteRegister,

RegWrite,

reset,

clk );



/* SIGN-ZERO EXTEND */

Extender Sign_Extend(Extend, Imm16, SignZero);

/* ALU - KHOI TINH TOAN CHINH */

assign ALUin1 = ReadData1;

Mux_2x32to32 Mux_Input_ALU( ALUin2,

ReadData2,

Extend,

ALUSrc);

ALU ALU_Unit(ALUResult,

ALUin1,

ALUin2,

Carry,

Zero,

Overflow,

Negative,

ALU_Control);

ALU_Control_Unit ALUControl( ALU_Control,

ALUOp,

Funct);

/* DATA MEMORY - BO NHO DU LIEU */

assign Mem_WriteData = ReadData2;

assign Mem_Address = ALUResult;

DataMem DataMemory( Mem_ReadData,

ALUResult,

Mem_WriteData,

MemWrite,

MemRead,

clk);

Mux_2x32to32 Mux_WriteData( Reg_WriteData,

ALUResult,

Mem_ReadData,

MemtoReg);



/* BNE CONTROL */

assign Bne_shift_in = Extend;

Shiftleft2 Shift_bne( Bne_shift_out, Bne_shift_in);

Add_32bit Adder_bne( PC_4,

Bne_shift_out,,,

Bne_Address);

not #(50) notBNE(NotZero,Zero);

and #(50) andBNE(Bne_Control,Branch,NotZero);

Mux_2x32to32 Mux_BNE( PC_Bne,

PC_4,

Bne_Address,

Bne_Control);

/* JUMP CONTROL */

assign Jump_shift_in = {6'b0,Instruction[25:0]};

assign Jump_Address = {PC_4[31:28],Jump_shift_out[27:0]};

Shiftleft2 Shift_jump(Jump_shift_out,Jump_shift_in);

Mux_2x32to32 Mux_Jump(PC_Jump,

PC_Bne,

Jump_Address,

Jump);

/* JUMP REGISTER CONTROL */

assign JR_Address = ReadData1;

assign PCin = PC_JR;

JR_Control_Unit JRControlUnit1( ALUOp, Funct,JR_Control);

Mux_2x32to32 MuxJR( PC_JR,

PC_Jump,

JR_Address,

JR_Control);



endmodule

Testbench:

`timescale 1 ps / 100 fs

module Stimul();

parameter ClockPeriod = 10000;

reg clk,reset;

MIPS M(clk, reset);

initial clk = 0;

always #(ClockPeriod/2) clk = ~clk;

initial

begin

reset = 1;

#ClockPeriod;

reset = 0;

#150000;

reset =1;

#ClockPeriod;

reset = 0;

end

endmodule

end

endmodule

Report

Documents

Transcript of Report