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

Register 2WriteRegister Read Data 32RegWrite Project 1: MIPS 32 by 32 Register File - Các thanh ghi được xây dựng từ các DFF với kích khởi sườn lên... Giới thiệu : - Trong project này ch

Register 2WriteRegister

Read

Data

32RegWrite

Project 1: MIPS 32 by 32 Register File

- 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

325

5

32

- 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

+ 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

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

2-into-4 decoder

D0D1D2D3

D0D1D2D3

- Để đọ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

reg RegWrite, clk,reset;

wire [31:0] ReadData1, ReadData2;

for (i=0; i<=31; i=i+1)

Code của file thanh ghi:

;

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

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],R19[2],R20[2],R21[2],R22[2],R23[2],R24[2],R25[2],R26[2],R27[2],R28[2],R29[2],R30[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],R19[3],R20[3],R21[3],R22[3],R23[3],R24[3],R25[3],R26[3],R27[3],R28[3],R29[3],R30[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],R19[4],R20[4],R21[4],R22[4],R23[4],R24[4],R25[4],R26[4],R27[4],R28[4],R29[4],R30[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],R19[5],R20[5],R21[5],R22[5],R23[5],R24[5],R25[5],R26[5],R27[5],R28[5],R29[5],R30[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],R19[6],R20[6],R21[6],R22[6],R23[6],R24[6],R25[6],R26[6],R27[6],R28[6],R29[6],R30[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],R19[7],R20[7],R21[7],R22[7],R23[7],R24[7],R25[7],R26[7],R27[7],R28[7],R29[7],R30[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],R19[8],R20[8],R21[8],R22[8],R23[8],R24[8],R25[8],R26[8],R27[8],R28[8],R29[8],R30[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],R19[9],R20[9],R21[9],R22[9],R23[9],R24[9],R25[9],R26[9],R27[9],R28[9],R29[9],R30[9],R31[9]);

reg32

gh10(clk,reset,andRW[10],WriteData,R0[10],R1[10],R2[10],R3[10],R4[10],R5[10],R6[10],R7[10],R8[10],R9[10],R10[10],R11[10],R12[10],R13[10],R14[10],R15[10],R16[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],R6[11],R7[11],R8[11],R9[11],R10[11],R11[11],R12[11],R13[11],R14[11],R15[11],R16[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],R6[12],R7[12],R8[12],R9[12],R10[12],R11[12],R12[12],R13[12],R14[12],R15[12],R16[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],R6[13],R7[13],R8[13],R9[13],R10[13],R11[13],R12[13],R13[13],R14[13],R15[13],R16[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],R6[14],R7[14],R8[14],R9[14],R10[14],R11[14],R12[14],R13[14],R14[14],R15[14],R1

reg32

gh15(clk,reset,andRW[15],WriteData,R0[15],R1[15],R2[15],R3[15],R4[15],R5[15],R6[15],R7[15],R8[15],R9[15],R10[15],R11[15],R12[15],R13[15],R14[15],R15[15],R16[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],R6[16],R7[16],R8[16],R9[16],R10[16],R11[16],R12[16],R13[16],R14[16],R15[16],R16[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],R6[17],R7[17],R8[17],R9[17],R10[17],R11[17],R12[17],R13[17],R14[17],R15[17],R16[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],R6[18],R7[18],R8[18],R9[18],R10[18],R11[18],R12[18],R13[18],R14[18],R15[18],R16[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],R6[19],R7[19],R8[19],R9[19],R10[19],R11[19],R12[19],R13[19],R14[19],R15[19],R16[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],R6[20],R7[20],R8[20],R9[20],R10[20],R11[20],R12[20],R13[20],R14[20],R15[20],R16[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],R6[21],R7[21],R8[21],R9[21],R10[21],R11[21],R12[21],R13[21],R14[21],R15[21],R16[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],R6[22],R7[22],R8[22],R9[22],R10[22],R11[22],R12[22],R13[22],R14[22],R15[22],R16[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],R6[23],R7[23],R8[23],R9[23],R10[23],R11[23],R12[23],R13[23],R14[23],R15[23],R16[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],R6[24],R7[24],R8[24],R9[24],R10[24],R11[24],R12[24],R13[24],R14[24],R15[24],R16[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],R6[25],R7[25],R8[25],R9[25],R10[25],R11[25],R12[25],R13[25],R14[25],R15[25],R16[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],R6[26],R7[26],R8[26],R9[26],R10[26],R11[26],R12[26],R13[26],R14[26],R15[26],R16[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],R6[27],R7[27],R8[27],R9[27],R10[27],R11[27],R12[27],R13[27],R14[27],R15[27],R1

reg32

gh28(clk,reset,andRW[28],WriteData,R0[28],R1[28],R2[28],R3[28],R4[28],R5[28],R6[28],R7[28],R8[28],R9[28],R10[28],R11[28],R12[28],R13[28],R14[28],R15[28],R16[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],R6[29],R7[29],R8[29],R9[29],R10[29],R11[29],R12[29],R13[29],R14[29],R15[29],R16[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],R6[30],R7[30],R8[30],R9[30],R10[30],R11[30],R12[30],R13[30],R14[30],R15[30],R16[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],R6[31],R7[31],R8[31],R9[31],R10[31],R11[31],R12[31],R13[31],R14[31],R15[31],R16[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,R13,R14,R15,R16,R17,R18,R19,R20,R21,R22,R23,R24,R25,R26,R27,R28,R29,R30,R31);

mux32_32

doc2(ReadRegister2,ReadData2,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);

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,d_out19,

d_out20,d_out21,d_out22,d_out23,d_out24,d_out25,d_out26,d_out27,d_out28,d_out29,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_out29,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);

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 :

32 bit ALU 32

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.

- Khi đó cờ Overflow là phép Xor giữa Cin và Cout.

+ 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 : 5 ten – 6 ten = 0101 – 0110 = 0101 + 1010 = 1111 (ok!)

-7 ten – 6 ten = 1001 – 0110 = 1001 + 1010 = 0011 (overflow!)

=> bit slt= MSB xor Overflow

- 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 :

0 0 1 2 0 1 2 1 2 2 3

0 0 1 0 1 1 2

0 0 0 1

c p p p p g p p p g p p g p g c

c p p p g p p g p g c

c p p g p g c

c p g c

……

- 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

CarryIn

Result0 3 ALU0

CarryIn

Result4 7 ALU1

CarryIn

Result8 11 ALU2

CarryIn

CarryOut

Result12 15 ALU3

P1 G1

P2 G2

P3 G3

a4 b4 a5 b5 a6 b6 a7 b7

a8 b8 a9 b9 a10 b10 a11 b11

a12 b12 a13 b13 a14 b14 a15 b15

Carry-lookahead unit

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