Solution Exercise 2A_Group 9

SOLUTION EXERCISE 2 COMPUTER ARCHITECTURE

Group 9: Nguyễn Thái Long – 5081139 Vũ Thị Thùy Trang – 50802298 Class: MT08KHTN

Solution Exercise 2 – Computer Architecture Group 9

2

Bài A.1:

1-3.

• Chuỗi bit nhị phân a: 101011 10000 01011 0000 0000 0000 0100 Op Rs Rt Immediate

Chuỗi a biểu diễn cho câu lệnh: sw $t3, 4($s0) Câu lệnh trên thuộc định dạng I-Type. Giá trị ở hệ thập lục phân: 0xAE0B0004

• Chuỗi bit nhị phân b: 100011 01000 01000 0000 0000 0100 0000 Op Rs Rt Immediate

Chuỗi a biểu diễn cho câu lệnh: lw $t0, 64($t0) Câu lệnh trên thuộc định dạng I-Type. Giá trị ở hệ thập lục phân: 0x8D080040

4-6. • Câu lệnh a: add $t0, $t0, $zero

Biễu diễn câu lệnh a ở mã máy: 000000 01000 00000 01000 00000 100000 Op Rs Rt Rd Shamt funct

Câu lệnh trên thuộc định dạng R-Type Biểu diễn thập lục phân của câu lệnh: 0x01004020 Biểu diễn thập lục phân của các trường 00 08 00 08 00 20 Op Rs Rt Rd Shamt funct

• Câu lệnh b: lw $t1, 4($s3) Biễu diễn câu lệnh a ở mã máy: 100011 10011 01001 0000 0000 0000 0100 Op Rs Rt immediate

Câu lệnh trên thuộc định dạng I-Type Biểu diễn thập lục phân của câu lệnh: 0x8E690004 Biểu diễn thập lục phân của các trường 23 13 09 0004 Op Rs Rt immediate


3

Bài A.2:

1. a) sll $t1, $t0, 10

srl $t1, $t1, 15

b) sll $t1, $t0, 10 srl $t1, $t1, 15 sll $t1, $t1, 14

2. a) sll $t1, $t0, 28

srl $t1, $t1, 28

b) sll $t1, $t0, 28

srl $t1, $t1, 28 sll $t1, $t1, 14

4. a)sll $t2, $t0, 15

srl $t2, $t2, 26 srl $t1, $t1, 6 sll $t1, $t1, 6 or $t1, $t1, $t2

b)lui $t2, 1111111111110000 ori $t2, 0011111111111111 and $t1, $t1, $t2 sll $t2, $t0, 15 srl $t2, $t2, 26 sll $t2, $t2, 14 or $t1, $t1, $t2

5. a) sll $t2, $t0, 27

srl $t2, $t2, 27 srl $t1, $t1, 5 sll $t1, $t1, 5 or $t1, $t1, $t2


4

b) lui $t2, 1111111111111000 ori $t2, 0011111111111111 and $t1, $t1, $t2 sll $t2, $t0, 5 srl $t2, $t2, 5 sll $t2, $t2, 14 or $t1, $t1, $t2

6.

a) sll $t2, $t0, 1 srl $t2, $t2, 30 srl $t1, $t1, 2 sll $t1, $t1, 2 or $t1, $t1, $t2

b) lui $t2, 1111111111111111 ori $t2, 0011111111111111 and $t1, $t1, $t2 sll $t2, $t0, 1 srl $t2, $t2, 30 sll $t2, $t2, 14 or $t1, $t1, $t2


5

Bài A.3 :

1-3:

• Đoạn mã a: Control flow:

Mã hợp ngữ MIPS : a, b, i tương ứng trong các thanh ghi $s0, $s1, $t0

add $t0, $zero, $zero # i = 0 addi $t1, $zero, 10 LOOP : beq $t0, $t1, EXIT #if(i=10) jump Exit add $s0, $s0, $s1 # a = a+b addi $t0, $t0, 1 # i = i+1 j LOOP EXIT :

Cần 6 lệnh MIPS để hiện thực lại đoạn mã C trên. Để hoàn thành vòng lặp trên, 42 câu lệnh MIPS đã được thực thi.

No

Yes

Start

i = 0

i < 10 ?

a = a + b

i = i + 1

DONE


6

• Đoạn mã b: Control flow:

Mã hợp ngữ MIPS : a, b tương ứng trong các thanh ghi $s0, $s1. $s2 chứa

địa chỉ nền của mảng D. addi $t0, $zero, 10 LOOP : beq $s0, $t0, EXIT # if (a=10) go to EXIT sll $t1, $s0, 2 # $t1 = a*4; add $t1, $t1, $s2 # $t1 = address of D[a] add $t2, $s0, $s1 # $t2 = a + b sw $t2, 0($t1) # D[a] = a + b addi $t0, $t0, 1 # a = a + 1 j LOOP EXIT :

Cần 8 lệnh MIPS để hiện thực lại đoạn mã C trên. Với giá trị khởi tạo a = 10, b = 1, tất cả phần tử của D bằng 0. Để hoàn

