Đồ án cấu trúc máy tính

Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

Project 1: MIPS 32 by 32 Register File

1. Giới thiệu :
-

File thanh ghi có nhiệm vụ dùng để lưu giữ giá trị tạm thời để phục vụ cho các quá

-

trình tính toán xử lý sau này.
File thanh ghi gồm có 32 thanh ghi từ R0 đến R31 trong đó mỗi thanh ghi gồm có

-

32 bits.
Các thanh ghi được xây dựng từ các DFF với kích khởi sườn lên.
+ Nhiệm vụ của DFF là khi tín hiệu reset = 1 thì sẽ cho đầu
ra Q = 0
+ và đầu ra Q = d khi tín hiệu enable = 1
 Vì vậy mỗi thanh ghi 32 bits sẽ được xây dựng từ 32 bộ DFF

2. Sơ đồ khối:

5

Read
Register 1

5

Read
Register 2

5

Write
Register

32

Write
Data

Read
Data 1

32

Read
Data 2

32
RegWrite

-

Trong đó:

+ với 5 bits Read Register 1 thì xác định được thanh ghi nguồn thứ
nhất rs
+ với 5 bits Read Register 2 thì xác định được thanh ghi nguồn thứ hai rt

Nhóm: Page 1


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

+ với 5 bits Write Register thì xác định được thanh ghi đích rd
+ Read data 1 sẽ đọc dữ liệu ra của thanh ghi rs
+ Read data 2 sẽ đọc dữ liệu ra của thanh ghi rt
+ Write data là 32 bits dữ liệu sẽ được ghi vào thanh ghi rd khi nào bits RegWrite
-

được set = 1
Từ 5 bits để xác định được thanh ghi cần chọn thì ta sử dụng bộ giải mã 5:32
Xây dựng bộ giải mã 5:32 từ các bộ giãi mã 2:4 và 3:8

Nhóm: Page 2


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

Sơ đồ mạch của của các bộ giải mã 2-4 và 3-8 :
2-into-4 decoder

S1

S0
S1

S0

D0

D0

D1

D1

D2

D2

D3

D3

-

Để đọc dữ liệu từ các thanh ghi thì ta sẽ sử dụng bộ multiplex 32-32
+ Bộ mux32-32 được xây dựng từ 32 bộ mux32-1 mà bộ mux32-1 sẽ được xây
dựng từ các bộ mux4-1 và mux 8-1

Nhóm: Page 3

Đồ án cấu trúc máy tính

Nhóm: Page 4

GVHD: Hồ Viết Việt


Đồ án cấu trúc máy tính

