bài tập thực hành về hệ điều hành

Giải Giải pháp dùng TestAndSet trong trường hợp này cho thấy khi tiến trình nào đó muốn vào vùng tranh chấp thì nó thực hiện hàm TestAndSet : hàm trả về false làm cho tiến trình bỏ qua v

WAIT and SIGNAL

strict WaitSignalVar

{ Boolean lock;

proceesQueue queue;

};

Void Wait(WaitSignalVar var)

{

If (TestAndSet(var.lock))

Var.ProcessQuere.Insert();

}

Void Signal(WaitSigntVar var)

{

Var.ProcessQuere.Remove();

Var.lock=false;

}

Chú ý: Hàm Insert() đặt tiến trình vào hang đợi và gán trạng thái tiến trình thành bị chặn Hàm Remove() chọn tiến trình trong hang đợi và gán trạng thái từ bị chặn trở thành sẵn sàng

Struct semaphore

{

Int count;

ProcessQuere queue;

};

Void P(semaphore s) //proveren: to test

{

If (s.count > 0)

s.count=s.count -1;

else

s.quere.Insert(); // block this process }

Void V(semaphore s)

{

If (s.quere.empty())

s.count=s.count + 1;

else

s.quere.Remove();

}

SEMAPHORE nhị phân

Void P(semaphore s) //proveren: to test

{

If (s.count ==1)

s.count=0;

else

s.quere.Insert(); // block this process }

Void V(semaphore s)

{

If (s.quere.empty())

s.count= 1;

else

s.quere.Remove();

}

Sử dụng cấu trúc SEMAPHORE để giải quyết vấn đề Mutual Exclusion( loại trừ tương hỗ)

Share semaphore s=1;

// ……

P(s);

// Critical Section

V(s);

Gán biến s=1 Trước khi vào vùng tranh chấp, gọi hàm P(s), và sau khi ra khỏi vùng tranh chấp thì gọi hàm V(s)

BÀI TẬP

Cho hàm TestAndSet sau:

Boolean testAndSet( Boolean locked)

{

If (locked)

Return true;

Else

{

Locked=true;

Return false;

}

}

a)Cho các tiến trình sử dụng TestAndSet như sau:

share Boolean lock=false;

//…….

While (TestAndSet(lock))

DoNoThing();

// Critical-Section

Lock=false;

Hãy chứng minh giải pháp TestAndSet thỏa mãn tính loại trừ tương

hỗ(Mutual Exclucsion) Hãy cho vd với 3 tiến trình P1, P2, P3.

Giải

Giải pháp dùng TestAndSet trong trường hợp này cho thấy khi tiến trình nào đó muốn vào vùng tranh chấp thì nó thực hiện hàm TestAndSet : hàm trả về false làm cho tiến trình bỏ qua vòng

While, đồng thời gán lock=true để khóa các tiến trình khác không vào miền găng Nếu tiến trình nào đó muốn vào miền găng(vùng tranh chấp) thì do lock=true nên vòng While bắt tiến trình đó phải chờ(do hàm TestAndSet trả về true)

VÍ DỤ:

 Do lock=true nên P1

thực hiện vòng While để

chờ vào miền găng

 Lock=false

 Thực hiện hàm TestAndSet trả về false,

thoát khỏi while và vào

miền găng, đồng thời

gán lock=true( ngụ ý khóa các tiến trình P1,P3 vào miền găng)

 Khi P2 ra khỏi miền găng, nó gán lock=false  Do lock=true nên P3 thực hiện vòng While để

chờ vào miền găng

 Khi lock=false nên hàm TestAndSet sẽ return về false làm cho P3 không còn chờ nữa(thoát

While) và vào miền

găng

 Gán lock=true để khóa P1 và P2 vào miền găng

BÀI TẬP SEMAPHORE

1)Cho các thao tác P,V như sau:

Void P(semaphore s)

{

if (s.count==1)

s.count=0;

else

s.queue.Insert();//block this process }

Void V(semaphore s)

{

If (s.queue.empty())

s.count=1;

else

s.queue.remove();//schedule a process }

Share semaphore s=1;

// -P(s);

Critical-Section;

V(s);

Chứng minh các tiến trình thỏa mãn yêu cầu mutual-exclusion 2)Cho cấu trúc SWAP như sau:

Void swap(Boolean a, Boolean b)

{

Boolean temp;

temp=b;

b=a;

a =temp;

}

Shared boolean lock=false;

Boolean key;

//….

Key=true;

Do

Swap(lock,key);

While (key);

//critical-section;

Lock=false;

a)Hãy sử dụng chỉ thị swap để tổ chức mutual exclusion

b)Hãy chứng minh các tiến trình thỏa yêu cầu mutual exclusion c)Cho ví dụ với n tiến trình

