Embed Size (px)
Citation preview
TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI
VIỆN ĐÀO TẠO SAU ĐẠI HỌC
BÀI TẬP LỚN
KIỂM CHỨNG VI MẠCH
Đề tài:
KIỂM CHỨNG BẰNG PHƯƠNG PHÁP MÔ
PHỎNG BỘ XỬ LÝ MIPS
Nhóm thực hiện: LÊ DOÃN THIỆNCÙ XUÂN TOẢNLÊ THỊ ÁNH NGỌC
Giảng viên hướng dẫn: TS. NGUYỄN ĐỨC MINH
Hà Nội, 1-2015
MỤC LỤC
MỤC LỤC..........................................................................................................................................................1
Phần 1. Tổng quan dòng vi xử lý MIPS.....................................................................................................2
1.1 Lịch sử phát triển..................................................................................................................................2
1.2 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)......3
1.3 Nguyên tắc thiết kế bộ MIPS.................................................................................................................4
1.4 Một số lệnh sử dụng trong MIPS..........................................................................................................5
1.5 Phân loại MIPS.....................................................................................................................................6
1.5.1. Thiết kế đơn xung nhịp................................................................................................................6
1.5.2. Thiết kế đa xung nhịp..................................................................................................................6
1.5.3. Thiết kế pipeline..........................................................................................................................7
1.6 Các ứng dụng của bộ xử lý MIPS.......................................................................................................10
Phần 2. Phân tích và thực hiện kiểm chứng............................................................................................12
2.1 Lựa chọn phương pháp kiểm chứng....................................................................................................12
2.1.1. Tầm quan trọng của kiểm chứng thiết kế..................................................................................12
2.1.2. Các loại kiểm chứng trong quy trình thiết kế vi mạch..............................................................12
2.2 Mô hình kiểm chứng............................................................................................................................13
2.3 Thực hiện thiết kế MIPS Pipeline........................................................................................................13
2.3.1. Yêu cầu thiết kế.........................................................................................................................13
2.3.2. Sơ đồ thiết kế.............................................................................................................................14
2.3.3. Thiết kế chi tiết từng khối.........................................................................................................15
2.4 Thực hiện các phép toán trong MIPS dùng C++...............................................................................18
Phần 3. Kết quả tổng hợp và mô phỏng...................................................................................................19
3.1 Sơ đồ khối của sản phẩm....................................................................................................................19
3.2 Thuật toán, linh kiện, kiến trúc mạch..................................................................................................19
Phần 4. Đánh giá kết quả và hướng phát triển........................................................................................20
1
Phần 1. Tổng quan dòng vi xử lý MIPS
1.1 Lịch sử phát triển
MIPS viết tắt của Microprocessor without Interlocked Pipeline Stages, là kiến trúc bộ tập
lệnh RISC phát triển bởi MIPS Technologies [1].
Bộ xử lý MIPS đầu tiên được nghiên cứu vào năm 1981 bởi một nhóm các nhà nghiên cứu
thuộc đại học Stanford do John L. Hennessy đứng đầu, với mục đich 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 (pipeline instructions),
một công nghệ đã được biết đến từ lâu nhưng lại khó phát triển.
Thông thường một đường ống sẽ mở rộng việc chạy một câu lệnh thành vài bước, bắt đầu
thực hiện “bước một” của câu lệnh trước khi câu lệnh trước hoàn thành. Trong khi đó, thiết
kế truyền thống yêu cầu phải đợi cho đến khi một câu lệnh hoàn thành mới được chạy câu
lệnh tiếp theo.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.
Đến năm 1984, Hennessy rời trường đại học Stanford để thành lập công ty MIPS
Computer System.Họ cho ra đời thiết kế đầu tiên là R2000 vào năm 1985, sau đó phát
triển R3000
vào năm 1998. Những CPU 32 bit 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.Tuy nhiên MIPS gặp khó
khăn trong 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
2
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
1.2 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)
Các thế hệ MIPS khởi đầu là kiến trúc 32 bit sau mở rộng ra 64 bit. Nhiều sửa đổi
của MIPS, bao gồm MIPS I, MIPS II, MIPS III, MIPS IV, MIPS V, MIPS32 và
MIPS64. Phiên bản hiện tại là MIPS32 và MIPS64.
Cũng có một vài tuỳ chọn mở rộng, baogồm MIPS-3D (1 tập lệnh đơn giản các câu lệnh
SIMD về dấu chấm động để thực hiện các tác vụ về đồ họa 3D), MIPS16e (khả năng nén
vi lệnh để tiết kiệm không gian bộ nhớ) và MIPS MT (MultirTheading) kiến trúc
đa luồng mới được bổ xung cho hệ thống.
Các dòng vi xử lý MIPS thương mại đã đượ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
3
Đượ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.
1.3 Nguyên tắc thiết kế bộ MIPS
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(32 bit)
− Í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 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
4
Thiết kế tốt đòi hỏi sự thỏa hiệp
− 3 loại định dạng chỉ thị [1]:
+ R-chỉ thị thanh ghi: 2 toán hạng nguồn thanh ghi, 1 toán hạng
đích thanh ghi.
+ I-chỉ thị trực tiếp: 1 toán hạng nguồn thanh ghi, 1 toán hạng
nguồn trực tiếp, 1 toán hạng đích thanh ghi.
+ J-chỉ thị nhảy: 1 toán hạng nguồn trực tiếp.
Hình 3.1 Ba định dạng chỉ thị lệnh
1.4 Một số lệnh sử dụng trong MIPS
Sau đây là các lệnh được sử dụng trong MIPS 32 bits[2]:
Bảng 3.1 Lệnh của MIPS 32 bits
5
1.5 Phân loại MIPS
1.5.1. Thiết kế đơn xung nhịp
Là thiết kế mà các pha thực hiện: nạp, giải mã and thực hiện, ghi của mỗi lệnh trong một
chu kỳ đồng hồ [3]:
Hình 3.2 Thiết kế đơn xung nhịp
Ư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ả – chu kỳ đồng hồ được đặt theo lệnh chậm nhất.
Các lệnh phức tạp như lệnh nhân dấu phẩy động: Tốn diện tích thiết kế vì cần nhân đôi
một số khối chức năng (VD: bộ cộng) vì chúng không thể được chia sẻ trong cùng 1 chu
kỳ đồng hồ.
1.5.2. Thiết kế đa xung nhịp
Là thiết kế mà chia lệnh thành các pha thực hiện: IF, ID, EX, MEM, WB. Mỗi pha thực
hiện trong 1 chu kỳ xung nhịp [4].
6
Hình 3.3 Thiết kế đa xung nhịp
Ưu điểm:− Thời gian thực hiện (= số pha) 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. Nhược điểm:
− Các lệnh thực hiện liên tiếp nhau.− Lệnh trước được thực hiện xong mới đến lệnh sau vì vậy xuất hiện khoảng thời
gian rỗi giữa các khâu.
1.5.3. Thiết kế pipeline
Khác với thiết kế đơn xung nhịp khi các lệnh đều được thực hiện xong trong một
chu kì máy, thiết kế pipeline chia một câu lệnh ra thành 5 bước (steps) [5]:
7
Hình 3.4 Các bước thực hiện lệnh
− 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 – WBCâ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:
Hình 3.5 Chu trình thực hiện lệnh
Dưới đây là sơ đồ kiến trúc MIPS khi thực hiện theo pipeline:
Hình 3.6 Sơ đồ kiến trúc MIPS pipeline
Các bước thực hiện một câu lệnh:
8
Đọ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 gianID/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.
9
1.6 Các ứng dụng của bộ xử lý MIPS
Kiến trúc MIPS được sử dụng rộng rãi trong các ứng dụng công nghiệp như DVD player,
Netwoking, camera số,…
DVD player (Pioneer DVR-57H)
Networking
3COM – 3102 Business IP Phone
3COM – 3106 Cordless Phone
10
Canon EOS 450D
Sony playstation PSX (CPU Type: LSI/MIPS R3000A, Architecture: 32 bit,
Clockspeed 33,8 MHz)
Sony Playstation Portable ( CPU 333MHz MIPS R4000) [2]
11
Phần 2. Phân tích và thực hiện kiểm chứngPhần này phân tích và phân chia các chức năng của sản phẩm từ đó lập ra kế hoạch thiết
kế, phát triển sản phẩm.
2.1 Lựa chọn phương pháp kiểm chứng
2.1.1. Tầm quan trọng của kiểm chứng thiết kế
Kiểm chứng vi mạch là quá trình tìm kiếm phát hiện lỗi trong thiết kế vi mạch.
Lỗi trong thiết kế vi mạch là sự sai khác trong hoạt động của thiết kế với yêu cầu kỹ thuật
đặt ra. Những lỗi này có thể xảy ra trong quá trình thiết kế, quá trình sản xuất vi mạch hoặc
quá trình sử dụng vi mạch trong hệ thống. Dù là lỗi xảy ra trong quá trình nào thì chi phí
để khắc phục cũng thường khá lớn do đó cần phát hiện sớm lỗi để tránh tốn nhiều thời
gian, công sức và tiền bạn để sửa lỗi.
2.1.2. Các loại kiểm chứng trong quy trình thiết kế vi mạch
Một số loại kiểm chứng thường dùng trong quy trình thiết kế vi mạch là kiểm chứng bằng
hình vẽ, kiểm chứng dùng mô phỏng và kiểm chứng hình thức.
Kiểm chứng mô phỏng Kiểm chứng hình thức
Kiểm chứng dựa trên xung nhịp. Các giá trị
đầu vào được đưa vào bản thiết kế hệ thống
và cho phép máy tính thực hiện việc tính
toán đầu ra
Kiểm chứng dùng các công thức, mô hình
toán học để mô hình hệ thống và chứng
minh tính hoạt động đúng của mạch.
Ưu điểm:
Trực quan với người sử dụng
Không quá khó để thiết lập hệ thống
mô phỏng vi mạch
Ưu điểm:
Khả năng tìm được lỗi cao hơn
Thời gian kiểm chứng có thể nhỏ
hơn
Độ bao phủ lớn hơn
Nhược điểm:
Độ bao phủ không cao
Tốn tài nguyên tính toán, mất nhiều
thời gian để mô phỏng hết các
trường hợp kiểm chứng cho vi mạch.
Tối ưu mạch ảnh hưởng lớn đến tốc
độ mô phỏng
Nhược điểm:
Khó hình dung và thiết lập mô hình
toán học cho mạch
Quy trình thiết lập mô hình toán học
mất nhiều thời gian
12
Thông qua việc phân tích các phương pháp kiểm chứng, đồng thời dựa vào giới hạn thời
gian hoàn thành đề tài cũng như mức độ phức tạp của kiến trúc MIPS, nhóm sẽ tiến hành
thực hiện kiểm chứng bộ MIPS pipeline dùng phương pháp mô phỏng.
2.2 Mô hình kiểm chứng
Nguyên tắc cơ bản của kiểm chứng là tạo sự dư thừa nên nhóm quyết định tạo một dạng
triển khai khác của thiết kế, sau đó tiến hành so sánh hai dạng triển khai.
Phương hướng triển khai:
Xây dựng mô hình thiết kế MIPS Pipeline ở mức RTL dùng ngôn ngữ Verilog và
công cụ Quatus của Altera.
Xây dựng mô hình tính giá trị đúng của các phép toán dùng ngôn ngữ C/C++ và sử
dụng visual express 2010.
Mô phỏng hai mô hình đồng thời và so sánh kết quả.
2.3 Thực hiện thiết kế MIPS Pipeline
2.3.1. Yêu cầu thiết kế
Yêu cầu chức năng
Bộ xử lý MIPS 32 bit có khả năng thực hiện các lệnh cơ bản như các phép
toán số học (cộng, trừ, nhân …), truy cập bộ nhớ với hai chỉ thị (lw, sw),
lưu trữ, đọc và ghi dữ liệu …
Thực hiện bằng ngôn ngữ mô tả phần cứng VerilogHDL.
Giải quyết được các xung đột cơ bản trong MIPS Pipeline.
Yêu cầu phi chức năng
13
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á.
2.3.2. Sơ đồ thiết kế
Các thông số đầu vào và đầu ra của thiết kế:
C ngổ S bitố H ngướ Mô tả
IReady 1 Input Tín hiệu báo bộ nhớ lệnh sẵn
sàng gửi dữ liệu
IData 32 Input Mã lệnh được lấy từ bộ nhớ lệnh
DataIn 32 Input Dữ liệu được đọc ra từ bộ nhớ dữ
liệu
DReady 1 Input Tín hiệu điều khiển việc đọc dữ
14
liệu vào từ bộ nhớ dữ liệu
IAddr 30 Output Địa chỉ lệnh trong bộ nhớ lệnh
cần thực thi
IRead 1 Output Tín hiệu điều khiển việc đọc địa
chỉ chứa lệnh cần thực thi trong
bộ nhớ lệnh
DRead 1 Output Tín hiệu điều khiển việc đọc từ
bộ nhớ dữ liệu
DAddr 30 Output Địa chỉ trong bộ nhớ dữ liệu cần
đọc/ghi dữ liệu
DWrite 4 Output Tín hiệu điều khiển việc ghi vào
bộ nhớ dữ liệu
DataOut 32 Output Dữ liệu được ghi vào bộ nhớ dữ
liệu
2.3.3. Thiết kế chi tiết từng khối
Trong phần này nhóm sẽ tập trung trình bày một số khối quan trọng trong kiến trúc MIPS
Pipeline
Khối Control Unit :
Là khối sinh ra các tín hiệu điều khiển cho con Mips khi có lệnh của bên ngoài đưa
vào dưới dạng mã lệnh.
Đầu vào : Op[5:0] , Funct[ 5:0] lấy từ mã lệnh.
Zero lấy từ đầu ra của khối ALU
Đầu ra : Các tín hiệu để điều khiển các khối khác là :
+) Tín hiệu đưa dữ liệu từ bộ nhớ ra thanh ghi Memtoreg
+) Tín hiệu Regwrite, Memwrite
+) Tín hiệu chọn ALUSrc, PCSrc, RegDst
+) Tín hiệu ALUControl
Khối Register File :15
Là khối thanh ghi của con Mips. Đầu vào sẽ là địa chỉ của các thanh ghi đưa vào từ
mã lệnh và dữ liệu quay về thanh ghi từ giai đoạn WB. Đầu ra sẽ là dữ liệu nằm
trong thanh ghi mà địa chỉ lệnh trỏ tới.
Đầu vào : +) RegwriteW : tín hiệu cho phép đọc mã lệnh tương ứng vào
thanh ghi qua WB
+) Mã lệnh tương ứng của Rs, Rt : InstrD[25:21], InstrD[20:16]
+) Dữ liệu trả về WriteRegW[4:0] và tín hiệu kết quả ResultW
Đầu ra : Dữ liệu được đọc trong 2 thanh ghi mà mã lệnh truy cập tới địa chỉ của nó
Readdata1, Readdata2
Khối ALU :
Là khối phục vụ nhiệm vụ tính toán.
Đầu vào : +) Tín hiệu chọn loại tính toán : cộng, trừ, nhân, chia : ALUControl được
sinh ra từ ControlUnit
+) Dữ liệu được đọc từ 2 thanh ghi trong tập thanh ghi Register file
Readdata1, Readdata2 32 bit
Đầu ra: +) Dữ liệu ra sau khi được tính toán ALUOut 32 bit.
+) Tín hiệu Zero sử dụng trong lệnh rẽ nhánh beq, bne.
Khối SignExt :
16
Khối được sử dụng với nhiệm vụ chuyển đổi dữ liệu dịch từ 16 bit trong mã lệnh
thành 32 bit để thực hiện cho nhiệm vụ tính toán.
Đầu vào : Dữ liệu dịch được lấy trong 16 bit cuối của mã lệnh Instr[15:0]
Đầu ra : Dữ liệu dich được chuyển thành 32 bit bằng cách lấy 16 bit đầu bằng bit thứ 16
và 16 bit cuối là Instr[15:0]. y[31:0] = [16(Instr[15]), Instr[15:0]].
Từ các khối trên và một số khối logic cơ bản khác ta xây dựng được bộ MIPS đa
xung nhịp như hình vẽ:
Ở đa xung nhịp ta chia lệnh thành 5 giai đoạn IF, ID, EX, MEM, WB. Mỗi giai đoạn được
thực hiện trong một chu kỳ. Trong sơ đồ gồm có các khối chính như là khối Control Unit,
khối Register File, khối ALU, khối SignExt.
Từ MIPS đa xung nhịp chúng ta tiến hành pipeline bộ vi xử lý bằng cách thêm
vào các thanh ghi trạng thái IFID, IDEX, EXMEM, MEMWB, PC. Các thanh ghi sẽ thực
hiện nhiệm vụ chuyển tiếp dữ liệu giữa các khâu
17
2.4 Thực hiện các phép toán trong MIPS dùng C++
Trong phần này nhóm sử dụng các phép toán có trong thư viện C để tính toán. Các
phép toán (Instruction) được sử dụng là : cộng, trừ, nhân, chia được mã hóa tương ứng với
các số từ 0 đến 3 và được sinh ngẫu nhiên trong file Instruction.txt, các toán hạng(Data)
cũng được sinh ra ngẫu nhiên trong file data.txt. Các giá trị trong hai file này cũng là đầu
vào cho quá trình mô phỏng mạch bằng techbench. Sau khi tính toán bằng các phép toán có
trong thư viện C, kết quả đầu ra sẽ được ghi vào file output.txt.
Hình bên dưới sẽ minh họa cho quá trình tính toán sử dụng thư viện C:
Kết quả so sánh giá trị đầu ra của hai kiểu tính toán sẽ kiểm chứng độ chính xác của việc thiết kết mạnh (verilog). Từ đó ta có thể phát hiện các lỗi (nếu có) trong quá trình thiết kế.
18
Code C++:
#include<iostream>#include<stdio.h>#include<conio.h>#include <cstdlib>#include<ctime>
using namespace std;long add (long a, long b);long sub (long a, long b);long mul (long a, long b);long divi (long a, long b);int main(){
int A[100],B[100],KQ[100];long i,j ,a,b ;int test_case;srand(time(0));
//Lấ*y giá trị toán hạng ngấ/u nhiên rồ2i đưa vào file Toanhang.txtfreopen("instruction.txt","w",stdout);for (int n=1;n<=50;n++){
int x=rand()%4;cout<<x<<" ";}fclose(stdout);
//Lấ*y hai toán tưA ngấ/u nhiên rồ2i đưa vào file đấ2u vào input.txtfreopen("data.txt","w",stdout);for (int m=1;m<=50;m++){
//srand(time(0));a = rand();b = rand();cout<<a<<" "<<b<<endl ;
}fclose(stdout);
//Cho toán hạng vào maAng Afreopen("data.txt","r",stdin);for ( i=1;i<=50;i++){
cin>>A[i*2-1]>>A[i*2];
}fclose(stdin);
//Cho toán tưA vào maAg Bfreopen("instruction.txt","r",stdin);for ( j=1;j<=50;j++)
cin>>B[j];fclose(stdin);
for (test_case=1;test_case<=50;test_case++){
switch (B[test_case]){
19
case 0: {
KQ[test_case]=add(A[test_case*2-1],A[test_case*2]);
break;}
case 1: {
KQ[test_case]=sub(A[test_case*2-1],A[test_case*2]);break;
}case 2:{
KQ[test_case]=mul(A[test_case*2-1],A[test_case*2]);break; }
case 3:{
KQ[test_case]=divi(A[test_case*2-1],A[test_case*2]);break; }
default: cout<< "ma lenh sai";}
}
// ghi kê*t quaA vào file đấ2u ra output.txtfreopen("output.txt","w",stdout);for (int k=1;k<=50;k++)
cout<<KQ[k]<<" ";fclose(stdout);
}long add(long a,long b){
return a+b;}
long sub (long a,long b){
return a-b;}long mul(long a,long b){
return a*b;}long divi ( long a, long b){
return a/b;}
20
Phần 3. Kết quả tổng hợp và mô phỏngPhần này trình bày về các phương án kỹ thuật được sử dụng để thiết kế sản phẩm.
Có thể là lựa chọn các linh kiện phần cứng cho mạch.
Có thể là lựa chọn thuật toán thực hiện một chức năng mạch.
Có thể là lựa chọn kiến trúc mạch
3.1 Sơ đồ khối của sản phẩm
Phần này làm rõ các khối thực hiện chức năng trong mạch, kết nối và giao tiếp giữa các
khối. Phần này phải làm rõ được tín hiệu vào và ra khỏi từng khối.
3.2 Thuật toán, linh kiện, kiến trúc mạch
Phần này làm rõ việc lựa chọn thuật toán hay linh kiện phần cứng hay kiến trúc mạch để
thực hiện các khối chức năng
Mỗi khối chức năng nên nêu ra ít nhất 2 phương án thực hiện và lựa chọn dựa trên các tiêu
chí kỹ thuật định lượng.
21
Phần 4. Đánh giá kết quả và hướng phát triểnPhần này mô tả việc thiết kế cụ thể từng khối chức năng.
Nếu là mạch phần cứng thì trình bày sơ đồ nguyên lý, mô phỏng sơ đồ nguyên lý của
mạch.
Nếu là phần mềm thì trình bày lưu đồ thuật toán, cấu trúc dữ liệu, khai báo các hàm.
22
[1] http://en.wikipedia.org/wiki/MIPS_instruction_set, truy cập ngày 25/01/2015.
[2] http://en.wikipedia.org/wiki/PlayStation_Portable, truy cập ngày 25/01/2015.
23