3. Code
Code Testbench cho file thanh ghi:
`timescale 1 ps / 100 fs
module RegFileStimulus();
parameter ClockDelay = 5000;
reg [4:0] ReadRegister1, ReadRegister2, WriteRegister;
Nhóm: Page 5

GVHD: Hồ Viết Việt


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

reg [31:0] WriteData;
reg RegWrite, clk,reset;
wire [31:0] ReadData1, ReadData2;
integer i;

regfile reg1(ReadData1,ReadData2,WriteData,
ReadRegister1,ReadRegister2,WriteRegister,RegWrite,clk,reset);
initial reset=0;
initial clk = 0;
always #(ClockDelay/2) clk = ~clk;
initial
begin
$monitor($time, " ReadData1=%h, ReadData2=%h, WriteData=%h, WriteReg=%d,
Reg1=%d, Reg2=%d, RegWrite=%b, clk=%b",
ReadData1, ReadData2, WriteData, WriteRegister, ReadRegister1,
ReadRegister2, RegWrite,clk);
// ghi du lieu vao thanh ghi
for (i=1; i<32; i=i+1)
begin
RegWrite=1;
ReadRegister1=i-1;
ReadRegister2=i;
WriteRegister=i;
WriteData=i*32'h100+i;
#(ClockDelay);
end
// doc du lieu ra lai
for (i=0; i<=31; i=i+1)
begin
RegWrite=0;
ReadRegister1=i;
ReadRegister2=i+1;
WriteRegister=i;
WriteData=i*32'h01020408;
#(ClockDelay/2);

end
$finish;
end
endmodule

Code của file thanh ghi:
module regfile(ReadData1,ReadData2,WriteData,
ReadRegister1,ReadRegister2,WriteRegister,RegWrite,clk,reset);
input RegWrite,clk,reset;
input [4:0] ReadRegister1, ReadRegister2, WriteRegister;
input [31:0] WriteData;
output [31:0] ReadData1,ReadData2;
wire[31:0] andRW,
R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11,R12,R13,R14,R15,R16,
Nhóm: Page 6


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

R17,R18,R19,R20,R21,R22,R23,R24,R25,R26,R27,R28,R29,R30,R31;
wire[31:0] lg0;
// phan ghi du lieu
decoder5_32 de1(WriteRegister,andRW,RegWrite);
reg32
gh0(clk,reset,1'b1,32'd0,R0[0],R1[0],R2[0],R3[0],R4[0],R5[0],R6[0],R7[0],R8[0],R9[
0],R10[0],R11[0],R12[0],R13[0],R14[0],R15[0],R16[0],R17[0],R18[0],R19[0],R20[0
],R21[0],R22[0],R23[0],R24[0],R25[0],R26[0],R27[0],R28[0],R29[0],R30[0],R31[0])
;

reg32
gh1(clk,reset,andRW[1],WriteData,R0[1],R1[1],R2[1],R3[1],R4[1],R5[1],R6[1],R7[1
],R8[1],R9[1],R10[1],R11[1],R12[1],R13[1],R14[1],R15[1],R16[1],R17[1],R18[1],R
19[1],R20[1],R21[1],R22[1],R23[1],R24[1],R25[1],R26[1],R27[1],R28[1],R29[1],R3
0[1],R31[1]);
reg32
gh2(clk,reset,andRW[2],WriteData,R0[2],R1[2],R2[2],R3[2],R4[2],R5[2],R6[2],R7[2
],R8[2],R9[2],R10[2],R11[2],R12[2],R13[2],R14[2],R15[2],R16[2],R17[2],R18[2],R
19[2],R20[2],R21[2],R22[2],R23[2],R24[2],R25[2],R26[2],R27[2],R28[2],R29[2],R3
0[2],R31[2]);
reg32
gh3(clk,reset,andRW[3],WriteData,R0[3],R1[3],R2[3],R3[3],R4[3],R5[3],R6[3],R7[3
],R8[3],R9[3],R10[3],R11[3],R12[3],R13[3],R14[3],R15[3],R16[3],R17[3],R18[3],R
19[3],R20[3],R21[3],R22[3],R23[3],R24[3],R25[3],R26[3],R27[3],R28[3],R29[3],R3
0[3],R31[3]);
reg32
gh4(clk,reset,andRW[4],WriteData,R0[4],R1[4],R2[4],R3[4],R4[4],R5[4],R6[4],R7[4
],R8[4],R9[4],R10[4],R11[4],R12[4],R13[4],R14[4],R15[4],R16[4],R17[4],R18[4],R
19[4],R20[4],R21[4],R22[4],R23[4],R24[4],R25[4],R26[4],R27[4],R28[4],R29[4],R3
0[4],R31[4]);
reg32
gh5(clk,reset,andRW[5],WriteData,R0[5],R1[5],R2[5],R3[5],R4[5],R5[5],R6[5],R7[5
],R8[5],R9[5],R10[5],R11[5],R12[5],R13[5],R14[5],R15[5],R16[5],R17[5],R18[5],R
19[5],R20[5],R21[5],R22[5],R23[5],R24[5],R25[5],R26[5],R27[5],R28[5],R29[5],R3
0[5],R31[5]);
reg32
gh6(clk,reset,andRW[6],WriteData,R0[6],R1[6],R2[6],R3[6],R4[6],R5[6],R6[6],R7[6
],R8[6],R9[6],R10[6],R11[6],R12[6],R13[6],R14[6],R15[6],R16[6],R17[6],R18[6],R
Nhóm: Page 7

Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

19[6],R20[6],R21[6],R22[6],R23[6],R24[6],R25[6],R26[6],R27[6],R28[6],R29[6],R3
0[6],R31[6]);
reg32
gh7(clk,reset,andRW[7],WriteData,R0[7],R1[7],R2[7],R3[7],R4[7],R5[7],R6[7],R7[7
],R8[7],R9[7],R10[7],R11[7],R12[7],R13[7],R14[7],R15[7],R16[7],R17[7],R18[7],R
19[7],R20[7],R21[7],R22[7],R23[7],R24[7],R25[7],R26[7],R27[7],R28[7],R29[7],R3
0[7],R31[7]);
reg32
gh8(clk,reset,andRW[8],WriteData,R0[8],R1[8],R2[8],R3[8],R4[8],R5[8],R6[8],R7[8
],R8[8],R9[8],R10[8],R11[8],R12[8],R13[8],R14[8],R15[8],R16[8],R17[8],R18[8],R
19[8],R20[8],R21[8],R22[8],R23[8],R24[8],R25[8],R26[8],R27[8],R28[8],R29[8],R3
0[8],R31[8]);
reg32
gh9(clk,reset,andRW[9],WriteData,R0[9],R1[9],R2[9],R3[9],R4[9],R5[9],R6[9],R7[9
],R8[9],R9[9],R10[9],R11[9],R12[9],R13[9],R14[9],R15[9],R16[9],R17[9],R18[9],R
19[9],R20[9],R21[9],R22[9],R23[9],R24[9],R25[9],R26[9],R27[9],R28[9],R29[9],R3
0[9],R31[9]);
reg32
gh10(clk,reset,andRW[10],WriteData,R0[10],R1[10],R2[10],R3[10],R4[10],R5[10],R
6[10],R7[10],R8[10],R9[10],R10[10],R11[10],R12[10],R13[10],R14[10],R15[10],R1
6[10],R17[10],R18[10],R19[10],R20[10],R21[10],R22[10],R23[10],R24[10],R25[10]
,R26[10],R27[10],R28[10],R29[10],R30[10],R31[10]);
reg32
gh11(clk,reset,andRW[11],WriteData,R0[11],R1[11],R2[11],R3[11],R4[11],R5[11],R
6[11],R7[11],R8[11],R9[11],R10[11],R11[11],R12[11],R13[11],R14[11],R15[11],R1

6[11],R17[11],R18[11],R19[11],R20[11],R21[11],R22[11],R23[11],R24[11],R25[11]
,R26[11],R27[11],R28[11],R29[11],R30[11],R31[11]);
reg32
gh12(clk,reset,andRW[12],WriteData,R0[12],R1[12],R2[12],R3[12],R4[12],R5[12],R
6[12],R7[12],R8[12],R9[12],R10[12],R11[12],R12[12],R13[12],R14[12],R15[12],R1
6[12],R17[12],R18[12],R19[12],R20[12],R21[12],R22[12],R23[12],R24[12],R25[12]
,R26[12],R27[12],R28[12],R29[12],R30[12],R31[12]);
reg32
gh13(clk,reset,andRW[13],WriteData,R0[13],R1[13],R2[13],R3[13],R4[13],R5[13],R
6[13],R7[13],R8[13],R9[13],R10[13],R11[13],R12[13],R13[13],R14[13],R15[13],R1

Nhóm: Page 8


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

6[13],R17[13],R18[13],R19[13],R20[13],R21[13],R22[13],R23[13],R24[13],R25[13]
,R26[13],R27[13],R28[13],R29[13],R30[13],R31[13]);
reg32
gh14(clk,reset,andRW[14],WriteData,R0[14],R1[14],R2[14],R3[14],R4[14],R5[14],R
6[14],R7[14],R8[14],R9[14],R10[14],R11[14],R12[14],R13[14],R14[14],R15[14],R1
6[14],R17[14],R18[14],R19[14],R20[14],R21[14],R22[14],R23[14],R24[14],R25[14]
,R26[14],R27[14],R28[14],R29[14],R30[14],R31[14]);
reg32
gh15(clk,reset,andRW[15],WriteData,R0[15],R1[15],R2[15],R3[15],R4[15],R5[15],R
6[15],R7[15],R8[15],R9[15],R10[15],R11[15],R12[15],R13[15],R14[15],R15[15],R1
6[15],R17[15],R18[15],R19[15],R20[15],R21[15],R22[15],R23[15],R24[15],R25[15]
,R26[15],R27[15],R28[15],R29[15],R30[15],R31[15]);

reg32
gh16(clk,reset,andRW[16],WriteData,R0[16],R1[16],R2[16],R3[16],R4[16],R5[16],R
6[16],R7[16],R8[16],R9[16],R10[16],R11[16],R12[16],R13[16],R14[16],R15[16],R1
6[16],R17[16],R18[16],R19[16],R20[16],R21[16],R22[16],R23[16],R24[16],R25[16]
,R26[16],R27[16],R28[16],R29[16],R30[16],R31[16]);
reg32
gh17(clk,reset,andRW[17],WriteData,R0[17],R1[17],R2[17],R3[17],R4[17],R5[17],R
6[17],R7[17],R8[17],R9[17],R10[17],R11[17],R12[17],R13[17],R14[17],R15[17],R1
6[17],R17[17],R18[17],R19[17],R20[17],R21[17],R22[17],R23[17],R24[17],R25[17]
,R26[17],R27[17],R28[17],R29[17],R30[17],R31[17]);
reg32
gh18(clk,reset,andRW[18],WriteData,R0[18],R1[18],R2[18],R3[18],R4[18],R5[18],R
6[18],R7[18],R8[18],R9[18],R10[18],R11[18],R12[18],R13[18],R14[18],R15[18],R1
6[18],R17[18],R18[18],R19[18],R20[18],R21[18],R22[18],R23[18],R24[18],R25[18]
,R26[18],R27[18],R28[18],R29[18],R30[18],R31[18]);
reg32
gh19(clk,reset,andRW[19],WriteData,R0[19],R1[19],R2[19],R3[19],R4[19],R5[19],R
6[19],R7[19],R8[19],R9[19],R10[19],R11[19],R12[19],R13[19],R14[19],R15[19],R1
6[19],R17[19],R18[19],R19[19],R20[19],R21[19],R22[19],R23[19],R24[19],R25[19]
,R26[19],R27[19],R28[19],R29[19],R30[19],R31[19]);
reg32
gh20(clk,reset,andRW[20],WriteData,R0[20],R1[20],R2[20],R3[20],R4[20],R5[20],R
6[20],R7[20],R8[20],R9[20],R10[20],R11[20],R12[20],R13[20],R14[20],R15[20],R1

Nhóm: Page 9


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

6[20],R17[20],R18[20],R19[20],R20[20],R21[20],R22[20],R23[20],R24[20],R25[20]
,R26[20],R27[20],R28[20],R29[20],R30[20],R31[20]);
reg32
gh21(clk,reset,andRW[21],WriteData,R0[21],R1[21],R2[21],R3[21],R4[21],R5[21],R
6[21],R7[21],R8[21],R9[21],R10[21],R11[21],R12[21],R13[21],R14[21],R15[21],R1
6[21],R17[21],R18[21],R19[21],R20[21],R21[21],R22[21],R23[21],R24[21],R25[21]
,R26[21],R27[21],R28[21],R29[21],R30[21],R31[21]);
reg32
gh22(clk,reset,andRW[22],WriteData,R0[22],R1[22],R2[22],R3[22],R4[22],R5[22],R
6[22],R7[22],R8[22],R9[22],R10[22],R11[22],R12[22],R13[22],R14[22],R15[22],R1
6[22],R17[22],R18[22],R19[22],R20[22],R21[22],R22[22],R23[22],R24[22],R25[22]
,R26[22],R27[22],R28[22],R29[22],R30[22],R31[22]);
reg32
gh23(clk,reset,andRW[23],WriteData,R0[23],R1[23],R2[23],R3[23],R4[23],R5[23],R
6[23],R7[23],R8[23],R9[23],R10[23],R11[23],R12[23],R13[23],R14[23],R15[23],R1
6[23],R17[23],R18[23],R19[23],R20[23],R21[23],R22[23],R23[23],R24[23],R25[23]
,R26[23],R27[23],R28[23],R29[23],R30[23],R31[23]);
reg32
gh24(clk,reset,andRW[24],WriteData,R0[24],R1[24],R2[24],R3[24],R4[24],R5[24],R
6[24],R7[24],R8[24],R9[24],R10[24],R11[24],R12[24],R13[24],R14[24],R15[24],R1
6[24],R17[24],R18[24],R19[24],R20[24],R21[24],R22[24],R23[24],R24[24],R25[24]
,R26[24],R27[24],R28[24],R29[24],R30[24],R31[24]);
reg32
gh25(clk,reset,andRW[25],WriteData,R0[25],R1[25],R2[25],R3[25],R4[25],R5[25],R
6[25],R7[25],R8[25],R9[25],R10[25],R11[25],R12[25],R13[25],R14[25],R15[25],R1
6[25],R17[25],R18[25],R19[25],R20[25],R21[25],R22[25],R23[25],R24[25],R25[25]
,R26[25],R27[25],R28[25],R29[25],R30[25],R31[25]);
reg32
gh26(clk,reset,andRW[26],WriteData,R0[26],R1[26],R2[26],R3[26],R4[26],R5[26],R

6[26],R7[26],R8[26],R9[26],R10[26],R11[26],R12[26],R13[26],R14[26],R15[26],R1
6[26],R17[26],R18[26],R19[26],R20[26],R21[26],R22[26],R23[26],R24[26],R25[26]
,R26[26],R27[26],R28[26],R29[26],R30[26],R31[26]);
reg32
gh27(clk,reset,andRW[27],WriteData,R0[27],R1[27],R2[27],R3[27],R4[27],R5[27],R
6[27],R7[27],R8[27],R9[27],R10[27],R11[27],R12[27],R13[27],R14[27],R15[27],R1

Nhóm: Page 10


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

6[27],R17[27],R18[27],R19[27],R20[27],R21[27],R22[27],R23[27],R24[27],R25[27]
,R26[27],R27[27],R28[27],R29[27],R30[27],R31[27]);
reg32
gh28(clk,reset,andRW[28],WriteData,R0[28],R1[28],R2[28],R3[28],R4[28],R5[28],R
6[28],R7[28],R8[28],R9[28],R10[28],R11[28],R12[28],R13[28],R14[28],R15[28],R1
6[28],R17[28],R18[28],R19[28],R20[28],R21[28],R22[28],R23[28],R24[28],R25[28]
,R26[28],R27[28],R28[28],R29[28],R30[28],R31[28]);
reg32
gh29(clk,reset,andRW[29],WriteData,R0[29],R1[29],R2[29],R3[29],R4[29],R5[29],R
6[29],R7[29],R8[29],R9[29],R10[29],R11[29],R12[29],R13[29],R14[29],R15[29],R1
6[29],R17[29],R18[29],R19[29],R20[29],R21[29],R22[29],R23[29],R24[29],R25[29]
,R26[29],R27[29],R28[29],R29[29],R30[29],R31[29]);
reg32
gh30(clk,reset,andRW[30],WriteData,R0[30],R1[30],R2[30],R3[30],R4[30],R5[30],R
6[30],R7[30],R8[30],R9[30],R10[30],R11[30],R12[30],R13[30],R14[30],R15[30],R1
6[30],R17[30],R18[30],R19[30],R20[30],R21[30],R22[30],R23[30],R24[30],R25[30]

,R26[30],R27[30],R28[30],R29[30],R30[30],R31[30]);
reg32
gh31(clk,reset,andRW[31],WriteData,R0[31],R1[31],R2[31],R3[31],R4[31],R5[31],R
6[31],R7[31],R8[31],R9[31],R10[31],R11[31],R12[31],R13[31],R14[31],R15[31],R1
6[31],R17[31],R18[31],R19[31],R20[31],R21[31],R22[31],R23[31],R24[31],R25[31]
,R26[31],R27[31],R28[31],R29[31],R30[31],R31[31]);
// phan read du lieu
mux32_32
doc1(ReadRegister1,ReadData1,R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11,R12,R1
3,R14,R15,R16,R17,R18,R19,R20,R21,R22,R23,R24,R25,R26,R27,R28,R29,R30,R3
1);
mux32_32
doc2(ReadRegister2,ReadData2,R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11,R12,R1
3,R14,R15,R16,R17,R18,R19,R20,R21,R22,R23,R24,R25,R26,R27,R28,R29,R30,R3
1);
endmodule
module reg32 (clk, reset,enable, d_in,
d_out0,d_out1,d_out2,d_out3,d_out4,d_out5,d_out6,d_out7,d_out8,
d_out9,d_out10,d_out11,d_out12,d_out13,d_out14,d_out15,d_out16,d_out17,d_out18
Nhóm: Page 11


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

,d_out19,
d_out20,d_out21,d_out22,d_out23,d_out24,d_out25,d_out26,d_out27,d_out28,d_out2
9,d_out30,d_out31);
input clk, reset,enable;

input [31:0] d_in;
output
d_out0,d_out1,d_out2,d_out3,d_out4,d_out5,d_out6,d_out7,d_out8,
d_out9,d_out10,d_out11,d_out12,d_out13,d_out14,d_out15,d_out16,d_out17,d_out18
,d_out19,
d_out20,d_out21,d_out22,d_out23,d_out24,d_out25,d_out26,d_out27,d_out28,d_out2
9,d_out30,d_out31;
D_FF dff0(d_out0 ,d_in[0] ,reset,clk,enable);
D_FF dff1(d_out1 ,d_in[1] ,reset,clk,enable);
D_FF dff2(d_out2 ,d_in[2] ,reset,clk,enable);
D_FF dff3(d_out3 ,d_in[3] ,reset,clk,enable);
D_FF dff4(d_out4 ,d_in[4] ,reset,clk,enable);
D_FF dff5(d_out5 ,d_in[5] ,reset,clk,enable);
D_FF dff6(d_out6 ,d_in[6] ,reset,clk,enable);
D_FF dff7(d_out7 ,d_in[7] ,reset,clk,enable);
D_FF dff8(d_out8 ,d_in[8] ,reset,clk,enable);
D_FF dff9(d_out9 ,d_in[9] ,reset,clk,enable);
D_FF dff10(d_out10 ,d_in[10] ,reset,clk,enable);
D_FF dff11(d_out11 ,d_in[11] ,reset,clk,enable);
D_FF dff12(d_out12 ,d_in[12] ,reset,clk,enable);
D_FF dff13(d_out13 ,d_in[13] ,reset,clk,enable);
D_FF dff14(d_out14 ,d_in[14] ,reset,clk,enable);
D_FF dff15(d_out15 ,d_in[15] ,reset,clk,enable);
D_FF dff16(d_out16 ,d_in[16] ,reset,clk,enable);
D_FF dff17(d_out17 ,d_in[17] ,reset,clk,enable);
D_FF dff18(d_out18 ,d_in[18] ,reset,clk,enable);
D_FF dff19(d_out19 ,d_in[19] ,reset,clk,enable);
D_FF dff20(d_out20 ,d_in[20] ,reset,clk,enable);
D_FF dff21(d_out21 ,d_in[21] ,reset,clk,enable);
D_FF dff22(d_out22 ,d_in[22] ,reset,clk,enable);

D_FF dff23(d_out23 ,d_in[23] ,reset,clk,enable);
D_FF dff24(d_out24 ,d_in[24] ,reset,clk,enable);
D_FF dff25(d_out25 ,d_in[25] ,reset,clk,enable);
D_FF dff26(d_out26 ,d_in[26] ,reset,clk,enable);
D_FF dff27(d_out27 ,d_in[27] ,reset,clk,enable);
D_FF dff28(d_out28 ,d_in[28] ,reset,clk,enable);
D_FF dff29(d_out29 ,d_in[29] ,reset,clk,enable);
D_FF dff30(d_out30 ,d_in[30] ,reset,clk,enable);
D_FF dff31(d_out31 ,d_in[31] ,reset,clk,enable);
endmodule
module D_FF (q, d, reset, clk,enable);
output q;
Nhóm: Page 12


Đồ án cấu trúc máy tính
input d, reset, clk,enable;
reg q;
wire clock;
and a1(clock,clk,enable);
// Indicate that q is stateholding
initial
q=0;
always @(posedge clock or posedge reset)
if (reset)
q = 0; // On reset, set to 0
else
q = d; // Otherwise out = d endmodule
endmodule
module decoder5_32(x,y,regwrite);

input[4:0] x;
input regwrite;
output[31:0] y;
wire[3:0] en;
decoder2_4 z1(x[4:3],en);
decoder3_8e z2(x[2:0],y[31:24],en[3],regwrite);
decoder3_8e z3(x[2:0],y[23:16],en[2],regwrite);
decoder3_8e z4(x[2:0],y[15:8],en[1],regwrite);
decoder3_8e z5(x[2:0],y[7:0],en[0],regwrite);
endmodule
module mux321(in32,out1,sel);
input[31:0] in32;
input[4:0] sel;
output out1;
wire[3:0] ra;
mux8_1 m0(in32[7:0],ra[0],sel[2:0]);
mux8_1 m1(in32[15:8],ra[1],sel[2:0]);
mux8_1 m2(in32[23:16],ra[2],sel[2:0]);
mux8_1 m3(in32[31:24],ra[3],sel[2:0]);
mux4_1 m4(ra[3:0],out1,sel[4:3]);
endmodule
module mux8_1(in8,out1,se);
input[7:0] in8;
input[2:0] se;
output out1;
wire nse0,nse1,nse2,x0,x1,x2,x3,x4,x5,x6,x7,or1,or2;
not n0(nse0,se[0]),n1(nse1,se[1]),n2(nse2,se[2]);
and va0(x0,in8[0],nse2,nse1,nse0),
va1(x1,in8[1],nse2,nse1,se[0]),
va2(x2,in8[2],nse2,se[1],nse0),

va3(x3,in8[3],nse2,se[1],se[0]),
va4(x4,in8[4],se[2],nse1,nse0),
va5(x5,in8[5],se[2],nse1,se[0]),
Nhóm: Page 13

GVHD: Hồ Viết Việt


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

va6(x6,in8[6],se[2],se[1],nse0),
va7(x7,in8[7],se[2],se[1],se[0]);
or c1(or1,x0,x1,x2,x3),
c2(or2,x4,x5,x6,x7),
c3(out1,or1,or2);
endmodule
module mux4_1(x,y,c);
input[3:0] x;
input[1:0] c;
output y;
wire and1,and2,and3,and4,ca1,ca2;
not d1(ca1,c[1]);
not d2(ca2,c[0]);
and d3(and1,x[0],ca1,ca2);
and d4(and2,x[1],ca1,c[0]);
and d5(and3,x[2],c[1],ca2);
and d6(and4,x[3],c[1],c[0]);
or d7(y,and1,and2,and3,and4);

endmodule
module mux32_32(read,readata,r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,
r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,
r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31);
input[31:0] r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,
r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,
r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31;
input[4:0] read;
output[31:0] readata;
mux321 n0(r0,readata[0],read);
mux321 n1(r1,readata[1],read);
mux321 n2(r2,readata[2],read);
mux321 n3(r3,readata[3],read);
mux321 n4(r4,readata[4],read);
mux321 n5(r5,readata[5],read);
mux321 n6(r6,readata[6],read);
mux321 n7(r7,readata[7],read);
mux321 n8(r8,readata[8],read);
mux321 n9(r9,readata[9],read);
mux321 n10(r10,readata[10],read);
mux321 n11(r11,readata[11],read);
mux321 n12(r12,readata[12],read);
mux321 n13(r13,readata[13],read);
mux321 n14(r14,readata[14],read);
mux321 n15(r15,readata[15],read);
mux321 n16(r16,readata[16],read);
mux321 n17(r17,readata[17],read);
mux321 n18(r18,readata[18],read);
mux321 n19(r19,readata[19],read);
Nhóm: Page 14

Đồ án cấu trúc máy tính
mux321 n20(r20,readata[20],read);
mux321 n21(r21,readata[21],read);
mux321 n22(r22,readata[22],read);
mux321 n23(r23,readata[23],read);
mux321 n24(r24,readata[24],read);
mux321 n25(r25,readata[25],read);
mux321 n26(r26,readata[26],read);
mux321 n27(r27,readata[27],read);
mux321 n28(r28,readata[28],read);
mux321 n29(r29,readata[29],read);
mux321 n30(r30,readata[30],read);
mux321 n31(r31,readata[31],read);
endmodule
module decoder2_4(vao2,ra4);
input[1:0] vao2;
output[3:0] ra4;
wire nv1,nv2;
not x1(nv1,vao2[1]), x2(nv2,vao2[0]);
and x3(ra4[0],nv1,nv2);
and x4(ra4[1],nv1,vao2[0]);
and x5(ra4[2],vao2[1],nv2);
and x6(ra4[3],vao2[1],vao2[0]);
endmodule
module decoder3_8e(vao3,ra8,ena,regwrite);
input[2:0] vao3;
input ena,regwrite;
output[7:0] ra8;

wire nv0,nv1,vn2;
not x1(nv0,vao3[0]),
x2(nv1,vao3[1]),
x3(nv2,vao3[2]);
and x4(ra8[0],regwrite,ena,nv2,nv1,nv0),
x5(ra8[1],regwrite,ena,nv2,nv1,vao3[0]),
x6(ra8[2],regwrite,ena,nv2,vao3[1],nv0),
x7(ra8[3],regwrite,ena,nv2,vao3[1],vao3[0]),
x8(ra8[4],regwrite,ena,vao3[2],nv1,nv0),
x9(ra8[5],regwrite,ena,vao3[2],nv1,vao3[0]),
x10(ra8[6],regwrite,ena,vao3[2],vao3[1],nv0),
x11(ra8[7],regwrite,ena,vao3[2],vao3[1],vao3[0]);
endmodule

4. Kết quả mô phỏng

Nhóm: Page 15

GVHD: Hồ Viết Việt


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

Project 2 : MIPS ALU
1. Giới thiệu :
- Trong project này chúng ta xây dựng khối ALU 32 bits với nhiệm vụ thực
hiện các lệnh số học đơn giản như ADD, SUB , XOR , SLT .
- ALU 32 bits được xây dựng từ 32 bộ alu 1 bit

- Đây là khối xử lý mọi công việc tính toán của bộ vi xử lý .
2. Sơ đồ khối :
Bus A

32

32
32 bit ALU
Bus B

Zero

32

Overflow
CarryOut

ALU
Control

Nhóm: Page 16

Output


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

ALU CONTROL LINES

00
01
10
11

FUNCTION
Add
XOR
Sub
SLT

Nguyên lý hoạt động của khối ALU:
- Khối ALU có 2 đầu vào A,B mỗi đầu vào 32 bits.
- Khối ALU sẽ dựa vào 2 bits ALU Control mà sẽ xác định phép toán cần xử lý
Vd: ALU Control = 10 thì sẽ thực hiện phép A – B
- Kết quả các phép toán sẽ được đưa ra ở Output 32 bits
- Ngoài ra còn có các bits cờ :
+ Zero : sẽ bằng 1 khi kết quả ở đầu ra Output = 0 và bằng 0 khi Output
khác 0
+ Overflow : sẽ được set bằng 1 khi thực hiện các phép toán ADD , SUB có
xảy ra tràn.
+ Carryout : sẽ được set bằng 1 trong các phép toán ADD, SUB khi xảy ra có
nhớ ở bits 31
+ Negative : sẽ được set bằng 1 khi kết quả sau khi tính toán là một số âm .
3. Xác định các cờ :
3.1 Xác định cờ Negative :
- Để xác định cờ Negative ta chỉ cần dựa vào bits MSB chính là bits thứ 31 của
output . Nếu bits thứ 31 này bằng 1 thì kết quả là số âm và cờ Negative được
set thành 1 và ngược lại.
3.2 Xác định cờ Zero :

- Để xác định cờ Zero thì ta sẽ OR 32 bits của đầu ra Output nếu kết quả bằng
0 thì cờ Zero được set bằng 1 và nếu khác 0 thì sẽ set bằng 0.
3.3 Xác định cờ Overflow :
- Cờ Overflow chỉ xuất hiện trong các trường hợp sau :

Phép toán
A+B
A+B
A–B
A -- B

A
≥0
<0
≥0
<0

B
≥0
<0
<0
≥0

Kết quả
<0
≥0
<0
≥0

-

Để xác định Overflow ta chỉ cần quan tâm đến cờ nhớ vào Cin và cờ nhớ ra

-

Cout ở bits MSB tức bits thứ 31.
Khi đó cờ Overflow là phép Xor giữa Cin và Cout.

Nhóm: Page 17


Đồ án cấu trúc máy tính

A+B < 0
(-A) + (-B) > 0
A – (-B) < 0
(-A) – B > 0

A
0
1
0
1

GVHD: Hồ Viết Việt

B
0
1
1

0

Binvert
0
0
1
1

Bmux
0
1
0
1

Cin
1
0
1
0

Cout
0
1
0
1

Sum
1
0
1

0

Overflow
1
1
1
1

Cin
1
0

Cout
0
1

Sum
1
0

Overflow
1
1

Bảng thu gọn

A+B < 0
(-A) + (-B) > 0

3.4

A
0
1

B
X
X

Binvert
X
X

Bmux
0
1

 Overflow = ~A*~Bmux*Cin + A*Bmux*~Cin
Cờ Carryout :

- Cờ carryout của bộ ALU 1 bit thứ 31
4. Xác định bits slt :
- Lệnh slt $t1,$t2,$t3
+ Bit slt sẽ được set 1 nếu rs < rt và ngược lại.
+ Do rs < rt => rs – rt < 0 vì vậy bits MSB của Output sẽ bằng 1 , ta dựa vào
đây để mà xác định bits slt .
+ Có 2 trường hợp xảy ra :
Khi không Overflow thì rs –rt < 0 => MSB = 1
Khi có Overflow thì rs – rt < 0
=> MSB = 0

 Vd : 5ten – 6ten = 0101 – 0110 = 0101 + 1010 = 1111 (ok!)
-7ten – 6ten = 1001 – 0110 = 1001 + 1010 = 0011 (overflow!)
=> bit slt= MSB xor Overflow

Bảng thể hiện mối quan hệ giữa Slt và MSB , Overflow

Nhóm: Page 18


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

A

B

Cin

MSB

Overflow

Slt

0

0

0

0

0

0

0

0

1

1

1

0

0

1

0

1

0

1

0

1

1

0

0

0

1

0

0

1

0

1

1

0

1

0

0

0

1

1

0

0

1

1

1

1

1

1

0

1

Bảng Karnaugh

AB

AB

AB

AB

Cin

00

01

11

10

0

0

1

1

1

1

0

0

1

0

 Slt = AB + A*~Cin + B*~Cin

Nhóm: Page 19


Đồ án cấu trúc máy tính
5. ALU 1 bit :
5.1 Carry-Lookaheader

Nhóm: Page 20

GVHD: Hồ Viết Việt


Đồ án cấu trúc máy tính

-

GVHD: Hồ Viết Việt

Sơ đồ trên sử dụng Ripple Carry tức là sử dụng theo kiểu nối tiếp nên sẽ làm
chậm quá trình xử lý tính toán của khối ALU
 Vì vậy ta sẽ sử dụng phương pháp Carry Lookahead sẽ giúp cải thiện quá
trình tính toán vì cờ nhớ Carry được sử dụng theo phương pháp song song
• Ta có bộ cộng full adder 1bit :

Nhóm: Page 21


Đồ án cấu trúc máy tính

–

GVHD: Hồ Viết Việt

Đặt gi = ai bi

pi = a i + bi


c1 = g 0 + p0 • c0
c 2 = g1 + p1 • g 0 + p1 • p 0 • c0
c3 = g 2 + p 2 • g1 + p 2 • p1 • g 0 + p 2 • p1 • p 0 • c 0
……..
c 4 = g 3 + p3 • g 2 + p3 • p 2 • g1 + p3 • p 2 • p1 • g 0 + p3 • p 2 • p1 • p 0 • c0
-

Carry Lookaheader 16 bit xây dựng từ bộ 4 bits .
Vì vậy bộ adder 32 bit của ALU sẽ gồm 2 bộ Carry Lookaheader 16 bits

Nhóm: Page 22


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt
CarryIn

a0
b0
a1
b1
a2
b2
a3
b3

CarryIn
Result0--3
ALU0
P0
G0

pi
gi
Carry-lookahead unit
C1

a4

b4
a5
b5
a6
b6
a7
b7

a8
b8
a9
b9
a10
b10
a11
b11

a12
b12
a13
b13
a14
b14
a15
b15

ci + 1

CarryIn
Result4--7

ALU1
P1
G1

pi + 1
gi + 1
C2

ci + 2

CarryIn
Result8--11
ALU2
P2
G2

pi + 2
gi + 2
C3

ci + 3

CarryIn
Result12--15
ALU3
P3
G3

pi + 3
gi + 3

C4

ci + 4

CarryOut

5.2 Mux 4-1 :
-

Trong bộ Alu 1 bit ta phải sử dụng bộ mux 4-1 để chọn đầu ra của một trong 4 phép
toán add , sub , xor , slt . Bộ mux sẽ dựa vào 2 bit ALU Control mà sẽ xác định đầu
ra

Nhóm: Page 23


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

6. Code :
`timescale 1 ps / 100 fs
module ALUStimulus();
parameter ClockDelay = 50000;
reg [31:0] BussA, BussB;
reg [1:0] ALUControl;
wire [31:0] Output;
wire zero, overflow, CarryOut, negative;
ALU alu1(Output, CarryOut, zero, overflow, negative, BussA, BussB, ALUControl);
initial

