Dấu chấm động:

Thế Khoảng thời Công nghệ

Ví dụ:
hệ gian
1 1940 – 1956 Vacuum tubes (đèn chân không)
2 1956 – 1963 Transistors (Linh kiện bán dẫn)
3 1964 – 1971 Integrated Circuits (vi mạch tích hợp)
4 1971 – nay Microprocessors (vi xử lý), CPU đa nhân, Super-
computer
5 Tương lai Parallel Processing (Tiến trình ss)
-Các thành phần cơ bản của máy tính: : Màn hình, Mainboard (bo mạch chủ),
CPU, Chân cắm dây nối HDD, RAM, Chân cắm mở rộng PCI /PCI Express, Nguồn
điện, Ổ quang CD / DVD, Ổ đĩa cứng, Bàn phím, Chuột
-Thành phần bên trong vi xử lý: control unit và data path
----------------------------------------------------------------------------------------------------------
Số nguyên có dấu:
- Dấu lượng: Bit trái nhất (MSB): bit dấu; Các bit còn lại giữ nguyên; Từ - 12710 - Số thực đặc biệt:
đến 12710.
- Bù 1: MSB: bit dấu; Số âm là đảo toàn bộ bit của dương; Từ - 12710 đến 12710.;
Cộng tiếp phần dư vào kết quả khi thực hiện phép cộng; Có 2 cách biểu diễn 0: -0
(00000000), +0(11111111).
- Bù 2: MSB: bit dấu; Số âm: đảo toàn bộ bit của dương rồi cộng 1; Từ - 12810 đến
12710; Bù 2 -> hệ 10: 1101 0110 = -27+26+2422+21=-42 (Lấy số âm của số đầu tiên
cộng tất cả số còn lại).
+ Lợi so với bù 1:
- Chỉ 1 cách biểu diễn 0.
- Không cần cộng phần dư vào kết quả.
- Số quá (thừa) k: - Số có thể chuẩn hóa:
+ Còn gọi là biểu diễn số dịch (biased presentation). + Lớn nhất:
+ Chọn k sao cho k + [số âm nhất] là số dương. VD: Chọn k = 128 cho phép bù 2 0 . 1111 1110 . 1111 1111 1111 1111 1111 111
(-128 + k = 0). + 1.[23 số 1]*2^127
- Nhận xét: + Nhỏ nhất:
+ Số bù 2 -> lưu trữ số có dấu và các phép tinh của chúng trên máy tinh 0 . 0000 0001 . 0000 0000 0000 0000 0000 000
(thường dùng nhất) + 1.[23 số 0]*2^-126
- Không cần thuật toán đặc biệt nào cho các phép tinh cộng và tinh trừ - Số không thể chuẩn hóa:
- Giúp phát hiện dễ dàng các trường hợp bị tràn. + Lớn nhất:
+ Dấu lượng / số bù 1 -> dùng các thuật toán phức tạp và bất lợi vì luôn có hai 0 . 0000 0000 . 1111 1111 1111 1111 1111 111
cách biểu diễn của số 0 (+0 và -0) + 0.[23 số 1]*2^-126
+ Dấu lượng -> phép nhân của số có dấu chấm động + Nhỏ nhất:
+ Số thừa K -> dùng cho số mũ của các số có dấu chấm động 0 . 0000 0000 . 0000 0000 0000 0000 0000 001
Giá trị không dấu và có dấu: +0.[22 số 0]1*2^-126
- Bit MSB = 0 thì giá trị có dấu bằng giá trị không dấu. Kiến trúc bộ lệnh
- Bit MSB = 1 thì giá trị có dấu bằng giá trị không dấu trừ đi 256 (28 nếu tinh theo - Complete Instruction Set Computer (CISC): bộ lệnh gồm rất nhiều lệnh, từ đơn
byte) hay 65536 (216 nếu tinh theo word). giản đến phức tạp
- VD: 1100 1100 1111 0000 -> Không dấu: 52464 -> Có dấu: 52464 - 65536 = - - Reduced Instruction Set Computer (RISC): bộ lệnh chỉ gồm các lệnh đơn giản
13072. *Các bộ phận trong quá trình biên dịch
And, or, xor, not: Compiler Trình biên dịch ngôn ngữ cấp cao -> hợp ngữ
Assembler Trình biên dịch hợp ngữ -> ngôn ngữ máy
Linker Thực tế khi lập trình, ta sẽ dùng nhiều file
(header / source) liên kết và kèm theo các thư
viện có sẵn
- AND dùng để tắt bit (AND với 0 luôn = 0)
->Cần chương trình Linker để liên kết các file
- OR dùng để bật bit (OR với 1 luôn = 1)
- XOR, NOT dùng để đảo bit (XOR với 1 = đảo bit đó) sau khi đã biên dịch thành mã máy này
- x AND 0 = 0 (Object file)
- x XOR x = 0
- Mở rộng: -> Tập tin thực thi (ví dụ: .exe, .bat, .sh)
¤ Lấy giá trị tại bit thứ i của x: (x SHR i) AND 1 Loader Khi double click vào những tập tin thực thi, cần chương
¤ Gán giá trị 1 tại bit thứ i của x: (1 SHL i) OR x
¤ Gán giá trị 0 tại bit thứ i của x: NOT(1 SHL i) AND x trình tính toán và tải vào memory để CPU xử lý
¤ Đảo bit thứ i của x: (1 SHL i) XOR x ->Loader
Prefix in byte
- Chuẩn IEC (International Electrotechnical Commission): kibi (Ki): 2^10 = 1024;
- Nạp lệnh (Fetch):
mebi (Mi): 2^20 = 1.048.576; gibi (Gi): 2^30; tebi (Ti): 2^40; pebi (Pi): 2^50; exbi
+ MAR <- PC; MBR <- Memory; IR <- MBR; PC <- PC + 1
(Ei): 2^60; zebi (Zi): 2^70; yobi (Yi): 2^80
+ PC (Program Counter): Lưu địa chỉ (address) của lệnh sắp được nạp
- Chuẩn SI (International System of Units): kilo (K): 2^10 = 1000; mega (M): 2^20 =
+ MAR (Memory Address Register): Lưu địa chỉ (address) sẽ được output ra
1.000.000; giga (G): 2^30; tera (T): 2^40; peta (P): 2^50; exa (E): 2^60; zetta (Z):
Address bus
2^70; yotta (i): 2^80
+ MBR (Memory Buffer Register): Lưu giá trị (value) sẽ được input output từ
- Chú ý: khi nói “kilobyte” chúng ta nghĩ là 1024 bytes nhưng thực ra nó là 1000
Data bus
bytes theo chuẩn SI, 1024 bytes là kibibyte (IEC)
+ IR (Instruction Register): Lưu mã lệnh sẽ được xử lý tiếp
- Hiện nay chỉ có các nhà sản xuất đĩa cứng và viễn thông mới dùng chuẩn SI.
- Thực thi lệnh (Execute): + AX (accumulator): chứa kết quả của các phép tinh. Kết quả 8 bit được chứa
+ Tính địa chỉ lệnh -> Nạp lệnh -> Giải mã lệnh -> Tính địa chỉ của trong AL
toán hạng -> Nạp toán hạng -> Thực hiện lệnh -> Tính địa chỉ của toán hạng chứa + Thanh ghi cơ sở BX (base): chứa địa chỉ cơ sở, ví dụ của bảng dùng trong lệnh
kết quả -> Ghi kết quả XLAT (Translate)
+ Các bước này được lặp đi lặp lại cho tất cả các lệnh tiếp theo + Thanh ghi đếm CX (count): dùng để chứa số lần lặp trong các lệnh lặp (Loop).
+ Quy trình này gọi là Instruction cycle – vòng lặp xử lý lệnh CL được dùng để chứa số lần dịch hoặc quay trong các lệnh dịch và quay thanh
MIPS: ghi
- MIPS sử dụng kiến trúc nạp-lưu + Thanh ghi dữ liệu DX (data): cùng AX chứa dữ liệu trong các phép tinh nhân
- MIPS sử dụng kiến trúc 3 toán hạng chia số 16 bit. DX còn được dùng để chứa địa chỉ cổng trong các lệnh vào ra dữ
- Kích thước lệnh bị ảnh hưởng bởi: Cấu trúc đường truyền bus, Kích thước và tổ liệu trực tiếp (IN/OUT)
chức bộ nhớ, Tốc độ CPU. + CS:IP: chứa địa chỉ lệnh tiếp theo trong đoạn mã lệnh CS.
- Giải pháp tối ưu lệnh: Dùng lệnh có kích thước ngắn, mỗi lệnh chỉ nên được + SS:BP: chứa địa chỉ của dữ liệu trong đoạn ngăn xếp SS hoặc khác.
thực thi trong đúng 1 chu kỳ CPU, Dùng bộ nhớ cache. + SS:SP: chứa địa chỉ hiện thời của đỉnh ngăn xếp
- Được xây dựng theo kiến trúc (RISC) với 4 nguyên tắc: + DS:SI: chứa địa chỉ dữ liệu nguồn trong đoạn dữ liệu DS trong các lệnh chuỗi
+ Càng đơn giản, càng ổn định + DS:DI: chứa địa chỉ dữ liệu đích trong đoạn dữ liệu DS trong các lệnh chuỗi
+ Càng nhỏ gọn, xử lý càng nhanh + SI và DI có thể được sử dụng như thanh ghi đa năng
+ Tăng tốc xử lý cho những trường hợp thường xuyên xảy ra - Thanh ghi cờ:
+ Thiết kế đòi hỏi sự thỏa hiệp tốt + C hoăc CF (carry flag)): CF=1 khi có nhớ hoặc mượn từ MSB
- Cấu trúc: + P hoặc PF (parity flag): PF=1 (0) khi tổng số bít 1 trong kết quả là chẵn (lẻ)
.data # data segment - khai báo + A hoặc AF (auxilary carry flag): cờ nhớ phụ
str: .asciiz “Hello asm !” + Z hoặc ZF (zero flag): ZF=1 khi kết quả bằng 0
.text # text segment - Viết lệnh sau chỉ thị này + S hoặc SF (Sign flag): SF=1 khi kết quả âm
.globl main + O hoặc OF (Overflow flag): cờ tràn
main: # starting point of program - Địa chỉ vật lý = Segment*16 + offset
- Kiến trúc MIPS: Có tổng cộng 32 thanh ghi đánh số từ $0 à $31, Mỗi thanh ghi - Lệnh:
có kích thước cố định 32 bit. + XCHG Đích, nguồn: hoán chuyển nội dung giữa đích và nguồn
- Không tồn tại khái niệm biến, thay vào đó là thanh ghi toán hạng. + ADC Đích, nguồn: Cộng có nhớ: Đích=Đích + nguồn+CF
- Thanh ghi: + MUL nguồn: EAX=EAX* nguồn; IMUL (Nhân có dấu)
+ DIV nguồn: EAX: thương; EDX: dư; IDIV (Chia có dấu)
+ NOT nguồn; NEG nguồn: lấy bù 2
+ CMP Đích, nguồn: Đích = nguồn (CF=0 ZF=1); > (CF=0 ZF=0); < (CF=1 ZF=0)
+ ROL Đích, CL: Quay trái; ROR: quay phải
+ SAL Đích, CL: Dịch trái số học; SHL: dịch trái logic
+ SAR Đích, CL: Dịch phải số học;
- Kiểu biển: b (1 byte), w (2 bytes), d (4 bytes), q (8 bytes), t (10 bytes)
Mạch Logic