thành vòng lặp trên, 1 câu lệnh MIPS đã được thực thi.

4 - 6. • Đoạn mã a:

Tổng số lệnh MIPS được thực thi: 501

No

DONE

Start

D[a] = a + b

Yes

a < 10 ?

a= a + 1


7

Mã C: $t1 : i; $s2: result; $s0 là giá trị nền của thanh ghi MemArray for (i=100; i>0; i--) { result += MemArray [100 – i]; }

• Đoạn mã b: Tổng số lệnh MIPS được thực thi: 301 Mã C: $t1 : i; $s2: result; $s0 là giá trị nền của thanh ghi MemArray

for (p=&MemArray[0]; p<MemArray[100];p++) { result += *p; }

Bài A.4:

1. a) Lỗi sai:

lw $a0, 4($sp) lw $ra, 0($sp) sửa thành: lw $a0, 0($sp) lw $ra, 4($sp)

b) - Lỗi sai: slti $t0, $a0, L1 sửa: slti $t0, $a0, 1 - Lỗi sai: addi $t0, $t0, -1 sửa: addi $a0, $a0, -1 - Lỗi sai:

lw $a0, 4($sp) lw $ra, 0($sp) sửa thành: lw $a0, 0($sp) lw $ra, 4($sp)

2. Chương trình kh ử đệ quy: FACT: addi $v0, $zero, 1 addi $t0, $zero, 1 addi $t1, $a0, 1 loop: slt $t2, $t0, $t1 beq $t2, $zero, exit mul $v0, $v0, $t0 addi $t0, $t0, 1 j loop


8

exit: jr $ra

• Số lệnh thực thi của chương trình trên là 9 và bằng 0,6 lần so với chương trình đệ quy

3. Với $a0 = 4, nội dung của stack sau mỗi lần gọi hà m

$sp

Ban đầu

Low addr

High addr

FACT(4)

Low addr

High addr

$sp $ra-fact(4) $a0-fact(4)

FACT(3)

Low addr

High addr

$sp

$ra-fact(4) $a0-fact(4)


FACT(2)

Low addr

High addr

$sp




FACT(1)

Low addr

High addr

$sp






9

4. a)

- Lỗi: slti $t0, $a0, 1 sửa: slti $t0, $a0, 2 (lỗi: khi $a0 = 1, chương trình sẽ nhảy xuống L1 và tiếp tục gọi đệ quy cho đến khi $a0 = -1)

- Lỗi: addi $v0, $a0, $0 sửa: add $v0, $a0, $0 - Lỗi: addi $s1, $v0, $0 sửa: add $s1, $v0, $0

b) - Lỗi: slti $t0, $a0, 1 sửa: slti $t0, $a0, 2 (lỗi: khi $a0 = 1,

chương trình sẽ nhảy xuống L1 và tiếp tục gọi đệ quy cho đến khi $a0 = -1) - Lỗi: addi $v0, $a0, $0 sửa: add $v0, $a0, $0 - Lỗi: addi $s1, $v0, $0 sửa: add $s1, $v0, $0

5. Chương trình tính Fibonaci kh ử đệ quy FIBO: slti $t0, $a0, 2 beq $t0, $zero, nhay add $v0, $a0, $zero jr $ra nhay: addi $t0, $zero, 1 addi $t2, $zero, 0 addi $t3, $zero, 1 loop: slt $t4, $t0, $a0 beq $t4, $zero, exit add $v0, $t2, $t3 add $t2, $t3, $zero add $t3, $v0, $zero addi $t0, $t0, 1 j loop exit: jr $ra

• Số lệnh của chương trình là 15 và bằng 0,8 số lệnh của chương trình đệ quy


10

6.

$sp

Ban đầu

Low addr

High addr

$a0-fib(4)

$s1-fib(4) $ra-fib(4)

FIB(4) - 1

Low addr

High addr

$sp

$a0-fib(3)


$a0-fib(4)


FIB(3) - 2

Low addr

High addr

$sp

$a0-fib(2)


$a0-fib(3)


$a0-fib(4)


FIB(2) - 3

Low addr

High addr

$sp

$a0-fib(1)


$a0-fib(2)


$a0-fib(3)


$a0-fib(4)


FIB(1) - 4

Low addr

High addr

$sp

$a0-fib(0)


$a0-fib(2)


$a0-fib(3)


$a0-fib(4)


FIB(0) - 5

Low addr

High addr

$sp

$a0-fib(1)


$a0-fib(3)


$a0-fib(4)


FIB(1) - 6

Low addr

High addr

$sp


11

Bài A.5:

1 – 2:

• Chuỗi a: A byte Giá trị trong mã ASCII ở dạng thập phân: 65 32 98 121 116 101 Giá trị trong mã Unicode 16-bit: 0041 0020 0062 0079 0074

0065

• Chuỗi b: computer Giá trị trong mã ASCII ở dạng thập phân: 99 111 109 112 117

116 101 114 Giá trị trong mã Unicode 16-bit: 0063 006f 006d 0070 0075

0074 0065 0072

3.