BÀI TẬP DEADLOCK

1)Cho trạng thái hiện hành của hệ thống như sau:

MAX(tối đa) ALLOCATION(đang có) AVAILABLE(dự trữ)

Nếu tiến trình P2 yêu cầu 4 cho R1, 1 cho R3 Hãy cho biết yêu cầu này có thể đáp ứng

mà vẫn bảo đảm không xảy ra tình trạng deadlock hay không?

Giải

Vì AVAILABLE[1]=4, AVAILABLE[3]=2 thỏa mãn yêu cầu P2, ta có :

MAX ALLOCATION AVAILABLE

SLEEPING BARBER PROBLEM

Một tiệm cắt tóc có n ghế cho khách chờ, 1 ghế hớt tóc và 1 thợ hớt tóc

 Nếu khách hàng vào tiệm và không có ghế trống, thì khách đi về

 Nếu khách vào tiệm nhưng thợ ngủ thì khách hàng đánh thức và hớt tóc

 Ngược lại, khách ngồi chờ

 Nếu thợ cắt xong, thì hớt cho khách kế tiếp Ngược lại thợ đi ngủ

Hãy sử dụng semaphore, viết các hàm chức năng điều khiển hoạt động của thợ và khách

Giải

Share semaphore cutHair=0;

Share semaphore waiting=0;

Share semaphore countMutex=1;

Void barber()

{

While (true)

{

P(cutHair);

GiveHaircut ();

}

}

-Void customer()

{

P(countMutex);

If (count== n+1)

Exit ();

Count=count +1;

If (count > 1)

{

// -//take a chair

// -V( countMutex);

P(waiting);

}

Else

V(countMutex);

// -V(cutHair);

ReceiveHair();

// -P( countMutex);

Count=count – 1;

If ( count > 0 )

V( waiting);

V(countMutex);

}

Bài tập Mutual Exclusion

*Xét đoạn code sau :

Share Boolean waiting[MAX_PID]=false;

Share Boolean lock = false ;

Int pid = ThisProcessPid();

Boolean ts;

Int nextPid;

//

waiting[pid]=true;

ts= true;

while (waiting[pid] and ts )

ts=TestAndSet(lock);

waiting[pid] =false;

//critical-section

nextPid = (pid + 1) mod MAX_PID;

while ( nextPid != pid && waiting[nextPid] == false ) nextPid= (pid + 1 ) mod MAX_PID ;

if (nextPid == pid )

lock = false;

else

waiting[nextPid]= false ;

Hãy chứng minh rằng giải pháp dùng TestAndSet bảo đảm tính loại trừ tương hỗ Giải:

Một tiến trình muốn vào miền găng chỉ khi biến ts bằng false hoặc waiting[pid] bằng false

 Nếu ts bằng false thì hàm TestAndSet phải trả về false đồng thời gán lock=true

 Bất kỳ tiến trình nào muốn vào miền găng thì hàm TestAndSet sẽ chặn lại

 Khi tiến trình ra khỏi miền găng thì biến lock gán bằng false

 Biến waiting[pid] cũng có thể gán false khi tiến trình nào đó rời khỏi miền găng

 Một tiến trình nào đó cũng có thể đặt phần tử biến waiting thành false nếu như

nó không thể gán lock bằng true Như vậy chỉ có chỉ có một tiến trình trong miền bởi vì thành phần waiting của nó là false

 Không có tiến trình nào có thể có biến ts bằng false ở cùng thời điểm

Vậy : Tính loại trừ lẫn nhau (mutual exclusion) được chứng minh

*Cho đoạn code sau :

Shared int turn = 1;

int myPid=0;// myPid =0 cho tiến trình 0, 1 cho tiến trình 1

int othePid=1 – myPid ;

while (turn != myPid )

DoNoThing();

// Critical-Section

Turn = otherPid;

a)Chứng minh đoạn code này không thỏa mãn cơ chế truy xuất miền găng

b) Sửa đoạn code để thỏa mãn tính mutual-exclusion

Giải

a)

 Khi một tiến trình thực hiện muốn vào miền găng thì bị chặn bởi vòng while

do turn # myPid

 Một tiến trình ở ngoài miền găng sẽ ngăn cản tiến trình khác vào miền găng b) share int turn = 0;

int mypid= 0;

while (turn != mypid)

DoNoThing();

turn =1;

// Critical-section;

turn =0;

*DEKKER’S ALGORITHM

// -Process_1

p1wantstoenter=true;

While (p2wantstoenter)

If (favoredprocess==second)

{ p1wantstoenter=false;

While (favoredprocess==second)

DoNoThing();

p1wantstoenter=true;

}

CRITICAL-SECTION;

favoredprocess=second;

p1wantstoenter=false;

// -Process_2 p2wantstoenter=true;