- Thao tác và lưu trữ dữ liệu trong bộ nhớ theo 2 nguyên tắc:
+ Alignment Restriction: từ nhớ phải bắt đầu tại địa chỉ là bội số của4.
+ Big Endian: Lưu trữ theo thứ tự byte từ trái sang phải.
- Toán hạng: add; addi; sub; subi; mult $s0, $s1 -> $hi $lo; div $s0 $s1 -> $lo
(thương) $hi (dư); Lấy giá trị từ $hi $lo: -> mflo $s0 hay mfhi $s0;
- Tràn số:
+ Kết quả phép tinh vượt qua miền giá trị cho phép -> Tràn số xảy ra
+ add, addi, sub: Phát hiện tràn số
+ addu, addiu, subu: Không phát hiện tràn số Bộ nhớ:
- Toán luận lý:
+ and, or, nor: Toán hạng nguồn thứ 2 (opr2) phải là thanh ghi (a nor b = not (a
or b))
+ andi, ori: Toán hạng nguồn thứ 2 (opr2) là hằng số
- Dịch:
+ Dịch trái luận lý (sll – shift left logical): Thêm vào các bit 0 bên phải
+ Dịch phải luận lý (srl – shift right logical): Thêm vào các bit 0 bên trái
+ Dịch phải số học (sra – shift right arithmetic): Thêm các bit = giá trị
bit dấu bên trái.
- Di chuyển dữ liệu:
+ Load word: lw $t0, 12($s0) -> lấy word ở $s0 + 12 lưu vào $t0
+ Save word: sw $t0, 12($s0) -> lưu word $t0 vào $s0 + 12
- $s0 là thanh ghi cơ sở (base register), 12 là độ dời (offset); Một thanh ghi có - RAID:
thể lưu bất kỳ giá trị 32-bit nào; + RAID 0: 2 đĩa lưu trữ xen kẽ nhau
- Ví dụ: A[12] = h - A[8] => lw $t0, 32($s3) -> sub $t0, $s2, $t0 -> sw $t0, + RAID 1: 2 đĩa cùng lưu trữ 1 kiểu dữ liệu
48($s3); 32 và 48 là bội số 4 của 8 và 12. + RAID 5: 4 đĩa lưu trữ. 1 dữ liệu sẽ chia ra 3 phần lưu ở 3 đĩa và lưu toàn bộ ở
+ Load byte: lb $s0, 3($s1) 1 đĩa. Ổ đĩa lưu toàn bộ dữ liệu sẽ xen kẽ nhau giữa 4 đĩa để tối ưu ổ cứng.
- Rẽ nhánh: (sử dụng 3 ổ đĩa vật lý trở lên)
+ beq opr1, opr2, label: if (opr1 == opr2) goto label - Nguyên lý cơ sở khi truy xuất:
+ bne opr1, opr2, label: if (opr1 != opr2) goto label + Temporal locality (Cục bộ về thời gian): Nếu một ô nhớ được dùng đến ở thời
+ j label: Jump to label <=> beq $0, $0, label điểm hiện tại, nó dễ có khả năng được dùng đến lần nữa trong tương lai gần
+ slt opr1, opr2, opr3: opr2 < opr3 ? opr1 = 1 : opr1 = 0; + Spatial locality (Cục bộ về không gian): Nếu một ô nhớ được dùng đến ở thời
- So sánh == -> Dùng lệnh beq điểm hiện tại, những ô lân cận dễ có khả năng sắp được dùng đến
- So sánh != -> Dùng lệnh bne - Ánh xạ: trực tiếp (Mỗi Block của BNC chỉ có thể được nạp
- So sánh < và > -> Dùng cặp lệnh (slt à bne) vào 1 Line của cache), liên kết toàn phần (Mỗi Block có thể nạp vào bất kỳ Line
- So sánh ≤ và ≥ -> Dùng cặp lệnh (slt à beq) nào của Cache), liên kết tập hợp (Cache được chia thành các Tập (Set)).
- Nguyên tắc: $0: (Không thay đổi) Luôn bằng 0; $s0 - $s7: (Khôi phục lại nếu thay - Thuật toán thay thế: Random, FIFO (First in first out), LFU (Least Frequenly
đổi); $sp: stack (Khôi phục lại nếu thay đổi); $ra: (Có thể thay đổi); $v0 - $v1: Used), LRU (Least Recently Used).
chứa kết quả (Có thể thay đổi); $a0 - $a1: chứa đối số (Có thể thay đổi); $t0 - $t9: - Chính sách đồng bộ (Write Policy):
temp (Có thể thay đổi). + Nếu 1 Line bị thay đổi trong Cache, khi nào sẽ thực hiện thao tác ghi lên lại
X86-32: RAM: Write Through: ngay lập tức; Write Back: khi Line này bị thay thế.
- x86-32 bit sử dụng kiến trúc thanh ghi-bộ nhớ + Nếu nhiều processor chia sẻ RAM, mỗi processor có cache riêng: Bus
- x86-32 bit sử dụng kiến trúc 2 toán hạng watching with WT: loại bỏ Line khi bị thay đổi trong 1 cache khác; Hardware
- Theo nguyên tắc Little Endian: Lưu trữ theo thứ tự phải sang trái transparency: tự động cập nhật các cache khác khi Line bị 1 cache thay đổi;
- Thanh ghi: Noncacheable shared memory: phần bộ nhớ dùng chung sẽ không
được đưa vào cache