• Chuỗi a: 61 64 64 Giá trị ở dạng kí tự chữ: add

• Chuỗi b: 73 68 69 66 74 Giá trị ở dạng kí tự chữ: shift

$a0-fib(2)


$a0-fib(4)


FIB(2) - 7

Low addr

High addr

$sp

$a0-fib(1)


$a0-fib(2)


$a0-fib(4)


FIB(1) - 8

Low addr

High addr

$sp

$a0-fib(0)


$a0-fib(2)


$a0-fib(4)


FIB(1) - 9

Low addr

High addr

$sp


12

Bài A.6:

1. lb $t0, 0($t1) # $t0 = 0x00000012 sb $t0, 0($t2) #ô nhớ: 1000 0010 12 FF FF FF

# $t2 = 0xFFFFFF12 Vậy: giá trị thanh ghi $t2 trỏ đến là 0xFFFFFF12

2. lb $t0, 0($t1) # $t0 = 0x00000080 sb $t0, 0($t2) #ô nhớ: 1000 0010 80 00 00 00

# $t2 = 0x00000080 Vậy: giá trị thanh ghi $t2 trỏ đến là 0x00000080

3. lb $t0, 0($t1) # $t0 = 0x00000011 sb $t0, 0($t2) #ô nhớ: 1000 0010 11 55 55 55

# $t2 = 0x55555511 Vậy: giá trị thanh ghi $t2 trỏ đến là 0x55555511

Bài A.7 :

1. PC = 0x0000 0000 Phạm vi bước nhảy có thể thực hiện được với 1 lệnh rẽ nhánh là: -217 -> 217 – 4 bit Sau khi thực hiện 1 lệnh rẽ nhánh, giá trị PC hiện tại: PC = PC + 4 + bước nhảy

a. 0x00001000 Khoảng cách từ PC tới địa chỉ trên là: 0x1000 = 216. Để đạt được địa chỉ trên, ta chỉ cần thực hiện 1 lệnh rẽ nhánh.

b. 0xFFFC0000 Khoảng cách từ PC tới đ ịa chỉ trên là: 0xFFFC0000= 4294705152 Số lệnh rẽ nhánh cần thực hiện: 4294705152

217 = 32766 lệnh 2. PC = 0x0000 0000

Giả sử 4 bit cao nhất hiện tại của PC có giá trị là X trong hệ thập lục phân. Phạm vi của địa chỉ mà ta có thể nhảy tới với 1 lệnh nhảy là 0xX000 0000 + 4 -> 0x XFFFFFFC + 4

a. 0x 0000 1000 Chỉ cần thực hiện 1 lệnh nhảy.

b. 0xFFFC 0000 Ở vị trí 0x0000 0000, với 1 lệnh nhảy, địa chỉ cao nhất mà PC có thể đạt đươc là: 0x0FFF FFFC + 4 = 0x1000 0000 Tương tự, ta cần thực hiện 15 lệnh nhảy để đến được địa chỉ: 0xF000 0000 Để đạt được địa chỉ 0xFFFC 0000 ta phải thực hiện thêm một lệnh nhảy nữa.


13

Vậy số lệnh nhảy ít nhất cần phải thực hiện là 16.

3. Cắt giảm trường immediate xuống còn 8 bit thì bư ớc nhảy tối đa của 1 lệnh rẽ nhánh giảm xuống còn: -29 -> 29 – 4 bit

a. 0x0000 1000

Số lệnh rẽ nhánh cần thực hiện: 216

29 = 128 lệnh b. 0xFFFC 0000

Số lệnh rẽ nhánh cần thực hiện: 429470515229 = 8388096 lệnh

4-6.

a. 8 registers • Cách thức hiệu chỉnh này không ảnh hưởng đến phạm vi của các địa chỉ của lệnh beq,

lệnh nhảy. • Lệnh nhảy thanh ghi: sự thay đổi này làm thay đổi phạm vi của lệnh nhảy thanh ghi

chỉ còn là 8 thanh ghi b. 10 bit immediate/ address field

• Phạm vi bước nhảy của câu lệnh beq giảm xuống còn: -211 -> 211 – 4 bit. • Phạm vi địa chỉ của lệnh nhảy:0xXXXX X000 + 4 -> 0xXXXX XFFC + 4

Trong đó: X là giá trị tương ứng trong PC cũ . • Không ảnh hưởng đến phạm vi của lệnh nhảy thanh ghi .

Bài A.8:

1. Với mỗi lần kiểm tra và thất bại của câu lệnh store conditional, có 7 lệnh sẽ phải được thực thi.

2. Đoạn mã trên có thể thất bại vì chưa ki ểm tra câu lệnh store conditional ở địa chỉ chứa trong R2 có thành công hay không.

3. try: MOVE R3, R4

MOVE R6, R7 LL R2, 0(R2) LL R5, 0(R1) SC R3, 0(R1) SC R6, 0(R1) BEQZ R3, try BEQZ R6, try MOV R4, R2


14

MOV R7, R5 4. a.

Processor 1 Processor 2 Cycle Processor 1 MEM ($s1)

Processor 2 $t1 $t0 $t1 $t0