begin
$monitor($time, " ALUControl=%b, BussA=%h, BussB=%h, Output=%h, Zero=%b, CarryOut=
%b, Overflow=%b, Negative=%b",
ALUControl,BussA,BussB,Output,zero,CarryOut,overflow,negative);
/* Addition unit testing */
ALUControl=00;
BussA=32'h00000DEF; BussB=32'h00000ABC; // Should output 000018AB
#(ClockDelay);
BussA=32'h00001234; BussB=32'h00000105; // Should output 00001339
#(ClockDelay);
BussA=32'h7FFFFFFF; BussB=32'h00000001; // Should output 80000000, overflow, negative
#(ClockDelay);
BussA=32'hC0000000; BussB=32'h60000000; // output 20000000 , carry
#(ClockDelay);
/* Subtraction unit testing */
ALUControl=10;
BussA=32'h00000DEF; BussB=32'h00000ABC; // Should output 00000333
#(ClockDelay);
BussA=32'h00001234; BussB=32'h00000105; // Should output 0000112F
#(ClockDelay);
BussA=32'h80000000; BussB=32'h00000001; // Should output 7FFFFFFF, overflow
#(ClockDelay);
BussA=32'h00000003; BussB=32'h00000007; // carry , negative , fffffffc
#(ClockDelay);
BussA=32'h0000125A; BussB=32'h0000125A; // output 0 , zero
#(ClockDelay);
BussA=32'h40000000; BussB=32'hA0000000; // Should output A0000000, overflow , carry ,negative
#(ClockDelay);
/* Xor */
ALUControl=01;

