Đề cương môn lập trình mạng máy tính- Trường Đại học bách khoa - Đại học đà nẵng.

Thực hành
1. Thao tác với mảng
3 mảng array1/2/3 và size1/2/3 do đề bài cho. Khai báo thêm một số chuỗi cần thiết
để in ra màn hình I/O trong quá trình thực thi.
- khoangtrang để in ra khoảng trắng giữa các phần tử trong mảng
- ina1/2/3 để thông báo in ra mảng array 1/2/3
- thongbaonhap để thông báo yêu cầu nhập số thứ tự của mảng; thongbao1 để thông
báo yêu cầu nhập chỉ số phần từ cần tìm; thongbao2 để thông báo kết quả phần tử cần tìm
Thực hiện các yêu cầu đề bài:
✓ In ra cửa sổ I/O của MARS tất cả các phần tử của mảng array1
Dòng 20 lệnh addi để khởi tạo biến đếm
i = 0 để duyệt qua các phần tử của mảng.
Dòng 21 để load địa chỉ array1 vào $t3,
dòng 22 để load giá trị size1 vào $t4.
Từ 23 - 25 để thực hiện in chuỗi ina1 ra màn hình ("\n\nArray 1: ") Dòng 27: $t1 = $t0 * 4 Dòng 28: $t1 = $t1 + $t3
Sau hai dòng này có được địa chỉ của
array1[i]. Dùng lw để lấy giá trị của
array1[i] cho vào thanh ghi $t2 (dòng 29)
Dòng 30: $v0 = 1 (để in ra integer)
Dòng 31: $a0 = $t2 (để truyền đối số
cần in) và Syscall để in ra màn hình array1[i]
Dòng 33 - 35: in khoảng trắng
Dòng 36: tăng biến i lên 1
Dòng 37: so sánh nếu i < size1 thì tiếp
tục vòng lặp cho đến hết mảng ✓ In array2:
Tương tự như khi array1 chỉ khác chỗ
phần tử của array1 là word = 4 byte còn array2 là byte.
Dòng 40: khởi tạo biến đếm i = 0
Dòng 41: load địa chỉ array2 vào $t3
Dòng 42: load giá trị size2 vào $t4
Dòng 43 - 45: in ra chuỗi ina2
Dòng 47 - 48: $t1 = $t0 + $t3 (địa chỉ
array2[i]) sau đó load byte để lấy giá trị cho vào thanh ghi $t2
Dòng 49 - 51 để in số nguyên
Dòng 52 - 54 để in khoảng trắng
Dòng 55: tăng biến đếm i lên 1
Dòng 56 xét xem đã duyệt đến phần tử
cuối hay chưa để dùng vòng lặp hay tiếp tục in mảng.
✓ Gán các giá trị cho mảng array3 sao cho array3[i] = array2[i] + array2[size2 - 1 - i]
Dòng 58: khởi tạo biến đếm i = 0
Dòng 59: $t3 = địa chỉ array3
Dòng 60: $t4 = giá trị size3
Dòng 61: $t5 = địa chỉ array2
Dòng 62: $t6 = giá trị size2
Dòng 64 - 65: $t1 = $t0 + $t5 (đại chỉ
array2[i]), load byte $t2 = array2[i]
Dòng 67 - 69: $t1 = $t6 - 1 - $t0 + $t5
(địa chỉ của array2[size - 1 - i]). Dòng
70: load byte $t7 = array2[size - 1 - i]) Dòng 71: $t7 = $t7 + $t2
(array2[i] + array2[size - 1 - i])
Dòng 73: store byte để lưu giá trị $t7
vào địa chỉ space đầu tiên của array3
arr3[i] = array2[i] + array2[size - 1 - i]
Dòng 74 tăng biến đếm i lên 1
Dòng 75 tăng vị trí địa chỉ space của
array3 lên 1 để chuẩn bị ghi giá trị vào space tiếp theo.
Dòng 76 để kiểm tra i < size3 ? để tiếp
thực hiện hay dừng vòng lặp
✓ Người sử dụng nhập vào mảng thứ mấy và chỉ số phần tử cần lấy trong mảng đó,
chương trình xuất ra phần tử tương ứng.
Dòng 79 - 81: in chuỗi thongbaonhap
Dòng 83 - 84: $v0 = 5 (read integer - đọc
số nguyên nhập từ bàn phím)
Dòng 85: số nguyên đọc được lưu ở $v0,
lấy số nguyên này lưu vào $t0
Dòng 87 - 89: in chuỗi thongbao1
Dòng 91 - 93: $v0 = 5 (read integer - đọc
số nguyên nhập từ bàn phím). Lưu số nguyên vào $t1
Dòng 95 – 97: in chuỗi thongbao2
Dòng 98/99/100: branch if equal
Xét $t0 = 1/2/3 để nhảy đến nhãn arr1/2/3 Ở nhãn arr1:
Dòng 103: $t3 = địa chỉ array1 Dòng 104: $t1 = $t1 * 4
Dòng 105: $t1 = $t1 + $t3 (địa chỉ của array1[i]) Dòng 106: $t2 = array1[i]
Dòng 107 – 109: in array1[i] ra màn hình
Dòng 110: nhảy đến nhãn kết thúc chương trình Ở nhãn arr2:
Dòng 112: $t3 = địa chỉ array2
Dòng 113: $t1 = $t1 + $t3 (địa chỉ của array2[i]) Dòng 114: $t2 = array2[i]
Dòng 115 – 117: in array2[i] ra màn hình
Dòng 116: nhảy đến nhãn kết thúc chương trình Ở nhãn arr3:
Dòng 120: $t3 = địa chỉ array3
Dòng 121: $t1 = $t1 + $t3 (địa chỉ của array3[i]) Dòng 122: $t2 = array3[i]
Dòng 123 – 125: in array3[i] ra màn hình
Dòng 126: nhảy đến nhãn kết thúc chương trình
Kiểm tra hoạt động chương trình: Test1 Test2
*Đã viết thêm hàm in array3 để kiểm tra hoạt động 3. Bài tập
a. Nhập một mảng các số nguyên n phần tử (nhập vào số phần tử và giá trị của từng
phần tử), xuất ra cửa sổ I/O của MARS theo từng yêu cầu sau:
✓ Xuất ra giá trị lớn nhất và nhỏ nhất của mảng
✓ Tổng tất cả các phần tử của mảng
✓ Người sử dụng nhập vào chỉ số của một phần tử nào đó và giá trị của phần tử đó được in ra cửa sổ
Đầu tiên khai báo array với 400 space, một số chuỗi cần dùng để thông báo
- promt để thông báo yêu cầu nhập số lượng phần tử mảng; promt2 để thông báo
nhập giá trị của các phần tử; promt3 để thông báo nhập chỉ số phần tử cần truy xuất
- inphantu để thông báo phần tử cần truy xuất; MAX/MIN = để thông báo giá trị lớn/ nhỏ nhất
- TongMang để thông báo tổng giá trị các phần tử của mảng
Bắt đầu .text sẽ là phần nhập số lượng phần tử và giá trị các phần tử của mảng
Dòng 14 $s0 = địa chỉ array
Dòng 16 – 18: in chuỗi promt
Dòng 20 – 22: $v0 = 5 thực hiện đọc giá
trị nhập từ bàn phím, lưu vào $t0 (Ở đây
là nhập số lượng phần tử mảng)
Dòng 24: $t1 = 0 khởi tạo biến đếm i = 0
Dòng 26: kiểm tra i > số lượng phần tử
mảng? Nếu đúng thì dừng vòng lặp
Nhap_Mang, nếu sai thì tiếp tục thực hiện câu lệnh kế tiếp
Dòng 28 – 30: in chuỗi promt2
Dòng 32 – 34: nhập số nguyên và chuyển số nguyên vào $t2 Dòng 35: $t3 = $t1 * 4 Dòng 36: $t3 = $t3 + $s0
Sau hai dòng này ta có địa chỉ của phần tử
array[i] để lưu giá trị được nhập vào
Dòng 37: store word lưu giá trị $t2 tại địa chỉ array[i] Dòng 38: tăng i lên 1
Dòng 39: quay lại nhãn Nhap_Mang
✓ Xuất ra giá trị lớn nhất và nhỏ nhất của mảng
Khi kết thúc vòng lặp Nhap_Mang sẽ
nhảy đến nhãn Do, ở nhãn Do sẽ thực
hiện các yêu cầu đề bài và trước tiên là tìm Max
Dòng 42 khởi tạo biến đếm i = 1
Dòng 43 tạo biến Max = array[0] bằng
cách lw giá trị array[0] vào $t9
Dòng 45 xét i > số lượng phần tử mảng?
Nếu đúng thì nhảy đến Xuat_Max, không
thì tiếp tục thực hiện. Dòng 47 $t3 = $t1 * 4 Dòng 48: $t3 = $t3 + $s0
Sau hai dòng này ta có địa chỉ của array[i]
Dòng 49: lw để $t4 = giá trị array[i]
Dòng 51: tăng biến đếm i
Dòng 52: so sáng array[i] > max? Nếu
đúng thì nhảy đến Cap_Nhap_Max nếu
sai thì nhảy GTLN để tiếp tục duyệt phần tử tiếp theo Ở nhãn Cap_Nhap_Max:
Dòng 58: $t9 = $t4 (max = array[i])
Dòng 59: nhảy về GTLN để tiếp tục xét Ở nhãn Xuat_Max:
Dòng 62 – 64: in chuỗi max
Dòng 66 – 68: in giá trị max được lưu trong $t9
Ở Tim_Min cũng tương tự như ở tìm
max, chỉ khác dòng 80 so với dòng 52 của tìm max. Dòng 71: i = 1 Dòng 72: $t9 = array[0] #min
Dòng 74: Xét đã đến cuối mảng hay
chưa để dừng vòng lặp và nhảy đến
Xuat_Min để in ra giá trị min
Dòng 76 – 78: $t4 = giá trị array[i]
Dòng 80: xét xem array[i] ($t4) < min
($t9) hay không? Nếu đúng thì đến
Cap_Nhat_Min để cập nhật lại giá trị
min, không thì nhảy về GTNN để xét
phần tử kế tiếp trong mảng Ở nhãn Cap_Nhap_Min:
$t9 = $t4 và tăng biến đếm i lên 1, sau
đó nhảy về GTNN để tiếp tục xét phần tử kế tiếp Ở nhãn Xuat_Min:
Dòng 90 – 92: in ra chuỗi min
Dòng 94 – 96: in ra giá trị $t9 (min)
✓ Tổng tất cả các phần tử của mảng
Dòng 99: $t1 = 0 khởi tạo i = 0
Dòng 100: $t2 = 0 khởi tạo sum = 0
Dòng 102: xét i > số lượng phần tử
mảng thì nhảy đến Xuat_Tong để xuất
ra tổng giá trị các phần tử
Dòng 104 – 106: lấy giá trị array[i] Dòng 108: $t2 = $t2 + $t4 (sum = sum + array[i])
Dòng 109: tăng biến đếm i
Dòng 110: nhảy về Sum để tính tiếp Ở nhãn Xuat_Tong:
Dòng 113 – 115: in chuỗi TongMang
Dòng 117 – 119: in ra giá trị số
nguyên trong thanh ghi $t2 (sum)
✓ Người sử dụng nhập vào chỉ số của một phần tử nào đó và giá trị của phần tử đó được in ra cửa sổ
Dòng 121 – 123: in chuỗi promt3
Dòng 125 – 127: đọc số nguyên được
nhập từ bàn phím và chuyển số nguyên
lưu trong $t0 (vị trí i của phần tử cần truy xuất)
Dòng 129 – 131: lấy địa chỉ array[i] và load giá trị vào $t2
Dòng 133 – 135: in chuỗi inphantu
Dòng 137 – 139: in số nguyên trong $t2 ra màn hình.
Chạy chương trình với input n = 10 và mảng -1, 3, 2, 5, -5, -2, -3, 7, 0, 4
b. Nhập một mảng các số nguyên n phần tử (nhập vào số phần tử và giá trị của từng
phần tử). Mảng này gọi là A. Chuyển dòng lệnh C dưới đây sang mã assembly của
MIPS. Với các biến nguyên i, j được gán lần lượt vào thanh ghi $s0, $s1; và địa chỉ nền
của mảng số nguyên A được lưu trong thanh ghi $s3. if (i < j) A[i] = i else A[i] = j; Khai báo: - 400 space cho mảng array
- Promt để thông báo nhập số lượng phần tử, promt1 để thông báo nhập giá trị phần tử .text
Dòng 7: $s2 = địa chỉ array
Dòng 9 – 11: in chuỗi promt
Dòng 13 – 15: Nhập số lượng phần tử của
mảng từ bàn phím và lưu vào thanh ghi $t0
Dòng 17: $t1 = 0 khởi tạo i = 0
Dòng 18: Kiểm tra i > số lượng phần tử?
Đúng thì nhảy đến Do, sai thì tiếp tục
Dòng 21 – 23: in chuỗi promt1
Dòng 25 – 27: Nhập giá trị của phần tử và lưu vào $t2
Dòng 28 – 29: lấy địa chỉ của array[i]
chuẩn bị lưu giá trị đã được nhập vào và lưu trong $t2 vào array[i] Dòng 30: array[i] = $t2
Dòng 31: tăng biến đếm i lên 1
Dòng 32: nhảy về Nhap_Mang để tiếp tục nhập
Giá trị i lưu trong $s0, j lưu trong $s1
Dòng 34: so sánh i < j? Đúng thì nhảy đến Gan_Bang_i
Dòng 36 – 37: lấy địa chỉ phần tử array[i] Dòng 38: array[i] = $s1 = j
Dòng 39: nhảy đến end để kết thúc chương trình Ở nhãn Gan_Bang_i:
Dòng 41 – 42: lấy địa chỉ phần tử array[i] Dòng 43: array[i] = $s0 = i
Nhãn end kết thúc chương trình Kiểm tra chương trình:
Trường hợp 1: i = 2 < j = 4
i và j đã được gán vào thanh ghi $s0, $s1
Sau khi chạy chương trình xong: Array[i] = array[2] = i = 2
Trường hợp 2: i = 4 > j = 2
Với cùng input nhưng thay i = 4, j = 2
Sau khi chạy chương trình xong: Array[i] = array[4] = j = 2