Bài Tập Hệ Điều Hành UIT chương 5

Môn học: Hệ điều hành

Họ tên: Nguyễn Thanh Hiếu

Báo cáo Bài tập chương 5

Lớp: IT007.M21.HTCL
Bài làm

Câu 1: Xét giải pháp phần mềm do Dekker đề nghị để tổ chức truy xuất độc quyền cho 2
tiến trình. Hai tiến trình P0 và P1 chia sẻ các biến sau:
 Var flag : array [0..1] of Boolean; (khởi động là false)
 Turn : 0..1;
Cấu trúc một tiến trình Pi ( i=0 hay 1, và j là tiến trình cịn lại như sau:

Giải:
- Giải pháp này thỏa mãn cả 3 yêu cầu
+ Nếu một tiến trình Pj muốn vào vùng tranh chấp, trong khi tiến trình Pi cũng đang
muốn vào vùng tranh chấp: =>dựa vài biến turn để xác nhận Pi hay Pj được tiến hành, do
turn chỉ có một giá trị cùng một lúc nên chỉ có một trong 2 được vào vùng tranh chấp của
nó => thoả mãn u cầu 1.
+ Khơng có bất kỳ động thái ngăn cản tiến trình Pj vào miền găng khi Pi đang không ở
trong miền găng (như đổi turn từ j thành i, đổi flag[j] thành false) => thoả mãn yêu cầu 2.
+ Khi Pi hoàn thành thì sẽ nhường lượt cho Pj, nếu Pi bị tắc thì Pj sẽ tiến và nhường lượt
cho Pi => thoả mãn yêu cầu 3.

Câu 2: Xét giải pháp đồng bộ hóa sau:


Giải:
- Ta thấy code này có đoạn j = 1 – i => đề chỉ đang nói tới xét 2 tiê trình P1 và P0 vì khi i

= 0 thì j = 1 và ngược lại.
- Giải thuật này không thoả mãn:
- Xét tình huống khi flag[0] = true; turn =0; lúc này P0 vào CS, Nếu lúc đó flag[1] = 1,
P1 có thể gán turn = 1 và vào ln CS .

Câu 3: Giả sử một máy tính khơng có chỉ thị TSL, nhưng có chỉ thị Swap có khả năng
hoán đổi nội dung của hai từ nhớ chỉ bằng một thao tác không thể phân chia:


Giải:
- Sử dụng chỉ thị này có thể tổ chức truy xuất độc quyền
- Cấu trúc chương trình tương ứng:
while(true){
key=true;
while(key=true)
swap(lock,key);
critical-section();
lock=false;
Noncritical-section();
}
Câu 4: Xét hai tiến trình sau:
process A {while (TRUE) na = na +1; }
process B { while (TRUE) nb = nb +1;

}

a. Đồng bộ hóa xử lý của 2 tiến trình trên, sử dụng 2 semaphore tổng quát, sao cho
tại bất kỳ thời điểm nào cũng có nb <= na <= nb +10
b. Nếu giảm điều kiện chỉ có là na <= nb +10, giải pháp của bạn sẽ được sửa chữa
như thế nào?

c. Giải pháp của bạn có cịn đúng nếu có nhiều tiến trình loại A và B cùng thực hiện?
a.
Semaphore_1=0;
Semaphore_2=10;
Process A:
while(1){
wait(Semaphore_2);
na=na+1;
signal(Semaphore_1);
}
Process B:
while(1){
wait(Semaphore_1);
nb=nb+1;
signal(Semaphore_2);
}


b.
Semaphore_2=10;
Process A:
while(1){
wait(Semaphore_2);
na=na+1;
}
Process B:
while(1){
nb=nb+1;
signal(Semaphore_2);
}

c.
- Giải pháp vẫn cịn đúng nếu có nhiều tiến trình loại A và B cùng thực hiện. Vì có thể có
nhiều tiến trình loại A hoặc loại B cùng thực hiện nhưng chỉ có 2 biến Semaphore toàn
cục mà chúng sẽ thao tác
Câu 5: Một biến X được chia sẻ bởi 2 tiến trình cùng thực hiện đoạn code sau :
do
X = X +1;
if ( X == 20) X = 0;
while ( TRUE );
 Bắt đầu với giá trị X = 0, chứng tỏ rằng giá trị X có thể vượt quá 20. Cần sửa chữa
đoạn chương trình trên như thế nào để đảm bảo X khơng vượt quá 20?
Giải
Semaphore mutex =1;
do {
down(mutex);
x=x+1;
if (x==20) x=0;
up(mutex);
}while(true);

Câu 6: Xét 2 tiến trình xử lý đoạn chương trình sau:
process P1 { A1 ; A2 }
process P2 { B1 ; B2 }


Đồng bộ hóa hoạt động của 2 tiến trình này sao cho cả A1 và B1 đều hoàn tất trước khi
A2 và B2 bắt đầu
Giải
Semaphore_1=0;
Semaphore_2=0;

Process P1{
A1;
wait(Semaphore_1);
signal(Semaphore_2);
A2;
}
Process P2{
B1;
wait(Semaphore_2);
signal(Semaphore_1);
B2;
}
Câu 7:

Giải
Semaphore_1=1;
Semaphore_2=1;
Process A:
for (int i=1; i<=100; i++){
wait(Semaphore_1);
Ai;
signal(Semaphore_2);
}
Process B:


for (int i=1; i<=100; i++){
wait(Semaphore_2);
Bi;
signal(Semaphore_1);

}
Câu 8:

Giải:
- Ứng với mỗi số được xem như một process hoặc thread
w := x1 * x2 (1)// 1 starts before 5 and 6
v := x3 * x4 (2)// 2 starts before 3 and 4
y := v * x5 (3)// 3 starts after 2 and before 5
z := v * x6 (4)// 4 starts after 2 and before 6
y := w * y (5)// 5 starts after 1, 3 and before 7
z := w * z (6) // 6 starts after 1, 4 and before 7
ans := y + z (7)// 7 starts after 5 and 6
- Ta sẽ tạo ra các semaphore gồm: s15, s16, s23, s24, s35, s46, s57, s67. Initial value của
tất cả các semaphore đều là 0. Giải thích việc đặt tên như sau: process nào thực thi trước
sẽ có số đại diện đứng trước, process thực thi sau sẽ có số đại diện đứng sau, ví dụ
process 1 thực thi trước process 5 và process 6 nên sẽ có s15, s16.
// Process 1
w = x1 * x2;
signal (s15);
signal (s16);
// Process 2
v = x3 * x4;


signal(s23);
signal(s24);
// Process 3
wait(s23);
y = v * x5;
signal(s35);

// Process 4
wait(s24);
z = v * x6;
signal(s46);
// Process 5
wait(s15);
wait(s35);
y = w * y;
signal(s57);
// Process 6
wait(s16);
wait(s46);
z = w * z;
signal(s67);
// Process 7
wait(s57);
wait(s67);
ans = y + z;