BussA=32'h12000042; BussB=32'h51240002; // output 43240040
#(ClockDelay);
BussA=32'h0AB0F04D; BussB=32'h12EC897E; // output 185C7933
#(ClockDelay);
end
endmodule
// ALU
module ALU(Output, CarryOut, zero, overflow, negative, BussA, BussB, ALUControl);
input[31:0]BussA,BussB;
input[1:0] ALUControl;
output[31:0] Output;
output CarryOut, zero, overflow, negative;
wire [15:0] p0,p1,g0,g1;
wire[15:1] ci0,ci1;
wire gnd=0;
wire nega=1;
wire B31mux;
alu_1b f0(BussA[0],BussB[0],ALUControl[1],ALUControl[1],ALUControl,slt,g0[0],p0[0],Output[0]);
alu_1b f1(BussA[1],BussB[1],ALUControl[1],ci0[1],ALUControl,gnd,g0[1],p0[1],Output[1]);
alu_1b f2(BussA[2],BussB[2],ALUControl[1],ci0[2],ALUControl,gnd,g0[2],p0[2],Output[2]);
alu_1b f3(BussA[3],BussB[3],ALUControl[1],ci0[3],ALUControl,gnd,g0[3],p0[3],Output[3]);
alu_1b f4(BussA[4],BussB[4],ALUControl[1],ci0[4],ALUControl,gnd,g0[4],p0[4],Output[4]);
alu_1b f5(BussA[5],BussB[5],ALUControl[1],ci0[5],ALUControl,gnd,g0[5],p0[5],Output[5]);

