Kiến trúc Universal

Kiến trúc Universal Architecture là kiến trúc 128 bit của bộ vi xử lý UAx. Kiến trúc này là kiến trúc hoàn toàn 128 bit ngay từ đầu khi thiết kế. Mục tiêu của kiến trúc này là nền tảng tính toán cho hầu hết tất cả thiết bị.
UAx cũng có thể dành cho các thiết bị nhúng, hoặc máy tính cầm tay.

Tổng quát

UA có 128 thanh ghi đa dụng 128 bit dành cho tính số nguyên. Số nguyên có thể là số âm hoặc không âm. Vì độ dài 128 bit khá lớn nên nó cũng có tập lệnh cho tính toán vector cho số nguyên. Ví dụ để tính phép tính cộng cho 4 số nguyên, nó cộng và dư carry của mỗi số ra thanh ghi da dụng khác tại vị trí dư bit
Ngoài ra UA cũng có 128 thanh ghi chấm động 128 bit.

127                      63            31            0
[-------------------------|------------|-------------] 

UA có một thanh ghi cờ có độ dài 128 bit gọi là uflag. Nó dùng kèm với các chỉ lệnh có điều kiện như CMOVcc, Jcc.
Mặc dù kích thước vi lệnh thay đổi từ 1 byte đến 10 bytes nhưng nó được thiết kế rất dễ giải mã. Điều này làm cho nó có sự lai giữa RISC và CISC, nên cực kì linh động trong mã hoá vi lệnh.

Thực hiện

Hiện tại thiết kế này chưa có bản ngôn ngữ mô tả phần cứng và cũng chưa có phiên bản hiện thực.

Kiến trúc

Thanh ghi

Kiến trúc UA khá nhiều thanh ghi, bao gồm :

• Thanh ghi đa dụng: R0->R127 (128 bit)
• Thanh ghi cờ  : RF dài 32 bit
• Thanh ghi đoạn  : rs0->rs7

Chuơng trình

Không gian địa chỉ bộ nhớ là không gian tuyến tính, nghĩa là các dãy địa chỉ liên tục 128 bit địa chỉ cho mỗi byte bộ nhớ. Do đó UA có thể có lên đến 340,282,366,920,938,463,463,374,607,431,768,211,456 bytes. Vì địa chỉ khác lớn cho một chuơng trình trong bộ nhớ, nên không gian này được chia ra thành đoạn. Một chuơng trình có thể có tới 4 đoạn, đoạn mã,2 đoạn dữ liệu,đoạn ngăn xếp. Thanh ghi này có chiều dài 64 bit.Bit thứ 63 là bit phân biệt bit mode hạt nhân hay ứng dụng.

+------------------------------------------------+ 

+ S +                                            + 

+------------------------------------------------+ 

Thanh ghi đoạn này chỉ đến mảng cấu trúc mô tả đoạn.

Cấu trúc mô tả đoạn

127                                                                       0 

+-------------------------------------------------------------------------+ 

+                      limitation                       +      type       + 

+-------------------------------------------------------------------------+

+                   112 bit base address                                  +

+-------------------------------------------------------------------------+

Cấu trúc mô tả đoạn bao gồm:

1. Địa chỉ cơ sở 128 bit
2. 16 bit phân loại đoạn
3. Giới hạn của đoạn 112 bit

Cấu trúc địa chỉ đoạn được lưu trong bảng cấu trúc mô tả đoạn. Bảng này được lưu trong bộ nhớ và thanh ghi DTR lưu địa chỉ cơ sở của đoạn. Vì vậy đoạn rỗng là đoạn có tất cả 256 bit đều bằng không.

Ngắt

Kiến trúc UA cho phép tới 8 bit ngắt tức 256 ngắt, trong đó 32 ngắt đầu tiên được sử dụng cho bộ vi xử lý. Có nhiều tín hiệu ngắt, một số nguồn của ngắt :

1. Vi lệnh, do một số vi lệnh sinh ra (syscall)
2. Ngắt từ thiết bị bên ngoài
3. Ngắt do bộ định thời
4. Ngắt liên-nhân

Bộ vi xử lý thường được tích hợp bộ định thời (có thể lập trình được ) để thực hiện việc ngắt từ các ứng dụng và ngắt liên nhân cho đa xử lý đối xứng. Hệ điều hành sử dụng cơ chế này để thực hiện đa luồng và đa tác vụ. Việc điều khiển ngắt được thực hiện qua cấu trúc dữ liệu và các thanh ghi trong bộ vi xử lý. Vi lệnh mov dùng để sao tải từ bộ nhớ đến thanh ghi điều khiển ngắt và ngược lại.

Vi lệnh UA

Mã vi lệnh của UA có hai chiều dài 2 bytes và 4 bytes, và có thể trộn lẫn với nhau giúp cho mã lệnh được nén thay vì cố định chỉ 4 bytes. Điều này có thể làm được thông qua trình biên dịch. Chiều dài tối đa của mã lệnh là 4 bytes , trường hợp đặc biệt là 10 bytes. Các kiểu mã hoá vi lệnh:

kiểu 3 toán hạng

Kiểu này có 3 bit mode và 3 toán hạng, kiểu này phổ dụng nhất trong UA. Tuỳ theo mức độ thi công mà mode có thể. Tuy nhiên mode 000 là mode của thanh ghi-thanh ghi. Kiểu này không mã hoá được displacement như x86 vì bị đóng trong 4 bytes.

 8 bit        7 bit   7 bit    7 bit        3 bit  

+----------+--------+---------+---------+--------+ 

+  inst    +   rd   +    rs   +   rt    +  ---   + 

+----------+--------+---------+---------+--------+ 

• add,sub,mul,div,and,or,xor,smul,sdiv

