HỆ ĐIỀU HÀNH - IT007.N25.

BÁO CÁO THỰC HÀNH

LAB 06: Quản Lý Bộ Nhớ
Sinh viên: Hồ Minh Trí
MSSV: 21522701
Lớp: IT007.N25.2

CÁC YÊU CẦU:

6.4 Hướng dẫn thực hành
Sử dụng ngôn ngữ lập trình C viết chương trình mô phỏng các giải thuật
thay thế trang
6.5 Bài tập ôn tập
1. Nghịch lý Belady là gì? Sử dụng chương trình đã viết trên để chứng
minh nghịch lý này.
2. Nhận xét về mức độ hiệu quả và tính khả thi của các giải thuật FIFO,
OPT, LRU.
❖ Giải thuật nào là bất khả thi nhất? Vì sao?
❖ Giải thuật nào là phức tạp nhất? Vì sao?

----------------------------------------------------

BÁO CÁO CHI TIẾT

1|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

6.4 Hướng dẫn thực hành:

*Chương trình:
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
static int preArray[10];
static int page_fault[100];
static int number_page_fault = 1;
int n;

int IsinpreArray(int page, int value) {

for (int i = 0; i < page; i++) {
if (value == preArray[i]) return i;
}
return -1;
}

int FarestElement(int *ref, int pivot, int page) {

int min[100] = { 100 };
int flag[10];
int vt = 0;
for (int i = 0; i < page; i++) {
for (int j = pivot; j < n; j++) {
if (preArray[i] == ref[j]) {
flag[i] = j;
break;
}
if (j + 1 == n)
flag[i] = j + 1;
}
}
int max = 0;
for (int i = 0; i < page; i++) {
if (flag[i] > max) {
max = flag[i];
vt = i;
}
}
return vt;
}

int FarestElementOppsite(int *ref, int pivot, int page, int n) {

int min[100] = { 100 };
int flag[10];

2|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

int vt = 0;
for (int i = 0; i < page; i++) {
for (int j = pivot; j >= 0; j--) {
if (preArray[i] == ref[j]) {
flag[i] = j;
break;
}
if (j == 0)
flag[i] = -1;
}
}
int x = 100;
for (int i = 0; i < page; i++) {
if (flag[i] < x) {
x = flag[i];
vt = i;
}
}
return vt;
}

void PrintResult(int total_page[10][100], int n, int page, int ref[100]) {

for (int i = 0; i < n; i++) {
printf("%d ", ref[i]);
}
printf("\n");
for (int i = 0; i < page; i++) {
for (int j = 0; j < n; j++) {
if (total_page[i][j] != -1) {
printf("%d ", total_page[i][j]);
}
else {
printf(" ");
}
}
printf("\n");
}
for (int i = 0; i < n; i++) {
if (page_fault[i] == 1) printf("* ");
else {
printf(" ");
}
}
printf("\n");
printf("Number of page Fault: %d\n", number_page_fault);
}

void FIFO_Algorithm(int ref[], int n, int page)

{
bool IsFault;
int total_page[10][100];

3|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

int current_page = 0;
for (int i = 0; i < page; i++) {
if (i == 0) { total_page[i][0] = ref[0]; }
else {
total_page[i][0] = -1;
}
}
page_fault[0] = 1;
for (int j = 1; j < n; j++) {
for (int i = 0; i < page; i++) {
total_page[i][j] = total_page[i][j-1];
preArray[i] = total_page[i][j - 1];
}
if (IsinpreArray(page, ref[j]) != -1) {
page_fault[j] = -1;
}
else {
current_page++;
if (current_page == page) current_page = 0;
total_page[current_page][j] = ref[j];
page_fault[j] = 1;
number_page_fault++;
}
}
PrintResult(total_page, n, page, ref);
}

void OPT_Algorithm(int ref[], int n, int page)

{
bool IsFault;
int total_page[10][100];
int current_page = 0;
for (int i = 0; i < page; i++) {
if (i == 0) { total_page[i][0] = ref[0]; }
else {
total_page[i][0] = -1;
}
}
page_fault[0] = 1;

for (int j = 1; j < n; j++)

{

for (int i = 0; i < page; i++) {

total_page[i][j] = total_page[i][j - 1];
preArray[i] = total_page[i][j - 1];
}
if (IsinpreArray(page, ref[j]) != -1) {
page_fault[j] = 0;
}
else {
if (j < page) {

4|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

current_page++;
total_page[current_page][j] = ref[j];
}
else {

int pivot = FarestElement(ref, j, page);

total_page[pivot][j] = ref[j];
}
page_fault[j] = 1;
number_page_fault++;
}
}
PrintResult(total_page, n, page, ref);
}