Nhóm: Page 24


Đồ án cấu trúc máy tính

GVHD: Hồ Viết Việt

alu_1b f6(BussA[6],BussB[6],ALUControl[1],ci0[6],ALUControl,gnd,g0[6],p0[6],Output[6]);
alu_1b f7(BussA[7],BussB[7],ALUControl[1],ci0[7],ALUControl,gnd,g0[7],p0[7],Output[7]);
alu_1b f8(BussA[8],BussB[8],ALUControl[1],ci0[8],ALUControl,gnd,g0[8],p0[8],Output[8]);
alu_1b f9(BussA[9],BussB[9],ALUControl[1],ci0[9],ALUControl,gnd,g0[9],p0[9],Output[9]);
alu_1b f10(BussA[10],BussB[10],ALUControl[1],ci0[10],ALUControl,gnd,g0[10],p0[10],Output[10]);
alu_1b f11(BussA[11],BussB[11],ALUControl[1],ci0[11],ALUControl,gnd,g0[11],p0[11],Output[11]);
alu_1b f12(BussA[12],BussB[12],ALUControl[1],ci0[12],ALUControl,gnd,g0[12],p0[12],Output[12]);
alu_1b f13(BussA[13],BussB[13],ALUControl[1],ci0[13],ALUControl,gnd,g0[13],p0[13],Output[13]);
alu_1b f14(BussA[14],BussB[14],ALUControl[1],ci0[14],ALUControl,gnd,g0[14],p0[14],Output[14]);
alu_1b f15(BussA[15],BussB[15],ALUControl[1],ci0[15],ALUControl,gnd,g0[15],p0[15],Output[15]);
alu_1b f16(BussA[16],BussB[16],ALUControl[1],ci16,ALUControl,gnd,g1[0],p1[0],Output[16]);
alu_1b f17(BussA[17],BussB[17],ALUControl[1],ci1[1],ALUControl,gnd,g1[1],p1[1],Output[17]);
alu_1b f18(BussA[18],BussB[18],ALUControl[1],ci1[2],ALUControl,gnd,g1[2],p1[2],Output[18]);
alu_1b f19(BussA[19],BussB[19],ALUControl[1],ci1[3],ALUControl,gnd,g1[3],p1[3],Output[19]);
alu_1b f20(BussA[20],BussB[20],ALUControl[1],ci1[4],ALUControl,gnd,g1[4],p1[4],Output[20]);
alu_1b f21(BussA[21],BussB[21],ALUControl[1],ci1[5],ALUControl,gnd,g1[5],p1[5],Output[21]);
alu_1b f22(BussA[22],BussB[22],ALUControl[1],ci1[6],ALUControl,gnd,g1[6],p1[6],Output[22]);
alu_1b f23(BussA[23],BussB[23],ALUControl[1],ci1[7],ALUControl,gnd,g1[7],p1[7],Output[23]);
alu_1b f24(BussA[24],BussB[24],ALUControl[1],ci1[8],ALUControl,gnd,g1[8],p1[8],Output[24]);
alu_1b f25(BussA[25],BussB[25],ALUControl[1],ci1[9],ALUControl,gnd,g1[9],p1[9],Output[25]);
alu_1b f26(BussA[26],BussB[26],ALUControl[1],ci1[10],ALUControl,gnd,g1[10],p1[10],Output[26]);
alu_1b f27(BussA[27],BussB[27],ALUControl[1],ci1[11],ALUControl,gnd,g1[11],p1[11],Output[27]);
alu_1b f28(BussA[28],BussB[28],ALUControl[1],ci1[12],ALUControl,gnd,g1[12],p1[12],Output[28]);
alu_1b f29(BussA[29],BussB[29],ALUControl[1],ci1[13],ALUControl,gnd,g1[13],p1[13],Output[29]);
alu_1b f30(BussA[30],BussB[30],ALUControl[1],ci1[14],ALUControl,gnd,g1[14],p1[14],Output[30]);
alu_1b f31(BussA[31],BussB[31],ALUControl[1],ci1[15],ALUControl,gnd,g1[15],p1[15],Output[31]);
// xac dinh cac bit g,p cua 2 bo 16b
calook_16b d1(ALUControl[1],p0,g0,ci0,gg0,pg0);
calook_16b d2(ci16,p1,g1,ci1,gg1,pg1);

