Embed Size (px)
Citation preview
TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI
VIỆN ĐIỆN TỬ - VIỄN THÔNG
BÁO CÁO BÀI TẬP LỚN KIẾN TRÚC MÁY TÍNH
THIẾT KẾ MIPS PIPELINE
GIẢNG VIÊN HƯỚNG DẪN: TS. NGUYỄN ĐỨC MINH
NHÓM SINH VIÊN
Đặng Văn Quân ĐT2 - K54 20092109
Lê Minh Thao ĐT5 - K54 20092399
Nguyễn Văn Hưng ĐT11 - K54 20091384
Nguyễn Văn Huấn ĐT2 - K54 20092165
Nguyễn Thị Mai Trang ĐT4 - K54 20092812
HÀ NỘI 11/2012
MỤC LỤC
TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI .................................................................................................. 1
MỤC LỤC ........................................................................................................................................................ 2
Tài liệu tham khảo …………………………………………………………………. 49Phần 1: Giới thiệu ý tưởng và
xác định chỉ tiêu kỹ thuật của kiến trúc MIPS Pepiline ....................................................................................... 3
1.1Phân tích nhu cầu và đặc điểm nổi bật trong kiến trúc MIPS Pipeline ............................................................... 3
1.1.1.Giới thiệu chung về kiến trúc MIPS- nhu cầu cần thiết cho sự ra đời của kiến trúc MIPS pipeline ........... 3
1.1.2.Đặc điểm nổi bật-nguyên tắc thiết kế trong kiến trúc MIPS pipeline ......................................................... 3
1.1.3.Lên ý tưởng cho đề tài ................................................................................................................................. 4
1.2Các sản phẩm đã có trên thị trường (Các công trình bài báo nghiên cứu đã có và có liên quan) ........................ 4
1.2.1.R2000 .......................................................................................................................................................... 4
1.2.2.R3000 .......................................................................................................................................................... 4
1.2.3.R4000 .......................................................................................................................................................... 4
1.2.4.R8000( 1994) .............................................................................................................................................. 4
1.2.5.R10000 (1995) ............................................................................................................................................ 4
1.2.6.Các sản phẩm hiện tại trên thị trường ......................................................................................................... 4
1.3Các chỉ tiêu kỹ thuật của sản phẩm ..................................................................................................................... 5
1.3.1.Chức năng sản phẩm ................................................................................................................................... 6
1.3.2.Chỉ tiêu kỹ thuật của sản phẩm. .................................................................................................................. 6
1.3.3.Thông số đầu vào,ra .................................................................................................................................... 6
1.3.4.Các yêu cầu phi chức năng .......................................................................................................................... 9
Phần 2.Phân tích chức năng và lập kế hoạch .................................................................................................... 10
2.1Phân chia chức năng ......................................................................................................................................... 10
2.1.1.Chức năng khối Instruction Memory ........................................................................................................ 10
2.1.2.Chức năng khối Register File .................................................................................................................... 10
2.1.3.Chức năng khối ALU và ALU control ...................................................................................................... 11
2.1.4.Chức năng khối Control Unit .................................................................................................................... 12
2.1.5.Chức năng khối Data Memory .................................................................................................................. 18
2.1.6.Kỹ thuật pipeline và xử lý xung đột .......................................................................................................... 18
2.1.7.Các khối chức năng khác .......................................................................................................................... 20
2.2Lập kế hoạch ..................................................................................................................................................... 20
Phần 3.Lựa chọn phương án kỹ thuật ............................................................................................................... 21
3.1Sơ đồ khối của sản phẩm .................................................................................................................................. 21
3.2Kiến trúc thiết kế ............................................................................................................................................... 22
Phần 4.Thiết kế mạch ...................................................................................................................................... 24
4.1Bộ đếm chương trình PC .................................................................................................................................. 24
4.2Bộ nhớ lệnh ....................................................................................................................................................... 24
4.3Register File ...................................................................................................................................................... 24
4.4Bộ nhớ dữ liệu .................................................................................................................................................. 26
4.5Xây dựng Datapath cho lệnh loại R .................................................................................................................. 26
4.6Khối điều khiển(CU)......................................................................................................................................... 29
4.7Khối xử lý xung đột (Hazard Unit). .................................................................................................................. 30
4.7.1.Khối chuyển tiếp dữ liệu ........................................................................................................................... 30
4.7.2.Điều khiển thanh ghi Pipeline ................................................................................................................... 30
Phần 5.Kết quả tổng hợp và mô phỏng ............................................................................................................. 33
5.1Kết quả tổng hợp từ Quartus ............................................................................................................................. 33
5.2Kết quả mô phỏng sử dụng Modelsim .............................................................................................................. 33
Kết quả mô phỏng trên Modelsim.......................................................................................................................... 35
Tài liệu tham khảo ………………………………………………………………….
49Phần 1: Giới thiệu ý tưởng và xác định chỉ tiêu kỹ thuật
của kiến trúc MIPS Pepiline
Phân tích nhu cầu và đặc điểm nổi bật trong kiến trúc MIPS Pipeline
Giới thiệu chung về kiến trúc MIPS- nhu cầu cần thiết cho sự ra đời của kiến trúc MIPS
pipeline
MIPS : Microprocessor without Interlocked Pipeline Stage là một kiến trúc vi xử lý
được phát triển bởi hãng MIPS Technologies và là kiến trúc chiếm đến 1/3 số lượng
chip sản xuất trên nền kiến trúc RISC.
Bộ xử lí MIPS đầu tiên được nghiên cứu vào năm 1981 với mục đích cơ bản là nhằm
tăng đột xuất hiệu năng thông qua sử dụng một đường ống lệnh ( pileline
instructions). Thiết kế theo pipeline làm giảm đáng kể thời gian rảnh rỗi của CPU
khi thực hiện liên tiếp các câu lệnh.
Khó khăn trong quá trình tìm hiểu thiết kế: theo phương pháp đường ống lệnh nó
yêu cầu một khóa đồng bộ (interlocks) được cài đặt để chắc chắn rằng các câu lệnh
chiếm nhiều chu kì đồng hồ để thực hiện sẽ dừng đường ống lại để nạp nhiều dữ
liệu hơn. Những khóa đồng bộ này cần một thời gian lớn để cài đặt và được cho là
rào cản chính trong việc tăng tốc độ xử lí trong tương lai.
Yêu cầu đặt ra trong quá trình thiết kế: yêu cầu tất cả các câu lệnh phải được hoàn
thành trong 1 chu kì xung nhịp nhờ thế lạo bỏ được sự cần thiết của khóa đồng bộ.
Thiết kế này đã loại bỏ được một số câu lệnh hữu dụng, đáng kể nhất là các lệnh
nhân, chia yêu cầu nhiều bước nhưng nó cho thấy hiệu suất tổng thể của hệ thống
tăng lên rõ rệt vì các vi xử lý có thể chạy ở xung nhịp lớn hơn rất nhiều.
Lịch sử phát triển sau đó:
Thiết kế đầu tiên ra đời vào năm 1985: R2000 sau đó phát triển tiếp R3000
vào năm 1998. Những CPU 32bit này tồn tại trong suốt những năm 1980 và
được sử dụng chủ yếu trong các dòng máy chủ SGI.
Năm 1991 MIPS cho ra đời bộ vi xử lý 64 bit đầu tiên R4000
Đặc điểm nổi bật-nguyên tắc thiết kế trong kiến trúc MIPS pipeline
Tính đơn giản quan trọng hơn tính quy tắc (Simplicity favors regularity)
Chỉ thị kích thước cố định (32bit)
Ít định dạng chỉ thị (3 loại định dạng)
Mã lệnh ở vị trí cố định (6 bit đầu)
Nhỏ hơn thì nhanh hơn
Số chỉ thị giới hạn
Số thanh ghi giới hạn
Số chế độ địa chỉ giói hạn
Tăng tốc trong các trường hợp thông dụng
Các toán hạng số học lấy từ thanh ghi ( máy tính dựa trên cơ chế load-store)
Các chỉ thị có thể chứa toán hạng trực tiếp
Thiết kế đòi hỏi sự thỏa hiệp
Ba loại chỉ thị định dạng
Nguyên tắc hoạt động của Pipeline
Chia nhỏ các lệnh thành các giai đoạn đường ống
Bắt đầu lệnh tiếp theo trước khi lệnh hiện tại kết thúc.
Lên ý tưởng cho đề tài
Mục đích là thiết kế một chip MIPS pipeline bằng ngôn ngữ mô tả Verilog HDL.
Lý do chọ đề tài: nhận thấy được sự cần thiết và phát triển ngày càng nhanh của hệ
thống xử lý đặt ra ngày càng cao trong quá trình thiết kế được tối ưu nhất, nhanh
nhất, Verilog HDL là một ngôn ngữ mô tả phần cứng linh hoạt, dễ làm và dễ mô
phỏng.
Các sản phẩm đã có trên thị trường (Các công trình bài báo nghiên cứu đã có và có liên
quan)
Sau khi MIPS cho ra đời bộ vi xử lý 64 bit đầu tiên R4000 vào năm 1991, MIPS đã
gặp khó khăn về tài chính trong khi tung sản phẩm này ra thị trường. Thiết kế này rất quan
trọng đối với SGI-một trong những khách hàng của MIPS lúc bấy giờ, vì thế SGI đã mua
lại công ty vào năm 1992 để bảo vệ thiết kế không bị mất đi. Từ đó MIPS trở thành một
công ty con của SGI và được biết đến bởi tên MIPS Technologies.
Các dòng vi xử lý thương mại MIPS đã được sản xuất:
R2000
Xuất hiện trên thị trường vào năm 1985, được bổ sung thêm nhiều câu lệnh mới, có
thể được khởi tạo ở chế độ big-endian hay little-endian, có 32 thanh ghi 32 bit, nhưng
không có thanh ghi mã điều kiện. R2000 cũng hỗ trợ tới 4 bộ xử lý, một trong số đó đảm
nhiệm việc xử lý các ngoại lệ và bẫy trong khi ba chiếc còn lại sử dụng cho các mục đích
khác. Điều này được hỗ trợ trong R2010 FTU - bộ xử lý có 32 thanh ghi 32 bit có thể được
sử dụng như là 16 thanh ghi 64 bit cho kết quả chính xác gấp đôi.
R3000
Theo sau R2000 vào năm 1998, nó bổ sung thêm 32kB Cache (và sớm được tăng
lên 64kB) cho các lệnh và dữ liệu, kèm theo đó là cơ chế cache coherency hỗ trợ cho nhiều
bộ xử lý. R3000 cũng bao gồm MMU - một tính năng phổ biến của CPUs kỷ nguyên này.
R3000 trở thành thiết kế MIPS đầu tiên thành công trong lĩnh vực thương mại. R3000A
được sử dụng cực kỳ thành công trong các máy Sony PlayStation, chạy với tốc độ 40 MHz,
truyền thông tin ở tốc độ 32 câu lệnh trong 1 giây. R3000 cũng đi kèm với R3100 FTU
trong cùng một chip đơn. Các hãng khác cũng tham gia sản xuất như Pacemips với R3400,
IDT với R3500. R3900 của Toshiba là chíp đầu tiên dạng SoC (System on a Chip) được
sử dụng trong các máy tính cá nhân cầm tay sử dụng hệ điều hành Windows CE.
R4000
Được đưa ra vào năm 1991, mở rộng tập lệnh MIPS để hỗ trợ đầy đủ kiến trúc 64
bit, chuyển FTU vào main để tạo ra một hệ thống chip đơn lẻ (Single-chip system), xử lý
với tốc độ lên tới 100Mhz, tuy nhiên để đạt được tốc độ này bộ nhớ đệm phải bị giảm
xuống còn 8kB và cần 3 chu kỳ để truy cập. Tần số xử lý cao đạt được nhờ việclưu trữ
thông qua công nghệ đường ống sâu (deep pipelining – hay còn gọi là super-pipelining tại
thời điểm đó). 1993 R4400 xuất hiện với 16kB cache, bộ xử lý 64 bit lớn và 1 bộ điều khiển
cache mở rộng lên tới 1MB (cahe level 2). Ngoài ra còn các họ R4200, R4300, VR4300,
R4300i, R4600 “Orion”, R4700 “Orion”, R5650, R5000, R5000FTU, RM7000,
RM9000...Các bộ xử lý này được sử dụng rất rộng rãi : Các máy Nitendo 64, Cisco routers,
WebTV set-top Box (Hiện nay là Micrisoft TV)…
R8000( 1994)
Là thiết kế MIPS siêu vô hướng (superscala) đầu tiên, cho phép xử lý 2 ALU và 2
phép tính nhớ mỗi chu kỳ. Thiết kế này mở rộng tới 6 chip, hỗ trợ 4MB cache mở rộng.
R10000 (1995)
Là một thiết kế chip đơn lẻ, chạy ở tốc độ cao hơn R8000, có 32kB cache chính cho
các câu lệnh và dữ liệu. Các thiết kế tiếp theo của R1000 là R12000 và R14000 với hỗ trợ
DDR SRAM trong cache và tốc độ lên tới 200 MHz. Ngoài ra còn các thiết kế R16000,
R16000A, R6000.
Hình 1.1: Thiết kế R10000 (1995)
Các sản phẩm hiện tại trên thị trường
MIPS32® 4K® Family
Họ vi xử lý MIPS32® 4K® được thiết kế cho các ứng dụng SoC. Đây là những ứng
dụng yêu cầu các bộ xử lý dễ sử dụng và có hiệu quả sử dụng năng lượng cao. Các
lõi MIPS32® 4K® có khả năng cấu hình và tổng hợp đã được sử dụng trong hàng
trăm hệ thống SoC.
Tính năng:
Thực hiện kỹ thuật đường ống 5 giai đoạn
Đường dữ liệu và địa chỉ 32 bit
Thực hiện kiến trúc tập lệnh tương thích như MIPS32
Có thể thực hiện lệnh ở một trong hai chế độ: đơn xung nhịp hoặc đa xung
nhịp
Cho phép người dùng định nghĩa và thêm các lệnh trong quá trình thiết kế
Tần số hoạt động tối thiểu: 0MHz
Có chế độ hoạt động ở mode tiết kiệm năng lượng
Có các bộ chia clock được điều khiển bằng phần mềm
Giá trên thị trường: $150USD
MIPS32® M4K™ Core
MIPS32® M4K™ Core có hiệu năng cao, có nhiều tính năng cho các ứng dụng thời
gian thực, các ứng dụng hệ thống nhúng như là vi điều khiển, các hệ thống điều
khiển công nghiệp, mạng không dây, ô tô và các thiết bị lưu trữ.
Với rất nhiều tính năng có thể cấu hình và tùy chọn bởi người dùng cho phép người
thiết kế tối ưu được hiệu năng của bộ xử lý , giảm kích thước và năng lượng tiêu
thụ.
Tính năng:
Thực hiện kỹ thuật đường ống 5 giai đoạn, có khả năng hoạt động trên
400MHz
Gồm 32 thanh ghi đa năng
Tương thích hoàn toàn với MIPS32
Thực hiện kiến trúc tập lệnh của MIPS32
Có thể hoạt động ở 2 chế độ: đơn xung nhịp hoặc đa xung nhịp
Có bộ chia clock được điều khiển bằng phần mềm
Các chỉ tiêu kỹ thuật của sản phẩm
Như ta đã biết, các bộ xử lí sẽ chỉ xử lí được tập các lệnh thuộc về kiến trúc bộ lệnh
của nó (tức là các lệnh đã được định sẵn trong bộ xử lí đó). Vì thế các hệ thống nhúng và
một số loại siêu máy tính thuộc về kiến trúc bộ lệnh MIPS thì chỉ có thể thực hiện các
chương trình thuộc kiến trúc bộ lệnh này (tức là chỉ thực thi được các chương trình viết
bằng bộ lệnh MIPS). Đó là lí do chúng ta cần nghiên cứu về MIPS.
Đến năm 1995 thì MIPS10000 ra đời đã mang lại thành công lớn cho sự phát triển
về công nghệ MIPS.Trong khuôn khổ của đề tài này, chúng ta hi vọng đạt được một cái
nhìn tổng quát nhất về kiến trúc MIPS để từ đó phát triển hơn. Nên sản phẩm tạo ra chỉ
mang những chức năng cơ bản nhất của MIPS.
Chức năng sản phẩm
Mục đích của bản thiết kế, nhằm tạo ra một bộ xử lý MIPS, nhằm tăng đột xuất hiệu
năng thông qua sử dụng đường ống lệnh (pipeline instructions). Thiết kế pipeline làm giảm
đáng kể thời gian rảnh rỗi của CPU khi thực hiện liên tiếp các câu lệnh. Bộ xử lý này chỉ
có khả năngthực hiện được một số lệnh cơ bản.
Kiến trúc tập lệnh này hộ trợ thực hiện:
Các phép toán số học: cộng, trừ, nhân…
Truy cập bộ nhớ với 2 chỉ thị: lw, sw.
Lưu trữ, đọc và ghi byte dữ liệu
Lệnh dịch, logic số học, nhảy (có điều kiện và không có điều kiện).
Chỉ tiêu kỹ thuật của sản phẩm.
Tần số clock 200MHz
Hiệu năng:
Tiêu thụ năng lượng:
Kích thước core:
Sau khi thiết kế xong bộ xử lý MIPS, để kiểm tra xem nó có đạt các chức năng đã
đặt ra, chúng ta tiến hành chạy mô phỏng bằng phần mềm của Altera (Quartus,
Moldemsim) với các thông số đầu vào ra cụ thể như sau:
Thông số đầu vào,ra
Thông số Ý nghĩa
Input clk Tín hiệu đồng hồ hệ thống
reset Tín hiệu reset không đồng bộ
instruction Mã lệnh
readData Dữ liệu vào
Output writeData Dữ liệu ra
aluOut Dữ liệu ra của khối ALU
selectWidth Chọn số bit của dữ liệu đọc và ghi
PC Địa chỉ lệnh tiếp theo
memWrite Tín hiệu Write Enable
memRead Tín hiệu Read Enable
Sơ đồ cấu trúc bản thiết kế
Sơ đồ chung
Hình 1.2: Sơ đồ tổng quát MIPS pipeline
Phân tích các thành phần cấu tạo.
Khác với chip Single-cycle khi các lệnh đều được thực hiện xong trong một chu kì máy,
chip pipeline chia một câu lệnh ra thành 5 bước (steps):
Nạp lệnh và cập nhập giá trị PC (Instruction Fetch – IF)
Đọc thanh ghi và giải mã lệnh ( Intruction Decode – ID)
Thực hiện lệnhR, tính địa chỉ bộ nhớ(Execution – EX)
Đọc hoặc ghi dữ liệu trên bộ nhớ dữ liệu (Memory access –MEM)
Ghi kết quả vào tệp thanh ghi (Write back – WB)
Câu lệnh sau không cần đợi câu lệnh trước hoàn tất mới bắt đầu thực hiện mà mỗi step
sẽ được thực hiện liên tiếp, do đó cải thiện đáng kể về tốc độ thực hiện các chương trình
Các bước thực hiện một câu lệnh:
Đọc lệnh từ bộ nhớ ( Instruction Fetch – IF)
Sử dụng địa chỉ lưu trong thanh ghi PC để giải mã ra mã máy của câu lệnh
tiếp theo và lưu vào thanh ghi trung gian IF/ID.
Giá trị PC được cộng thêm 4 và lưu vào thanh ghi trung gian IF/ID
Giải mã lệnh và đọc các thanh ghi (Intruction Decode – ID)
Sử dụng mã máy của câu lệnh lưu trong thanh ghi IF/ID làm đầu vào cho
khối Regfile
Khối Control sử dụng phần opcode của mã máy của câu lệnh để giải mã thành
các tín hiệu điều khiển, ngoài tín hiệu SignEx được sử dụng cho khối mở rộng,
các tín hiệu khác được lưu vào thanh ghi trung gian ID/EX
Đọc các thanh ghi Rs, Rt từ bộ thanh ghi và lưu vào thanh ghi trung gian
ID/EX
Khối mở rộng sử dụng tín hiệu SignEx từ khối Control để mở rộng dấu hay
mở rộng zero của 16 bit thấp của mã máy thành 32 bit và lưu vào thanh ghi
ID/EX
Địa chỉ các thanh ghi Rs, Rt, Rd được lưu vào thanh ghi ID/EX
Tính toán kết quả của câu lệnh hoặc địa chỉ (Execution – EX)
Khối ALU sử dụng các đầu vào đã được lưu trong thanh ghi ID/EX để tính
toán và lưu kết quả vào thanh ghi trung gian EX/MEM
Một bộ mux được dùng để lựa chọn thanh ghi đích từ 2 thanh ghi Rt, Rd và
lưu địa chỉ vào thanh ghi EX/MEM
Địa chỉ mới của PC sau câu lệnh BNE cũng được tính toán trong khối này.
Một số bộ mux được dùng để lựa chọn giá trị mới cho PC từ các câu lệnh rẽ
nhánh BNE, J, JR.
Các tín hiệu điều khiển MemWrite, MemtoReg và RegWrite được lưu tiếp
vào thanh ghi EX/MEM
Đọc hoặc ghi dữ liệu trên bộ nhớ dữ liệu ( Memory access – MEM)
Sử dụng kết quả tính toán từ khối ALU và tín hiệu điều khiển MemWrite từ
thanh ghi EX/MEM để thực hiện đọc hoặc ghi vào bộ nhớ dữ liệu. Kết quả đọc
ghi vào thanh ghi trung gian MEM/WB.
Các giá trị đầu ra của ALU, địa chỉ thanh ghi đích cùng với 2 tín hiệu điều
khiển MemtoReg và RegWrite được ghi lại vào thanh ghi MEM/WB
Ghi kết quả vào thanh ghi ( Write back – WB)
Sử dụng tín hiệu MemtoReg từ thanh ghi MEM/WB để lựa chọn dữ liệu cần
ghi vào thanh ghi.
Sử dụng địa chỉ thanh ghi đích và tín hiệu cho phép ghi RegWrite để thực
hiện công việc ghi dữ liệu vào bộ thanh ghi.
Thiết kế các thanh ghi pipeline
Hình 1.3: ????
Ta sử dụng các thanh ghi pipeline làm trung gian lưu kết quả thực hiện của mỗi khối
trong mỗi chu kỳ để làm đầu vào cho các khối sau trong chu kì tiếp theo.
Có 4 thanh ghi pipelined nằm giữa các khối:
Thanh ghi IF/ID: dùng để lưu các giá trị PC+4 và mã máy của câu lệnh
Thanh ghi ID/EX: dùng để lưu các giá trị PC+4, địa chỉ của lệnh Jump, 2 giá
trị đọc ra từ bộ thanh ghi. Giá trị mở rộng 32bits từ 16bits. Địa chỉ các thanh ghi
Rs,Rt,Rd. Các tín hiệu điều khiển từ khối Control: ALUOp, ALUSrc, RegDst,
Branch, Jump, MemWrite, MemRead, RegWrite, MemtoReg.
Thanh ghi EX/MEM: Dùng để lưu các giá trị: Kết quả tính toán của khối
ALU, giá trị dùng để ghi vào bộ nhớ file các thanh ghi, địa chỉ của thanh ghi
đích. Các tín hiệu điều khiển: MemWrite, RegWrite, MemtoReg.
Thanh ghi MEM/WB: Để lưu các giá trị : Giá trị được đọc ra từ bộ nhớ dữ
liệu, kết quả của khối ALU, địa chỉ thanh ghi đích.
Các tín hiệu điều khiển được xác định trong giai đoạn giải mã và được lưu trong các
thanh ghi trạng tháigiữa các giai đoạn pipeline.
Thanh ghi trạng thái, phần mở rộng của
thanh ghi ID/EX. Đầu vào lấy tín hiệu
điều khiển từ khối Control Unit, đầu ra
đưa vào thanh ghi trạng thái trong phần
mở rộng của thanh ghi EX/MEM
Thanh ghi trạng thái, phần mở rộng của
thanh ghi EX/MEM
Thanh ghi trạng thái phần mở rộng của
thanh ghi MEM/WB. Với tín hiệu đầu
ra RegWriteW làm tín hiệu điều khiển
cho khối Register File và MemtoRegW
làm tín hiệu điều khiển cho bộ MUX
lấy tín hiệu WriteBack
Các yêu cầu phi chức năng
Bộ xử lý MIPS sau khi được thiết kế không chỉ đạt những chức năng kĩ thuật mà cần
đạt yêu cầu phi chức năng như sau:
Dễ sử dụng trong việc mô phỏng
Đáp ứng được các câu lệnh cơ bản
Dễ dàng nâng cấp và sửa lỗi khi cần thiết.
Giá thành hợp lý
MIPS hoạt động ổn định và có độ tin cậy cao
Năng lượng tiêu thụ thấp
Tuy nhiên trong khuôn khổ của bài tập lớn này, chúng em chỉ dừng lại ở việc nghiên
cứu và mô tả kiến trúc của bộ xử lý MIPS, không đặt vấn đề giá thành làm một tiêu chí
đánh giá.
Phân tích chức năng và lập kế hoạch
Phân chia chức năng
Trong quá trình thiết kế, MIPS được chia thành các khối, cụ thể chức năng và phân chia
các khối như sau:
Hình 2.. Sơ đồ các khối chức năng của MIPS
Chức năng khối Instruction Memory
Dùng để lưu trữ lệnh dưới dạng mã máy (nhị phân).
Kích thước mỗi lệnh khi dịch ra mã máy là 32 bits, tốn 32 bits để lưu trữ.
Đầu vào bộ nhớ lệnh là địa chỉ lệnh cần lấy, đầu ra là mã máy của câu lệnh tương
ứng lấy được.
Hình 2.2: Khối Instruction Memory
Khối bộ nhớ lệnh Instruction Mem chỉ có
một cổng đọc , khối này nhận một đầu vào
địa chỉ 32 bit A và đầu ra là dữ liệu RD 32
bit (dữ liệu ở đây là lệnh của chương trình).
Khối MUX 2-1, thực hiện chức năng chon
tín hiệu đầu vào cho bộ đếm chương trình
PC
Khối tăng PC, để đếm địa chỉ trong quá
trình nạp lệnh
Đầu vào của bộ nhớ lệnh chính là đầu ra
của bộ đếm chương trình Program Counter
PC. Bộ đếm chương trình là một thanh ghi
32 bit, đầu ra của khối này PCF trỏ tới lệnh
hiện tại. Đầu vào PC’ là địa chỉ của lệnh
tiếp theo cần thực thi.
Khối Data Mem có một cổng đọc hoặc ghi. Nếu tín hiệu cho phép ghi WE=1 thì dữ
liệu WD sẽ được viết vào bộ nhớ dữ liệu tại địa chỉ tương ứng A tại sườn lên của
xung clock. Nếu WE =0 dữ liệu sẽ được đọc ra RD.
Chức năng khối Register File
Hình 2.3: Register File
Tệp thanh ghi fie gồm 32 thanh ghi, mỗi thanh ghi 32 bit. Khối này có 2 cổng đọc
và 1 cổng ghi. Hai cổng đọc nhận các đầu vào địa chỉ 5 bit (ứng với 32 thanh ghi)
A1, A2. Đầu ra là dữ liệu RD1, RD2 tương ứng với các đầu vào địa chỉ A1, A2.
Cổng ghi nhận đầu vào địa chỉ A3 (5 bit ) và đầu vào của dữ liệu cần ghi 32 bit
WD3.
Ngoài ra còn có các tín hiệu clock và đầu vào cho phép ghi Write Enable WE. Nếu
tín hiệu WE ở mức cao 1, dữ liệu WD3 sẽ được ghi vào trong thanh ghi file tương
ứng tại sườn lên của xung clock.
Chức năng khối ALU và ALU control
Hình 2.4: ALU
Khối ALU có 2 đầu vào là các toán hạng SrcA và SrcB 32 bit, một đầu ra
ALUResult 32 bit. Ngoài ra ALU còn có một đầu vào điều khiển ALUControl 4 bit
để xác định các phép toán cần thực hiện.
ALUControl ALU Operation
0000 AND
0001 OR
0010 ADD
0011 XOR
0100 NOR
0101 Not use
0110 SUB
0111 SLT
1000 SLL
1001 SRL
1010 SRA
1011…1111 Not use
Hình 2.5: Datapath khi thực hiện lệnh loại R
ALU nhận dữ liệu từ các đầu ra của thanh ghi file hoặc ngay trong mã lệnh.
Chức năng khối Control Unit
Hình 2.6: Control Unit
Khối điều khiển CU tính toán các tín hiệu điều khiển dựa trên các trường opcode
Instr[31-26] và funct Instr[5-0] của lệnh.
Hầu hết các tín hiệu điều khiển nằm ở trường opcode, tuy nhiên các lệnh loại R phải
sử dụng thêm trường funct để xác định các phép toán ALU.
Như trên hình vẽ, khối Control Unit tính toán hầu hết các tín hiệu điều khiển
như:MemtoRegD,MemWriteD,BranchD,ALUSrcD,RegDstD,RegWriteD,MemRe
adD, ALUSelectShilfD, ALUControlD. Tất cả các tín hiệu điều khiển này được đưa
vào thanh ghi trạng thái.
Khối ALU Decoder sử dụng trường Funct[5-0] và 2 bit Op để tính toán
ALUControl.
Mã hóa ALUOp:
ALUO
p
Ý nghĩa
000 Add
001 Subtract
010 Look at func field
011 And
100 Or
101 Xor
110 Not use
111 Set less than
Bảng sự thật của khối ALUDecoder:
ALUO
p
Funct ALUControl Jr ALUSelectShift
000 X 0010 (add) 0 0
001 X 0110 (subtract) 0 0
011 X 0000 (and) 0 0
100 X 0001 (or) 0 0
101 X 0011 (xor) 0 0
110 X X 0 0
111 X 0111 (slt) 0 0
010 100000 0010 (add) 0 0
010 100010 0110 (subtract) 0 0
010 100100 0000 (and) 0 0
010 100101 0001 (or) 0 0
010 100110 0011 (xor) 0 0
010 100111 0100 (nor) 0 0
010 101010 0111 (slt) 0 0
010 000000 1000 (sll) 0 1
010 000010 1001 (srl) 0 1
010 000011 1010 (sra) 0 1
010 001000 0010 (jr) 1 0
Bảng 2.1: Bảng sự thật khối ALUDecoder
Instr R-type lw lb lh sw sb sh beq
Opcode 00000
0
10001
1
10000
0
100001 10101
1
10100
0
10100
1
000100
RegDst 1 0 0 0 x x x x
ALUOp 010 000 000 000 000 000 000 xxx
ALUSrc 0 1 1 1 1 1 1 x
Bne 0 0 0 0 0 0 0 0
Beq 0 0 0 0 0 0 0 1
MemRead 0 1 1 1 0 0 0 X
MemWrit
e
0 0 0 0 1 1 1 0
RegWrite 1 1 1 1 0 0 0 0
Mem2Reg 0 1 1 1 x x x x
Jump 0 0 0 0 0 0 0 0
S xx 10 00 01 10 00 01 xx
Bảng 2.2: Bảng sự thật khối MainDecoder
Instr bne addi andi ori xori slti j jal
Opcode 00010
1
00100
0
00110
0
001101 00111
0
00101
0
00001
0
000011
RegDst x 0 0 0 0 0 x x
ALUOp xxx 000 011 100 101 111 xxx xxx
ALUSrc x 1 1 1 1 1 x x
Bne 1 0 0 0 0 0 0 0
Beq 0 0 0 0 0 0 0 0
MemRead x 0 0 0 0 0 0 0
MemWrit
e
0 0 0 0 0 0 0 0
RegWrite 0 1 1 1 1 1 0 0
Mem2Reg x 0 0 0 0 0 x x
Jump 0 0 0 0 0 0 1 1
S xx xx xx xx xx xx xx xx
Bảng 2.3: Bảng giải sự thật MainDecoder (tiếp)
Chức năng khối Data Memory
Hình 2.7: Data Memory
Kỹ thuật pipeline và xử lý xung đột
Hình 2.8: Khối Hazard unit
Xung đột cấu trúc
Nguyên nhân xảy ra xung đột
Do các lệnh được thực hiện đồng thời, tại cùng 1 chu kì, hai lệnh khác nhau có thể
cùng truy cập đến 1 tài nguyên dẫn đến xung đột. Trong kiến trúc von Neumann,
lệnh và dữ liệu cùng nằm trên 1 bộ nhớ, khi có hai yêu cầu đọc dữ liệu và đọc lệnh
sẽ dẫn đến xung đột.
Xử lý xung đột.
Thêm tài nguyên phần cứng. Với kiến trúc Havard lệnh và dữ liệu được chia thành
hai bộ nhớ và bus khác nhau, do vậy sẽ không xảy ra xung đột cấu trúc.
Xung đột dữ liệu (RAW: read after write)
Nguyên nhân
Khi toán hạng của lệnh sau phụ thuộc vào lệnh trước chưa được hoàn thành sẽ gây
ra việc đọc sai dữ liệu, và gọi là xung đột dữ liệu
Xét đoạn lệnh sau:
Hình 2.9: Xung đột điều khiển
Lệnh add sẽ công nội dung của thanh ghi $s2 và $s3 vào thanh ghi $s0, kết quả được
hoàn thành và lưu vào thanh ghi ở chu kì 5, nhưng tại chu kì 3, lệnh and đã dung
nội dung $s0 làm toán hạng, do vậy kết quả sẽ không như mong muốn. Tương tự
đối với lệnh or.
Giải quyết xung đột:
Có 2 cách để giải quết loại xung đột này là chờ dữ liệu tính xong rồi thực hiện lệnh
kế tiếp, hoặc chuyển dữ liệu sau khi được tính toán ở giai đoạn MEM hoặc WB về
giai đoạn EX.
Phương pháp chờ: phần cứng sẽ phát hiện sự phụ thuộc dữ liệu và dừng những lệnh
nào có dữ liệu phụ thuộc vào lệnh trước đó cho tới khi dữ liệu được sẵn sàng.
Hình2.10: phương pháp dừng chương trình
Phương pháp chuyển tiếp dữ liệu: các lệnh thường được tính toán ở giai đoạn EX
rồi chuyển đến các giai đoạn MEM và WB, do vậy ta có thể chuyển dữ liệu trờ về
giai đoạn EX cho các lệnh phụ thuộc dữ liệu phía sau.
Hình 2.11: Chuyển tiếp dữ liệu
Giải quết xung đột cho lệnh lw
Lệnh lw chỉ tính toán địa chỉ ở giai đoạn đoạn EX, dữ liệu thực sự chỉ có được ở
giai đoạn MEM, do vậy chúng ta không thể chuyển tiếp từ giai đoạn MEM. Yêu
cầu dừng chương trình cần được thực hiện.
Hình 2.12: Dừng chương trình
Xung đột điều khiển
a. Nguyên nhân
Khi thực hiện các lệnh điều khiển chương trình như bne, beq,jr,j… điều kiện nhảy
được tính toán ở giai đoạn EX, nếu điều kiện đúng chương trình sẽ nhảy tới địa chỉ cho
trước, không may thay, các lệnh kế tiếp đã được nạp vào các giai đoạn IF, ID và chương
trình sẽ làm việc không như mong muốn.
b. Giải quyết xung đột
Giải quyết xung đột bằng phương pháp chờ.
VD: xét đoạn chương trình
beq $t1, $t2, 40
and $t0, $s0, $s1
or $t1, $s4, $s0
sub $t2, $s0, $s5
Lệnh beq được tính toán và quết định nhảy ở giai đoạn EX,các lệnh and,or,sub sẽ
phải chờ cho tới khi lệnh beq tính toán xong điều kiện, nếu điều kiện nhảy không
đúng thì chúng mới được nạp vào đường ống. Việc chờ tính toán điều khiển làm
mất 3chu kì, do vậy sẽ làm tăng CPI.
Giải quết xung đột bằng cách tính toán điều kiện nhảy sớm
Chúng ta có thể tính toán điệu kiện nhảy sớm ở giai đoạn ID, việc quết định nhảy
sớm sẽ làm giảm thời gian chờ và tăng hiệu suất.
Các khối chức năng khác
Khối này thực hiện mở rộng bit từ
16bit-> 32bit
Khối dịch trái 2 bit
Lập kế hoạch
Mục Công việc Người thực
hiện Bắt đầu Ngày kết thúc
1 Tìm hiểu yêu cầu và
phân chia công việc Toàn nhóm 01/10 05/10
2 Phân tích hệ thống Toàn nhóm 08/10 12/10
3 Thiết kế Controller Thao 15/10 02/11
4 Thiết kế khối datapath Quân 15/10 02/11
5 Thanh ghi Pipeline và xử
lý Hazard
Hưng, Trang,
Huấn 15/10 02/11
6
Ghép các khối, mô
phỏng và kiểm tra chức
năng toàn bộ
Hưng, Quân 05/11 16/11
Lựa chọn phương án kỹ thuật
Sơ đồ khối của sản phẩm
So sánh đánh giá thiết kế sử dụng kỹ thuật pipeline với các thiết kế khác
So sánh, đánh giá các thiết kế đơn xung nhịp, đa xung nhịp, kỹ thuật pipeline dựa
trên các tiêu chí về tốc độ xung đồng hồ, hiệu quả sử dụng chu kỳ đồng hồ, hiệu năng,diện
tích thiết kế và lưu lượng của bộ xử lý:
Thiết kế đơn xung nhịp (Single Cycle MIPS):
Ưu điểm: Đơn giản và dễ hiểu
Nhược điểm: Sử dụng chu kì đồng hồ không hiệu quả vì chu kì đồng hồ được
đặt theo lệnh chậm nhất.
Tốn diện tích thiết kế vì cần nhân đôi một số khối chức năng (Ví dụ: bộ cộng) vì
chúng không thể được chia sẻ trong cùng một chu kì động hồ.
Hình 3.1: Biểu đồ thời gian thiết kế đơn xung nhịp
Hình 3.2: Datapath thiết kế đơn xung nhịp
Thiết kế đa xung nhịp (Multi-Cycle MIPS): Chia lệnh thành các phần thực hiện IF,
ID, EX, MEM, WB. Mỗi pha thực hiện trong 1 chu kì xung nhịp.
Ưu điểm: Thời gian thực hiện của mỗi lệnh được điều chỉnh tùy thuộc độ
phức tạp của lệnh.
Các khối chức năng được chia sẻ giữa các pha khác nhau của lệnh do một khối chức
năng cụ thể không cần trong toàn bộ các pha thục hiện của lệnh.
Hình 3.3: Biểu đồ thời gian thiết kế đa xung nhịp
Hình 3.4: Datapath thiết kế đa xung nhịp
Thiết kế MIPS dựa trên kỹ thuậtpipeline
Hình 3.5: Sơ đồ khối thiết kế MIPS pipeline
Thiết kế MIPS dựa trên kỹ thuật pipeline (Kỹ thuật đường ống) là phương pháp kết
hợp ưu điểm của hai phương pháp trên:
Quy tắc:
Chia việc thực hiện lệnh thành 5 giai đoạn, tại một thời điêm bất kỳ thực hiện
tất cả các giai đoạn nhưng của các lệnh khác nhau.
Thực hiện lệnh tiếp theo trước khi lệnh hiện tại kết thúc
Chu kỳ đồng hồ quyết định bởi giai đoạn thực hiện lệnh chậm nhất
Với một số lệnh có chu kỳ lãng phí nhưng vẫn phải thêm để đảm bảo pipeline
Ưu điểm:
Cải thiện thông lượng lượng – tổng số công việc hoàn thành trong 1 khoảng
thời gian
Dễ triển khai:
Các lệnh có cùng độ dài
Ít định dạng lệnh, các định dạng lệnh có tính đối xứng
Chỉ truy cập bộ nhớ bằng lệnh lw và sw
Mỗi lệnh chỉ ghi lớn nhất một kết quả ở hai giai đoạn cuối (MEM hoặc
WB)
Toán hạnh được sắp xếp trong bộ nhớ sao cho một lệnh dịch chuyển dữ
liệu chỉ cần một lần truy cập bộ nhớ
Hình 3.6: So sánh biểu đồ thời gian của thiết kế đơn xung và pipeline
Kiến trúc thiết kế
Hình 3.7: Chi tiết kiến trúc thiết kế MIPS pipeline
Thiết kế mạch
Sau khi xác định rõ các chỉ tiêu kỹ thuật, phương án thiết kế, kiến trúc thiết kế, ta
tiến hành thiết kế mạch theo từng khối. Cụ thể các khối được trình bày như sau:
Bộ đếm chương trình PC
Hình 4.1: Thanh ghi bộ đếm chương trình
Thanh ghi bộ đếm chương trình chứa địa chỉ của lệnh cần thực thi. PC được cập nhật ở mọi
chu kỳ mà không cần tín hiệu điều khiển PC.
Đầu vào PC’: 32 bit, đây chính là địa chỉ của lệnh tiếp theo cần thực hiện
trong bộ nhớ lệnh.
Đầu ra PC: 32 bit, trỏ tới lệnh hiện tại của chương trình trong bộ nhớ lệnh.
Ngoài ra khối bộ đếm chương trình này còn có tín hiệu đầu vào clock.
Hình 4.2. Quá trình xử lí lệnh
Bộ nhớ lệnh
Hình 4.3. Khối Intruction Memory
Bộ nhớ lệnh lưu trữ chương trình thực thi dưới dạng mã máy.
Khối bộ nhớ lệnh gồm có một cổng đọc.
Đầu vào: địa chỉ 32 bit nơi chứa lệnh cần thực thi.
Đầu ra: lệnh cần thực thi tương ứng với địa chỉ đầu vào.
Register File
Hình 4.4:Tệp thanh ghi
Tệp thanh ghi file gồm 32 thanh ghi như sau:
Số thanh ghi Tên quy ước Chức năng
$0 $zero Luôn có giá trị bằng 0
$1 $at Thanh ghi giành riêng cho các lệnh giả
$2-$3 $v0, $v1 Chứa giá trị trả về của hàm
$4-$7 $a0, $a3 Chứa các tham số cho hàm
$8-$15 $t0-$t7 Chứa dữ liệu tạm thời
$16-$23 $s0-$s7 Thanh ghi lưu trữ, dành riêng cho các chương
trình con
$24-$25 $t8-$t9 Thanh ghi tạm thời
$26-$27 $k0-$k1 Dành riêng cho kernel, không được sử dụng
$28 $gp Con trỏ toàn cục
$29 $sp Con trỏ stack
$30 $fp Con trỏ khung
$31 $ra Chứa địa chỉ trả về
Khối thanh ghi file gồm 2 cổng đọc và một cổng ghi.
Các cổng đọc:
A1, A2 là các đầu vào địa chỉ 5 bit (32 thanh ghi)
RD1, RD2 là các đầu ra dữ liệu tương ứng với các địa chỉ đầu vào tương ứng.
Cổng ghi:
A3: đầu vào địa chỉ của thanh ghi đích cần ghi
WD3: đầu vào dữ liệu cần ghi
WE3: tín hiệu cho phép ghi. Nếu WE3 =1 thì dữ liệu sẽ được ghi vào thanh
ghi tại sườn lên của xung clock
Bộ nhớ dữ liệu
Hình 4.5.Bộ nhớ dữ liệu
Khối bộ nhớ dữ liệu gồm có một cổng dành cho việc đọc hoặc ghi dữ liệu. Đọc và
ghi dự liệu có chung đầu vào địa chỉ.
Ghi dữ liệu:
Nếu tín hiệu cho phép ghi WE=1 thì dữ liệu được ghi vào trong bộ nhớ dữ liệu tại
sườn lên của xung clock
Đọc dữ liệu:
Nếu WE=0 thì dữ liệu được được đọc ra chân RD
Xây dựng Datapath cho lệnh loại R
Thanh ghi bộ đếm chương trình có chứa địa chỉ của lệnh sẽ được thực thi. Giai đoạn
đầu tiên trong chu trình thực hiện là đọc lệnh từ bộ nhớ lệnh. Vì vậy PC phải được
kết nối với đầu vào địa chỉ của bộ nhớ lệnh.
Hình 4.6. Kết nối Datapath cho lệnh R
Mã lệnh đầu tiên Instr 32 bit sẽ được lấy ra. Giai đoạn tiếp theo sẽ phụ thuộc vào
lệnh cụ thể.
Đầu tiên chúng ta sẽ xây dựng Datapath cho lệnh lw sau đó sẽ bổ sung và tổng quát
hóa cho các lệnh còn lại.
Đối với lệnh lw, bước đầu tiên là đọc thanh ghi nguồn là thanh ghi chứa địa chỉ cơ
sở của dữ liệu cần đọc trong bộ nhớ. Từ trường rs Instr[25-21] này ta sẽ xác định
được thanh ghi.
Các bit địa chỉ thanh ghi nguồn này được đưa vào đầu vào địa chỉ A1 của tệp thanh
ghi. Giá trị trong thanh ghi được đọc ra RD1.
Lệnh lw có một địa chỉ offset, địa chỉ này được lưu ngay trong lệnh Instr[15-0]. Giá
trị offset này là một hằng số 16 bit vì vậy ta phải mở rộng dấu lên 32 bit SignImm
Hình 4.7. Xây dựng khối mở rộng bit
Sau bước này bộ xử lý cần tính địa chỉ dữ liệu cần nạp trong bộ nhớ dữ liệu bằng
cách cộng địa chỉ cơ sở và địa chỉ offset.
Hình 4.8. Tính toán địa chỉ bộ nhớ
Khối ALU nhận hai toán hạng đầu vào SrcA và SrcB. SrcA là giá trị đọc được
từ thanh ghi, SrcB là giá trị sau khi qua khối mở rộng dấu từ 16 bits thành 32 bits.
Giá trị địa chỉ offset đã được mở rộng dấu.
ALU thực hiện nhiều phép toán số học và logic vì vậy cần có một tín hiệu điều
khiển ALUControl 3 bit để xác định phép toán cần thực hiện.
Khối ALU có 2 đầu ra là ALUResult và Zero. Đối với lệnh cộng đầu vào điều
khiển ALUControl=010. Đầu ra ALUResult nối vào đầu vào địa chỉ của bộ nhớ dữ
liệu.
Dữ liệu từ bộ nhớ dữ liệu sẽ được đọc ra bus dữ liệu ReadData, sau đó được ghi
trở lại thanh ghiđích vào cuối chu kỳ clock.
Hình 4.8. Xác định đường dữ liệu quay lại về Register File
Thanh ghi đích cho lệnh lw được xác định qua trường rt Instr[20-16] và được kết
nối với địa chỉ đầu vào của cổng ghi A3 của tệp thanh ghi.
Tín hiệu điều khiển RegWrite được nối với đầu vào WE3, tín hiệu này có mức
cao trong quá trình ghi do đó dữ liệu được ghi vào thanh ghi. Việc ghi dữ liệu diễn
ra vào cuối sườn lên của xung clock.
Trong khi lệnh lw đang được thực thi bộ xử lý sẽ tính toán địa chỉ của lệnh tiếp
theo PC’. Trongkiến trúc MIPS, mỗi lệnh 32 bit vì vậy địa chỉ lệnh tiếp theo sẽ là
PC + 4.
Địa chỉ của lện tiếp theo được ghi vào thanh ghi PC tại sườn lên của xung clock
tiếp theo.
Hình 4.9: Xác định địa chỉ của lệnh tiếp theo trong PC
Tiếp theo, ta mở rộng thêm Datapath để thực hiện lệnh sw.
Cả 2 lệnh lw và sw đều đọc địa chỉ cơ sở từ cổng 1 của tệp thanh ghi và có chứa
trường offset nằm ngay trong lệnh.
ALU cộng địa chỉ cơ sở và địa chỉ offset để tìm địa chỉ bộ nhớ.
Tuy nhiên lệnh sw đọc địa chỉ từ tệp thanh ghi và ghi vào trong bộ nhớ dữ liệu.
Hình 4.10: Đường dữ liệu cho lệnh sw
Thanh ghi cần đọc được xác định trong trường rt Instr[20-16]. Instr[20-16] được
kết nối với đầu vào địa chỉ A2, cổng 2 của tệp thanh ghi. RD2 là giá trị thanh ghi
tương ứng với địa chỉ A2. RD2 được đưa vào đầu vào WD của bộ nhớ dữ liệu.
Đầu vào cho phép ghi WE được điều khiển bởi MemWrite. Với lệnh sw,
MemWrite=1 và dữ liệu được ghi vào bộ nhớ, ALUControl =010 để thực hiện phép
cộng địa chỉ cơ sở và địa chỉ offset.
Ngoài ra RegWrite =0 để ngăn việc ghi vào tệp thanh ghi vì dữ liệu vẫn được
đọc ra từ bộ nhớ dữ liệu.
Tiếp theo mở rộng Datapath cho các lệnh loại R như add, sub, and, or và slt. Tất
cả các lệnh này đều đọc 2 toán hạng từ tệp thanh ghi, tính toán giá trị bằng ALU và
ghi lại kết quả vào thanh ghi thứ 3 trong tệp thanh ghi. Chỉ có sự khác biệt duy nhất
là các lệnh này thực hiện các phép toán khác nhau. Do đó ta chỉ cần thay đổi
ALUControl tương ứng.
Vì toán hạng thứ 2 được đưa vào SrcB của ALU có thể từ thanh ghi hoặc là giá
trị tức thì SignImm(luôn được nối với SrcB) nên ta cần bộ MUX 2:1 để chọn.
Bộ MUX này được điều khiển bởi tín hiệu ALUSr:
ALUSrc =0 cho lệnh loại R để chọn SrcB từ tệp thanh ghi
ALUSrc=1 cho các lệnh lw và sw để chọn SignImm
Chân WD3 của tệp thanh ghi luôn nhận đầu vào dữ liệu từ bộ nhớ dữ liệu hoặc
ALUResult do đóta cần một bộ MUX 2:1 thứ 2 để chọn.
Bộ MUX này được điều khiển bởi tín hiệu MemtoReg
MemtoReg =0 chọn ALUResult
MemtoReg=1 khi thực hiện lệnh lw để chọn ReadData
Hình 4.11. Đường dữ liệu tăng cường cho lệnh loại R
Bộ MUX 2:1 thứ 3 dùng để chọn trường rt hoặc rd của tệp thanh ghi.
Bộ MUX này được điều khiển bởi tín hiệu RegDst
RegDst =1 đối với các lệnh loại R để chọn WriteReg từ trường rd Instr[15-11]
RegDst =0 khi thực hiện lệnh lw để chọn trường rt Instr[20-16].
Cuối cùng ta mở rộng Datapath để xử lý lệnh beq.
Lệnh beq so sánh 2 thanh ghi, sự kiện rẽ nhánh xảy ra nếu 2 thanh ghi có giá
trị bằng nhau.
Địa chỉ rẽ nhánh chính là tổng của PC và địa chỉ offset của lệnh rẽ nhánh.
Địa chỉ offset này có thể dương hoặc âm và được lưu trong trường
immInstr[31-26]. Địa chỉ tiếp theo nếu rẽ nhánh xảy ra sẽ là : PC’= PC + 4 +
SignImm x 4.
Khi lệnh rẽ nhánh xảy ra PCBranch được tính bằng cách dịch trái SignImm
2 bit và sau đó cộngvới PCPlus4.
Hai thanh ghi nguồn được so sánh qua việc tính hiệu của chúng SrcASrcB sử
dụng ALU.
Nếu 2 thanh ghi bằng nhau thì cờ zero =1. Ngoài ra đối với lệnh rẽ nhánh beq thì tín
hiệu điều khiển Branch=1, ALUControl =110 vì vậy ALU thực hiện phép trừ SrcASrcB.
ALUSrc=0 để chọn toán hạng nguồn SrcB từ tệp thanh ghi.
Các tín hiệu RegWrite và MemWrite bằng 0 vì lệnh beq không ghi vào bộ
nhớ hay tệp thanh ghi.
Một bộ MUX 2:1 được thêm vào để chọn PC’ từ PCPlus4 hay PCBranch. Bộ
MUX này được điều khiển bởi tín hiệu PCSrc.
Hình 4.12: Datapath cho lệnh beq
Khối điều khiển(CU)
Khối điều khiển đưa ra tín hiệu điều khiển dựa trên các trường opcode Instr[31-26] và
funct Instr [5-0] của lệnh.
Hình 4.13: Khối control unit
Hầu hết các tín hiệu điều khiển có được từ trường opcode như MemtoReg,
MemWrite, Branch, ALUSrc, RegDst, RegWrite, ALUOp[1-0].
Tuy nhiên đối với các lệnh loại R ngoài trường opcode còn có thêm trường funct
để xác định phép toán.
Do đó khối điều khiển được chia thành 2 khối logic tổ hợp:
Khối main decoder xác định tín hiệu điều khiển dựa vào opcode
Khối ALU decoder xác định phép toán ALUControl thông qua trường funct
và ALUOp[1-0]
Khối xử lý xung đột (Hazard Unit).
Khối HazardUnit có nhiệm vụ phát hiện các xung đột về dữ liệu và xung đột điều
khiển rồi tạo ra các tín hiệu chuyển tiếp cho dữ liệu (ForwardAE,ForwardBE…),
các tín hiệu điều khiển thanh ghi như stallF, stallD,flushE.
Khối chuyển tiếp dữ liệu
Dữ liệu được chuyển tiếp từ giai đoạn MEM, WB về giai đoạn EX, do vậy ta sẽ
dùng bộ mux 4 đầu vào để chọn dữ liệu cho ALU tính toán
Hình 4.14 Chuyển tiếp dữ liệu
Tín hiệu điểu khiển bộ lựa chọn
Register File MEM WB
ForwardAE 00 10 01
ForwardBE 00 10 01
Mã lệnh trong Verilog
if((RsE!=0)&&(RsE==WriteRegM)&&(RegWriteM))ForwardAE=2'b10; else
if((RsE!=0)&&(RsE==WriteRegW)&&(RegWriteW))ForwardAE=2'b01; else
ForwardAE=2'b00;
if((RtE!=0)&&(RtE==WriteRegM)&&(RegWriteM))ForwardBE=2'b10; else
if((RtE!=0)&&(RtE==WriteRegW)&&(RegWriteW))ForwardBE=2'b01; else
ForwardBE=2'b00;
Điều khiển thanh ghi Pipeline
Khi xảy ra xung đột điều khiển, các thanh ghi IF, ID cần được giữ nguyên giá trị cũ
(stall), thanh ghi EX cần được xóa, khối HazardUnit sẽ làm nhiệm vụ phát hiện xung
đột và tạo ra các tín hiệu stallF, stallD, FlushE tương ứng để xóa,giữ giá trị cũ cho
các thanh ghi.
Hazard khi thực hiện lệnh lw
Hazard do lệnh lw cần dừng 1 chu kì xủ lý, do vậy khối HazardUnit sẽ tạo ra tín
hiệu stallF,stallD,FlushE điều khiển thanh ghi xử lý hazard
StallF StallD flushE
Giá trị 1 1 1
Nhiệm vụ Giữ lại giá trị cũ
cho thanh ghi IF
Giữ lại giá trị cũ
cho thanh ghi ID
Xóa thanh ghi EX
Mã lệnh trong Verilog.
lwstall=((RsD==RtE)||(RtD==RtE))&&(MemtoRegE);
{StallF,StallD,FlushE}={3{lwstall}}; //ghép bit
Hazard khi thực hiện lệnh điều khiển chương trình
Khi thực hiện lệnh điều khiển chương trình bne,beq,…chúng ta cần xóa các thanh
ghi IF,ID khi điều kiện nhảy đúng, khối HazardUnit phát hiện và tạo ra các tín hiệ
stallF,StallD,FlushE để điều khiển thanh ghi pipeline
StallF StallD flushE
Giá trị 1 1 1
Nhiệm vụ Giữ lại giá trị cũ
cho thanh ghi IF
Giữ lại giá trị cũ
cho thanh ghi ID
Xóa thanh ghi EX
Mã verilog
branchstall=(branchD&&((RsD==WriteRegE)||(RtD==WriteRegE))&&RegWr
iteE)||(branchD&&MemtoRegM&&((RsD==WriteRegM)||(RtD==WriteRegM
)));
{StallF,StallD,FlushE}={3{branchstall}}; //ghép bit
Dễ thấy các tín hiệu stallF,stallD,FlushE được sinh ra do lệnh lw và lệnh điều khiển
chương trình có tác dụng giống nhau, do vậy ta có cộng hai tín hiệu này thành 1 tín
hiệu duy nhất.
{StallF,StallD,FlushE}={3{lwstall}}|{3{branchstall}};
Khối tính toán rẽ nhánh sớm
Để giảm ảnh hưởng của các lệnh rẽ nhánh có điều kiện, chúng ta cần tính toán điều
kiện nhảy sớm nhất có thể, ở đây ta sẽ tính toán trong giai đoạn ID.
In0!=in1 Out=1
In0==in1 Out=1
Xử lý xung đột dữ liệu cho lệnh nhảy
Xét lệnh sau: add $1,$2,$3
bne $1,$2,Lable
Do khối so sánh đặt ở giai đoạn ID nên ta phải chuyển tiếp dữ liệu từ giai đoạn EX
(lệnh add) về giai đoạn ID, Giai đoạn EX sẽ được thêm 1 bộ lựa chọn để chọn dữ
liệu từ registerfile hoặc từ dữ liệu chuyển tiếp, tín hiệu điều khiển được sinh ra từ
khối HazardUnit.
RegisterFile MEM
ForwardAD 0 1
ForwardBD 0 1
Mã Verilog cho tín hiệu lựa chọn
ForwardAD=(RsD!=0)&&(RsD==WriteRegM)&&RegWriteM;
ForwardBD=(RtD!=0)&&(RtD==WriteRegM)&&RegWriteM;
Kết quả tổng hợp và mô phỏng
Kết quả tổng hợp từ Quartus
Hình 5.1: Kết quả tổng hợp từ Quartus
Kết quả tổng hợp:
Số phần tử Logic (LE): 1.273
Số thanh ghi: 279
Số bits nhớ: 2.048
Clock setup: fclk = 81.63MHz (period=12.250ns)
Kết quả mô phỏng sử dụng Modelsim
Tổng hợp kết quả mô phỏng:
STT Mã ASM Mã máy Status
1 addi $1,$3,258 20610102 Passed
2 add $2,$3,$4 00641020 Passed
3 sub $2,$3,$4 00641022 Passed
4 or $4, $7, $2 00e22025 Passed
5 and $4,$7,$2 00e22024 Passed
6 xor $4,$7,$2 00e22027 Passed
7 lw $1, 0($2) 8c410000 Passed
8 sw $3,32($5) aca30020 Passed
9 bne $0 $1 -1 14220001 Passed
10 beq $0 $10 1140001 Passed
11 slt $1,$14 $15 01cf082a Passed
12 sll $1 $2,4 00020900 Passed
13 srl $1 $2 4 00020902 Passed
14 sra $1 $2 4 00 412003 Passed
15 andi $1 $2 ,0xffff 3041ffff Passed
16 ori $1,$2 0000 34410000 Passed
17 xori $1 $2 5555 38415555 Passed
18 slti $1,$3,0x01ff 28a101ff Passed
19 lb $1, 32($0) 80010020 Passed
20 lh $2, 32 ($0) 84020020 Passed
21 sb $4, 36 ($0) a0040024 Passed
22 sh $4, 36($0) a4040024 Passed
Test với bài toán tìm số lớn nhất của mảng lưu trong bộ nhớ:
Quy ước:
$0 = 0
$1 = 1
$2 số phần tử của mảng, giả sử là 5
$3 địa chỉ bắt đầu của mảng, giả sử bắt đầu từ 0
$4 chỉ số mảng
$5 lưu kết quả tạm thời các phần tử trong mảng
$6 lưu kết quả là giá trị lớn nhất tìm được, kết quả này được lưu trong ô nhớ kế tiếp với
phần tử cuối
STT Mã ASM Giải thích lệnh PC Mã máy
1 addi $1,$0,1 0 20010001
2 addi $2,$0,5 4 20020005
3 addi $3,$0,0 8 20030000
4 add $4,$1,$0 12 00202020
5 lw $6,0($3) max = phần tử đầu tiên 16 8C660000
6 loop: beq $4,$2,end bắt đầu từ phần tử thứ 2 20 10440007
7 addi $3,$3,4 địa chỉ ô nhớ tiếp theo 24 20630004
8 addi $4,$4,1 28 20840001
9 lw $5,0($3) 32 8C650000
10 slt $7,$5,$6 nếu ô nhớ tiếp theo nhỏ
hơn max thì thực hiện lặp,
ngược lại thì gán cho max
36 00A6382A
11 beq $7,$1,end_if 40 10270001
12 addi $6,$5,0 44 20A60000
13 end_if: j loop 48 08000005
14 end: sw $6,4($3) 52 AC660004
Kết quả mô phỏng trên Modelsim
Tài liệu tham khảo
Slide bài giảng Kiến trúc máy tính, TS Nguyễn Đức Minh.
Digital Design and Computer Architecture, David Money Harris & Sarah L. Harris.
Computer Organization Design, John L. Hennessy.
Asic-world.com