void LRU_Algorithm(int ref[], int n, int page)

{
bool IsFault;
int total_page[10][100];
int current_page = 0;
for (int i = 0; i < page; i++) {
if (i == 0) {
total_page[i][0] = ref[0];
}
else {
total_page[i][0] = -1;
}
}
page_fault[0] = 1;

for (int j = 1; j < n; j++)

{

for (int i = 0; i < page; i++) {

total_page[i][j] = total_page[i][j - 1];
preArray[i] = total_page[i][j - 1];
}
if (IsinpreArray(page, ref[j]) != -1) {
page_fault[j] = 0;
}
else {
if (j < page) {
current_page++;
total_page[current_page][j] = ref[j];
}
else {

int pivot = FarestElementOppsite(ref, j, page, n);

total_page[pivot][j] = ref[j];
}
page_fault[j] = 1;

5|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

number_page_fault++;
}
}
PrintResult(total_page, n, page, ref);
}

*Chạy thử với các input:

- Default references :
-FIFO & 5 page frame:

6|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

-OPT & 3 page frame:

-LRU & 4 page frame:

7|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

- Manual input:
-Input: 2 6 0 1 1 1 0 3 1 7 0 9 & 3 (page frame).
-FIFO:

OPT:

8|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

LRU:

6.5 Bài tập ôn tập:

9|Page
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

1. Nghịch lý Belady là gì? Sử dụng chương trình đã viết trên để chứng minh
nghịch lý này.
. Nghịch lý Belady là một hiện tượng trong đó tỉ lệ lỗi trang của một giải thuật thay thế
trang có thể tăng khi số lượng khung được cấp phát tăng. Điều này có nghĩa là việc cung
cấp nhiều bộ nhớ hơn cho một chương trình có thể làm cho nó chạy chậm hơn. Nghịch lý
Belady chỉ xảy ra với một số giải thuật thay thế trang, chẳng hạn như FIFO, Second
Chance hay Clock. Các giải thuật khác, như LRU (Least Recently Used), LFU (Least
Frequently Used) hay OPT (Optimal) không bị ảnh hưởng bởi nghịch lý Belady.

.Chứng Minh (Input: 1 2 3 4 1 2 5 1 2 3 4 5):

-Với 3 page frame:

 9 page fault.

-Với 4 page frame:

10 | P a g e
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

 10 page fault.

2. Nhận xét về mức độ hiệu quả và tính khả thi của các giải thuật FIFO, OPT, LRU.
❖ Giải thuật nào là bất khả thi nhất? Vì sao?
❖ Giải thuật nào là phức tạp nhất? Vì sao?

.Các giải thuật FIFO, OPT, LRU là các giải thuật thay thế trang trong bộ nhớ ảo,
có nhiệm vụ chọn trang nào sẽ bị đẩy ra khỏi bộ nhớ chính khi cần nạp một trang
mới vào. Các giải thuật này có những đặc điểm và hiệu quả khác nhau:
 Giải thuật FIFO (First In First Out) là giải thuật đơn giản nhất, dựa trên
nguyên tắc trang nào được nạp vào bộ nhớ chính trước sẽ bị đẩy ra
trước. Giải thuật này có thể gây ra nhiều lỗi trang và bị ảnh hưởng bởi
nghịch lý Belady. Giải thuật này là khả thi nhưng không hiệu quả.
 Giải thuật OPT (Optimal) là giải thuật tối ưu, dựa trên nguyên tắc thay thế
trang nào sẽ không được sử dụng trong khoảng thời gian dài nhất trong
tương lai. Giải thuật này có tỉ lệ lỗi trang thấp nhất và không bị nghịch lý
Belady. Tuy nhiên, giải thuật này là bất khả thi vì nó yêu cầu biết trước
chuỗi tham chiếu của các trang.

11 | P a g e
SV - MSSV: HỒ MINH TRÍ - 21522701
 L A B 0 6 – Q U Ả N LÝ B Ộ N H Ớ

 Giải thuật LRU (Least Recently Used) là giải thuật xấp xỉ giải thuật OPT,
dựa trên nguyên tắc thay thế trang nào đã không được sử dụng gần đây
nhất. Giải thuật này có hiệu quả cao và không bị nghịch lý Belady. Tuy
nhiên, giải thuật này là phức tạp vì nó yêu cầu theo dõi thời gian sử dụng của
các trang.
Vậy, có thể kết luận:
 Giải thuật OPT là bất khả thi nhất vì nó yêu cầu biết trước chuỗi tham chiếu
của các trang.
 Giải thuật LRU là phức tạp nhất vì nó yêu cầu theo dõi thời gian sử dụng
của các trang.

12 | P a g e
SV - MSSV: HỒ MINH TRÍ - 21522701