// xac dinh carryout
and and0(pre_c16,pg0,ALUControl[1]);
or or0(ci16,pre_c16,gg0); // c1= g0 + p0*c0
and and1(pre_c32_1,pg1,gg0); // c2= g1+ p1*g0 + p1*p0*c0
and and2(pre_c32_2,pg0,pg1,ALUControl[1]);
or or1(carryOut,pre_c32_1,pre_c32_2,gg1);
chonb pl(carryOut,ALUControl[1],CarryOut0);
not an1(notcary,ALUControl[0]); // de loai bo carry trong xor va slt ko can hien thi
and an2(CarryOut,notcary,CarryOut0);
// xac dinh bit slt
chonb q4(BussB[31],ALUControl[1],B31mux);
sslt q1(BussA[31],B31mux,ci1[15],slt);
// xac dinh flag zero
testzero q2(Output,zero);
// xac dinh overflow
oveflows q3(BussA[31],B31mux,ci1[15],overflow0);
and t1(overflow,notcary,overflow0);
// xac dinh negative
and an(negative,Output[31],nega);
endmodule
module alu_1b(a,b,bsel,cin,opcode,slt,g,p,result);
input a,b,bsel,cin,slt;
input[1:0] opcode;
output g,p,result;
wire rxor,bchon;
chonb f1(b,bsel,bchon);
pfa f2(a,bchon,cin,g,p,sum);
xor s(rxor,a,bchon);
mux4_1 f3({slt,sum,rxor,sum},result,opcode);
endmodule

module testzero(result,zeroflag);

Nhóm: Page 25