0 1 2 99 30 40 ll $t1,0($s1) ll $t1,0($s1) 1 99 2 99 99 40 sc $t0,0($s1) 2 99 1 2 99 40 sc $t0,0($s1) 3 99 1 2 99 0

b. Processor 1 Processor 2 Cycle Processor 1 MEM

($s1) Processor 2

$s4 $t1 $t0 $s4 $t1 $t0 try: add $t0,

$0, $s4 0 2 3 4 99 10 20 10

ll $t1, 0($s1) 1 2 3 4 99 10 99 10 try: add $t0, $0, $s4

2 2 3 2 99 10 99 10

ll $t1, 0($s1) 3 2 99 2 99 10 99 10 sc $t0, 0($s1) 4 2 99 1 2 10 99 10 beqz $t0, try sc $t0, 0($s1) 5 2 99 1 2 10 99 0 add $s4, $0, $t1 beqz $t0, try 6 99 99 1 2 10 99 0

Bài A.9:

1.

a. Pseudo instruction: move $t1, $t2 Lệnh MIP tương ứng: addu $t1, $zero, $t2

b. Pseudo instruction: beq $t1, small, LOOP Chuỗi lệnh MIPS tương ứng: addi $t0, $zero, small beq $t1, $t0, LOOP

2.

a. la $s0, v Câu lệnh này không cần sửa đổi trong giai đoạn liên kết

b. blt $a0, $v0, Loop Trong giai đoạn lien kết, nhãn Loop sẽ được chuyển sang địa chỉ tuyệt đối


15

Bài A.10:

1. a) Giả sử:

- Địa chỉ của V được lưu trong thanh ghi $s0 - k được lưu trong thanh ghi $a0 - j được lưu trong thanh ghi $a1

swap: sll $t0, $a0, 2 add $t0, $t0, $s0 lw $t9, 0($t0) sll $t1, $a1, 2 add $t1, $t1, $s0 lw $t8, 0($t1) sw $t9, 0($t1) sw $t8, 0($t0) jr $ra

b) Giả sử: p được lưu trong thanh ghi $a0 swap: lw $t0, 0($a0) lw $t1, 4($a0) sw $t0, 4($a0) sw $t1, 0($a0) jr $ra

2. Theo hàm sort (trong hình 2.35 COD3e) hàm swap sẽ được thay đổi như sau:

swap: sll $t0, $a1, 2 add $t0, $t0, $a0 lw $t1, 0($t0) lw $t2, 4($t0) sw $t2, 0($t0) sw $t1, 4($t0) jr $ra

giả sử địa chỉ của v được lưu trong $a0, j được lưu trong thanh ghi $a1

3. Nếu sắp xếp cho các byte 8-bit thì các hàm sẽ được thay thay đổi như sau: a) swap: add $t0, $t0, $s0

lb $t9, 0($t0) add $t1, $t1, $s0 lb $t8, 0($t1) sb $t9, 0($t1) sb $t8, 0($t0) jr $ra


16

b) swap: lb $t0, 0($a0)

lb $t1, 1($a0) sb $t0, 1($a0) sb $t1, 0($a0) jr $ra

4. a) Thay đổi các thanh ghi lại s (s-registers) thay thế cho các thanh ghi loại t (t-

registers) không giúp đoạn mã khổi phục và lưu trữ các thanh ghi. Thậm chí có thể phải làm cho số lệnh restore và save của đoạn mã nhiều hơn

b) Sử dụng lệnh bltz thay cho s lt và bne cũng không ảnh hưởng đến việc restore và save các thanh ghi

5. a) Khi sắp xếp một mảng 10 phần tử, sự thay đổi trên không làm tăng hay giảm câu

lệnh phải thực thi

