THIẾT kế CPU RISC 32 BIT đơn CHU kỳ THỰC HIỆN LỆNH ADD (có code)

THIẾT KẾ CPU RISC 32 BIT ĐƠN CHU
KỲ THỰC HIỆN LỆNH ADD

1


MỤC LỤC
DANH MỤC CÁC HÌNH VẼ...................................................................................................................vi
DANH MỤC CÁC BẢNG BIỂU.............................................................................................................vii
DANH MỤC CÁC TỪ VIẾT TẮT........................................................................................................viii
CHƯƠNG 1. TỔNG QUAN VỀ CPU KIẾN TRÚC RISC...................................................................1
1.1 GIỚI THIỆU.......................................................................................................................................1
1.1.1 Lịch sử..............................................................................................................................................2
1.1.2 Lý thuyết về CPU RISC...................................................................................................................6
1.1.2.1 Quy trình thiết kế số.....................................................................................................................6
1.1.2.2 Dẫn nhập thiết kế..........................................................................................................................8
1.1.2.3 Testbench trong Verilog................................................................................................................9
1.1.2.4 Mô phỏng....................................................................................................................................10
1.1.2.5 Kiến trúc CPU RISC 32 bit đơn chu kỳ......................................................................................11
1.1.3Hướng nghiên cứu..........................................................................................................................14
1.2 NGUYÊN LÝ CHUNG....................................................................................................................14
1.2.1 Nguyên tắc lưu dữ liệu trong bộ nhớ.............................................................................................14
CHƯƠNG 2: NỘI DUNG CỦA ĐÈ TÀI................................................................................................17
2.1 ĐƯỜNG DỮ LIỆU CỦA LỆNH ADD............................................................................................17
2.2 CONTROL UNIT.............................................................................................................................18
2.3 KHỐI RF...........................................................................................................................................19
2.4 KHỐI ALU........................................................................................................................................20
CHƯƠNG 3: KẾT QUẢ MÔ PHỎNG..................................................................................................22
3.1 MÔ HÌNH MÔ PHỎNG...................................................................................................................22
3.2 KẾT QUẢ MÔ PHỎNG...................................................................................................................22
3.3 KẾT QUẢ NẠP TRÊN KIT DE2.....................................................................................................23

CHƯƠNG 4: NHẬN XÉT........................................................................................................................26
CHƯƠNG 5: KẾT LUẬN........................................................................................................................27
PHỤ LỤC....................................................................................................................................................29

2


DANH MỤC CÁC HÌNH VẼ
HÌNH 1-1: CHIP VI XỬ LÝ ARM............................................................................................................1
HÌNH 1-2: LUỒNG THIẾT KẾ ASIC.....................................................................................................8
HÌNH 1-3: HAI CÁCH KHÁC NHAU ĐẺ ĐỊNH NGHĨA DỮ LIỆU KIỂM TRA NGÕ
VÀO.............................................................................................................................................................11
HÌNH 1-4: KIẾN TRÚC CPU RISC 32 BIT ĐƠN CHU KỲ.............................................................12
HÌNH 1-5: NGUYÊN TẮC ALIGNMENT RESTRICTION..............................................................15
HÌNH 2-1: ĐƯỜNG DỮ LIỆU LỆNH ADD.........................................................................................17
HÌNH 2-2: KHỐI CONTROL UNIT......................................................................................................18
HÌNH 2-3: KHỐI REGISTER FILE......................................................................................................19
HÌNH 2-4: KHỐI ALU 32 BIT................................................................................................................20
HÌNH 2-5: NGUYÊN TẮC THỰC HIỆN PHÉP CỘNG 32 BIT.......................................................21
HÌNH 3-1: SƠ ĐỒ MÔ PHỎNG CPU RISC........................................................................................22
HÌNH 3-2: MÔ PHỎNG DẠNG SÓNG BẰNG PHẦN MỀM QUARTUS......................................22
HÌNH 3-3:SƠ ĐỒ ĐẤU CHÂN...............................................................................................................23
HÌNH 3-4: KẾT QUẢ NẠP KIT 1..........................................................................................................24
HÌNH 3-5: KẾT QUẢ NẠP KIT 2..........................................................................................................25

3


DANH MỤC CÁC BẢNG BIỂU
BẢNG 1-1: SO SÁNH CPU RISC VỚI CÁC CPU KHÁC...................................................................1

BẢNG 1-2: CÁC HỆ THỐNG VÀ CÁC RISC PHỔ BIẾN..................................................................6
BẲNG 1-3: THANH GHI TRONG CPU RISC....................................................................................14
BẢNG 1-4: CẤU TRÚC LỆNH...............................................................................................................16
BẢNG 2-1: KHỐI CONTROL UNIT LOẠI R.....................................................................................18
BẢNG 2-2: BẢNG SỰ THẬT FULL ADDER.......................................................................................20

4


DANH MỤC CÁC TỪ VIẾT TẮT
RF

Register File

IM

Instruction Memory

DM

Data Memory

PC

Program Counter

ALU Arithmetic logic unit
CPU Central Processing Unit
RTL Register Transfer Language
Vxl

Vi xử lý

5


Trang 1/38