các vi lệnh có thể sử dụng 3 bit cuối để xác định điều kiện thực thi

Kiểu 2 toán hạng

Chiều dài cũng 4 bytes
Phù hợp với lệnh cp với 4 bit điều kiện,3 bit mode cho thanh ghi hay địa chỉ bộ nhớ,size qui đinh kích cỡ toán hạng.

   8 bit   7 bit r    7bit r    cond.  mode    size
+--------+---------+---------+-------+-------+---------+ 
+  inst  +    rd   +   rs    +         10 bit          + 
+--------+---------+---------+-------+-------+---------+ 

• BE BNE BGT BLT BGE BLE : branch to 10 bit offset
• LB,LH,LW,LD,LQ:rd= [rs]+offset 10 bit
• SB,SW,SD,SQ,SDQ: rd->[rs]+offset
• BCNT : đếm bit của %rs -> %rd

Kiểu tích hợp hằng

Chiều dài 4 bytes

+--------+-----------------------------------------+
+   JI   +               imm24                     +
+--------+-----------------------------------------+
Nhảy vô điều kiện tới địa chỉ tương đối imm24, địa chỉ này là có dấu
li24: load immediate 24 bit to %r0

+----------+-------+---+---------------------------+
+  ins     +  rd   + - +       imm16               +
+----------+-------+---+---------------------------+

• ADDI,SUBI,MULI,DIVI $imm16,%rd: %rd=imm16 op %rd
• LI $imm16,%rd

Kiểu 1 toán hạng

Chiều dài 2 bytes

   8 bit  1bit    7 bit 
 +--------+----+----------+ 
 +  inst  + M  +   op1    + 
 +--------+----+----------+ 

Kiểu này dành cho lệnh jmp hoặc call và các lệnh chỉ có một toán hạng. Bit M dùng để xác dịnh thanh ghi hay địa chỉ. Điều này cũng không cần thiết cho lệnh jmp và call.

• JNL jump and link to %r127
• trap
• LDT,SDT : tải/lưu segment descriptor table
• LIDT,SIDT : tải/lưu interrupt descriptor table
• LTR,STR  : tải/lưu thread register

Bộ tập lệnh

Các toán tử của vi lệnh là thanh ghi với thanh ghi ngoại trừ L/S có thể thanh ghi - bộ nhớ. Dấu ghạch ngang '-' là thay đổi tuỳ thuộc vào câu lệnh. Mỗi opcode là tương ứng cho một lệnh của hợp ngữ điều này tạo điều kiện cho lập trình viên dễ hiểu hơn khi lập trình. Sau đây là bảng mô tả tập lệnh UA :

STT	Tên	Hợp ngữ	Mã hoá	Mô tả
1	ADD	add %rd,%rs,%rt	00000001 dddddddsssssssttttttt ccc	Cộng, %rd=%rs+%rt,ba bit điều kiện
2	ADC	adc %rd,%rs,%rt	00000010 dddddddsssssssttttttt ccc	Cộng với carry
3	SUB	sub %rd,%rs,%rt	00000011 dddddddsssssssttttttt ccc	Trừ dấu, %rd=%rs+%rt
4	SUBB	subb %rd,%rs,%rt	00000100 dddddddsssssssttttttt ccc	Trừ với mượn carry
5	MUL	mul %rd,%rs,%rt	00000101 dddddddsssssssttttttt ccc	Phép nhân có dấu: r[0]:r[1]=%rs * %rt
6	UMUL	umul %rd,%rs,%rt	00000110 dddddddsssssssttttttt ccc	phép nhân không dấu
7	DIV	div %rd,%rs,%rt	00000111 dddddddsssssssttttttt ccc	phép chia có dấu
8	UDIV	udiv %rd,%rs,%rt	00001000 dddddddsssssssttttttt ccc	phép chia không dấu
9	AND	and %rd,%rs,%rt	00001001 dddddddsssssssttttttt ccc	logic and
10	OR	or %rd,%rs,%rt	00001010 dddddddsssssssttttttt ccc	logic or
11	XOR	xor %rd,%rs,%rt	00001011 dddddddsssssssttttttt ccc	logic xor
12	BE	be %rd,%rs,10 off	00010000 dddddddsssssss imm 10 bit	nhánh đến 10 bit offset nếu %rd=%rs
13	BNE	bne %rd,%rs,10bit off	00010001 dddddddsssssss imm 10 bit	rẽ nhánh đến 10 bit offset nếu %rd !=%rs
14	BGT	bgt %rd,%rs,10bit off	00010010 dddddddsssssss imm 10 bit	rẽ nhánh đến 10 bit offset nếu %rd > %rs
15	BLT	blt %rd,%rs,10bit off	00010011 dddddddsssssss imm 10 bit	rẽ nhánh nếu rd<rs
18	CMP	cmp %rd,%rs	00010110 dddddddsssssss ----------	so sánh rd và rs
19	SHL	shl %rd,%rs,$imm7	00010111 dddddddsssssssiiiiiii ccc	shift left có 3 bit điều kiện: rd=%rs<<i7
20	SHR	shr %rd,%rs,$imm7	00011000 dddddddsssssssiiiiiii ccc	shift right rd=%rs>>i7
21	ROTL	rotl %rd,%rs,$imm7	00011001 dddddddsssssssiiiiiii ccc	rotate left
22	ROTR	rotr %rd,%rs,$imm7	00011010 dddddddsssssssiiiiiii ccc	rotate right
23	LB	lb %rd,%rs,$imm10	00011011 dddddddsssssss imm10 bit	load byte to rd from (%rs+i10)
24	LH	lh %rd,%rs,$imm10	00011100 dddddddsssssss imm10	load half word to rd from (%rs+i10)

Xem thêm

• Vi xử lý
• X86