b) Số lần so sánh của thanh ghi $s1 với 0 là 2

)1(2 +××

nn . Khi thay lệnh bltz bằng 2

lệnh slt và bne, số câu lệnh sẽ giảm đi: 2

)1( +× nn (lệnh). Với n = 10, số lệnh

giảm đ i là: 2

)110(10 +× = 55 (lệnh)

6. Khi sắp xếp giảm giần thì sự thay đổi ở cả 2 câu a và b không làm thay đổi số các câu

lệnh. Ở câu b, 2 lệnh slt và bne chỉ để so sánh xem $s1 có bé hơn 0 hay không, không ảnh hưởng đến việc sắp xếp mảng tăng hay giảm.

Bài A.11:

a. int find (int a[], int n, int x){

int i; for(i = 0; i!=n; i++)

if (a[i] == x) return i; return -1;

} 1. Mã hợp ngữ MIPS:

$a0 : chứa địa chỉ nền của mảng a. n, x lần lượt được lưu trong $a1, $a2 find: add $t0, $zero, $zero # i=0


17

Loop: beq $t0, $a1, Exit1 # if (i=n) jump to Exit1 sll $t1, $t0, 2 add $t1, $t1, $a0 # $t1 = &a[i] lw $t2, 0($t1) # $t2 = a[i] beq $t2, $a2, Exit2 #if($t2 = x) jump to Exit2 addi $t0, $t0, 1 # i=i+1 j Loop Exit1: addi $v0, $zero, -1 # $v0 = -1 jr $ra Exit2: add $v0, $t0, $zero # $v0 = i jr $ra

2. Mã C, sử dụng con trỏ int find (int* a, int n, int x) { int* p; for (p=&a[0]; p!=&a[n]; p++) { if (*p = x) return (p-a); } return -1; }

3. Mã hợp ngữ MIPS, sử dụng con trỏ $a0: con trỏ chỉ tới a[0] n, x lần lượt được lưu trong $a1, $a2 find: addu $t0, $a0, $zero # $t0 = &a[0] sll $t1, $a1, 4 add $t1, $t1, $a0 # $t1 = &a[n] Loop: lw $t2, 0($t0) # $t2 = a[i] beq $t2, $a2, Exit2 # if($t2=x) jump Exit2 addi $t0, $t0, 4 # $t0 = &a[i+1] beq $t0, $t1, Exit1 # if(p=&a[n]) jump Exit1 j Loop Exit1: addi $v0, $zero, -1 # $v0 = -1 jr $ra Exit2: sub $v0, $t0, $a0 jr $ra

4. Trong trường hợp xấu nhất: Đoạn mã dùng mảng thực hiện 7n lệnh Đoạn mã dùng con trỏ thực hiện 5n lệnh

5. Đoạn mã sử dụng mảng dùng 3 thanh ghi tạm thời Đoạn mã sử dụng con trỏ dùng 3 thanh ghi tạm thời


18

6. Nếu các thanh ghi $t0 - $t7 và $a0 - $a3 trong quy ước gọi hàm đều thuộc loại “callee-saved”, đoạn mã ở câu 3 được viết lại như sau:

find: addi $sp, $sp, -12 sw $t0, 0($sp) sw $t1, 4($sp) sw $t2, 8($sp) addu $t0, $a0, $zero # $t0 = &a[0]

sll $t1, $a1, 4 add $t1, $t1, $a0 # $t1 = &a[n] Loop: lw $t2, 0($t0) # $t2 = a[i] beq $t2, $a2, Exit2 # if($t2=x) jump Exit2 addi $t0, $t0, 4 # $t0 = &a[i+1] beq $t0, $t1, Exit1 # if(p=&a[n]) jump Exit1 j Loop Exit1: addi $v0, $zero, -1 # $v0 = -1

lw $t0, 0($sp) lw $t1, 4($sp) lw $t2, 8($sp)

addi $sp, $sp, 12 jr $ra Exit2: sub $v0, $t0, $a0

lw $t0, 0($sp) lw $t1, 4($sp) lw $t2, 8($sp)

addi $sp, $sp, 12 jr $ra

b. int count(int a[], int n, int x) { int res = 0; int i; for (i=0;i!=n;i++) if (a[i] == x) res = res+1; return res; } 1. Mã hợp ngữ MIPS:

$a0 : chứa địa chỉ nền của mảng a. n, x lần lượt được lưu trong $a1, $a2


19

count: add $t0, $zero, $zero # res=0 add $t1, $zero, $zero # i=0 Loop: beq $t1, $a1, Exit # if (i=n) jump to Exit sll $t2, $t1, 2 add $t2, $t2, $a0 # $t2 = &a[i] lw $t3, 0($t2) # $t3 = a[i] bne $t3, $a2, Incre addi $t0, $t0, 1 Incre: addi $t1, $t1, 1 # i=i+1 j Loop Exit: add $v0, $zero, $t0 jr $ra

2. Mã C, sử dụng con trỏ int count (int* a, int n, int x) { int* p; int res =0; for (p=&a[0]; p!=&a[n]; p++) { if (*p = x) res++; } return res; }

3. Mã hợp ngữ MIPS, sử dụng con trỏ $a0: con trỏ chỉ tới a[0] n, x lần lượt được lưu trong $a1, $a2 count: addu $t0, $a0, $zero # $t0 = &a[0] sll $t1, $a1, 4 add $t1, $t1, $a0 # $t1 = &a[n] add $t2, $zero, $zero Loop: lw $t3, 0($t0) # $t3 = a[i] bne $t3, $a2, Incre addi $t2, $t2, 1 Incre: addi $t0, $t0, 4 # $t0 = &a[i+1] j Loop Exit: addi $v0, $zero, $t2 jr $ra

4. Trong trường hợp xấu nhất: Đoạn mã dùng mảng thực hiện 8n lệnh Đoạn mã dùng con trỏ thực hiện 5n lệnh


20

5. Đoạn mã sử dụng mảng dùng 4 thanh ghi tạm thời Đoạn mã sử dụng con trỏ dùng 4 thanh ghi tạm thời

6. Nếu các thanh ghi $t0 - $t7 và $a0 - $a3 trong quy ước gọi hàm đều thuộc loại “callee-saved”, đoạn mã ở câu 3 được viết lại như sau:

count: addi $sp, $sp, -16 sw $t0, 0($sp) sw $t1, 4($sp) sw $t2, 8($sp) sw $t3, 12($sp) addu $t0, $a0, $zero # $t0 = &a[0]

sll $t1, $a1, 4 add $t1, $t1, $a0 # $t1 = &a[n] add $t2, $zero, $zero Loop: lw $t3, 0($t0) # $t3 = a[i] bne $t3, $a2, Incre addi $t2, $t2, 1 Incre: addi $t0, $t0, 4 # $t0 = &a[i+1] j Loop Exit: addi $v0, $zero, $t2 lw $t0, 0($sp) lw $t1, 4($sp) lw $t2, 8($sp) lw $t3, 12($sp) addi $sp, $sp, 16 jr $ra

Bài A.12:

1. a) addi $s0, $zero, 10