CHƯƠNG 1. TỔNG QUAN VỀ CPU KIẾN TRÚC RISC
1.1 Giới thiệu
RISC (Reduced Instructions Set Computer - Máy tính với tập lệnh đơn giản hóa) là một
phương pháp thiết kế các bộ vi xử lý theo hướng đơn giản hóa tập lệnh, thời gian thực
hiện được đồng bộ bằng xung clock là như nhau. Các bộ vi xử lý RISC thông dụng hiện
nay là PowerPC của IBM, DEC Alpha, PIC, ARM, SuperH, MIPS, SPARC, và PA-RISC.

Hình 1-1: Chip vi xử lý ARM
Bảng 1-1: So sánh CPU RISC với các CPU khác

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 2/38

1.1.1 Lịch sử
Nhiều tính năng trong các bộ VXL được thiết kế nhằm giúp công việc lập trình trở nên dễ
dàng hơn những tính năng thường cần vài chu kỳ máy để thực hiện lại thường bị các phần
mềm bỏ sót. Cộng thêm sự khác biệt về hiệu năng giữa các CPU và bộ nhớ chính đã dẫn
đến nhiều kỹ thuật hoặc nhằm tổ chức lại quá trình thực thi trong bộ xử lý, nhằm hạn chế
số lần truy cập bộ nhớ.
Những phần mềm trong thực tế hầu hết tốn nhiều thời gian để thi hành một số tác vụ đơn

giản, vì vậy một số nhà nghiên cứu hướng đến việc tối ưu hóa những tác vụ này. Do xung
nhịp (clock rate) của CPU bị hạn chế bởi thời gian thực hiện lệnh chậm nhất, nên nếu tối
ưu lệnh này sẽ khiến cho toàn bộ tập lệnh được thực thi nhanh hơn nhiều. Mục tiêu của
RISC chính là đơn giản hóa các lệnh, để mỗi lệnh có thể được thực thi chỉ trong 1 chu kỳ
máy. Việc tập trung đơn giản hóa các lệnh đã cho ra đời các loại "Máy tính với tập lệnh
được đơn giản hóa" - RISC.
Những năm cuối 1970, các nhà nghiên cứu của IBM đã khẳng định rằng hầu hết các
phương pháp đánh địa chỉ trực giao bị các chương trình bỏ sót. Đây là kết quả không
mong muốn khi sử dụng các trình biên dịch cấp cao thay vì sử dụng hợp ngữ.
Andrew Tanenbaum dựa vào kết quả đo đạc lúc đó khẳng định những thiết kế thừa quá
mức. Ông cho rằng phần lớn các hằng có thể thực hiện bằng 13 bit, trong khi đó các CPU
được thiết kế theo bội số của 8 thường là 8, 16 hoặc 32. Nếu CPU cho phép các hằng
được cất trong những bit dư của mã lệnh sẽ làm giảm bớt đi rất nhiều lần truy cập bộ nhớ.
Thay vì phải đọc từ bộ nhớ hay từ thanh ghi, quá trình thực thi sẽ nhanh hơn vì các hằng
đã ở ngay đó khi CPU cần.
Một nghiên cứu nữa cũng chúng tỏ rằng những tính năng này hiếm khi được sử dụng vì
thực ra chúng thực hiện chậm hơn một nhóm lệnh cùng thực hiện nhiệm vụ đó. Đây
giống như một nghịch lý của tiến trình thiết kế VXL, người lập trình chỉ quan tâm đến
những lệnh được sử dụng phổ biến.
CPU bắt đầu hoạt động nhanh hơn bộ nhớ. Năm 1970, người ta tiên đoán sự việc này sẽ
còn tiếp diễn không quá 1 thập niên nữa, và đến lúc đó CPU sẽ nhanh hơn bộ nhớ gấp
nhiều lần. CPU cần thêm nhiều thanh ghi (hay còn gọi là cache) để có thể thực hiện ở tốc
độ nhanh hơn. Nếu giảm sự phức tạp của CPU, những thanh ghi và bộ nhớ đệm mới sẽ
cần khoảng trống trên chip.
RISC thường có tập lệnh rất lớn. Cũng từ khuynh hướng đơn giản hóa đó, một số thiết kế
thú vị ra đời như MISC (Minimal Instruction Set Computer - Máy tính với tập lệnh tối
thiểu) hay OISC (One Instruction Set Computer) với những máy tính như Transport
Triggered Architectures, trong khi các thiết kế khác đi sâu vào vấn đề Turing tarpit.
Thời gian đầu của ngành công nghiệp máy tính, trình biên dịch chưa hình thành. Công
việc lập trình được thực hiện hoặc bằng ngôn ngữ máy (mã nhị phân) hoặc bằng hợp ngữ.

Để việc lập trình đơn giản, các VXL được thêm những lệnh có thể biểu diễn trực tiếp

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 3/38

những cấu trúc của ngôn ngữ lập trình cấp cao. Lúc đó thiết kế phần cứng dễ hơn nhiều
so với thiết kế trình dịch, vì thế mọi phức tạp đều dồn vào phần cứng.
Điểm khác nhau của CPU RISC so với CPU CISC là khả năng thực thi mọi thứ trong các
thanh ghi, đọc và lưu dữ liệu vào các thanh ghi. Do đó để tránh hiểu lầm nhiều nhà
nghiên cứu thích dùng thuật ngữ load-store.
Giờ đây để hoàn thành cùng một việc, chương trình được viết với những lệnh đơn giản
thay vì với một lệnh phức tạp, phần lớn các lệnh phải đọc từ bộ nhớ nhiều hơn do đó
cũng mất nhiều thời gian hơn.
Những CPU thời kỳ trước không có nhiều thanh ghi vì những nguyên nhân sau:


Một bit trong CPU bao giờ cũng giá trị cao hơn rất nhiều so với một bit ở bộ nhớ
ngoài. Với công nghệ tích hợp ở thời kỳ này để có thể sử dụng thêm thanh ghi nhất
định phải có thêm vùng trống trên board hoặc trên chip.



Một lượng lớn thanh ghi cũng sẽ cần một lượng lớn các bit trong mã lệnh để xác
định các thanh ghi đó.

Vì những lý do trên, những chuyên gia thiết kế VXL nỗ lực để mỗi lệnh có thể thi hành
càng nhiều kĩ thuật càng tốt. Điều này dẫn đến một lệnh sẽ làm tất cả công việc như nạp 2
số cần cộng, cộng chúng lại, và cuối cùng lưu trở lại vào bộ nhớ. Cũng lệnh đó lại có thể

đọc một số từ thanh ghi và số còn lại từ bộ nhớ sau đó lưu kết quả vào bộ nhớ. Khuynh
hướng thiết kế VXL này được gọi là Complex Instruction Set Computer – CISC.
Mục đích chung của thời gian này là mỗi lệnh giúp đỡ càng nhiều khả năng đánh địa chỉ
càng tôt. Điều này dẫn đến một số phức tạp cho CPU, mặc dù theo nguyên lý mỗi lệnh có
thể được tối ưu khác nhau, làm quá trình thiết kế nhanh hơn nếu người lập trình sử dụng
các lệnh đơn giản.
Những năm đầu thập niên 1980, công nghệ thiết kế VXL đã đạt đến đỉnh điểm. Sự tăng
cường chỉ còn có thể hoàn thiện với công nghệ bán dẫn, như giảm bớt đường kính của
các transistor hoặc dây nối trên chip. Dù cấu trúc tinh vi của chip không thay đổi nhưng
với kích thước nhỏ hơn nó vẫn có thể phục vụ ở tốc độ cao hơn. Cũng có nhiều nỗ lực để
thiết kế các chip VXL đồng thời. Thay vì làm cho chip chạy với tốc độ nhanh hơn người
ta làm cho nhiều chip có thể cùng chia sẻ các tác vụ.
Ý tưởng đầu tiên có lẽ là "kênh dẫn" (pipeline). Đây là một khả năng nhằm chia nhỏ thời
gian thực hiện một lệnh thành nhiều chu trình, và các chu trình khác nhau của các lệnh
khác nhau có thể được thực thi đồng thời. Một bộ xử lý thông thường đọc một lệnh, giải
mã nó, đọc những vùng nhớ lệnh đó cần, thực thi lệnh, trả kết quả về. Với kỹ thuật "kênh
dẫn", VXL có thể đọc một lệnh ngay sau khi nó đọc xong lệnh trước đó, tức là nó vừa
giải mã một lệnh vừa đọc lệnh kế tiếp, tới chu kỳ kế VXL sẽ làm việc với ba lệnh cùng
lúc, và cứ thế tiếp tục. Lệnh theo sau sẽ hoàn thành ngay sau khi lệnh trước hoàn tất nên
đây là một giải pháp rất hiệu quả nhằm tận dụng tối đa tài nguyên của các VXL.

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 4/38

Một cách khác là dùng nhiều phân đoạn xử lý song song trong cùng một VXL. Giả sử
phải giải quyết một lệnh VXL sẽ tìm cách làm ngay lập tức lệnh kế tiếp trong một đơn vị
xử lý khác. Tuy nhiên đây là một giải pháp khá khó thực hiện vì nhiều lệnh đôi khi lại
phụ thuộc vào kết quả của lệnh trước nó.