While (p1wantstoenter)

If (favoredprocess==first) { p2wantstoenter=false;

While (favoredprocess==first) DoNoThing();

p2wantstoenter=true;

} CRITICAL-SECTION;

favoredprocess=first;

p2wantstoenter=false;

p2wantstoenter=false;

favovedprocess=first;

{

Process_1;

Process_2;

}

Chứng minh rằng thuật toán Dekker thỏa mãn yêu cầu truy xuất đến miền găng

Giải

 Các biến p1wantstoenter =true có nghĩa là tiến trình 1 muốn vào miền găng, khi

ra khỏi sẽ gán thành false

 Giả sử P1 xử lý trước nên p1wantstoenter =true ->tiến trình 1 sẽ bỏ qua điều kiện vòng while do khi đó p2wantstoenter =false -> P1 vào miền găng

 Trong khi P1 ở trong miền găng thì tiến trình P2 muốn vào miền găng nhưng do điều kiện while p1wantstoenter =true nên P2 phải thực hiện vòng while này Biến favoredprocess=first làm cho P2 phải chờ trong khi P1 đang ở trong miền găng

 Biến favoredprocess=first làm cho điều kiện vòng while đúng nên buộc P2 phải chờ

 Khi P1 ra khỏi miền găng, nó gán biến favoredprocess=second và

p1wantstoenter=false Như vậy tiến trình P2 mới thoát ra khỏi vòng while để vào miền găng Vậy tính loại trừ lẫn nhau(mutual exclusion) được bảo đảm

DEKKER’S ALGORITHM DẠNG 2

Share Boolean wantIn[2] = false;

Shrare int favored = 0;

Int myPid = 0 ;

Int otherPid = 1 – myPid;

P1

wantIn[myPid] = true ;

while (wantIn[otherPid])

{

If (favored == otherPid)

{ wantIn[myPid]=false;

while (favored==otherPid)

DoNothing();

wantIn[myPid]=true;

}

P2 wantIn[otherPid] = true ; while (wantIn[myPid]) {

If (favored == myPid)

{ wantIn[otherPid]=false; while (favored==myPid)

DoNothing();

wantIn[otherPid]=true; }

//CRITICAL-SECTION

Favored = otherPid;

wantIn[myPid] = false ;

} //CRITICAL-SECTION Favored = myPid;

wantIn[otherPid] = false ;

*PETERSON’S ALGORITHM

Shared Boolean wantIn[2]=false;

Share int turn =1;

Int myPid=0; //for process 0 Set to 1 for process 1

Int otherPid = 1 – myPid;

P1

wantIn[myPid] = true ;

turn = otherPid ;

while (wantIn[otherPid] && turn == otherPid)

DoNothing();

//CRITICAL-SECTION

wantIn[myPid] = false;

P2 wantIn[otherPid] = true ; turn = myPid ;

while (wantIn[myPid] && turn == myPid)

DoNothing();

//CRITICAL-SECTION wantIn[otherPid] = false;

Chứng minh rằng thuật toán Peterson thỏa mãn yêu cầu truy xuất đến miền găng Giải:

 Xét trường hợp tiến trình P1 vào miền găng : wantIn[myPid] = true ; turn = otherPid

 Khi đó điều kiện wantIn[otherPid] && turn == otherPid bằng false ->P1 vào miền găng Trong khi đó, nếu P2 muốn vào miền găng thì điều kiện while không thỏa, nghĩa là điề kiện bằng true ->làm cho P2 phải chờ cho đến khi P1 ra khỏi miền găng

 Xét trường hợp cả hai tiến trình cùng thực hiện , cùng gán wantIn[myPid] = wantIn[otherPid] = true ; nhưng biến turn sẽ gán myPid hoặc otherPid Nếu turn=otherPid thì tiến trình P1 phải chờ để cho tiến trình P2 thao tác trên miền găng, ngược lại nếu turn = myPid thì tiến trình P2 phải chờ trong khi tiến trình P1

ở trong miền găng

 Vậy thuật toán đảm bảo tính chất Mutual Exclusion

*BAKERY’S ALGORITHM

Chứng minh thuật toán Bakery thỏa mãn yêu cầu truy truy xuất miền găng

// -Shared Boolean choosing[N] =false;

Share int number[N] = 0;

Int myPid = 0; // for process 0 X for process x

Int jj ;

Choosing[myPid] = true;

Number[myPid] = MAX(number) + 1 ;

Choosing[myPid] = false ;

For (jj=0 ; jj < N ; jj =jj+1)

{

While (choosing[jj])

DoNothing();

While (number[jj] != 0 && ((number[jj] < number[myPid]) || (number[jj] == number[myPid] && j < i ))

DoNothing();

}

//CRITICAL-SECTION

Number[myPid] = 0;