Loop:add $s0, $s0, $s1 addi $s0, $s0, -1 beq $s0, $zero, exit j loop exit:


21

b) sll $s1, $s2, 28 srl $s2, $s2, 4 or $s1, $s1, s2

2. a)

– MOV r0, #10 1110 001 1101 0 1111 0000 000000001010

– ADD ro, r1 1110 000 0100 0 0000 0000 00000 00 0 0001

– SUBS r0, 1 1110 001 0010 0 0000 0000 0000 00000001

– BNE LOOP 0001 101 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0

b) ROR r1, r2, #4 1110 001 1101 0 0010 0001 0010 00000000

3.

a) CMP r1, r0 ; if r0 < r1: N = 0 BNE FARAWAY ;if N = 0 jump to FARAWAY

b) ADD r0, r1, r2 4.

a) CMP r1, r0 1110 001 1010 1 0001 0000 000000000000

BNE FARAWAY 0101 101 0 Displacement to FARAWAY

b) ADD r0, r1, r2

1110 000 0100 0 0001 0000 00000 00 0 0002

Bài A.13:

1. Kiểu đ ịa chỉ của 2 câu lệnh ARM: LDR r0, [r1] và LDMIA r0, {r1, r2, r4} là định địa chỉ gián tiếp qua thanh ghi.

2. a. Hợp ngữ ARM: LDR r0, [r1] Hợp ngữ MIPS: lw r0, 0(r1)


22

b. Hợp ngữ ARM: LDMIA r0, {r1, r2, r4} Hợp ngữ MIPS: lw r1, 0(r0) lw r2, 4(r0) lw r4, 8(r0)

3-4.

a. Hợp ngữ ARM: LDR r0, =Table1 LDR r1, #100 EOR r2, r2, r2 ADDLP: LDR r4, [r0] ADD r2, r2, r4 ADD r0, r0, #4 SUBS r1, r1, #1 BNE ADDLP Hợp ngữ MIPS tương ứng: Giả sử $s0 chứa địa chỉ nền của Table1 add $t0, $s0, $zero addi $t1, $zero, 100 add $t2, $zero, $zero Loop: lw $t3, 0($t0) add $t2, $t2, $t3 addi $t0, $t0, 4 addi $t1, $t1, -1 bne $t1, $zero, Loop Exit: Tổng số lệnh ARM được thực thi là: 100 x 5 + 3 = 503 lệnh Tổng số lệnh MIPS được thực thi là: 100 x 5 + 4 = 503 lệnh

b. Hợp ngữ ARM: ROR r1, r2, #4 Hợp ngữ MIPS: giả sử r1 tương ứng là $t0, r2 tương ứng là $t1 sll $t0, $t1, 28 sra $t2, $t1, 4 or $t0, $t0, $t2 Tổng số lệnh ARM được thực thi là: 1 lệnh Tổng số lệnh MIPS được thực thi là: 3 lệnh

5. CPIMIPS = CPIARM ; CRMIPS = 1.5 CRARM

Nếu cùng thực hiện 1 đoạn chương trình thì b ộ xử lý ARM nhanh hơn MIPS


23

Time ARMTime MIPS

= CR MIPSCR ARM

= 1.5 lần

Bài A.14:

1. a) ADD r3, r2, r1, LSL #3

Giả sử r3 là $s3, r2 là $s2, r1 là $s. Câu lệnh được chuyển thành: sll $s3, $s1, 3 add $s3, $s3, $s2 b) ADD r3, r2, r1, ROR #3

Giả sử r3 là $s3, r2 là $s2, r1 là $s. Câu lệnh được chuyển thành: sll $t0, $s1, 29 srl $t1, $s1, 3 add $t0, $t0, $t1 add $s3, $s2, $t0

2. a) sll $s3, $s1, 3

add $s3, $s3, $s2

b) srl $t0, $s1, 3 add $s3, $s2, $t0

3. a) sll $s3, $s1, 3

add $s3, $s3, $s2 b) srl $t0, $s1, 3

add $s3, $s2, $t0 4.

a) addi r3, r2, 0x1 ADD r3, r1, #0x1 b) addi r3, r2, 0x8000 ADD r3, r2, #0x8000

Bài A.15:

1-2. a. mov edx, [esi+4 *ebx]

Giả sử edx, esi, ebx tương ừng với các thanh ghi $s0, $s1, $s2


24