Cả hai phương án trên hướng tới việc cải tiến bằng cách tăng độ phức tạp của CPU. Vì
kích thước trên chip là hạn hẹp đó để thêm những khả năng mới này cần loại bỏ đi những
tính năng khác. Vì thế RISC được lợi ích trước tiên do về cấu hình nó dễ hiểu hơn CISC
khá lớn. Những thiết kế RISC đầu đời phát triển được thêm những khả ích mới giúp
chúng hình thành những chip CISC tương ứng. Lúc này các chuyên gia bắt đầu phát hiện
đến việc cộng những điều này vào những chip CISC trong khi vẫn chắc chắn đường kính
của chúng, công việc này kéo dài suốt những năm cuối thập niên 1980 và đầu 1990.
Dù ở bất kỳ khả năng nào, đơn vị logic của một chip RISC bao giờ cũng cần ít transistor
hơn so với của một chip CISC. Sự kiện này giúp người lập trình có rất nhiều sự nhạy bén,
ví dụ họ có thể:
Những
điểmthước
thường
thấyghi.
trong 1 chip RISC:
1. Tăngđặc
số kích
thanh
2. Sử dụng các phương pháp tối ưu để tăng mức độ xử lý song song bên trong CPU
Ngày
nay,superscalar)
một số kiến trúc RISC được hình thành dựa vào kiến trúc Harvard, trong đó
(pipeline,
đường
liệuthước
và đường
3. Tăngdữkích
cachechương trình khác biết. Điều này làm cho quá trình đọc dữ liệu
và mã lệnh có thể thực hiện đồng thời do đó có thể nâng cao công suất của VXL.
4. Thêm các tính năng như I/O, timer v.v…

Một trong những điểm yếu của các VXL RISC thế hệ đầu tiên là hiệu ứng branch delay
5.
Thêm
bộnày
xử lý
vector.
slot.
Hiệucác
ứng
xảy
ra khi có 1 lệnh nhảy có điều kiện, lúc đó dù có thực hiện nhảy
hayTận
không
một
hoặc
một công
số lệnh
theocũ,sau
vẫn khi
được
thi điều
do các
được
6.
dụngthìcác
dây
chuyền
nghệ
trong
vớithực

CISC
nàylệnh
rất này
khó đã
khăn
do
đưa
vào
pipeline
trong
lúc
lệnh
nhảy
đang
được
xử
lý.
Điều
này
gây
ra
một
khoảng
thời
kích thước chip lớn hơn
gian trễ khi thực thi lệnh nhảy có điều kiện. branch delay slot không những xuất hiện
7.
Cung
cấp VXL
nhữngRISC

chip như
cho MIPS,
những PA-RISC
ứng dụng và
có SPARC
yêu cầumà
caocòn
về cả
thờitrong
giancác
sử DSP
dụng như
pin
trong
những
µPD77230 hoặc TMS320C3x. Tuy nhiên ngày nay trong các thiết kế RISC hiện đại
người
đã cóchuẩn
thể loại
được(víhiệu
1. Địnhta dạng
mãbỏlệnh
dụ ứng
lệnhnày.
có chiều dài cố định, các bit của mã lệnh luôn
nằm
vị trí cố
địnhbiết
trong
lệnh)

trình
giải
mã lệnh
giản
hơn.
VXLởRISC
được
đếnmã
đầu
tiênsẽlàlàm
siêuquá
máy
tính
CDC
6600đơn
được
Jim
Thornton và
Seymour
Cray
thiết
kế
năm
1964,
nó
có
74
mã
lệnh
(8086

có
400
mã
lệnh)
cộng
vớimọi
12
2. Các thanh ghi đồng nhất, do đó chúng có thể được sử dụng thay thế nhau
trong
máy
tính đơn
giản
được
gọithanh
là "bộ
lý ngoại
vi"nguyên
để xử lý
CDCdấu
6600
sử dụng
tình huống
(tuy
nhiên
các
ghixửdành
cho số
vàI/O.
số thực
chấm

độngkiến
vẫn
trúc
load-store,
nó
hỗ
trợ
2
phương
pháp
đánh
địa
chỉ,
có
11
đơn
vị
được
"kênh
dẫn
hóa",
phân biệt nhau).
năm đơn vị đọc dữ liệu và 2 đơn vị để lưu dữ liệu (bộ nhớ của nó được tổ chức theo bank
3.
đánh
giản.
có động
nhữngđồng
phương
địa chỉ

phức
tạp cần
kết
do Cách
đó các
đơnđịa
vị chỉ
đọc đơn
ghi có
thểĐể
hoạt
thời).pháp
Tốcđánh
độ xung
đồng
hồ/lệnh
nhanh
hợp
cácsophép
sốtruy
học.xuất bộ nhớ.
hơn với
10 lần
với toán
tốc độ
4.
Hỗ trợ
rất ít thời
kiểugian
dữ liệu

CISC thực
có thểhiện
có cả
thao
tác với
xử
Cũng
khoảng
đó (một
John số
L. chip
Hennessy
dựcác
án lệnh
MIPS
ở Đại
họcchuỗi,
Stanford
lý
số 1981.
phức hoặc
nhưvào
thếkhả
chẳng
giờ tồnđểtạiphục
trongvụ1tối
chip
lý
năm
MIPSma

hầutrận.
nhưNhững
chỉ chúlệnh
trọng
năngbao
pipeline
đaRISC
kĩ năng
tưởng).
của các VXL. Cho dù đã được thực hiện trước đó rồi, nhưng với RISC, phương pháp này
đã thực sự được cải tiến vượt bậc. Nhưng vấn đề thiết yếu nhất, cũng phiền toái nhất, là
nó yêu cầu tất cả các lệnh quyết định phải được thực thi trong 1 chu kỳ máy. Nếu đáp ứng

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 5/38

được yêu cầu này, pipeline có thể thi hành ở tốc độ rất cao và đây hầu như là yếu tố quyết
định đến tốc độ của VXL. Tuy nhiên nó cũng có mặt trái là phải bỏ đi rất nhiều lệnh có
ích như nhân, chia.
Hầu hết các dự án kể trên đều nhằm mục đích cải tiến các kỹ thuật hiện có, phải chờ tới
năm 1975, dự án đầu tiên nhằm cho ra đời 1 chip RISC hoàn chỉnh mới được thực hiện ở
IBM. Được đặt tên theo số của ngôi nhà nơi dự án được thực hiện, dự án này đã cho ra
đời họ VXL IBM 801 vốn được sử dụng rộng rãi trong các phần cứng của IBM.
Một máy tính khác được thiết kế trên với kiến trúc load-store là Data General Nova. Đây
là một CPU nhỏ 16 bit được thiết kế năm 1968 bởi 1 công ty Mỹ tên là Data General.
Tuy nhiên VXL RISC được biết nhiều nhất lại đến từ một dự án được thực hiện bởi
chương trình VLSI (Very Large-Scale Integration) của DARPA (Defense Advanced
Research Projects Agency). Dự án trên đã cho ra đời rất nhiều phát triển liên quan đến

thiết kế, sản xuất chip và cả đồ họa máy tính.
Dự án RISC của Đại học Caifornia, Berkeley bắt đầu năm 1980 dưới sự hướng dẫn của
David Patterson với mục đích nâng cấp hiệu suất của các VXL dựa trên kỹ thuật pipeline
và register windows. Một VXL thông thường có khá ít thanh ghi, các chương trình có thể
tùy ý sử dụng các thanh ghi đó bất cứ lúc nào. Vì thông thường mỗi lần gọi 1 chương
trình con, VXL cần lưu lại giá trị một số thanh ghi và sau đó hồi phục lại các thanh ghi đó
khi thực hiện lệnh return.
Dự án RISC cho ra đời VXL RISC-I năm 1982. VXL này chứa 44.420 transistor (so với
100.000 transistor cho 1 VXL CISC), với 32 lệnh nhưng hoàn toàn vượt xa các VXL đơn
chip cùng thời. VXL RISC-II ra đời năm 1983 với 39 lệnh, chứa 40.760 transistor và
nhanh gấp 3 lần RISC-I.
Trong những năm đầu, các dự án chủ yếu chỉ được biết đến trong các trường đại học. Đến
năm 1986, tất cả các dự án về RISC bắt đầu cho ra đời sản phẩm. Ngày nay hầu hết các
chip RISC, đều được thiết kế dựa trên kiến trúc RISC-II của Berkeley
Bảng 1-2: Các hệ thống và các RISC phổ biến

Họ MIPS, trong các máy tính SGI, PlayStation và Nintendo 64 game consoles
Họ POWER trong các SuperComputers/mainframes của IBM
Freescale (trước đây là Motorola SPS) và IBM's PowerPC trong Nintendo Gamecube,
Microsoft Xbox 360, Nintendo Wii and Sony PlayStation 3 game consoles, và cho
tới gần đây là Apple Macintosh
SPARC và UltraSPARC, trong tất cả các hệ thống của Sun

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 6/38

Hewlett-Packard PA-RISC
DEC Alpha

ARM — Palm, Inc. Ban đầu sử dụng (CISC) Motorola 680x0 trong những PDA đầu
tiên, nhưng hiện tại là (RISC) ARM; Nintendo sử dụng 1 chip ARM7 trong Game
Boy Advance và Nintendo DS. Nhiều nhà sản xuất điện thoại di động, như Nokia
cũng dựa trên kiến trúc của ARM.
1.1.2 Lý thuyết về CPU RISC
1.1.2.1 Quy trình thiết kế số
Môi trường thiết kế tự động trong thiết kê số, quá trình thiết kế sơ khai bằng việc mô tả
thiết kế bằng nhiều mức độ trừu tượng khác nhau và hoàn thành bằng việc lập thành danh
sách các thiết bị cũng như các đường gắn kến giữa các linh kiện lại với nhau (netlist) cho
một mạch tích hợp với phần mềm cụ thể(ASIC), mạch in (layout) cho một mạch tích hợp
theo mục đích khách hàng (custom IC), hoặc một chương trình cho một thiết bị logic có
khả năng lập trình được (PLD). Nhiệm vụ của thiết kế, một thiết kế sẽ được mô tả bởi sự
hỗn hợp giữa trình bày ở cấp độ hành vi (behavioural) Verilog, sử dụng những gói
(module) thiết kế Verilog đã được thiết kế sơ khai, và việc gài chương trình các bus và
wire để hợp nhất các gói thiết kế này hình thành một hệ thống hoàn chỉnh. Kĩ sư thiết kế
cũng phải có phương hướng tạo ra dữ liệu để kiểm tra (testbench) xem thiết kế có đúng
nhiệm vụ hay chưa cũng như dùng để thực hiện phần mềm sau khi kết hợp. mô phỏng để
kiểm tra thiết kế bằng phần mềm Quartus, chèn những phương pháp kiểm tra, tìm kiếm
thông thường hoặc kết hợp cả ba nguyên tắc trên. Sau bước kiểm tra đánh giá thiết kế,
thiết kế sẽ được hướng dẫn bằng việc gắn kết để hình thành phần cứng thực sự cho hệ
thống thiết kế cuối cùng (ASIC, custom IC or FPLD,…). Nếu hệ thống thiết kế là ASIC,
thiết kế sẽ được trình bày bởi nhà sản xuất khác; nếu là custom IC, thiết kế sẽ được sản
xuất hiện tại của nhà sản xuất; nếu là FPLD, thiết kế sẽ được nạp lên thiết bị lập trình
được. Sau bước kết hợp và trước khi phần cứng được hình thành, một phương thức mô
phỏng khác phải được hình thành. Việc mô phỏng này, ta có thể sử dụng testbench tương
tự testbench đã sử dụng trong thử nghiệm trước kết hợp (presynthesis).

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add

Trang 7/38

Hình 1-2: luồng thiết kế ASIC

1.1.2.2 Dẫn nhập thiết kế
Ban đầu trong thiết kế hệ thống số là bước kết nạp thiết kế. Trong phần này, thiết kế được
mô tả bằng Verilog theo phương pháp phân tầm từ cao xuống thấp (top-down). Một thiết
kế hoàn thành chỉ có thể gồm những linh kiện ở mức cổng logic hoặc mức transistor,
những khối (module) phần cứng có chức năng cấu thành rắc rối hơn được phân tập ở mức
độ hành vi, hoặc những linh kiện được chỉ mục bởi phương pháp bus. Do những thiết kế
Verilog ở mức cao thường được mô tả ở mức độ mà tại đó nó mô tả hệ thống những
thanh ghi và sự truyền dữ liệu giữa những thanh ghi này thông qua mô hình bus, việc mô
Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 8/38

tả hệ thống thiết kế ở cấp độ này được xem như là mức độ kết nối gói dữ liệu giữa các
thanh ghi (RTL). Một thiết kế hoàn chỉnh được mô tả như vậy sẽ tạo ra được phần cứng
tương ứng thực sự rõ ràng. Những cấu trúc thiết kế Verilog ở cấp độ RTL sử dụng những
phát biểu qui trình (producedural statements), phép gài liên tục (continuous assignments),
và những biểu hiện được gọi sử dụng khối (module) đã xây dựng sẵn. Những tuyên bố
qui trình Verilog (procedural statements) được dùng để mô tả mức độ hành vi ở mức cao.
Một hệ thống hoặc một linh kiện được mô tả ở cấp độ hành vi thì tương ứng với việc mô
tả trong ngôn ngữ phần mềm. Mô tả hệ thống một cách qui trình như vậy, cấu trúc if-else,
case của Verilog cũng như những ngôn ngữ phần mềm khác đều sử dụng như nhau.
Những phép gán liên tục (continuous assignment) trong Verilog là những phép gán
cho việc thể hiện chức năng những khối logic, những phép cài bus, và phát biểu việc liên
kết giữa hệ thống bus và các đường ngõ vào và đường ngõ ra. Kết hợp với những hàm
Boolean và những biểu thức có điều kiện, những cấu trúc phương pháp ngôn ngữ này có

thể được để được hình thành những linh kiện và hệ thống theo những phép gán thanh ghi
và bus của chúng. Những linh kiện này có thể nhỏ như là mức cổng hay transistor, hoặc
có thể lớn như là một bộ vi xử lí hoàn chỉnh. Những phát biểu gọi sử dụng khối Verilog
đã được thiết kế sẵn (instantiantion statements) được sử dụng cho những linh kiện mức
độ không cao trong một thiết kế ở cấp độ cao hơn. Thay vì mô tả ở mức độ hành vi,
chức năng, hoặc bus của một hệ thống, chúng ta có thể mô tả một hệ thống bằng Verilog
bằng cách kết nối những linh kiện ở mức độ thấp hơn.
1.1.2.3 Testbench trong Verilog
Một hệ thống được thiết kế dùng Verilog phải được thực thi và kiểm chứng xem thiết kế
đã đúng mục đích chưa trước khi hình thành ra phần cứng. Trong thời gian chạy mô
phỏng này, những khuyết điểm trong mô hình và sự không tương xứng giữa các linh kiện
dùng trong thiết kế có lẽ sẽ được tìm ra. Chạy mô phỏng một thiết kế cần phải hình thành
ra một đường dữ liệu ngõ vào tìm ra và quá trình quan sát kết quả sau khi chạy mô
phỏng, dữ liệu dùng để kiểm chứng này được gọi là testbench. Một testbench sử dụng cấu
trúc mức cao của Verilog để tạo ra dữ liệu kiểm tra, quan sát đáp ứng ngõ ra, và cả việc
bắt tay giữa những tín hiệu trong thiết kế. Bên trong testbench, hệ thống thiết kế
Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 9/38

cần chạy mô phỏng sẽ được gọi ra (instantiate) trong testbench. Dữ liệu testbench
cùng với tiến trình thiết kế sẽ tạo ra một mô hình mô phỏng mà sẽ được sử dụng bởi một
phương pháp mô phỏng Verilog.
1.1.2.4 Mô phỏng
Chạy mô phỏng dùng trong việc kiểm tra thiết kế được thi hành trước khi thiết kế được
kết hợp. Bước chạy mô phỏng này được biết như mô phỏng ở cấp độ hành vi, cấp độ RTL
hay trước tổng hợp. Ở mức độ RTL, một mô hình bao gồm xung chu kì clock nhưng
không bao gồm trí hoãn thời gian trên cổng và cáp kết nối (wire). Chạy mô phỏng ở mức
độ này sẽ chính xác theo xung clock. Thời gian của việc chạy mô phỏng ở mức độ RTL là

theo tín hiệu xung clock, không quan tâm đến những vấn đề như: nguy hiểm tiềm ẩn có
thể khiến thiết kế bị lỗi (hazards, glitch), hiện tượng chạy đua không kiểm soát giữa
những tín hiệu (race conditions), những vi phạm về thời gian setup và hold của tín hiệu
ngõ vào, và những vấn đề liên quan đến định thời khác. Ưu điểm của việc mô phỏng này
là tốc độ chạy mô phỏng nhanh so với chạy mô phỏng ở mức cổng hoặc mức transistor.
Chạy mô phỏng cho một thiết kế đòi hỏi dữ liệu kiểm tra. Thông thường trong môi
trường mô phỏng Verilog sẽ cung cấp nhiều phương pháp khác nhau để đưa dữ liệu kiểm
tra này vào thiết kế để kiểm tra. Dữ liệu kiểm tra có thể được tạo ra bằng đồ họa sử dụng
những công cụ soạn thảo dạng sóng, hoặc bằng testbench. Những ngõ ra của công cụ mô
phỏng là những dạng sóng ngõ ra (có thể quan sát trực quan).

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 10/38

Hình 1-3 Hai cách khác nhau để định nghĩa dữ liệu kiểm tra ngõ vào

Để chạy mô phỏng với Verilog testbench, trong testbench sẽ kêu phần mềm thiết kế ra để
kiểm chứng, lúc này hệ thống lập trình được xem như là một thành viên của testbench,
testbench sẽ cung cấp dữ liệu kiểm tra đến ngõ vào của hệ thống thiết kế. Với mỗi xung
clock thì ngõ ra bộ đếm sẽ tăng lên 1. Chú ý rằng, theo biểu đồ thời gian thì ngõ ra bộ
đếm thay đổi tại cạnh lên xung clock và không có thời gian trì hoãn do cổng cũng như trì
hoãn trên đường truyền. Kết quả chạy mô phỏng cho thấy chức năng của mạch đếm là
chính xác mà không cần quan tâm đến tần số xung clock. Hiển nhiên, những linh kiện
phần cứng thực sự sẽ có đáp ứng khác nhau. Hơn nữa, nếu tần số xung clock được cấp
vào mạch thực sự quá nhanh so với tốc độ truyến tín hiệu bên trong các cổng và transistor
của thiết kế thì ngõ ra của thiết kế sẽ không thể biết được. Việc mô phỏng này không
cung cấp chi tiết về các vấn đề định thời của hệ thống thiết kế được mô phỏng. Do đó,
những vấn đề giấu kín về định thời của phần cứng do trì hoãn trên cổng sẽ không thể phát

hiện được. Đây là vấn đề điển hình của quá trỉnh mô phỏng tiền tổng hợp hoặc mô phỏng
ở mức độ hành vi. Thiết kế hoạt động yếu thế nào, phục vụ được ở tần số nào chỉ có thể
biết được bằng việc kiểm tra thiết kế sau tổng hợp.
1.1.2.5 CPU RISC 32 bit đơn chu kỳ
RISC(Reduced Instruction Set Computer): bộ lệnh chỉ gồm các lệnh đơn giản.

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 11/38

Nhiệm vụ cơ bản nhất của CPU là phải thực hiện các lệnh được yêu cầu, gọi là
instruction, Các CPU sẽ sử dụng các tập lệnh (instruction set) khác nhau để có thể giao
tiếp với nó.
CPU xử lý lệnh qua 2 bước, gọi là chu kỳ lệnh:
-

Nạp lệnh (Fetch): Di chuyển lệnh từ memory vào thanh ghi(register) trong CPU
Thực thi lệnh (Excute): Giải mã lệnh và thực thi thao tác yêu cầu

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 12/38

Hình 1-4: Kiến trúc CPU RISC 32 bit đơn chu kỳ

Ngôn ngữ máy cho phép người lập trình viên trình bày các chu trình đơn giản mà bộ vi
xử lý (CPU) có thể thực hiện được ngay các giới thiệu này được gọi là chỉ thị / lệnh
(instruction) hoặc mã máy (machine code):

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 13/38

-

Mỗi bộ vi xử lý (CPU) có 1 ngôn ngữ riêng, gọi là bộ lệnh (instruction set)
Trong cùng 1 dòng vi xử lý (processor family) bộ lệnh gần giống nhau.

Instruction là dãy bit chứa yêu cầu mà bộ xử lý trong CPU (ALU) phải thực hiện.
- Instruction gồm 2 thành phần:
 Mã lệnh (opcode): thao tác cần thực hiện.
 Thông tin về toán hạng (operand): các thành viên bị tác động bởi thao tác chứa
trong mã lệnh.
xây dựng theo kiến trúc (RISC) với 4 nguyên tắc:
-

Càng đơn giản, độ ổn đinh cao.
Càng nhỏ gọn, tốc độ xử lý nhanh.
Tăng tốc xử lý cho những vấn đề thường xuyên xảy ra.
Thiết kế đòi hỏi sự thỏa hiệp tốt.

Nguyên tắc lưu dữ liệu trong bộ nhớ
- MIPS thao tác và lưu trữ dữ liệu trong bộ nhớ theo 2 nguyên tắc:
 Alignment Restriction: Các đối tượng lưu trong bộ nhớ (từ nhớ) phải bắt đầu tại
địa chỉ là bội số của kích thước đối tượng. Mà mỗi từ nhớ có kích thước là 32 bit =
4 byte = kích thước lưu trữ của 1 thanh ghi trong CPU
 Big Endian: MIPS lưu trữ thứ tự các byte trong 1 word trong bộ nhớ theo nguyên

tắc Big Endian.
Thanh ghi trong CPU
- Thanh ghi lưu trữ
 MIPS lấy ra 8 thanh ghi ($16 - $23) dùng để thi hành các phép tính số học, được
đặt tên tương ứng là $s0 - $s7.
- Thanh ghi tạm thời
 MIPS lấy ra 8 thanh ghi ($8 - $15) dùng để chứa kết quả trung gian, được đặt tên
tương ứng là $t0 - $t7.

Bảng 1-3: Thanh ghi trong CPU RISC

Số

Tên

Ý nghĩa

$0

$zero

Hằng số 0

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 14/38

$1

$at

Assembler Temporary

$2-$3

$v0-$v1

Giá trị trả về của hàm hoặc biểu thức

$4-$7

$a0-$a3

Các tham số của hàm

$8-$15

$t0-$t7

Thanh ghi tạm (không giữ giá trị trong quá trình gọi hàm)

$16-$23

$s0-$s7

Thanh ghi lưu trữ (giữ giá trị trong suốt quá trình gọi hàm)

$24-$25

$t8-$t9

Thanh ghi tạm

$26-27

$k0-$k1

Dự trữ cho nhân Hệ điều hành

$28

$gp

Con trỏ toàn cục (global pointer)

$29

$sp

Con trỏ stack

$30

$fp

Con trỏ frame

$31

$ra

Địa chỉ trả về

1.1.3 Hướng nghiên cứu
Các tập lênh của CPU RISC
Tìm hiểu đường đi của các lệnh trong cấu trúc RISC.
Lưu giá vào trị thanh ghi trong Register File.
Tổ chức lại quá trình thực hiện trong bộ vi xử lý hoặc nhằm giảm bớt số lần truy xuất bộ
nhớ.
Các hằng hoàn toàn có thể biểu diễn bằng 13 bit, trong khi đó các CPU được thiết kế theo
bội số của 8 (thường là 8, trong những bit dư của mã lệnh sẽ làm giảm đi rất nhiều lần
truy xuất bộ nhớ. Thay vì phải đọc từ bộ nhớ hay từ thanh ghi các hằng đã ở ngay đó khi
CPU cần, vì thế quá trình thực thi sẽ nhanh hơn.
1.2 Nguyên lý chung
1.2.1 Nguyên tắc lưu dữ liệu trong bộ nhớ
MIPS lưu dữ liệu trong bộ nhớ theo nguyên tắc Alignment Restriction, nghĩa là các đối
tượng lưu trong bộ nhớ phải bắt đầu tại địa chỉ là bội số của kích thước đối tượng.
Như vậy, từ nhớ phải bắt đầu tại địa chỉ là bội số của 4.
Sắp thẳng hàng và không thẳng hàng

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 15/38

Hình 1-5: Nguyên tắc Alignment Restriction

1.2.2 Cú pháp lệnh
opt opr , opr1, opr2

opt (operator): Tên thao tác (toán tử, tác tử).
opr (operand): Thanh ghi (toán hạng đích) chứa kết quả.
opr1 (operand 1): Thanh ghi (toán hạng nguồn 1).
opr2 (operand 2): Thanh ghi / hằng số (toán hạng nguồn 2).

Bảng 1-4:Cấu trúc lệnh

Type

R

Format (bits)
31-

Opcode (6)

-0

Rs (5)

Rt (5)

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add

Rd (5)

Shamt (5)

Funct (6)

Trang 16/38

J

Opcode (6)

I

Opcode (6)

Rs (5)

Rt (5)

Immediate (16)
Address (26)

Trong đó:
Opcode: xác định số học / logic hoạt động sẽ được thực hiện.
Rs: Thanh ghi đích mà kết quả sẽ được lưu giữ.
Rt: Thanh ghi nguồn có chứa toán hạng thứ nhất.
Rd: Thanh ghi nguồn có chứa toán hạng thứ hai.
Shamt: Chứa số bit cần dịch trong các lệnh dịch.
Funct: chứa số bit của từng loại lệnh khác nhau.

CHƯƠNG 2. NỘI DUNG CỦA ĐỀ TÀI
2.1 Đường dữ liệu của lệnh add

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add

Trang 17/38

Hình 2-1: đường dữ liệu lệnh add

Khi xung clock kích vào PC, trạng thái hiện tại của PC là địa chỉ 0, nó sẽ chuyển qua
khối Instruction Memory tại đây thực hiện lệnh 0, chuyển các địa chỉ thanh ghi đích (r1),
các thanh ghi chứa dữ liệu (r2 và r3) khối Register File để thực hiện lệnh add. Dữ liệu từ
RF sẽ qua khối ALU, tại đây thực hiện lệnh cộng 2 dữ liệu sau đó kết quả lưu lại địa chỉ
đích của khối Register File. Tiếp tục thực hiện các lệnh tiếp theo khi xung clock được
kích.

2.2 Control Unit
RegDst

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add

Control Unit


Trang 18/38
ALUSrc
MemtoReg
Opcode [31-26]
RegWrite
MemRead
MemWrite
Branch
ALUOp

Hình 2-2: Khối Control Unit
Bảng 2-1: Khối Control Unit loại R

Khối Control Unit sử dụng để điều khiển các khối chính, tùy thuộc vào từng loại mà các
bits điều khiển khác nhau.
2.3 Khối Register file

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 19/38

Hình 2-3 :Khối Register File

Khối Register File khá quan trọng trong cấu trúc CPU RISC. Dữ liệu trong thanh ghi
được lưu trữ sẵn một giá trị gốc, sử dụng để mô phỏng. trong đồ án chỉ sử dụng khoảng
10 thanh ghi để lư trữ giá trị. Sau mỗi lệnh add thực hiện, thanh ghi sẽ thay đổi giá trị.

2.4 Khối ALU

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add


Trang 20/38

Hình 2-4: Khối ALU 32bit

Khối ALU dùng để thực thi các lệnh trong CPU RISC, sử dụng bảng sự thật của bộ full
adder để thực hiện lệnh add 32bit.
Bảng 2-2: bảng sự thật bộ Full Adder

Thiết kế CPU RISC 32 bit đơn chu kỳ thực hiện lệnh add