Mã giả: move $t0, $s1 sll $t1, $s2, 2 add $t0, $t0, $t1 lw $s0, 0($t0) Mã MIPS: add $t0, $s1, $zero sll $t1, $s2, 2 add $t0, $t0, $t1 lw $s0, 0($t0)

b. Giả sử: ax, bx, cx tương ứng với các thanh ghi $s0, $s1, $s2 Mã giả: li $t0, 00101100 li $t2, 00000011 li $t1, 11110000 and $t0, $t0, $t1 or $t0, $t0, $t2 Mã MIPS: addi $t0, $zero, 00101100 addi $t2, $zero, 00000011 addi $t1, $zero, 11110000 and $t0, $t0, $t1 or $t0, $t0, $t2

3-4.

a. mov edx, [esi+4*ebx] Kích thước các trường biểu diễn: Opcode – 1byte MODR/M – 1 byte SIB – 1 byte Displacement – 4 bytes

Lệnh MIPS: Giả sử edx, esi, ebx tương ừng với các thanh ghi $s0, $s1, $s2 add $t0, $s1, $zero sll $t1, $s2, 2 add $t0, $t0, $t1 lw $s0, 0($t0)

b. add eax, 0x12345678 Kích thước các trường biểu diễn: Opcode – 1 byte MODR/M – byte SIB – 1 byte Immediate – 4 bytes

Lệnh MIPS: giả sử eax tương ứng với thanh ghi $s0


25

addi $s0, $zero, 0x12345678

Bài A.16:

1. a) Lệnh REP MOVSB dùng để chép byte từ một chuỗi nguồn sang một chuỗi đ ích. b) Lệnh REP MOVSD dùng để chép word từ một chuỗi nguồn sang một chuỗi đ ích.

2. Giả sử $a0 tương ứng với ECX, $a1 tương ứng với EDI và $a2 tương ứng với ESI. Các đoạn MIPS được viết như sau:

a) move $t0, $a0 move $t1, $a1 move $t2, $a2

Loop: beq $t0, $0, Exit lb $t3, 0($t2) sb $t3, 0($t1) addi $t1, $t1, 1 addi $t2, $t2, 1 addi $t0, $t0, -1 j Loop

Exit:

b) move $t0, $a0 move $t1, $a1 move $t2, $a2 Loop: beq $t0, $0, Exit

lw $t3, 0($t2) sw $t3, 0($t1) addi $t1, $t1, 4 addi $t2, $t2, 4 addi $t0, $t0, -1 j Loop

Exit:

3. Khi thời gian chu kỳ xung clock bằng nhau và ECX rất lớn, thì speed-up sẽ phụ thuộc vào số chu kỳ của mỗi lần lặp:

speed-up = perloopeClockClyclEXCperloopClockCycleEXC

x

MIPS

86××


26

= perloopeClockClyclperloopClockCycle

x

MIPS

86

= 57 = 1.4

4. Giả sử a lưu trong $a0, b lưu trong $a1, giá trị return lưu trong $v0 a) f: add $v0, $a0, $a1

jr $ra Số byte để lưu trữ các lệnh trong MIPS: 8 bytes Số byte để lưu trữ các lệnh trong x86: 11 bytes Vậy: kích thước mã x86 gấp 1.4 lần kích thước mã MIPS

b) f: lw $t0, 0($a0) lw $t1, 0($a1) add $t0, $t0, $t1 add $t1, $t0, $zero sw $t0, 0($a0) sw $t1, 0($a1) jr $ra

Số byte để lưu trữ các lệnh trong MIPS: 28 bytes Số byte để lưu trữ các lệnh trong x86: 19 bytes Vậy: kích thước mã MIPS gấp 1.5 lần k ích thước mã x86

5. Dùng bộ xử lý xong xong, có thể thực hiện được điều này trong MIPS và x86 6. Với các điều kiện trong đề bài, speed-up sẽ phụ thuộc vào ClockCycle mỗi chương

trình. a) ClockCycleMIPS = 2

ClockCyclex86 = 11

Speed-up = 86x

MIPS

ClockCycleClockCycle =

112 = 0.2

b) ClockCycleMIPS = 7

ClockCyclex86 = 19

Speed-up = 86x

MIPS

ClockCycleClockCycle =

197 = 0.4

Bài A.17:

1. a. Time = CPI ×InstructionClock rate

= (2×500+10×300+3×100 )×106

5×109 = 0.86 s


27

b. Time = CPI ×InstructionClock rate

= (1×500 +10×300 +4×100)×106

5×109 = 0.78 s 2. Sau khi cải tiến thì: ICnew = 0.75 ICold , CRnew = 0.9 CRold

Timenew = 0.75 × ICold × CPI

0.9 × CRold= 0.83 Timeold

Đây là 1 sự lựa chọn tốt vì nó giúp giảm thời gian thực thi chương trình.

3. a. TimeArith = 2×500 ×106

5×109 = 0.2 s Hiệu suất các lệnh số học tăng gấp đôi thì th ời gian thực thi của bộ xử lý là: Timenew = TimeArith new + TimeL/S + TimeBranch

= 0.22

+(10 × 300 + 3 × 100) × 109

5 × 106 = 0.76s

Speed− up = Timeold

Timenew=

0.860.76

= 1.13

Hiệu suất các lệnh số học tăng 10 lần thì thời gian thực thi của bộ xử lý là: Timenew = TimeArith new + TimeL/S + TimeBranch

= 0.210

+(10 × 300 + 3 × 100) × 109

5 × 106 = 0.68s


Timenew=

0.860.68

= 1.26

b. TimeArith = 1×500 ×106

5×109 = 0.1 s

Hiệu suất các lệnh số học tăng gấp đôi thì th ời gian thực thi của bộ xử lý là: Timenew = TimeArith new + TimeL/S + TimeBranch

= 0.12

+(10 × 300 + 4 × 100) × 109

5 × 106 = 0.73s


Timenew=

0.780.73

= 1.07

Hiệu suất các lệnh số học tăng 10 lần thì thời gian thực thi của bộ xử lý là: Timenew = TimeArith new + TimeL/S + TimeBranch

= 0.110

+(10 × 300 + 4 × 100) × 109

5 × 106 = 0.69s


Timenew=

0.780.69

= 1.13

4. a. CPIavg = (2 × 60% + 6 × 20% + 3 × 20%) = 3 b. CPIavg = (2 × 80% + 6 × 15% + 3 × 5%) = 2.65

5. Hiệu suất tăng 25% => Thời gian thực thi giảm 25% => CPI trung bình giảm 25% a. CPIavg new = CPIavg old x (100% - 25%) = 3 x 75% = 2.25

CPI𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒉𝒉 =𝟐𝟐.𝟐𝟐𝟐𝟐− (𝟔𝟔 ×𝟐𝟐𝟐𝟐% + 𝟑𝟑 × 𝟐𝟐𝟐𝟐%)

𝟔𝟔𝟐𝟐%= 𝟐𝟐.𝟕𝟕𝟐𝟐


28

b. CPIavg new = CPIavg old x (100% - 25%) = 2.65 x 75% = 1.99

CPI𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒉𝒉 =𝟏𝟏.𝟗𝟗𝟗𝟗− (𝟔𝟔 ×𝟏𝟏𝟐𝟐% + 𝟑𝟑 × 𝟐𝟐%)

𝟖𝟖𝟐𝟐%= 𝟏𝟏.𝟏𝟏𝟕𝟕𝟐𝟐

6. Hiệu suất tăng 50% => Thời gian thực thi giảm 50% => CPI trung bình giảm 50% a. CPIavg new = CPIavg old x (100% - 50%) = 3 x 50% = 1.5

CPI𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒉𝒉 =𝟏𝟏.𝟐𝟐 − (𝟔𝟔 × 𝟐𝟐𝟐𝟐% + 𝟑𝟑 × 𝟐𝟐𝟐𝟐%)

𝟔𝟔𝟐𝟐%= −𝟐𝟐.𝟐𝟐

=> Không thể cải thiện hiệu suất đến 50% b. CPIavg new = CPIavg old x (100% - 50%) = 2.65 x 50% = 1.325

CPI𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒂𝒉𝒉 =𝟏𝟏.𝟑𝟑𝟐𝟐𝟐𝟐 − (𝟔𝟔 × 𝟏𝟏𝟐𝟐% + 𝟑𝟑 × 𝟐𝟐%)

𝟖𝟖𝟐𝟐%= 𝟐𝟐.𝟑𝟑𝟑𝟑

Bài A.18:

1) Yêu cầu theo hàng tức là địa chỉ phải là bội số của 4 trong khi chương trình lại tính toán địa chỉ không theo bội số của 4. Như vậy chương trình sẽ load và store sai địa chỉ dẫn đến viêc chương trình có thể chạy sai.

2) Nếu “a” là con trỏ đến một dãy các phần tử 1 byte, và nếu thay lw va sw bằng lb và sb thì chương trình này sẽ chạy đúng.

3) a) f: move $v0, $zero

move $t0, $zero L: sll $t1, $t0, 2 add $t1, $t1, $a0 lw $t1, 0($t1) bne $t1, $a2, S addi $v0, $v0, 1 S: addi $t0, $t0, 1 bne $t0, $a1, L jr $ra

b) f: move $t0, $a0

move $t1, $a1 sll $t2, $a2, 2 add $t2, $t2, $a0

L: lw $t3, 0($t0) lw $t4, 0($t1) add $t3, $t3, $t4 sw $t3, 0($t0) addi $t0, $t0, 4


29

addi $t1, $t1, 4 bne $t0, $t2, L jr $ra

4) a) Mảng v: 0 0 0 0 0 b) Mảng v: 5 4 3 2 1

5) Trong hàm sort, trước khi bước vào vòng lặp thứ 1, mảng v chưa dc thay đổi, nên nội dung của nó cũng giống như nội dung cảu mảng v trong câu 4

6) Sau khi trả về chương trình t ừ hàm “sor t” mảng v có nội dung a) v: 0 0 0 0 0 b) v: 1 2 3 4 5

Documents

Solution Exercise 2A_Group 9